gsd-pi 2.47.0 → 2.48.0-dev.ced2eca

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -160,15 +160,17 @@ describe("auto-worktree-milestone-merge", () => {
 
     const result = mergeMilestoneToMain(repo, "M020", roadmap);
 
-    assert.match(result.commitMessage, /^feat\(M020\):/, "subject has conventional commit prefix");
+    assert.match(result.commitMessage, /^feat:/, "subject has conventional commit prefix without milestone ID");
     assert.ok(result.commitMessage.includes("Backend foundation"), "subject includes milestone title");
     assert.ok(result.commitMessage.includes("- S01: Core API"), "body lists S01");
     assert.ok(result.commitMessage.includes("- S02: Error handling"), "body lists S02");
     assert.ok(result.commitMessage.includes("- S03: Logging infra"), "body lists S03");
+    assert.ok(result.commitMessage.includes("GSD-Milestone: M020"), "body has GSD-Milestone trailer");
     assert.ok(result.commitMessage.includes("Branch: milestone/M020"), "body has branch metadata");
 
     const gitMsg = run("git log -1 --format=%B main", repo).trim();
-    assert.match(gitMsg, /^feat\(M020\):/, "git commit message starts with feat(M020):");
+    assert.match(gitMsg, /^feat:/, "git commit message starts with feat:");
+    assert.ok(gitMsg.includes("GSD-Milestone: M020"), "git commit has GSD-Milestone trailer");
     assert.ok(gitMsg.includes("- S01: Core API"), "git commit body has S01");
   });
 
@@ -213,11 +215,11 @@ describe("auto-worktree-milestone-merge", () => {
     const result = mergeMilestoneToMain(repo, "M040", roadmap);
 
     const mainLog = run("git log --oneline main", repo);
-    assert.ok(mainLog.includes("feat(M040)"), "milestone commit on main");
+    assert.ok(mainLog.includes("feat:"), "milestone commit on main");
 
     run("git push origin main", repo);
     const remoteLog = run("git log --oneline main", bareDir);
-    assert.ok(remoteLog.includes("feat(M040)"), "milestone commit reachable on remote after manual push");
+    assert.ok(remoteLog.includes("feat:"), "milestone commit reachable on remote after manual push");
 
     assert.strictEqual(typeof result.pushed, "boolean", "pushed flag remains boolean");
   });
@@ -248,7 +250,7 @@ describe("auto-worktree-milestone-merge", () => {
     let threw = false;
     try {
       const result = mergeMilestoneToMain(repo, "M050", roadmap);
-      assert.ok(result.commitMessage.includes("feat(M050)"), "merge commit created despite .gsd conflict");
+      assert.ok(result.commitMessage.includes("feat:") && result.commitMessage.includes("GSD-Milestone: M050"), "merge commit created despite .gsd conflict");
     } catch (err) {
       threw = true;
     }
@@ -274,7 +276,7 @@ describe("auto-worktree-milestone-merge", () => {
     let threw = false;
     try {
       const result = mergeMilestoneToMain(repo, "M060", roadmap);
-      assert.ok(result.commitMessage.includes("feat(M060)"), "merge commit created");
+      assert.ok(result.commitMessage.includes("feat:") && result.commitMessage.includes("GSD-Milestone: M060"), "merge commit created");
     } catch (err) {
       threw = true;
     }
@@ -312,7 +314,7 @@ describe("auto-worktree-milestone-merge", () => {
     let errMsg = "";
     try {
       const result = mergeMilestoneToMain(dir, "M070", roadmap);
-      assert.ok(result.commitMessage.includes("feat(M070)"), "merge commit created on master");
+      assert.ok(result.commitMessage.includes("feat:") && result.commitMessage.includes("GSD-Milestone: M070"), "merge commit created on master");
     } catch (err) {
       threw = true;
       errMsg = err instanceof Error ? err.message : String(err);
@@ -392,7 +394,7 @@ describe("auto-worktree-milestone-merge", () => {
     let threw = false;
     try {
       const result = mergeMilestoneToMain(repo, "M090", roadmap);
-      assert.ok(result.commitMessage.includes("feat(M090)"), "#1738 merge succeeds after cleaning synced dirs");
+      assert.ok(result.commitMessage.includes("feat:") && result.commitMessage.includes("GSD-Milestone: M090"), "#1738 merge succeeds after cleaning synced dirs");
     } catch (err: unknown) {
       threw = true;
     }
@@ -419,7 +421,7 @@ describe("auto-worktree-milestone-merge", () => {
     let threw = false;
     try {
       const result = mergeMilestoneToMain(repo, "M100", roadmap);
-      assert.ok(result.commitMessage.includes("feat(M100)"), "#2151: merge succeeds after stashing dirty files");
+      assert.ok(result.commitMessage.includes("feat:") && result.commitMessage.includes("GSD-Milestone: M100"), "#2151: merge succeeds after stashing dirty files");
     } catch {
       threw = true;
     }
@@ -519,7 +521,7 @@ describe("auto-worktree-milestone-merge", () => {
     let errMsg = "";
     try {
       const result = mergeMilestoneToMain(repo, "M140", roadmap);
-      assert.ok(result.commitMessage.includes("feat(M140)"), "merge commit created");
+      assert.ok(result.commitMessage.includes("feat:") && result.commitMessage.includes("GSD-Milestone: M140"), "merge commit created");
     } catch (err) {
       threw = true;
       errMsg = err instanceof Error ? err.message : String(err);
@@ -589,7 +591,7 @@ describe("auto-worktree-milestone-merge", () => {
     assert.ok(existsSync(squashMsgPath), "SQUASH_MSG planted before merge");
 
     const result = mergeMilestoneToMain(repo, "M160", roadmap);
-    assert.ok(result.commitMessage.includes("feat(M160)"), "merge commit created");
+    assert.ok(result.commitMessage.includes("feat:") && result.commitMessage.includes("GSD-Milestone: M160"), "merge commit created");
 
     assert.ok(!existsSync(squashMsgPath), "#1853: SQUASH_MSG must not persist after successful squash-merge");
   });
@@ -609,7 +611,7 @@ describe("auto-worktree-milestone-merge", () => {
     ]);
 
     const result = mergeMilestoneToMain(repo, "M170", roadmap);
-    assert.ok(result.commitMessage.includes("feat(M170)"), "merge commit created");
+    assert.ok(result.commitMessage.includes("feat:") && result.commitMessage.includes("GSD-Milestone: M170"), "merge commit created");
 
     assert.ok(
       existsSync(join(repo, "uncommitted-agent-code.ts")),

package/src/resources/extensions/gsd/tests/discuss-queued-milestones.test.ts

@@ -0,0 +1,241 @@
+/**
+ * discuss-queued-milestones.test.ts — Tests for #2307.
+ *
+ * /gsd discuss was previously gated on state.activeMilestone, which prevented
+ * users from discussing queued (pending) milestones during roadmap grooming.
+ *
+ * These tests verify:
+ *   1. deriveState correctly identifies pending milestones (the set the picker
+ *      will show when no active milestone is present)
+ *   2. resolveMilestoneFile correctly resolves context artifacts for pending
+ *      milestones so the picker can report their discussion state
+ *   3. The guided-flow.ts source code no longer hard-exits when no active
+ *      milestone exists but pending milestones are present
+ *   4. The helper functions for queued discuss exist in the source
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+import { deriveState } from "../state.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { resolveMilestoneFile } from "../paths.ts";
+
+// ─── Fixture Helpers ──────────────────────────────────────────────────────────
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-discuss-queued-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeMilestoneDir(base: string, mid: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+}
+
+function writeContext(base: string, mid: string, content: string): void {
+  writeMilestoneDir(base, mid);
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-CONTEXT.md`), content);
+}
+
+function writeContextDraft(base: string, mid: string, content: string): void {
+  writeMilestoneDir(base, mid);
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-CONTEXT-DRAFT.md`), content);
+}
+
+function writeRoadmap(base: string, mid: string, content: string): void {
+  writeMilestoneDir(base, mid);
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`), content);
+}
+
+function readGuidedFlowSource(): string {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = dirname(thisFile);
+  return readFileSync(join(thisDir, "..", "guided-flow.ts"), "utf-8");
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("discuss-queued-milestones (#2307)", () => {
+
+  test("1. pending milestones appear in registry when active milestone exists", async () => {
+    const base = createBase();
+    try {
+      // M001: active — has context + roadmap with a slice
+      writeContext(base, "M001", "# M001: Active\nContext here.");
+      writeRoadmap(base, "M001",
+        "# M001: Active\n\n## Slices\n- [ ] **S01: Do work** `risk:low` `depends:[]`\n  > After this: works\n");
+
+      // M002: pending — context only, no roadmap
+      writeContext(base, "M002", "# M002: Queued\nFuture work.");
+
+      // M003: pending — draft context only
+      writeContextDraft(base, "M003", "# M003: Draft\nSeed material.");
+
+      invalidateAllCaches();
+      const state = await deriveState(base);
+
+      assert.ok(!!state.activeMilestone, "M001 should be the active milestone");
+      assert.strictEqual(state.activeMilestone?.id, "M001");
+
+      const pendingIds = state.registry
+        .filter(m => m.status === "pending")
+        .map(m => m.id);
+
+      assert.ok(pendingIds.includes("M002"), "M002 should be pending");
+      assert.ok(pendingIds.includes("M003"), "M003 should be pending");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("2. first context-only milestone is active, subsequent ones are pending", async () => {
+    const base = createBase();
+    try {
+      // M001: first milestone with context but no roadmap — deriveState marks it active
+      writeContext(base, "M001", "# M001: First\nContext here.");
+      // M002: will be pending since M001 is active
+      writeContext(base, "M002", "# M002: Second\nMore future work.");
+
+      invalidateAllCaches();
+      const state = await deriveState(base);
+
+      // deriveState makes the first unfinished milestone "active" even without a roadmap
+      assert.ok(!!state.activeMilestone, "first milestone should be active");
+      assert.strictEqual(state.activeMilestone?.id, "M001", "M001 is the active milestone");
+
+      const pendingIds = state.registry
+        .filter(m => m.status === "pending")
+        .map(m => m.id);
+
+      assert.ok(pendingIds.includes("M002"),
+        "M002 should be pending — it comes after the active M001");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("3. resolveMilestoneFile finds CONTEXT.md for pending milestone", (t) => {
+    const base = createBase();
+    try {
+      writeContext(base, "M002", "# M002: Queued\nContent.");
+
+      const contextFile = resolveMilestoneFile(base, "M002", "CONTEXT");
+      assert.ok(contextFile !== null, "resolveMilestoneFile should find CONTEXT.md for M002");
+      assert.ok(contextFile!.endsWith("M002-CONTEXT.md"),
+        "resolved path should point to M002-CONTEXT.md");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("4. resolveMilestoneFile finds CONTEXT-DRAFT.md for pending milestone", (t) => {
+    const base = createBase();
+    try {
+      writeContextDraft(base, "M003", "# M003: Draft\nSeed content.");
+
+      const draftFile = resolveMilestoneFile(base, "M003", "CONTEXT-DRAFT");
+      assert.ok(draftFile !== null, "resolveMilestoneFile should find CONTEXT-DRAFT.md for M003");
+      assert.ok(draftFile!.endsWith("M003-CONTEXT-DRAFT.md"),
+        "resolved path should point to M003-CONTEXT-DRAFT.md");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("5. resolveMilestoneFile returns null when pending milestone has no context", (t) => {
+    const base = createBase();
+    try {
+      writeMilestoneDir(base, "M004");
+
+      const contextFile = resolveMilestoneFile(base, "M004", "CONTEXT");
+      assert.strictEqual(contextFile, null,
+        "resolveMilestoneFile should return null when no CONTEXT.md exists");
+
+      const draftFile = resolveMilestoneFile(base, "M004", "CONTEXT-DRAFT");
+      assert.strictEqual(draftFile, null,
+        "resolveMilestoneFile should return null when no CONTEXT-DRAFT.md exists");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test("6. guided-flow no longer hard-exits when no active milestone but pending exist", () => {
+    const source = readGuidedFlowSource();
+
+    // The old guard was a simple early-exit:
+    //   if (!state.activeMilestone) {
+    //     ctx.ui.notify("No active milestone. Run /gsd to create one first.", "warning");
+    //     return;
+    //   }
+    //
+    // The new guard should check for pending milestones and route instead.
+    const oldGuardPattern = /if\s*\(!state\.activeMilestone\)\s*\{\s*ctx\.ui\.notify\("No active milestone/;
+    assert.ok(
+      !oldGuardPattern.test(source),
+      "guided-flow must not unconditionally exit when activeMilestone is null",
+    );
+  });
+
+  test("7. showDiscussQueuedMilestone helper exists in guided-flow", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("showDiscussQueuedMilestone"),
+      "guided-flow must export showDiscussQueuedMilestone helper",
+    );
+  });
+
+  test("8. dispatchDiscussForMilestone helper exists in guided-flow", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("dispatchDiscussForMilestone"),
+      "guided-flow must export dispatchDiscussForMilestone helper",
+    );
+  });
+
+  test("9. dispatchDiscussForMilestone does not set pendingAutoStart", () => {
+    const source = readGuidedFlowSource();
+
+    // Extract the dispatchDiscussForMilestone function body
+    const fnMatch = source.match(
+      /async function dispatchDiscussForMilestone\s*\([^)]*\)[^{]*\{([\s\S]*?)\n\}/,
+    );
+    assert.ok(!!fnMatch, "dispatchDiscussForMilestone function body must be present");
+
+    if (fnMatch) {
+      assert.ok(
+        !fnMatch[1].includes("pendingAutoStart"),
+        "dispatchDiscussForMilestone must NOT set pendingAutoStart — discussing a queued milestone must not activate it",
+      );
+    }
+  });
+
+  test("10. slice picker includes queued milestone option when pending milestones exist", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("discuss_queued_milestone"),
+      "slice picker must include a 'discuss_queued_milestone' action id for queued milestones",
+    );
+    assert.ok(
+      source.includes("Discuss a queued milestone"),
+      "slice picker must label the queued milestone action clearly",
+    );
+  });
+
+  test("11. queued milestone picker labels entries with [queued]", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("[queued]"),
+      "queued milestone picker must label entries with [queued] to distinguish from active",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/feature-branch-lifecycle-integration.test.ts

@@ -252,7 +252,7 @@ describe('feature-branch-lifecycle-integration', async () => {
       // Exactly one new commit on feature branch (the squash merge)
       const featureLog = run(`git log --oneline ${featureBranch}`, repo);
       assert.ok(
-        featureLog.includes(`feat(${milestoneId})`),
+        featureLog.includes("feat:"),
         "feature branch has milestone merge commit",
       );
 

package/src/resources/extensions/gsd/tests/forensics-error-filter.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Regression test for #2539: extractTrace should not count benign bash
+ * exit-code-1 (grep no-match) or user skips as errors.
+ */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { extractTrace } from "../session-forensics.ts";
+
+/**
+ * Build a minimal JSONL entry pair: assistant tool_use → toolResult.
+ * This is the shape extractTrace() expects from session activity files.
+ */
+function makeToolPair(
+  toolName: string,
+  input: Record<string, unknown>,
+  resultText: string,
+  isError: boolean,
+): unknown[] {
+  const toolCallId = `toolu_${Math.random().toString(36).slice(2, 10)}`;
+  return [
+    {
+      type: "message",
+      message: {
+        role: "assistant",
+        content: [
+          {
+            type: "toolCall",
+            id: toolCallId,
+            name: toolName,
+            arguments: input,
+          },
+        ],
+      },
+    },
+    {
+      type: "message",
+      message: {
+        role: "toolResult",
+        toolCallId,
+        toolName,
+        isError,
+        content: [{ type: "text", text: resultText }],
+      },
+    },
+  ];
+}
+
+describe("extractTrace error filtering (#2539)", () => {
+  test("grep exit-code-1 (no matches) is not counted as an error", () => {
+    const entries = makeToolPair(
+      "bash",
+      { command: "grep -rn 'nonexistent' src/" },
+      "(no output)\nCommand exited with code 1",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 0, "grep no-match should not be an error");
+  });
+
+  test("user skip is not counted as an error", () => {
+    const entries = makeToolPair(
+      "bash",
+      { command: "npm run test" },
+      "Skipped due to queued user message",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 0, "user skip should not be an error");
+  });
+
+  test("real bash error is still counted", () => {
+    const entries = makeToolPair(
+      "bash",
+      { command: "cat /nonexistent" },
+      "cat: /nonexistent: No such file or directory\nCommand exited with code 1",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 1, "real error should still be counted");
+    assert.match(trace.errors[0], /No such file or directory/);
+  });
+
+  test("non-bash tool error is still counted", () => {
+    const entries = makeToolPair(
+      "edit",
+      { path: "foo.ts", oldText: "x", newText: "y" },
+      "oldText not found in file",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 1, "non-bash tool errors should still be counted");
+  });
+
+  test("mixed entries: only real errors are counted", () => {
+    const entries = [
+      // benign grep no-match
+      ...makeToolPair("bash", { command: "grep -rn 'pattern' src/" }, "(no output)\nCommand exited with code 1", true),
+      // user skip
+      ...makeToolPair("bash", { command: "npm test" }, "Skipped due to queued user message", true),
+      // real error
+      ...makeToolPair("bash", { command: "node broken.js" }, "SyntaxError: Unexpected token\nCommand exited with code 1", true),
+      // successful command (not an error)
+      ...makeToolPair("bash", { command: "echo hello" }, "hello", false),
+    ];
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 1, "only the real error should be counted");
+    assert.match(trace.errors[0], /SyntaxError/);
+  });
+
+  test("exit code 1 with actual output is still an error", () => {
+    const entries = makeToolPair(
+      "bash",
+      { command: "npm run lint" },
+      "src/foo.ts:10:5 - error TS2304: Cannot find name 'x'\nCommand exited with code 1",
+      true,
+    );
+    const trace = extractTrace(entries);
+    assert.equal(trace.errors.length, 1, "lint error with output should be counted");
+  });
+});

package/src/resources/extensions/gsd/tests/forensics-journal.test.ts

@@ -0,0 +1,162 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+describe("forensics journal & activity log awareness", () => {
+  const forensicsSrc = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+  const promptSrc = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
+
+  it("scanJournalForForensics reads journal files directly (no full queryJournal load)", () => {
+    // Must NOT use queryJournal which loads ALL entries into memory
+    assert.ok(
+      !forensicsSrc.includes('queryJournal('),
+      "forensics.ts must NOT call queryJournal() which loads all entries at once",
+    );
+    // Must have its own journal scanning with file-level limits
+    assert.ok(
+      forensicsSrc.includes("scanJournalForForensics"),
+      "forensics.ts must have scanJournalForForensics function",
+    );
+  });
+
+  it("journal scanning limits files parsed to avoid memory bloat", () => {
+    assert.ok(
+      forensicsSrc.includes("MAX_JOURNAL_RECENT_FILES"),
+      "must have MAX_JOURNAL_RECENT_FILES constant to limit parsed files",
+    );
+    assert.ok(
+      forensicsSrc.includes("MAX_JOURNAL_RECENT_EVENTS"),
+      "must have MAX_JOURNAL_RECENT_EVENTS constant to limit events extracted",
+    );
+  });
+
+  it("older journal files are line-counted without full JSON parse", () => {
+    assert.ok(
+      forensicsSrc.includes("olderEntryCount") || forensicsSrc.includes("olderFiles"),
+      "must handle older files separately from recent files",
+    );
+  });
+
+  it("ForensicReport includes journalSummary field", () => {
+    assert.ok(
+      forensicsSrc.includes("journalSummary"),
+      "ForensicReport must include journalSummary field",
+    );
+  });
+
+  it("ForensicReport includes activityLogMeta field", () => {
+    assert.ok(
+      forensicsSrc.includes("activityLogMeta"),
+      "ForensicReport must include activityLogMeta field",
+    );
+  });
+
+  it("buildForensicReport calls scanJournalForForensics", () => {
+    assert.ok(
+      forensicsSrc.includes("scanJournalForForensics"),
+      "buildForensicReport must call scanJournalForForensics",
+    );
+  });
+
+  it("buildForensicReport calls gatherActivityLogMeta", () => {
+    assert.ok(
+      forensicsSrc.includes("gatherActivityLogMeta"),
+      "buildForensicReport must call gatherActivityLogMeta",
+    );
+  });
+
+  it("forensics detects journal-based anomalies", () => {
+    assert.ok(
+      forensicsSrc.includes("detectJournalAnomalies"),
+      "forensics.ts must have detectJournalAnomalies function",
+    );
+    // Check for specific journal anomaly types
+    assert.ok(forensicsSrc.includes('"journal-stuck"'), "must detect journal-stuck anomalies");
+    assert.ok(forensicsSrc.includes('"journal-guard-block"'), "must detect journal-guard-block anomalies");
+    assert.ok(forensicsSrc.includes('"journal-rapid-iterations"'), "must detect journal-rapid-iterations anomalies");
+    assert.ok(forensicsSrc.includes('"journal-worktree-failure"'), "must detect journal-worktree-failure anomalies");
+  });
+
+  it("formatReportForPrompt includes journal summary section", () => {
+    assert.ok(
+      forensicsSrc.includes("Journal Summary"),
+      "prompt formatter must include a Journal Summary section",
+    );
+  });
+
+  it("formatReportForPrompt includes activity log overview section", () => {
+    assert.ok(
+      forensicsSrc.includes("Activity Log Overview"),
+      "prompt formatter must include an Activity Log Overview section",
+    );
+  });
+
+  it("activity log scanning uses tail-read with byte cap (not full file load)", () => {
+    // scanActivityLogs uses nativeParseJsonlTail + MAX_JSONL_BYTES for efficient reading
+    assert.ok(
+      forensicsSrc.includes("nativeParseJsonlTail"),
+      "activity log scanning must use nativeParseJsonlTail for tail-reading",
+    );
+    assert.ok(
+      forensicsSrc.includes("MAX_JSONL_BYTES"),
+      "activity log scanning must respect MAX_JSONL_BYTES cap",
+    );
+    // Only reads last 5 files
+    assert.ok(
+      forensicsSrc.includes("slice(-5)"),
+      "activity log scanning must limit to last 5 files",
+    );
+  });
+
+  it("activity log entries are distilled through extractTrace, not sent raw", () => {
+    assert.ok(
+      forensicsSrc.includes("extractTrace("),
+      "activity log entries must be distilled through extractTrace before reporting",
+    );
+  });
+
+  it("prompt output is hard-capped at 30KB", () => {
+    assert.ok(
+      forensicsSrc.includes("MAX_BYTES") && forensicsSrc.includes("30 * 1024"),
+      "formatReportForPrompt must have a 30KB hard cap",
+    );
+    assert.ok(
+      forensicsSrc.includes("truncated at 30KB"),
+      "prompt must show truncation message when capped",
+    );
+  });
+
+  it("forensics prompt documents journal format", () => {
+    assert.ok(
+      promptSrc.includes("### Journal Format"),
+      "forensics.md must document the journal format",
+    );
+    assert.ok(
+      promptSrc.includes("flowId"),
+      "forensics.md must reference flowId concept",
+    );
+    assert.ok(
+      promptSrc.includes("causedBy"),
+      "forensics.md must reference causedBy for causal chains",
+    );
+  });
+
+  it("forensics prompt includes journal directory in runtime path reference", () => {
+    assert.ok(
+      promptSrc.includes("journal/"),
+      "forensics.md runtime path reference must include journal/",
+    );
+  });
+
+  it("investigation protocol references journal data", () => {
+    assert.ok(
+      promptSrc.includes("journal timeline") || promptSrc.includes("journal events"),
+      "investigation protocol must reference journal data for tracing",
+    );
+  });
+});