gsd-pi 2.49.0 → 2.50.0-dev.d210a87

package/src/resources/extensions/gsd/tests/retry-diagnostic-reasoning.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Regression tests for #2195: formatTraceSummary (used by getDeepDiagnostic →
+ * retry prompts) must NOT include lastReasoning from prior assistant text.
+ *
+ * Including prior assistant free-text in retry diagnostics causes hallucination
+ * loops when the previous turn was truncated or malformed.
+ *
+ * The crash recovery path (formatCrashRecoveryBriefing) has its own safe handling
+ * of lastReasoning and is NOT affected by this change.
+ */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync, mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { extractTrace, getDeepDiagnostic } from "../session-forensics.ts";
+
+/** Build a minimal assistant text reasoning entry. */
+function makeAssistantText(text: string): unknown {
+  return {
+    type: "message",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text }],
+    },
+  };
+}
+
+/** Build a minimal assistant tool call + tool result pair. */
+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("retry diagnostic excludes lastReasoning (#2195)", () => {
+  test("extractTrace still captures lastReasoning in the trace object", () => {
+    const entries = [
+      makeAssistantText("I am going to write the summary file now"),
+      ...makeToolPair("write", { path: "/tmp/SUMMARY.md" }, "ok", false),
+      makeAssistantText("The task is complete — all files written."),
+    ];
+
+    const trace = extractTrace(entries);
+    // extractTrace should still collect lastReasoning for crash recovery
+    assert.ok(trace.lastReasoning.length > 0,
+      "extractTrace should still populate lastReasoning");
+    assert.ok(trace.lastReasoning.includes("all files written"),
+      "lastReasoning should contain the last assistant text");
+  });
+
+  test("getDeepDiagnostic output does NOT contain lastReasoning", () => {
+    // Create a temporary activity directory with a JSONL file
+    const tempBase = mkdtempSync(join(tmpdir(), "gsd-diag-test-"));
+    const gsdDir = join(tempBase, ".gsd");
+    const activityDir = join(gsdDir, "activity");
+    mkdirSync(activityDir, { recursive: true });
+
+    try {
+      // Build entries with both tool calls and assistant reasoning
+      const entries = [
+        makeAssistantText("Let me analyze the codebase structure first"),
+        ...makeToolPair("bash", { command: "ls src/" }, "index.ts\nutils.ts", false),
+        makeAssistantText("I see the milestone/M001 branch has a significantly different ... 3. "),
+      ];
+
+      // Write JSONL activity file
+      const jsonl = entries.map(e => JSON.stringify(e)).join("\n");
+      writeFileSync(join(activityDir, "2025-01-01T00-00-00.jsonl"), jsonl);
+
+      const diagnostic = getDeepDiagnostic(tempBase);
+
+      // Diagnostic should exist (we have tool calls)
+      assert.ok(diagnostic !== null, "diagnostic should not be null");
+
+      // Diagnostic should contain structured execution evidence
+      assert.ok(diagnostic!.includes("Tool calls completed:"),
+        "should include tool call count");
+      assert.ok(diagnostic!.includes("ls src/"),
+        "should include commands run");
+
+      // Diagnostic must NOT contain the assistant's free-text reasoning
+      assert.ok(!diagnostic!.includes("Last reasoning"),
+        "diagnostic must not include 'Last reasoning' label");
+      assert.ok(!diagnostic!.includes("analyze the codebase"),
+        "diagnostic must not include prior assistant text");
+      assert.ok(!diagnostic!.includes("significantly different"),
+        "diagnostic must not include truncated assistant reasoning");
+    } finally {
+      rmSync(tempBase, { recursive: true, force: true });
+    }
+  });
+
+  test("getDeepDiagnostic still includes errors and file operations", () => {
+    const tempBase = mkdtempSync(join(tmpdir(), "gsd-diag-test-"));
+    const gsdDir = join(tempBase, ".gsd");
+    const activityDir = join(gsdDir, "activity");
+    mkdirSync(activityDir, { recursive: true });
+
+    try {
+      const entries = [
+        makeAssistantText("Writing the plan file"),
+        ...makeToolPair("write", { path: "M001/S01/S01-PLAN.md" }, "ok", false),
+        ...makeToolPair("bash", { command: "npm run build" }, "Error: type mismatch", true),
+        makeAssistantText("The build failed, let me investigate"),
+      ];
+
+      const jsonl = entries.map(e => JSON.stringify(e)).join("\n");
+      writeFileSync(join(activityDir, "2025-01-01T00-00-00.jsonl"), jsonl);
+
+      const diagnostic = getDeepDiagnostic(tempBase);
+      assert.ok(diagnostic !== null);
+
+      // Structured evidence should be present
+      assert.ok(diagnostic!.includes("S01-PLAN.md"),
+        "should include files written");
+      assert.ok(diagnostic!.includes("npm run build"),
+        "should include commands run");
+      assert.ok(diagnostic!.includes("type mismatch"),
+        "should include errors");
+
+      // But NOT the assistant's free-text
+      assert.ok(!diagnostic!.includes("Writing the plan"),
+        "must not include assistant reasoning");
+      assert.ok(!diagnostic!.includes("build failed"),
+        "must not include assistant reasoning about failures");
+    } finally {
+      rmSync(tempBase, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/retry-state-reset.test.ts

@@ -16,6 +16,7 @@ import {
   resolveHookArtifactPath,
 } from "../post-unit-hooks.ts";
 import { uncheckTaskInPlan } from "../undo.ts";
+import { parseUnitId } from "../unit-id.ts";
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
@@ -183,8 +184,7 @@ test('Full retry reset: all steps combined', () => {
       retryArtifact: "NEEDS-REWORK.md",
     };
 
-    const parts = trigger.unitId.split("/");
-    const [mid, sid, tid] = parts;
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(trigger.unitId);
 
     // Simulate completedUnits
     let completedUnits = [
@@ -264,11 +264,10 @@ test('Retry reset: idempotent when artifacts already missing', () => {
     };
 
     // These should not throw even with missing files
-    const parts = trigger.unitId.split("/");
-    const [mid, sid, tid] = parts;
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(trigger.unitId);
 
     // Uncheck — returns false because no PLAN file
-    const uncheckResult = uncheckTaskInPlan(base, mid, sid, tid);
+    const uncheckResult = uncheckTaskInPlan(base, mid, sid!, tid!);
     assert.ok(!uncheckResult, "uncheck returns false when no PLAN exists");
 
     // Summary does not exist — no crash

package/src/resources/extensions/gsd/tests/rewrite-count-persist.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Regression tests for #2203: rewrite-docs circuit breaker must persist
+ * across session restarts.
+ *
+ * The rewrite attempt counter was stored in-memory on the session object,
+ * resetting to 0 on every session restart. This allowed the rewrite-docs
+ * dispatch rule to fire indefinitely, never tripping the MAX_REWRITE_ATTEMPTS
+ * circuit breaker.
+ *
+ * The fix persists the counter to `.gsd/runtime/rewrite-count.json`.
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, existsSync, readFileSync, writeFileSync, rmSync, mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { getRewriteCount, setRewriteCount } from "../auto-dispatch.ts";
+
+describe("rewrite-docs circuit breaker persistence (#2203)", () => {
+  let tempBase: string;
+
+  beforeEach(() => {
+    tempBase = mkdtempSync(join(tmpdir(), "gsd-rewrite-test-"));
+    // Create .gsd/ directory so gsdRoot resolves to it
+    mkdirSync(join(tempBase, ".gsd", "runtime"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempBase, { recursive: true, force: true });
+  });
+
+  test("getRewriteCount returns 0 when no file exists", () => {
+    const count = getRewriteCount(tempBase);
+    assert.equal(count, 0);
+  });
+
+  test("setRewriteCount writes and getRewriteCount reads back", () => {
+    setRewriteCount(tempBase, 2);
+    const count = getRewriteCount(tempBase);
+    assert.equal(count, 2);
+  });
+
+  test("counter persists across simulated session restarts", () => {
+    // Session 1: increment to 1
+    setRewriteCount(tempBase, 1);
+
+    // "Session restart" — only the disk file survives, session object is gone
+    const countAfterRestart = getRewriteCount(tempBase);
+    assert.equal(countAfterRestart, 1, "counter should survive session restart");
+
+    // Session 2: increment to 2
+    setRewriteCount(tempBase, countAfterRestart + 1);
+    assert.equal(getRewriteCount(tempBase), 2);
+  });
+
+  test("setRewriteCount(0) resets the counter", () => {
+    setRewriteCount(tempBase, 3);
+    assert.equal(getRewriteCount(tempBase), 3);
+
+    setRewriteCount(tempBase, 0);
+    assert.equal(getRewriteCount(tempBase), 0);
+  });
+
+  test("getRewriteCount handles corrupt JSON gracefully", () => {
+    const filePath = join(tempBase, ".gsd", "runtime", "rewrite-count.json");
+    // writeFileSync is imported at the top of this file
+    writeFileSync(filePath, "not json{{{");
+    const count = getRewriteCount(tempBase);
+    assert.equal(count, 0, "corrupt file should return 0");
+  });
+
+  test("rewrite-count.json is written to .gsd/runtime/", () => {
+    setRewriteCount(tempBase, 1);
+    const filePath = join(tempBase, ".gsd", "runtime", "rewrite-count.json");
+    assert.ok(existsSync(filePath), "rewrite-count.json should exist");
+
+    const content = JSON.parse(readFileSync(filePath, "utf-8"));
+    assert.equal(content.count, 1);
+    assert.ok(content.updatedAt, "should include timestamp");
+  });
+});

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -236,6 +236,32 @@ test("parseRoadmapSlices: ## Slices with valid checkboxes does NOT invoke prose
   assert.equal(slices[0]?.done, true);
 });
 
+// ── Regression test for #1940 ───────────────────────────────────────────────
+// '## Slice Roadmap' header is not recognized by extractSlicesSection, causing
+// checkbox-format slices to be missed and all slices reported as incomplete.
+
+test("parseRoadmapSlices: ## Slice Roadmap heading recognized (#1940)", () => {
+  const roadmapContent = [
+    "# M002: Current Milestone", "",
+    "**Vision:** Ship it.", "",
+    "## Slice Roadmap", "",
+    "- [x] **S01: Foundation** `risk:low` `depends:[]`",
+    "  > After this: base layer works.",
+    "- [x] **S02: Core Logic** `risk:medium` `depends:[S01]`",
+    "- [ ] **S03: Polish** `risk:low` `depends:[S01,S02]`", "",
+    "## Boundary Map",
+  ].join("\n");
+  const slices = parseRoadmapSlices(roadmapContent);
+  assert.equal(slices.length, 3, "should parse 3 slices under '## Slice Roadmap'");
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true, "S01 should be marked done");
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, true, "S02 should be marked done");
+  assert.equal(slices[2]?.id, "S03");
+  assert.equal(slices[2]?.done, false, "S03 should be pending");
+  assert.deepEqual(slices[2]?.depends, ["S01", "S02"]);
+});
+
 test("parseRoadmapSlices: ## Slices with only non-matching lines returns prose fallback results", () => {
   const weirdContent = `# M020: Odd
 

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -171,7 +171,7 @@ test('(k) run-uat prompt template', () => {
   const milestoneId = 'M001';
   const sliceId = 'S01';
   const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
-  const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
+  const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
   const uatType = 'live-runtime';
   const inlinedContext = '<!-- no context -->';
   let promptResult: string | undefined;
@@ -234,7 +234,7 @@ test('(k2) run-uat prompt references gsd_summary_save, not direct write', () =>
     milestoneId: 'M001',
     sliceId: 'S01',
     uatPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
-    uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md',
+    uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
     uatType: 'artifact-driven',
     inlinedContext: '<!-- no context -->',
   });
@@ -265,14 +265,13 @@ test('(l) dispatch preconditions via resolveSliceFile', () => {
         'resolveSliceFile(..., "UAT") returns non-null when UAT file exists (dispatch trigger state)',
       );
 
-      const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
-      assert.deepStrictEqual(
-        uatResultFilePath,
-        null,
-        'resolveSliceFile(..., "UAT-RESULT") returns null when result file missing (dispatch trigger state)',
+      // UAT spec without a verdict line means UAT has not been run yet
+      const rawContent = readFileSync(uatFilePath!, 'utf-8');
+      assert.ok(
+        !/verdict:\s*[\w-]+/i.test(rawContent),
+        'UAT file without verdict indicates UAT has not been run (dispatch trigger state)',
       );
 
-      const rawContent = readFileSync(uatFilePath!, 'utf-8');
       assert.deepStrictEqual(
         extractUatType(rawContent),
         'artifact-driven',
@@ -286,13 +285,18 @@ test('(l) dispatch preconditions via resolveSliceFile', () => {
 test('test block at line 307', () => {
     const base = createFixtureBase();
     try {
-      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
-      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '# UAT Result\n\nverdict: PASS\n');
+      // Write UAT file with a verdict — simulates completed UAT
+      writeSliceFile(base, 'M001', 'S01', 'UAT', '# UAT Result\n\nverdict: PASS\n');
 
-      const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
+      const uatFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT');
       assert.ok(
-        uatResultFilePath !== null,
-        'resolveSliceFile(..., "UAT-RESULT") returns non-null when result file exists (idempotent skip state)',
+        uatFilePath !== null,
+        'resolveSliceFile(..., "UAT") returns non-null when UAT file exists',
+      );
+      const content = readFileSync(uatFilePath!, 'utf-8');
+      assert.ok(
+        /verdict:\s*[\w-]+/i.test(content),
+        'UAT file with verdict indicates UAT has been completed (idempotent skip state)',
       );
     } finally {
       cleanup(base);
@@ -390,7 +394,7 @@ test('(p) run-uat prompt allows PASS when human-only checks remain as NEEDS-HUMA
       milestoneId: 'M001',
       sliceId: 'S01',
       uatPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
-      uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md',
+      uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
       uatType: 'mixed',
       inlinedContext: '<!-- no context -->',
     });
@@ -432,7 +436,7 @@ test('(n) stale replay guard', async () => {
       );
 
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
-      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '---\nverdict: FAIL\n---\n');
+      writeSliceFile(base, 'M001', 'S01', 'UAT', '---\nverdict: FAIL\n---\n');
 
       const state = {
         activeMilestone: { id: 'M001', title: 'Test roadmap' },
@@ -449,7 +453,153 @@ test('(n) stale replay guard', async () => {
       assert.deepStrictEqual(
         result,
         null,
-        'existing UAT-RESULT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
+        'existing UAT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
+      );
+    } finally {
+      cleanup(base);
+    }
+});
+
+test('(q) verdict in ASSESSMENT file skips UAT dispatch (file-based path)', async () => {
+    // Regression test for #2644: run-uat prompt writes the verdict to
+    // S{sid}-ASSESSMENT.md (via gsd_summary_save artifact_type:"ASSESSMENT"),
+    // but checkNeedsRunUat only checked S{sid}-UAT.md — causing a stuck loop.
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M001-ROADMAP.md'),
+        [
+          '# M001: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: First slice** `risk:low` `depends:[]`',
+          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+
+      // UAT spec file WITHOUT a verdict (the spec never gets one)
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
+      // ASSESSMENT file WITH a verdict (where run-uat actually writes it)
+      writeSliceFile(base, 'M001', 'S01', 'ASSESSMENT', '---\nverdict: PASS\n---\n# UAT Assessment\n');
+
+      const state = {
+        activeMilestone: { id: 'M001', title: 'Test roadmap' },
+        activeSlice: { id: 'S02', title: 'Next slice' },
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Plan S02',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
+      assert.deepStrictEqual(
+        result,
+        null,
+        'verdict in ASSESSMENT file should prevent re-dispatch of run-uat',
+      );
+    } finally {
+      cleanup(base);
+    }
+});
+
+test('(r) no ASSESSMENT file still dispatches UAT (no false skip)', async () => {
+    // Guard: when there is no ASSESSMENT file at all, UAT should still dispatch
+    // normally. The ASSESSMENT check must not cause a false-negative skip.
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M001-ROADMAP.md'),
+        [
+          '# M001: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: First slice** `risk:low` `depends:[]`',
+          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+
+      // UAT spec file WITHOUT a verdict, and NO ASSESSMENT file
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
+
+      const state = {
+        activeMilestone: { id: 'M001', title: 'Test roadmap' },
+        activeSlice: { id: 'S02', title: 'Next slice' },
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Plan S02',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
+      assert.deepStrictEqual(
+        result,
+        { sliceId: 'S01', uatType: 'artifact-driven' },
+        'without ASSESSMENT file, UAT still dispatches normally',
+      );
+    } finally {
+      cleanup(base);
+    }
+});
+
+test('(s) ASSESSMENT without verdict does not skip UAT dispatch', async () => {
+    // Guard: an ASSESSMENT file that exists but has no verdict line should
+    // NOT suppress UAT dispatch — only a file with an actual verdict should.
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M001-ROADMAP.md'),
+        [
+          '# M001: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: First slice** `risk:low` `depends:[]`',
+          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+
+      // UAT spec WITHOUT verdict
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
+      // ASSESSMENT file WITHOUT verdict (partial/incomplete assessment)
+      writeSliceFile(base, 'M001', 'S01', 'ASSESSMENT', '# UAT Assessment\n\nStill running checks...\n');
+
+      const state = {
+        activeMilestone: { id: 'M001', title: 'Test roadmap' },
+        activeSlice: { id: 'S02', title: 'Next slice' },
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Plan S02',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
+      assert.deepStrictEqual(
+        result,
+        { sliceId: 'S01', uatType: 'artifact-driven' },
+        'ASSESSMENT without verdict should not suppress UAT dispatch',
       );
     } finally {
       cleanup(base);