tj_core/
pack.rs

1//! Pack assembler: turns events + derived state into compact resume Markdown.
2
3use serde::Serialize;
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
6pub enum PackMode {
7    Compact,
8    Full,
9}
10
11#[derive(Debug, Clone, Serialize)]
12pub struct TaskPack {
13    pub task_id: String,
14    pub mode: PackMode,
15    pub schema_version: String,
16    pub text: String,
17    pub metadata: PackMetadata,
18}
19
20#[derive(Debug, Clone, Serialize)]
21pub struct PackMetadata {
22    pub generated_at: String,
23    pub source_event_count: usize,
24    pub cache_hit: bool,
25    pub truncated: bool,
26}
27
28use anyhow::Context;
29use rusqlite::Connection;
30
31fn render_recent_events(conn: &Connection, task_id: &str, limit: usize) -> anyhow::Result<String> {
32    let mut out = format!("## Recent events (last {limit})\n");
33    let mut stmt = conn.prepare(
34        "SELECT ei.timestamp, ei.type, ei.status, sf.text FROM events_index ei
35         LEFT JOIN search_fts sf ON sf.event_id = ei.event_id
36         WHERE ei.task_id=?1 ORDER BY ei.timestamp DESC LIMIT ?2",
37    )?;
38    let rows = stmt.query_map(rusqlite::params![task_id, limit as i64], |r| {
39        let ts: String = r.get(0)?;
40        let ty: String = r.get(1)?;
41        let st: String = r.get(2)?;
42        let txt: Option<String> = r.get(3)?;
43        Ok((ts, ty, st, txt.unwrap_or_default()))
44    })?;
45    for row in rows {
46        let (ts, ty, st, txt) = row?;
47        let one_line = txt
48            .lines()
49            .next()
50            .unwrap_or("")
51            .chars()
52            .take(120)
53            .collect::<String>();
54        let marker = if st == "suggested" { " [?]" } else { "" };
55        out.push_str(&format!("- {ts} [{ty}]{marker} {one_line}\n"));
56    }
57    out.push('\n');
58    Ok(out)
59}
60
61fn render_evidence(conn: &Connection, task_id: &str) -> anyhow::Result<String> {
62    let mut out = String::from("## Evidence\n");
63    let mut stmt = conn
64        .prepare("SELECT text, strength FROM evidence WHERE task_id=?1 ORDER BY evidence_id ASC")?;
65    let rows = stmt.query_map(rusqlite::params![task_id], |r| {
66        let t: String = r.get(0)?;
67        let s: String = r.get(1)?;
68        Ok((t, s))
69    })?;
70    let mut count = 0;
71    for row in rows {
72        let (t, s) = row?;
73        out.push_str(&format!("- {t} ({s})\n"));
74        count += 1;
75    }
76    if count == 0 {
77        out.push_str("- (none)\n");
78    }
79    out.push('\n');
80    Ok(out)
81}
82
83fn render_rejected(conn: &Connection, task_id: &str) -> anyhow::Result<String> {
84    let mut out = String::from("## Rejected\n");
85    let mut id_stmt = conn.prepare(
86        "SELECT event_id FROM events_index
87         WHERE task_id=?1 AND type='rejection'
88         ORDER BY timestamp ASC",
89    )?;
90    let mut text_stmt = conn.prepare("SELECT text FROM search_fts WHERE event_id=?1 LIMIT 1")?;
91    let event_ids: Vec<String> = id_stmt
92        .query_map(rusqlite::params![task_id], |r| r.get::<_, String>(0))?
93        .collect::<Result<_, _>>()?;
94    let mut count = 0;
95    for eid in event_ids {
96        let text: String = text_stmt.query_row(rusqlite::params![eid], |r| r.get(0))?;
97        out.push_str(&format!("- {text}\n"));
98        count += 1;
99    }
100    if count == 0 {
101        out.push_str("- (none)\n");
102    }
103    out.push('\n');
104    Ok(out)
105}
106
107fn render_active_decisions(conn: &Connection, task_id: &str) -> anyhow::Result<String> {
108    let mut out = String::from("## Active decisions\n");
109    let mut stmt = conn.prepare(
110        "SELECT text FROM decisions WHERE task_id=?1 AND status='active' ORDER BY decision_id ASC",
111    )?;
112    let rows = stmt.query_map(rusqlite::params![task_id], |r| r.get::<_, String>(0))?;
113    let mut count = 0;
114    for row in rows {
115        out.push_str(&format!("- {}\n", row?));
116        count += 1;
117    }
118    if count == 0 {
119        out.push_str("- (none)\n");
120    }
121    out.push('\n');
122    Ok(out)
123}
124
125fn render_lifecycle(conn: &Connection, task_id: &str) -> anyhow::Result<String> {
126    let mut out = String::from("## Lifecycle\n");
127    let mut stmt = conn.prepare(
128        "SELECT timestamp, type FROM events_index
129         WHERE task_id=?1 AND type IN ('open','close','reopen','supersede','redirect')
130         ORDER BY timestamp ASC",
131    )?;
132    let rows = stmt.query_map(rusqlite::params![task_id], |r| {
133        let ts: String = r.get(0)?;
134        let ty: String = r.get(1)?;
135        Ok((ts, ty))
136    })?;
137    let mut count = 0;
138    for row in rows {
139        let (ts, ty) = row?;
140        let verb = match ty.as_str() {
141            "open" => "opened",
142            "close" => "closed",
143            "reopen" => "reopened",
144            "supersede" => "superseded",
145            "redirect" => "redirected",
146            _ => &ty,
147        };
148        out.push_str(&format!("- {ts} {verb}\n"));
149        count += 1;
150    }
151    if count == 0 {
152        out.push_str("- (none)\n");
153    }
154    out.push('\n');
155    Ok(out)
156}
157
158pub fn assemble(conn: &Connection, task_id: &str, mode: PackMode) -> anyhow::Result<TaskPack> {
159    let mode_str = match mode {
160        PackMode::Compact => "compact",
161        PackMode::Full => "full",
162    };
163
164    // Read-through cache: if we have a stored pack with the same mode, return it.
165    let cached: Option<(String, String, i64)> = conn
166        .query_row(
167            "SELECT text, generated_at, source_event_count FROM task_pack_cache
168         WHERE task_id=?1 AND mode=?2",
169            rusqlite::params![task_id, mode_str],
170            |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
171        )
172        .ok();
173    if let Some((cached_text, cached_at, cached_count)) = cached {
174        // Detect truncation by re-checking for the marker.
175        let was_truncated = cached_text.contains("_(truncated to fit pack budget)_");
176        return Ok(TaskPack {
177            task_id: task_id.to_string(),
178            mode,
179            schema_version: "1.0".into(),
180            text: cached_text,
181            metadata: PackMetadata {
182                generated_at: cached_at,
183                source_event_count: cached_count as usize,
184                cache_hit: true,
185                truncated: was_truncated,
186            },
187        });
188    }
189
190    let (title, status): (String, String) = conn
191        .query_row(
192            "SELECT title, status FROM tasks WHERE task_id=?1",
193            rusqlite::params![task_id],
194            |r| Ok((r.get(0)?, r.get(1)?)),
195        )
196        .with_context(|| format!("task not found: {task_id}"))?;
197
198    let event_count: usize = conn.query_row(
199        "SELECT COUNT(*) FROM events_index WHERE task_id=?1",
200        rusqlite::params![task_id],
201        |r| r.get::<_, i64>(0).map(|n| n as usize),
202    )?;
203
204    let mut text = format!("# {title}  [status: {status}]\n\n");
205    if matches!(mode, PackMode::Full) {
206        text.push_str(&render_lifecycle(conn, task_id)?);
207    }
208    text.push_str(&render_active_decisions(conn, task_id)?);
209    if matches!(mode, PackMode::Full) {
210        text.push_str(&render_rejected(conn, task_id)?);
211        text.push_str(&render_evidence(conn, task_id)?);
212    }
213    let recent_limit = match mode {
214        PackMode::Compact => 3,
215        PackMode::Full => 10,
216    };
217    text.push_str(&render_recent_events(conn, task_id, recent_limit)?);
218
219    // Token-budget truncation: cap pack size so it always fits an LLM context window.
220    const FULL_BUDGET: usize = 10 * 1024;
221    const COMPACT_BUDGET: usize = 2 * 1024;
222    const TRUNC_MARKER: &str = "\n\n_(truncated to fit pack budget)_\n";
223    let budget = match mode {
224        PackMode::Full => FULL_BUDGET,
225        PackMode::Compact => COMPACT_BUDGET,
226    };
227    let truncated = text.len() > budget;
228    if truncated {
229        let cutoff = text[..budget].rfind('\n').unwrap_or(budget);
230        text.truncate(cutoff);
231        text.push_str(TRUNC_MARKER);
232    }
233
234    let generated_at = chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true);
235
236    // Write-through cache.
237    conn.execute(
238        "INSERT OR REPLACE INTO task_pack_cache(task_id, mode, text, generated_at, source_event_count)
239         VALUES (?1, ?2, ?3, ?4, ?5)",
240        rusqlite::params![task_id, mode_str, text, generated_at, event_count as i64],
241    )?;
242
243    Ok(TaskPack {
244        task_id: task_id.to_string(),
245        mode,
246        schema_version: "1.0".into(),
247        text,
248        metadata: PackMetadata {
249            generated_at,
250            source_event_count: event_count,
251            cache_hit: false,
252            truncated,
253        },
254    })
255}
256
257#[cfg(test)]
258mod tests {
259    use super::*;
260
261    #[test]
262    fn pack_mode_round_trips_via_serde() {
263        let s = serde_json::to_string(&PackMode::Compact).unwrap();
264        assert_eq!(s, "\"Compact\"");
265    }
266
267    #[test]
268    fn cache_is_invalidated_on_new_event() {
269        use crate::db;
270        use crate::event::*;
271        use tempfile::TempDir;
272
273        let d = TempDir::new().unwrap();
274        let conn = db::open(d.path().join("s.sqlite")).unwrap();
275        let mut open_e = Event::new(
276            "tj-inv",
277            EventType::Open,
278            Author::User,
279            Source::Cli,
280            "x".into(),
281        );
282        open_e.meta = serde_json::json!({"title": "Inv"});
283        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
284        db::index_event(&conn, &open_e).unwrap();
285
286        let _ = assemble(&conn, "tj-inv", PackMode::Compact).unwrap();
287        let p2 = assemble(&conn, "tj-inv", PackMode::Compact).unwrap();
288        assert!(p2.metadata.cache_hit);
289
290        let dec = Event::new(
291            "tj-inv",
292            EventType::Decision,
293            Author::Agent,
294            Source::Chat,
295            "D".into(),
296        );
297        db::upsert_task_from_event(&conn, &dec, "feedface").unwrap();
298        db::index_event(&conn, &dec).unwrap();
299
300        let p3 = assemble(&conn, "tj-inv", PackMode::Compact).unwrap();
301        assert!(
302            !p3.metadata.cache_hit,
303            "new event must invalidate the cache"
304        );
305    }
306
307    #[test]
308    fn pack_cache_returns_cached_text_on_second_call() {
309        use crate::db;
310        use crate::event::*;
311        use tempfile::TempDir;
312
313        let d = TempDir::new().unwrap();
314        let conn = db::open(d.path().join("s.sqlite")).unwrap();
315        let mut open_e = Event::new(
316            "tj-c",
317            EventType::Open,
318            Author::User,
319            Source::Cli,
320            "x".into(),
321        );
322        open_e.meta = serde_json::json!({"title": "Cache"});
323        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
324        db::index_event(&conn, &open_e).unwrap();
325
326        let p1 = assemble(&conn, "tj-c", PackMode::Compact).unwrap();
327        assert!(!p1.metadata.cache_hit);
328        let p2 = assemble(&conn, "tj-c", PackMode::Compact).unwrap();
329        assert!(p2.metadata.cache_hit, "second call should hit cache");
330        assert_eq!(p1.text, p2.text);
331    }
332
333    #[test]
334    fn compact_mode_omits_optional_sections() {
335        use crate::db;
336        use crate::event::*;
337        use tempfile::TempDir;
338
339        let d = TempDir::new().unwrap();
340        let conn = db::open(d.path().join("s.sqlite")).unwrap();
341        let mut open_e = Event::new(
342            "tj-cm",
343            EventType::Open,
344            Author::User,
345            Source::Cli,
346            "x".into(),
347        );
348        open_e.meta = serde_json::json!({"title": "Compact"});
349        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
350        db::index_event(&conn, &open_e).unwrap();
351        let dec = Event::new(
352            "tj-cm",
353            EventType::Decision,
354            Author::Agent,
355            Source::Chat,
356            "D1".into(),
357        );
358        db::upsert_task_from_event(&conn, &dec, "feedface").unwrap();
359        db::index_event(&conn, &dec).unwrap();
360
361        let pack = assemble(&conn, "tj-cm", PackMode::Compact).unwrap();
362        assert!(pack.text.contains("# Compact"));
363        assert!(pack.text.contains("Active decisions"));
364        assert!(pack.text.contains("Recent events"));
365        assert!(
366            !pack.text.contains("Lifecycle"),
367            "compact should omit Lifecycle: {}",
368            pack.text
369        );
370        assert!(
371            !pack.text.contains("Rejected"),
372            "compact should omit Rejected: {}",
373            pack.text
374        );
375        assert!(
376            !pack.text.contains("Evidence"),
377            "compact should omit Evidence: {}",
378            pack.text
379        );
380    }
381
382    #[test]
383    fn full_mode_truncates_when_exceeding_budget() {
384        use crate::db;
385        use crate::event::*;
386        use tempfile::TempDir;
387
388        let d = TempDir::new().unwrap();
389        let conn = db::open(d.path().join("s.sqlite")).unwrap();
390        let mut open_e = Event::new(
391            "tj-big",
392            EventType::Open,
393            Author::User,
394            Source::Cli,
395            "x".into(),
396        );
397        open_e.meta = serde_json::json!({"title": "Big"});
398        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
399        db::index_event(&conn, &open_e).unwrap();
400        for i in 0..100 {
401            let ev = Event::new(
402                "tj-big",
403                EventType::Evidence,
404                Author::Agent,
405                Source::Chat,
406                format!("Evidence #{i}: {}", "lorem ipsum ".repeat(50)),
407            );
408            db::upsert_task_from_event(&conn, &ev, "feedface").unwrap();
409            db::index_event(&conn, &ev).unwrap();
410        }
411        let pack = assemble(&conn, "tj-big", PackMode::Full).unwrap();
412        assert!(
413            pack.text.len() <= 12 * 1024,
414            "pack must stay under ~12KB; got {} bytes",
415            pack.text.len()
416        );
417        assert!(pack.metadata.truncated, "metadata.truncated must be true");
418        assert!(pack.text.contains("truncated to fit pack budget"));
419    }
420
421    #[test]
422    fn corrected_events_appear_with_correction_event_type() {
423        use crate::db;
424        use crate::event::*;
425        use tempfile::TempDir;
426
427        let d = TempDir::new().unwrap();
428        let conn = db::open(d.path().join("s.sqlite")).unwrap();
429        let mut open_e = Event::new(
430            "tj-co",
431            EventType::Open,
432            Author::User,
433            Source::Cli,
434            "x".into(),
435        );
436        open_e.meta = serde_json::json!({"title": "Corr"});
437        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
438        db::index_event(&conn, &open_e).unwrap();
439
440        let bad = Event::new(
441            "tj-co",
442            EventType::Finding,
443            Author::Classifier,
444            Source::Hook,
445            "Migration done (wrong)".into(),
446        );
447        db::upsert_task_from_event(&conn, &bad, "feedface").unwrap();
448        db::index_event(&conn, &bad).unwrap();
449
450        let mut corr = Event::new(
451            "tj-co",
452            EventType::Correction,
453            Author::User,
454            Source::Cli,
455            "Migration NOT done; finding was wrong".into(),
456        );
457        corr.corrects = Some(bad.event_id.clone());
458        db::upsert_task_from_event(&conn, &corr, "feedface").unwrap();
459        db::index_event(&conn, &corr).unwrap();
460
461        let pack = assemble(&conn, "tj-co", PackMode::Full).unwrap();
462        assert!(pack.text.contains("[correction]"));
463        assert!(pack.text.contains("Migration NOT done"));
464    }
465
466    #[test]
467    fn suggested_events_get_question_mark_marker_in_pack() {
468        use crate::db;
469        use crate::event::*;
470        use tempfile::TempDir;
471
472        let d = TempDir::new().unwrap();
473        let conn = db::open(d.path().join("s.sqlite")).unwrap();
474        let mut open_e = Event::new(
475            "tj-q",
476            EventType::Open,
477            Author::User,
478            Source::Cli,
479            "x".into(),
480        );
481        open_e.meta = serde_json::json!({"title": "Q"});
482        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
483        db::index_event(&conn, &open_e).unwrap();
484
485        let mut suggested = Event::new(
486            "tj-q",
487            EventType::Decision,
488            Author::Classifier,
489            Source::Hook,
490            "Adopt Rust".into(),
491        );
492        suggested.status = EventStatus::Suggested;
493        db::upsert_task_from_event(&conn, &suggested, "feedface").unwrap();
494        db::index_event(&conn, &suggested).unwrap();
495
496        let pack = assemble(&conn, "tj-q", PackMode::Full).unwrap();
497        let recent_pos = pack.text.find("## Recent events").unwrap();
498        let recent_section = &pack.text[recent_pos..];
499        assert!(
500            recent_section.contains("[?]"),
501            "suggested event must show [?] marker in Recent events:\n{recent_section}"
502        );
503    }
504
505    #[test]
506    fn pack_renders_recent_events_full_mode() {
507        use crate::db;
508        use crate::event::*;
509        use tempfile::TempDir;
510
511        let d = TempDir::new().unwrap();
512        let conn = db::open(d.path().join("s.sqlite")).unwrap();
513        let mut open_e = Event::new(
514            "tj-re",
515            EventType::Open,
516            Author::User,
517            Source::Cli,
518            "x".into(),
519        );
520        open_e.meta = serde_json::json!({"title": "Recent"});
521        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
522        db::index_event(&conn, &open_e).unwrap();
523        for i in 0..6 {
524            let e = Event::new(
525                "tj-re",
526                EventType::Hypothesis,
527                Author::Agent,
528                Source::Chat,
529                format!("hypothesis {i}"),
530            );
531            db::upsert_task_from_event(&conn, &e, "feedface").unwrap();
532            db::index_event(&conn, &e).unwrap();
533        }
534
535        let pack = assemble(&conn, "tj-re", PackMode::Full).unwrap();
536        assert!(pack.text.contains("## Recent events"));
537        let count = pack.text.matches("[hypothesis]").count();
538        assert!(
539            count >= 5,
540            "expected >=5 hypotheses, got {count} in {}",
541            pack.text
542        );
543    }
544
545    #[test]
546    fn pack_renders_evidence_section() {
547        use crate::db;
548        use crate::event::*;
549        use tempfile::TempDir;
550
551        let d = TempDir::new().unwrap();
552        let conn = db::open(d.path().join("s.sqlite")).unwrap();
553        let mut open_e = Event::new(
554            "tj-ev",
555            EventType::Open,
556            Author::User,
557            Source::Cli,
558            "x".into(),
559        );
560        open_e.meta = serde_json::json!({"title": "Ev"});
561        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
562        db::index_event(&conn, &open_e).unwrap();
563
564        let mut ev = Event::new(
565            "tj-ev",
566            EventType::Evidence,
567            Author::Agent,
568            Source::Chat,
569            "Hook startup at 12ms vs 380ms node".into(),
570        );
571        ev.evidence_strength = Some(EvidenceStrength::Strong);
572        db::upsert_task_from_event(&conn, &ev, "feedface").unwrap();
573        db::index_event(&conn, &ev).unwrap();
574
575        let pack = assemble(&conn, "tj-ev", PackMode::Full).unwrap();
576        assert!(pack.text.contains("## Evidence"));
577        assert!(pack.text.contains("12ms"));
578        assert!(pack.text.contains("(strong)"));
579    }
580
581    #[test]
582    fn pack_renders_rejected_options() {
583        use crate::db;
584        use crate::event::*;
585        use tempfile::TempDir;
586
587        let d = TempDir::new().unwrap();
588        let conn = db::open(d.path().join("s.sqlite")).unwrap();
589        let mut open_e = Event::new(
590            "tj-r",
591            EventType::Open,
592            Author::User,
593            Source::Cli,
594            "x".into(),
595        );
596        open_e.meta = serde_json::json!({"title": "Rej"});
597        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
598        db::index_event(&conn, &open_e).unwrap();
599
600        let rej = Event::new(
601            "tj-r",
602            EventType::Rejection,
603            Author::Agent,
604            Source::Chat,
605            "TypeScript: loses single-binary distribution".into(),
606        );
607        db::upsert_task_from_event(&conn, &rej, "feedface").unwrap();
608        db::index_event(&conn, &rej).unwrap();
609
610        let pack = assemble(&conn, "tj-r", PackMode::Full).unwrap();
611        assert!(pack.text.contains("## Rejected"));
612        assert!(pack.text.contains("TypeScript"));
613    }
614
615    #[test]
616    fn pack_renders_active_decisions() {
617        use crate::db;
618        use crate::event::*;
619        use tempfile::TempDir;
620
621        let d = TempDir::new().unwrap();
622        let conn = db::open(d.path().join("s.sqlite")).unwrap();
623        let mut open_e = Event::new(
624            "tj-ad",
625            EventType::Open,
626            Author::User,
627            Source::Cli,
628            "x".into(),
629        );
630        open_e.meta = serde_json::json!({"title": "Decisions test"});
631        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
632        db::index_event(&conn, &open_e).unwrap();
633
634        let dec = Event::new(
635            "tj-ad",
636            EventType::Decision,
637            Author::Agent,
638            Source::Chat,
639            "Adopt Rust".into(),
640        );
641        db::upsert_task_from_event(&conn, &dec, "feedface").unwrap();
642        db::index_event(&conn, &dec).unwrap();
643
644        let pack = assemble(&conn, "tj-ad", PackMode::Full).unwrap();
645        assert!(
646            pack.text.contains("## Active decisions"),
647            "missing section: {}",
648            pack.text
649        );
650        assert!(
651            pack.text.contains("Adopt Rust"),
652            "decision text missing: {}",
653            pack.text
654        );
655    }
656
657    #[test]
658    fn assemble_includes_lifecycle_history() {
659        use crate::db;
660        use crate::event::*;
661        use tempfile::TempDir;
662
663        let d = TempDir::new().unwrap();
664        let conn = db::open(d.path().join("s.sqlite")).unwrap();
665
666        let mut open_e = Event::new(
667            "tj-l",
668            EventType::Open,
669            Author::User,
670            Source::Cli,
671            "x".into(),
672        );
673        open_e.meta = serde_json::json!({"title": "Lifecycle"});
674        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
675        db::index_event(&conn, &open_e).unwrap();
676
677        let close_e = Event::new(
678            "tj-l",
679            EventType::Close,
680            Author::User,
681            Source::Cli,
682            "done".into(),
683        );
684        db::upsert_task_from_event(&conn, &close_e, "feedface").unwrap();
685        db::index_event(&conn, &close_e).unwrap();
686
687        let pack = assemble(&conn, "tj-l", PackMode::Full).unwrap();
688        assert!(pack.text.contains("## Lifecycle"));
689        assert!(pack.text.contains("opened"));
690        assert!(pack.text.contains("closed"));
691    }
692
693    #[test]
694    fn assemble_header_only_compact() {
695        use crate::db;
696        use crate::event::*;
697        use tempfile::TempDir;
698
699        let d = TempDir::new().unwrap();
700        let conn = db::open(d.path().join("s.sqlite")).unwrap();
701
702        let mut open_e = Event::new(
703            "tj-h",
704            EventType::Open,
705            Author::User,
706            Source::Cli,
707            "x".into(),
708        );
709        open_e.meta = serde_json::json!({"title": "Header test"});
710        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
711        db::index_event(&conn, &open_e).unwrap();
712
713        let pack = assemble(&conn, "tj-h", PackMode::Compact).unwrap();
714        assert!(
715            pack.text.contains("# Header test"),
716            "header missing: {}",
717            pack.text
718        );
719        assert!(
720            pack.text.contains("status: open"),
721            "status missing: {}",
722            pack.text
723        );
724        assert_eq!(pack.metadata.source_event_count, 1);
725        assert!(!pack.metadata.cache_hit);
726    }
727}
tj_core/pack.rs

tj_core/
pack.rs
