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: crate::SCHEMA_VERSION.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, goal, outcome, outcome_tag, external): (
191        String,
192        String,
193        Option<String>,
194        Option<String>,
195        Option<String>,
196        Option<String>,
197    ) = conn
198        .query_row(
199            "SELECT title, status, goal, outcome, outcome_tag, external FROM tasks WHERE task_id=?1",
200            rusqlite::params![task_id],
201            |r| {
202                Ok((
203                    r.get(0)?,
204                    r.get(1)?,
205                    r.get(2)?,
206                    r.get(3)?,
207                    r.get(4)?,
208                    r.get(5)?,
209                ))
210            },
211        )
212        .with_context(|| format!("task not found: {task_id}"))?;
213
214    let event_count: usize = conn.query_row(
215        "SELECT COUNT(*) FROM events_index WHERE task_id=?1",
216        rusqlite::params![task_id],
217        |r| r.get::<_, i64>(0).map(|n| n as usize),
218    )?;
219
220    let mut text = format!("# {title}  [status: {status}]\n\n");
221
222    // v0.4.0 task-as-goal block. Goal renders even when empty so the
223    // shape is consistent and the absence is visible. Outcome only
224    // when closed (avoids "(open)" noise on every active task).
225    // External only when populated.
226    let goal_str = goal.as_deref().unwrap_or("(not set)");
227    text.push_str(&format!("**Goal**: {goal_str}\n"));
228    if status == "closed" {
229        let outcome_str = outcome.as_deref().unwrap_or("(not recorded)");
230        let tag = outcome_tag
231            .as_deref()
232            .map(|t| format!(" [{t}]"))
233            .unwrap_or_default();
234        text.push_str(&format!("**Outcome**{tag}: {outcome_str}\n"));
235    }
236    if let Some(ext) = external.as_deref().filter(|s| !s.is_empty()) {
237        text.push_str(&format!("**External**: {ext}\n"));
238    }
239
240    // v0.5.0 Phase B: artifacts auto-extracted from event text. Render
241    // only categories that have entries — empty groups are noise on a
242    // 30-event task. Order is stable so packs diff cleanly.
243    let arts = crate::db::task_artifacts(conn, task_id)?;
244    if !arts.is_empty() {
245        text.push_str("**Artifacts**:\n");
246        if !arts.commit_hashes.is_empty() {
247            text.push_str(&format!("- commits: {}\n", arts.commit_hashes.join(", ")));
248        }
249        if !arts.pr_urls.is_empty() {
250            text.push_str(&format!("- PRs: {}\n", arts.pr_urls.join(", ")));
251        }
252        if !arts.linked_issues.is_empty() {
253            text.push_str(&format!("- issues: {}\n", arts.linked_issues.join(", ")));
254        }
255        if !arts.files.is_empty() {
256            text.push_str(&format!("- files: {}\n", arts.files.join(", ")));
257        }
258        if !arts.branch_names.is_empty() {
259            text.push_str(&format!("- branches: {}\n", arts.branch_names.join(", ")));
260        }
261    }
262    text.push('\n');
263
264    if matches!(mode, PackMode::Full) {
265        text.push_str(&render_lifecycle(conn, task_id)?);
266    }
267    text.push_str(&render_active_decisions(conn, task_id)?);
268    if matches!(mode, PackMode::Full) {
269        text.push_str(&render_rejected(conn, task_id)?);
270        text.push_str(&render_evidence(conn, task_id)?);
271    }
272    let recent_limit = match mode {
273        PackMode::Compact => 3,
274        PackMode::Full => 10,
275    };
276    text.push_str(&render_recent_events(conn, task_id, recent_limit)?);
277
278    // Token-budget truncation: cap pack size so it always fits an LLM context window.
279    const FULL_BUDGET: usize = 10 * 1024;
280    const COMPACT_BUDGET: usize = 2 * 1024;
281    const TRUNC_MARKER: &str = "\n\n_(truncated to fit pack budget)_\n";
282    let budget = match mode {
283        PackMode::Full => FULL_BUDGET,
284        PackMode::Compact => COMPACT_BUDGET,
285    };
286    let truncated = text.len() > budget;
287    if truncated {
288        let cutoff = text[..budget].rfind('\n').unwrap_or(budget);
289        text.truncate(cutoff);
290        text.push_str(TRUNC_MARKER);
291    }
292
293    let generated_at = chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true);
294
295    // Write-through cache.
296    conn.execute(
297        "INSERT OR REPLACE INTO task_pack_cache(task_id, mode, text, generated_at, source_event_count)
298         VALUES (?1, ?2, ?3, ?4, ?5)",
299        rusqlite::params![task_id, mode_str, text, generated_at, event_count as i64],
300    )?;
301
302    Ok(TaskPack {
303        task_id: task_id.to_string(),
304        mode,
305        schema_version: crate::SCHEMA_VERSION.into(),
306        text,
307        metadata: PackMetadata {
308            generated_at,
309            source_event_count: event_count,
310            cache_hit: false,
311            truncated,
312        },
313    })
314}
315
316#[cfg(test)]
317mod tests {
318    use super::*;
319
320    #[test]
321    fn pack_mode_round_trips_via_serde() {
322        let s = serde_json::to_string(&PackMode::Compact).unwrap();
323        assert_eq!(s, "\"Compact\"");
324    }
325
326    #[test]
327    fn cache_is_invalidated_on_new_event() {
328        use crate::db;
329        use crate::event::*;
330        use tempfile::TempDir;
331
332        let d = TempDir::new().unwrap();
333        let conn = db::open(d.path().join("s.sqlite")).unwrap();
334        let mut open_e = Event::new(
335            "tj-inv",
336            EventType::Open,
337            Author::User,
338            Source::Cli,
339            "x".into(),
340        );
341        open_e.meta = serde_json::json!({"title": "Inv"});
342        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
343        db::index_event(&conn, &open_e).unwrap();
344
345        let _ = assemble(&conn, "tj-inv", PackMode::Compact).unwrap();
346        let p2 = assemble(&conn, "tj-inv", PackMode::Compact).unwrap();
347        assert!(p2.metadata.cache_hit);
348
349        let dec = Event::new(
350            "tj-inv",
351            EventType::Decision,
352            Author::Agent,
353            Source::Chat,
354            "D".into(),
355        );
356        db::upsert_task_from_event(&conn, &dec, "feedface").unwrap();
357        db::index_event(&conn, &dec).unwrap();
358
359        let p3 = assemble(&conn, "tj-inv", PackMode::Compact).unwrap();
360        assert!(
361            !p3.metadata.cache_hit,
362            "new event must invalidate the cache"
363        );
364    }
365
366    #[test]
367    fn pack_cache_hits_after_incremental_ingest_with_no_new_events() {
368        // Reproduces the MCP hot loop: client calls task_pack(X), the server
369        // runs ingest_new_events (which now reads only the JSONL tail), then
370        // calls assemble(X). After B2 the second call must hit the cache —
371        // before B2, full rebuild_state replayed every event through index_
372        // event() which DELETEd the cache row, so we always missed.
373        use crate::db;
374        use crate::event::*;
375        use std::io::Write;
376        use tempfile::TempDir;
377
378        let d = TempDir::new().unwrap();
379        let jsonl = d.path().join("events.jsonl");
380        let project = "cafef00dcafef00d";
381
382        let mut open_e = Event::new(
383            "tj-cmcp",
384            EventType::Open,
385            Author::User,
386            Source::Cli,
387            "x".into(),
388        );
389        open_e.meta = serde_json::json!({"title": "Cached"});
390        let dec = Event::new(
391            "tj-cmcp",
392            EventType::Decision,
393            Author::Agent,
394            Source::Chat,
395            "Adopt Rust".into(),
396        );
397
398        let mut f = std::fs::File::create(&jsonl).unwrap();
399        writeln!(f, "{}", serde_json::to_string(&open_e).unwrap()).unwrap();
400        writeln!(f, "{}", serde_json::to_string(&dec).unwrap()).unwrap();
401        drop(f);
402
403        let conn = db::open(d.path().join("s.sqlite")).unwrap();
404
405        // First MCP call: ingest, then pack.
406        db::ingest_new_events(&conn, &jsonl, project).unwrap();
407        let first = assemble(&conn, "tj-cmcp", PackMode::Compact).unwrap();
408        assert!(
409            !first.metadata.cache_hit,
410            "first assemble must populate cache"
411        );
412
413        // Second MCP call: ingest again (zero new events in JSONL), then pack.
414        let n_new = db::ingest_new_events(&conn, &jsonl, project).unwrap();
415        assert_eq!(n_new, 0, "no new events should be ingested");
416        let second = assemble(&conn, "tj-cmcp", PackMode::Compact).unwrap();
417        assert!(
418            second.metadata.cache_hit,
419            "repeat assemble after a no-op ingest must hit the cache"
420        );
421        assert_eq!(first.text, second.text);
422    }
423
424    #[test]
425    fn pack_cache_returns_cached_text_on_second_call() {
426        use crate::db;
427        use crate::event::*;
428        use tempfile::TempDir;
429
430        let d = TempDir::new().unwrap();
431        let conn = db::open(d.path().join("s.sqlite")).unwrap();
432        let mut open_e = Event::new(
433            "tj-c",
434            EventType::Open,
435            Author::User,
436            Source::Cli,
437            "x".into(),
438        );
439        open_e.meta = serde_json::json!({"title": "Cache"});
440        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
441        db::index_event(&conn, &open_e).unwrap();
442
443        let p1 = assemble(&conn, "tj-c", PackMode::Compact).unwrap();
444        assert!(!p1.metadata.cache_hit);
445        let p2 = assemble(&conn, "tj-c", PackMode::Compact).unwrap();
446        assert!(p2.metadata.cache_hit, "second call should hit cache");
447        assert_eq!(p1.text, p2.text);
448    }
449
450    #[test]
451    fn compact_mode_omits_optional_sections() {
452        use crate::db;
453        use crate::event::*;
454        use tempfile::TempDir;
455
456        let d = TempDir::new().unwrap();
457        let conn = db::open(d.path().join("s.sqlite")).unwrap();
458        let mut open_e = Event::new(
459            "tj-cm",
460            EventType::Open,
461            Author::User,
462            Source::Cli,
463            "x".into(),
464        );
465        open_e.meta = serde_json::json!({"title": "Compact"});
466        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
467        db::index_event(&conn, &open_e).unwrap();
468        let dec = Event::new(
469            "tj-cm",
470            EventType::Decision,
471            Author::Agent,
472            Source::Chat,
473            "D1".into(),
474        );
475        db::upsert_task_from_event(&conn, &dec, "feedface").unwrap();
476        db::index_event(&conn, &dec).unwrap();
477
478        let pack = assemble(&conn, "tj-cm", PackMode::Compact).unwrap();
479        assert!(pack.text.contains("# Compact"));
480        assert!(pack.text.contains("Active decisions"));
481        assert!(pack.text.contains("Recent events"));
482        assert!(
483            !pack.text.contains("Lifecycle"),
484            "compact should omit Lifecycle: {}",
485            pack.text
486        );
487        assert!(
488            !pack.text.contains("Rejected"),
489            "compact should omit Rejected: {}",
490            pack.text
491        );
492        assert!(
493            !pack.text.contains("Evidence"),
494            "compact should omit Evidence: {}",
495            pack.text
496        );
497    }
498
499    #[test]
500    fn full_mode_truncates_when_exceeding_budget() {
501        use crate::db;
502        use crate::event::*;
503        use tempfile::TempDir;
504
505        let d = TempDir::new().unwrap();
506        let conn = db::open(d.path().join("s.sqlite")).unwrap();
507        let mut open_e = Event::new(
508            "tj-big",
509            EventType::Open,
510            Author::User,
511            Source::Cli,
512            "x".into(),
513        );
514        open_e.meta = serde_json::json!({"title": "Big"});
515        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
516        db::index_event(&conn, &open_e).unwrap();
517        for i in 0..100 {
518            let ev = Event::new(
519                "tj-big",
520                EventType::Evidence,
521                Author::Agent,
522                Source::Chat,
523                format!("Evidence #{i}: {}", "lorem ipsum ".repeat(50)),
524            );
525            db::upsert_task_from_event(&conn, &ev, "feedface").unwrap();
526            db::index_event(&conn, &ev).unwrap();
527        }
528        let pack = assemble(&conn, "tj-big", PackMode::Full).unwrap();
529        assert!(
530            pack.text.len() <= 12 * 1024,
531            "pack must stay under ~12KB; got {} bytes",
532            pack.text.len()
533        );
534        assert!(pack.metadata.truncated, "metadata.truncated must be true");
535        assert!(pack.text.contains("truncated to fit pack budget"));
536    }
537
538    #[test]
539    fn corrected_events_appear_with_correction_event_type() {
540        use crate::db;
541        use crate::event::*;
542        use tempfile::TempDir;
543
544        let d = TempDir::new().unwrap();
545        let conn = db::open(d.path().join("s.sqlite")).unwrap();
546        let mut open_e = Event::new(
547            "tj-co",
548            EventType::Open,
549            Author::User,
550            Source::Cli,
551            "x".into(),
552        );
553        open_e.meta = serde_json::json!({"title": "Corr"});
554        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
555        db::index_event(&conn, &open_e).unwrap();
556
557        let bad = Event::new(
558            "tj-co",
559            EventType::Finding,
560            Author::Classifier,
561            Source::Hook,
562            "Migration done (wrong)".into(),
563        );
564        db::upsert_task_from_event(&conn, &bad, "feedface").unwrap();
565        db::index_event(&conn, &bad).unwrap();
566
567        let mut corr = Event::new(
568            "tj-co",
569            EventType::Correction,
570            Author::User,
571            Source::Cli,
572            "Migration NOT done; finding was wrong".into(),
573        );
574        corr.corrects = Some(bad.event_id.clone());
575        db::upsert_task_from_event(&conn, &corr, "feedface").unwrap();
576        db::index_event(&conn, &corr).unwrap();
577
578        let pack = assemble(&conn, "tj-co", PackMode::Full).unwrap();
579        assert!(pack.text.contains("[correction]"));
580        assert!(pack.text.contains("Migration NOT done"));
581    }
582
583    #[test]
584    fn suggested_events_get_question_mark_marker_in_pack() {
585        use crate::db;
586        use crate::event::*;
587        use tempfile::TempDir;
588
589        let d = TempDir::new().unwrap();
590        let conn = db::open(d.path().join("s.sqlite")).unwrap();
591        let mut open_e = Event::new(
592            "tj-q",
593            EventType::Open,
594            Author::User,
595            Source::Cli,
596            "x".into(),
597        );
598        open_e.meta = serde_json::json!({"title": "Q"});
599        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
600        db::index_event(&conn, &open_e).unwrap();
601
602        let mut suggested = Event::new(
603            "tj-q",
604            EventType::Decision,
605            Author::Classifier,
606            Source::Hook,
607            "Adopt Rust".into(),
608        );
609        suggested.status = EventStatus::Suggested;
610        db::upsert_task_from_event(&conn, &suggested, "feedface").unwrap();
611        db::index_event(&conn, &suggested).unwrap();
612
613        let pack = assemble(&conn, "tj-q", PackMode::Full).unwrap();
614        let recent_pos = pack.text.find("## Recent events").unwrap();
615        let recent_section = &pack.text[recent_pos..];
616        assert!(
617            recent_section.contains("[?]"),
618            "suggested event must show [?] marker in Recent events:\n{recent_section}"
619        );
620    }
621
622    #[test]
623    fn pack_renders_recent_events_full_mode() {
624        use crate::db;
625        use crate::event::*;
626        use tempfile::TempDir;
627
628        let d = TempDir::new().unwrap();
629        let conn = db::open(d.path().join("s.sqlite")).unwrap();
630        let mut open_e = Event::new(
631            "tj-re",
632            EventType::Open,
633            Author::User,
634            Source::Cli,
635            "x".into(),
636        );
637        open_e.meta = serde_json::json!({"title": "Recent"});
638        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
639        db::index_event(&conn, &open_e).unwrap();
640        for i in 0..6 {
641            let e = Event::new(
642                "tj-re",
643                EventType::Hypothesis,
644                Author::Agent,
645                Source::Chat,
646                format!("hypothesis {i}"),
647            );
648            db::upsert_task_from_event(&conn, &e, "feedface").unwrap();
649            db::index_event(&conn, &e).unwrap();
650        }
651
652        let pack = assemble(&conn, "tj-re", PackMode::Full).unwrap();
653        assert!(pack.text.contains("## Recent events"));
654        let count = pack.text.matches("[hypothesis]").count();
655        assert!(
656            count >= 5,
657            "expected >=5 hypotheses, got {count} in {}",
658            pack.text
659        );
660    }
661
662    #[test]
663    fn pack_renders_evidence_section() {
664        use crate::db;
665        use crate::event::*;
666        use tempfile::TempDir;
667
668        let d = TempDir::new().unwrap();
669        let conn = db::open(d.path().join("s.sqlite")).unwrap();
670        let mut open_e = Event::new(
671            "tj-ev",
672            EventType::Open,
673            Author::User,
674            Source::Cli,
675            "x".into(),
676        );
677        open_e.meta = serde_json::json!({"title": "Ev"});
678        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
679        db::index_event(&conn, &open_e).unwrap();
680
681        let mut ev = Event::new(
682            "tj-ev",
683            EventType::Evidence,
684            Author::Agent,
685            Source::Chat,
686            "Hook startup at 12ms vs 380ms node".into(),
687        );
688        ev.evidence_strength = Some(EvidenceStrength::Strong);
689        db::upsert_task_from_event(&conn, &ev, "feedface").unwrap();
690        db::index_event(&conn, &ev).unwrap();
691
692        let pack = assemble(&conn, "tj-ev", PackMode::Full).unwrap();
693        assert!(pack.text.contains("## Evidence"));
694        assert!(pack.text.contains("12ms"));
695        assert!(pack.text.contains("(strong)"));
696    }
697
698    #[test]
699    fn pack_renders_rejected_options() {
700        use crate::db;
701        use crate::event::*;
702        use tempfile::TempDir;
703
704        let d = TempDir::new().unwrap();
705        let conn = db::open(d.path().join("s.sqlite")).unwrap();
706        let mut open_e = Event::new(
707            "tj-r",
708            EventType::Open,
709            Author::User,
710            Source::Cli,
711            "x".into(),
712        );
713        open_e.meta = serde_json::json!({"title": "Rej"});
714        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
715        db::index_event(&conn, &open_e).unwrap();
716
717        let rej = Event::new(
718            "tj-r",
719            EventType::Rejection,
720            Author::Agent,
721            Source::Chat,
722            "TypeScript: loses single-binary distribution".into(),
723        );
724        db::upsert_task_from_event(&conn, &rej, "feedface").unwrap();
725        db::index_event(&conn, &rej).unwrap();
726
727        let pack = assemble(&conn, "tj-r", PackMode::Full).unwrap();
728        assert!(pack.text.contains("## Rejected"));
729        assert!(pack.text.contains("TypeScript"));
730    }
731
732    #[test]
733    fn pack_renders_active_decisions() {
734        use crate::db;
735        use crate::event::*;
736        use tempfile::TempDir;
737
738        let d = TempDir::new().unwrap();
739        let conn = db::open(d.path().join("s.sqlite")).unwrap();
740        let mut open_e = Event::new(
741            "tj-ad",
742            EventType::Open,
743            Author::User,
744            Source::Cli,
745            "x".into(),
746        );
747        open_e.meta = serde_json::json!({"title": "Decisions test"});
748        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
749        db::index_event(&conn, &open_e).unwrap();
750
751        let dec = Event::new(
752            "tj-ad",
753            EventType::Decision,
754            Author::Agent,
755            Source::Chat,
756            "Adopt Rust".into(),
757        );
758        db::upsert_task_from_event(&conn, &dec, "feedface").unwrap();
759        db::index_event(&conn, &dec).unwrap();
760
761        let pack = assemble(&conn, "tj-ad", PackMode::Full).unwrap();
762        assert!(
763            pack.text.contains("## Active decisions"),
764            "missing section: {}",
765            pack.text
766        );
767        assert!(
768            pack.text.contains("Adopt Rust"),
769            "decision text missing: {}",
770            pack.text
771        );
772    }
773
774    #[test]
775    fn assemble_includes_lifecycle_history() {
776        use crate::db;
777        use crate::event::*;
778        use tempfile::TempDir;
779
780        let d = TempDir::new().unwrap();
781        let conn = db::open(d.path().join("s.sqlite")).unwrap();
782
783        let mut open_e = Event::new(
784            "tj-l",
785            EventType::Open,
786            Author::User,
787            Source::Cli,
788            "x".into(),
789        );
790        open_e.meta = serde_json::json!({"title": "Lifecycle"});
791        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
792        db::index_event(&conn, &open_e).unwrap();
793
794        let close_e = Event::new(
795            "tj-l",
796            EventType::Close,
797            Author::User,
798            Source::Cli,
799            "done".into(),
800        );
801        db::upsert_task_from_event(&conn, &close_e, "feedface").unwrap();
802        db::index_event(&conn, &close_e).unwrap();
803
804        let pack = assemble(&conn, "tj-l", PackMode::Full).unwrap();
805        assert!(pack.text.contains("## Lifecycle"));
806        assert!(pack.text.contains("opened"));
807        assert!(pack.text.contains("closed"));
808    }
809
810    #[test]
811    fn assemble_header_only_compact() {
812        use crate::db;
813        use crate::event::*;
814        use tempfile::TempDir;
815
816        let d = TempDir::new().unwrap();
817        let conn = db::open(d.path().join("s.sqlite")).unwrap();
818
819        let mut open_e = Event::new(
820            "tj-h",
821            EventType::Open,
822            Author::User,
823            Source::Cli,
824            "x".into(),
825        );
826        open_e.meta = serde_json::json!({"title": "Header test"});
827        db::upsert_task_from_event(&conn, &open_e, "feedface").unwrap();
828        db::index_event(&conn, &open_e).unwrap();
829
830        let pack = assemble(&conn, "tj-h", PackMode::Compact).unwrap();
831        assert!(
832            pack.text.contains("# Header test"),
833            "header missing: {}",
834            pack.text
835        );
836        assert!(
837            pack.text.contains("status: open"),
838            "status missing: {}",
839            pack.text
840        );
841        assert_eq!(pack.metadata.source_event_count, 1);
842        assert!(!pack.metadata.cache_hit);
843    }
844}
tj_core/pack.rs

tj_core/
pack.rs
