gsd-pi 2.58.0-dev.d63175c → 2.58.0-dev.e002a57

package/src/resources/extensions/gsd/tests/queue-execution-guard.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Unit tests for the queue-mode execution guard (#2545).
+ *
+ * When queue phase is active, the agent should only create milestones —
+ * not execute work. This guard blocks write/edit/bash tool calls that
+ * target source code (non-.gsd/ paths) during queue mode.
+ *
+ * Exercises shouldBlockQueueExecution() — a pure function that checks:
+ *   (a) queuePhaseActive false → pass (not in queue mode)
+ *   (b) toolName is read-only (read, grep, find, ls) → pass
+ *   (c) toolName is ask_user_questions → pass (discussion tool)
+ *   (d) write/edit to .gsd/ path → pass (planning artifacts)
+ *   (e) write/edit to source path → block
+ *   (f) bash command → block (could execute work)
+ *   (g) registered GSD tools (gsd_milestone_generate_id, gsd_summary_save) → pass
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { shouldBlockQueueExecution } from '../bootstrap/write-gate.ts';
+
+// ─── Scenario 1: Not in queue mode — all tools pass ──
+
+test('queue-guard: allows all tools when queue phase is not active', () => {
+  const r1 = shouldBlockQueueExecution('write', '/src/index.ts', false);
+  assert.strictEqual(r1.block, false, 'write should pass outside queue mode');
+
+  const r2 = shouldBlockQueueExecution('bash', 'npm test', false);
+  assert.strictEqual(r2.block, false, 'bash should pass outside queue mode');
+
+  const r3 = shouldBlockQueueExecution('edit', '/src/index.ts', false);
+  assert.strictEqual(r3.block, false, 'edit should pass outside queue mode');
+});
+
+// ─── Scenario 2: Read-only tools always pass in queue mode ──
+
+test('queue-guard: allows read-only tools during queue mode', () => {
+  for (const tool of ['read', 'grep', 'find', 'ls', 'glob']) {
+    const result = shouldBlockQueueExecution(tool, '/src/index.ts', true);
+    assert.strictEqual(result.block, false, `${tool} should pass in queue mode`);
+  }
+});
+
+// ─── Scenario 3: Discussion/planning tools pass in queue mode ──
+
+test('queue-guard: allows discussion and planning tools during queue mode', () => {
+  const r1 = shouldBlockQueueExecution('ask_user_questions', '', true);
+  assert.strictEqual(r1.block, false, 'ask_user_questions should pass');
+
+  const r2 = shouldBlockQueueExecution('gsd_milestone_generate_id', '', true);
+  assert.strictEqual(r2.block, false, 'gsd_milestone_generate_id should pass');
+
+  const r3 = shouldBlockQueueExecution('gsd_summary_save', '', true);
+  assert.strictEqual(r3.block, false, 'gsd_summary_save should pass');
+});
+
+// ─── Scenario 4: Write to .gsd/ paths passes (planning artifacts) ──
+
+test('queue-guard: allows writes to .gsd/ paths during queue mode', () => {
+  const r1 = shouldBlockQueueExecution('write', '.gsd/milestones/M001/M001-CONTEXT.md', true);
+  assert.strictEqual(r1.block, false, 'write to .gsd/ should pass');
+
+  const r2 = shouldBlockQueueExecution('write', '/project/.gsd/PROJECT.md', true);
+  assert.strictEqual(r2.block, false, 'write to .gsd/PROJECT.md should pass');
+
+  const r3 = shouldBlockQueueExecution('edit', '.gsd/QUEUE.md', true);
+  assert.strictEqual(r3.block, false, 'edit to .gsd/QUEUE.md should pass');
+
+  const r4 = shouldBlockQueueExecution('write', '.gsd/REQUIREMENTS.md', true);
+  assert.strictEqual(r4.block, false, 'write to .gsd/REQUIREMENTS.md should pass');
+
+  const r5 = shouldBlockQueueExecution('write', '.gsd/DECISIONS.md', true);
+  assert.strictEqual(r5.block, false, 'write to .gsd/DECISIONS.md should pass');
+});
+
+// ─── Scenario 5: Write/edit to source code paths blocked ──
+
+test('queue-guard: blocks writes to source code during queue mode', () => {
+  const r1 = shouldBlockQueueExecution('write', 'src/index.ts', true);
+  assert.strictEqual(r1.block, true, 'write to src/ should be blocked');
+  assert.ok(r1.reason, 'should provide a reason');
+  assert.ok(r1.reason!.includes('queue'), 'reason should mention queue');
+
+  const r2 = shouldBlockQueueExecution('write', '/project/src/components/App.tsx', true);
+  assert.strictEqual(r2.block, true, 'write to component file should be blocked');
+
+  const r3 = shouldBlockQueueExecution('edit', 'package.json', true);
+  assert.strictEqual(r3.block, true, 'edit to package.json should be blocked');
+
+  const r4 = shouldBlockQueueExecution('edit', '/project/lib/utils.ts', true);
+  assert.strictEqual(r4.block, true, 'edit to lib/ should be blocked');
+});
+
+// ─── Scenario 6: Bash commands blocked during queue mode ──
+
+test('queue-guard: blocks bash commands during queue mode', () => {
+  const r1 = shouldBlockQueueExecution('bash', 'npm install some-package', true);
+  assert.strictEqual(r1.block, true, 'npm install should be blocked');
+  assert.ok(r1.reason, 'should provide a reason');
+
+  const r2 = shouldBlockQueueExecution('bash', 'node src/index.ts', true);
+  assert.strictEqual(r2.block, true, 'running node should be blocked');
+});
+
+// ─── Scenario 7: Bash read-only commands pass during queue mode ──
+
+test('queue-guard: allows read-only bash commands during queue mode', () => {
+  const r1 = shouldBlockQueueExecution('bash', 'cat src/index.ts', true);
+  assert.strictEqual(r1.block, false, 'cat should pass');
+
+  const r2 = shouldBlockQueueExecution('bash', 'ls -la src/', true);
+  assert.strictEqual(r2.block, false, 'ls should pass');
+
+  const r3 = shouldBlockQueueExecution('bash', 'git log --oneline -10', true);
+  assert.strictEqual(r3.block, false, 'git log should pass');
+
+  const r4 = shouldBlockQueueExecution('bash', 'find . -name "*.ts"', true);
+  assert.strictEqual(r4.block, false, 'find should pass');
+
+  const r5 = shouldBlockQueueExecution('bash', 'grep -rn "TODO" src/', true);
+  assert.strictEqual(r5.block, false, 'grep should pass');
+
+  const r6 = shouldBlockQueueExecution('bash', 'head -20 src/index.ts', true);
+  assert.strictEqual(r6.block, false, 'head should pass');
+
+  const r7 = shouldBlockQueueExecution('bash', 'wc -l src/index.ts', true);
+  assert.strictEqual(r7.block, false, 'wc should pass');
+
+  const r8 = shouldBlockQueueExecution('bash', 'git diff HEAD~1', true);
+  assert.strictEqual(r8.block, false, 'git diff should pass');
+
+  const r9 = shouldBlockQueueExecution('bash', 'gh issue view 42', true);
+  assert.strictEqual(r9.block, false, 'gh issue view should pass');
+});
+
+// ─── Scenario 8: mkdir for .gsd/ milestone directories passes ──
+
+test('queue-guard: allows mkdir for .gsd/ milestone directories', () => {
+  const r1 = shouldBlockQueueExecution('bash', 'mkdir -p .gsd/milestones/M010/slices', true);
+  assert.strictEqual(r1.block, false, 'mkdir -p .gsd/ should pass');
+});
+
+// ─── Scenario 9: Web search and library tools pass ──
+
+test('queue-guard: allows web search and library tools during queue mode', () => {
+  const r1 = shouldBlockQueueExecution('search-the-web', '', true);
+  assert.strictEqual(r1.block, false, 'search-the-web should pass');
+
+  const r2 = shouldBlockQueueExecution('resolve_library', '', true);
+  assert.strictEqual(r2.block, false, 'resolve_library should pass');
+
+  const r3 = shouldBlockQueueExecution('get_library_docs', '', true);
+  assert.strictEqual(r3.block, false, 'get_library_docs should pass');
+
+  const r4 = shouldBlockQueueExecution('fetch_page', '', true);
+  assert.strictEqual(r4.block, false, 'fetch_page should pass');
+});

package/src/resources/extensions/gsd/tests/quick-turn-end-cleanup.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Tests that cleanupQuickBranch is called on turn_end to squash-merge the
+ * quick branch back to the original branch after the agent completes.
+ *
+ * Relates to #2668: /gsd quick does not squash-merge branch back after agent
+ * completes task. cleanupQuickBranch() exists but is never invoked.
+ *
+ * The fix registers a turn_end hook in register-hooks.ts that calls
+ * cleanupQuickBranch() after each turn, which is a no-op when no quick-task
+ * state is pending.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Structural test: verify turn_end hook exists in register-hooks.ts ──────
+
+describe("quick task turn_end cleanup (#2668)", () => {
+  const hooksSource = readFileSync(
+    join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),
+    "utf-8",
+  );
+
+  it("register-hooks.ts imports cleanupQuickBranch from quick.ts", () => {
+    assert.ok(
+      hooksSource.includes("cleanupQuickBranch"),
+      "register-hooks.ts must reference cleanupQuickBranch",
+    );
+
+    // Verify it's imported (not just mentioned in a comment)
+    const importMatch = hooksSource.match(
+      /import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/,
+    );
+    assert.ok(
+      importMatch,
+      "cleanupQuickBranch must be imported from quick module",
+    );
+  });
+
+  it("registers a turn_end handler that calls cleanupQuickBranch", () => {
+    // Find the turn_end registration
+    const turnEndMatch = hooksSource.match(
+      /pi\.on\(\s*["']turn_end["']/,
+    );
+    assert.ok(
+      turnEndMatch,
+      "register-hooks.ts must register a turn_end handler",
+    );
+
+    // Extract the turn_end handler body — find everything from the pi.on("turn_end"
+    // to the matching closing });
+    const turnEndIdx = hooksSource.indexOf(turnEndMatch[0]);
+    assert.ok(turnEndIdx !== -1);
+
+    // Get the rest of the source from that point
+    const rest = hooksSource.slice(turnEndIdx);
+
+    // The handler must call cleanupQuickBranch
+    // Look for cleanupQuickBranch within the first handler body (up to first `});`)
+    const handlerEnd = rest.indexOf("});");
+    assert.ok(handlerEnd !== -1, "turn_end handler has a closing });");
+
+    const handlerBody = rest.slice(0, handlerEnd);
+    assert.ok(
+      handlerBody.includes("cleanupQuickBranch"),
+      "turn_end handler must call cleanupQuickBranch",
+    );
+  });
+
+  it("turn_end handler calls cleanupQuickBranch without arguments (uses cwd default)", () => {
+    // cleanupQuickBranch(basePath = process.cwd()) — calling without args is correct
+    // because the handler runs in the same process where handleQuick set up cwd
+    const turnEndIdx = hooksSource.indexOf('pi.on("turn_end"') !== -1
+      ? hooksSource.indexOf('pi.on("turn_end"')
+      : hooksSource.indexOf("pi.on('turn_end'");
+    assert.ok(turnEndIdx !== -1);
+
+    const rest = hooksSource.slice(turnEndIdx);
+    const handlerEnd = rest.indexOf("});");
+    const handlerBody = rest.slice(0, handlerEnd);
+
+    // Should call cleanupQuickBranch() — either bare or with no-arg form
+    assert.ok(
+      handlerBody.includes("cleanupQuickBranch("),
+      "turn_end handler invokes cleanupQuickBranch()",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/reassess-handler.test.ts

@@ -9,6 +9,7 @@ import {
   closeDatabase,
   insertMilestone,
   insertSlice,
+  insertAssessment,
   getSlice,
   getMilestoneSlices,
   getAssessment,
@@ -323,3 +324,119 @@ test('handleReassessRoadmap returns structured error payloads with actionable me
     cleanup(base);
   }
 });
+
+// ─── Bug #2957: Stale VALIDATION survives roadmap remediation ────────────
+
+test('handleReassessRoadmap invalidates stale milestone-validation when roadmap changes (#2957)', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    // Seed: M001 with S01-S04 all complete, plus a stale VALIDATION with needs-remediation
+    insertMilestone({ id: 'M001', title: 'Test Milestone', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice One', status: 'complete', demo: 'Demo' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Slice Two', status: 'complete', demo: 'Demo' });
+    insertSlice({ id: 'S03', milestoneId: 'M001', title: 'Slice Three', status: 'complete', demo: 'Demo' });
+    insertSlice({ id: 'S04', milestoneId: 'M001', title: 'Slice Four', status: 'complete', demo: 'Demo' });
+
+    // Insert milestone-validation assessment with needs-remediation verdict (stale)
+    const validationPath = join('.gsd', 'milestones', 'M001', 'M001-VALIDATION.md');
+    insertAssessment({
+      path: validationPath,
+      milestoneId: 'M001',
+      sliceId: null,
+      taskId: null,
+      status: 'needs-remediation',
+      scope: 'milestone-validation',
+      fullContent: '---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation\nNeeds remediation.',
+    });
+
+    // Verify the validation row exists before reassess
+    const adapter = _getAdapter()!;
+    const before = adapter.prepare(
+      `SELECT * FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as Record<string, unknown> | undefined;
+    assert.ok(before, 'milestone-validation row should exist before reassess');
+
+    // Now reassess the roadmap: add remediation slice S05
+    // This simulates the scenario from #2957 where validation produced needs-remediation
+    // and then roadmap was reassessed to add a remediation slice
+    const result = await handleReassessRoadmap({
+      milestoneId: 'M001',
+      completedSliceId: 'S04',
+      verdict: 'on-track',
+      assessment: 'S04 completed. Adding remediation slice S05.',
+      sliceChanges: {
+        modified: [],
+        added: [
+          {
+            sliceId: 'S05',
+            title: 'Remediation Slice',
+            risk: 'low',
+            depends: ['S04'],
+            demo: 'Fix the issues found during validation.',
+          },
+        ],
+        removed: [],
+      },
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    // The stale milestone-validation row must be deleted after roadmap changes
+    const after = adapter.prepare(
+      `SELECT * FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as Record<string, unknown> | undefined;
+    assert.equal(after, undefined, 'milestone-validation row should be deleted after roadmap changes — stale validation must not survive remediation (#2957)');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap does NOT invalidate validation when no roadmap structural changes (#2957)', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    // Seed: M001 with slices, plus a validation with pass verdict
+    insertMilestone({ id: 'M001', title: 'Test Milestone', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice One', status: 'complete', demo: 'Demo' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Slice Two', status: 'pending', demo: 'Demo' });
+
+    // Insert milestone-validation assessment with pass verdict
+    const validationPath = join('.gsd', 'milestones', 'M001', 'M001-VALIDATION.md');
+    insertAssessment({
+      path: validationPath,
+      milestoneId: 'M001',
+      sliceId: null,
+      taskId: null,
+      status: 'pass',
+      scope: 'milestone-validation',
+      fullContent: '---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nAll good.',
+    });
+
+    // Reassess with no structural changes (empty added/modified/removed)
+    const result = await handleReassessRoadmap({
+      milestoneId: 'M001',
+      completedSliceId: 'S01',
+      verdict: 'confirmed',
+      assessment: 'S01 completed. No changes needed.',
+      sliceChanges: {
+        modified: [],
+        added: [],
+        removed: [],
+      },
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    // Validation should still exist when no structural changes occurred
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT * FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as Record<string, unknown> | undefined;
+    assert.ok(row, 'milestone-validation row should survive when no structural changes occurred');
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/reconciliation-edge-cases.test.ts

@@ -0,0 +1,162 @@
+// GSD State Machine Regression Tests — Event Replay & Reconciliation (#3161)
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { findForkPoint, readEvents, appendEvent } from "../workflow-events.ts";
+import type { WorkflowEvent } from "../workflow-events.ts";
+import { extractEntityKey, detectConflicts } from "../workflow-reconcile.ts";
+
+// ─── Helper: build a full WorkflowEvent from cmd + params ────────────────────
+
+function makeEvent(cmd: string, params: Record<string, unknown>, ts?: string): WorkflowEvent {
+  const hash = createHash("sha256")
+    .update(JSON.stringify({ cmd, params }))
+    .digest("hex")
+    .slice(0, 16);
+  return { cmd, params, ts: ts ?? new Date().toISOString(), hash, actor: "agent", session_id: "test-session" };
+}
+
+// ─── Temp dir management ─────────────────────────────────────────────────────
+
+const tempDirs: string[] = [];
+
+function tempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-recon-test-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+});
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("reconciliation-edge-cases", () => {
+
+  // findForkPoint
+  test("findForkPoint returns -1 for completely diverged logs", () => {
+    const eA = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
+    const eB = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T02" });
+
+    const logA: WorkflowEvent[] = [eA];
+    const logB: WorkflowEvent[] = [eB];
+
+    assert.equal(findForkPoint(logA, logB), -1, "completely diverged logs should return -1");
+  });
+
+  test("findForkPoint returns last index when one log is prefix of another", () => {
+    const e1 = makeEvent("start_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
+    const e2 = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
+    const e3 = makeEvent("complete_slice", { milestoneId: "M001", sliceId: "S01" });
+
+    const logA: WorkflowEvent[] = [e1, e2];
+    const logB: WorkflowEvent[] = [e1, e2, e3];
+
+    assert.equal(findForkPoint(logA, logB), 1, "prefix log should fork at last shared index");
+  });
+
+  test("findForkPoint returns -1 for empty logs", () => {
+    assert.equal(findForkPoint([], []), -1, "two empty logs should return -1");
+  });
+
+  // extractEntityKey
+  test("extractEntityKey returns null for malformed events (missing taskId)", () => {
+    const event = makeEvent("complete_task", {});
+    // params has no taskId — should return null rather than return a bad key
+    assert.equal(extractEntityKey(event), null, "missing taskId should yield null entity key");
+  });
+
+  test("extractEntityKey returns null for unknown commands", () => {
+    const event = makeEvent("future_cmd", { foo: "bar" });
+    assert.equal(extractEntityKey(event), null, "unknown command should yield null entity key");
+  });
+
+  test("plan_slice and complete_slice use different entity types", () => {
+    const planEvent = makeEvent("plan_slice", { sliceId: "S01" });
+    const completeEvent = makeEvent("complete_slice", { sliceId: "S01" });
+
+    const planKey = extractEntityKey(planEvent);
+    const completeKey = extractEntityKey(completeEvent);
+
+    assert.ok(planKey !== null, "plan_slice should produce an entity key");
+    assert.ok(completeKey !== null, "complete_slice should produce an entity key");
+    assert.equal(planKey!.type, "slice_plan", "plan_slice entity type should be 'slice_plan'");
+    assert.equal(completeKey!.type, "slice", "complete_slice entity type should be 'slice'");
+    assert.notEqual(
+      planKey!.type,
+      completeKey!.type,
+      "plan_slice and complete_slice must map to different entity types",
+    );
+  });
+
+  // detectConflicts
+  test("detectConflicts finds no conflicts when entities do not overlap", () => {
+    const mainDiverged: WorkflowEvent[] = [
+      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
+    ];
+    const wtDiverged: WorkflowEvent[] = [
+      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T02" }),
+    ];
+
+    const conflicts = detectConflicts(mainDiverged, wtDiverged);
+    assert.equal(conflicts.length, 0, "non-overlapping task edits should produce no conflicts");
+  });
+
+  test("detectConflicts flags conflict when both sides touch the same task", () => {
+    const mainDiverged: WorkflowEvent[] = [
+      makeEvent("start_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
+    ];
+    const wtDiverged: WorkflowEvent[] = [
+      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
+    ];
+
+    const conflicts = detectConflicts(mainDiverged, wtDiverged);
+    assert.equal(conflicts.length, 1, "same task touched by both sides should produce exactly one conflict");
+
+    const conflict = conflicts[0]!;
+    assert.equal(conflict.entityType, "task", "conflict entityType should be 'task'");
+    assert.equal(conflict.entityId, "T01", "conflict entityId should be 'T01'");
+  });
+
+  test("detectConflicts ignores events with null entity keys", () => {
+    // Events with unknown commands produce null keys and must not cause false conflicts.
+    const mainDiverged: WorkflowEvent[] = [
+      makeEvent("unknown_future_cmd", { milestoneId: "M001" }),
+    ];
+    const wtDiverged: WorkflowEvent[] = [
+      makeEvent("another_unknown_cmd", { milestoneId: "M001" }),
+    ];
+
+    const conflicts = detectConflicts(mainDiverged, wtDiverged);
+    assert.equal(conflicts.length, 0, "unknown commands with null entity keys should not produce conflicts");
+  });
+
+  // appendEvent — filesystem creation
+  test("appendEvent creates event log if directory does not exist", () => {
+    const base = tempDir();
+    // Remove the .gsd directory if it somehow exists — appendEvent should create it.
+    const gsdDir = path.join(base, ".gsd");
+    if (fs.existsSync(gsdDir)) fs.rmSync(gsdDir, { recursive: true, force: true });
+
+    appendEvent(base, {
+      cmd: "complete_task",
+      params: { milestoneId: "M001", sliceId: "S01", taskId: "T01" },
+      ts: new Date().toISOString(),
+      actor: "agent",
+    });
+
+    const logPath = path.join(base, ".gsd", "event-log.jsonl");
+    assert.ok(fs.existsSync(logPath), "event-log.jsonl should be created by appendEvent");
+
+    const events = readEvents(logPath);
+    assert.equal(events.length, 1, "event log should contain exactly one event");
+    assert.equal(events[0]!.cmd, "complete_task", "persisted event should have the correct cmd");
+  });
+});

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

@@ -296,3 +296,100 @@ Do the second thing.
   assert.equal(slices[0]?.id, "S01");
   assert.equal(slices[1]?.id, "S02");
 });
+
+// ── Regression tests for #2567 ─────────────────────────────────────────────
+// Prose H3 parser fails on common LLM-generated patterns: numbered prefixes,
+// parenthetical numbering, bracketed IDs, and indented headings.
+
+test("parseRoadmapSlices: numbered H3 headers under ## Slices (#2567)", () => {
+  const numberedContent = `# M002: My Milestone
+
+**Vision:** Ship the product.
+
+## Slices
+
+### 1. S01: Setup Environment
+Set up the dev environment and tooling.
+
+### 2. S02: Build Core
+Implement the core logic.
+**Depends on:** S01
+
+### 3. S03: Polish UI
+Final polish and theming.
+**Depends on:** S01, S02
+`;
+  const slices = parseRoadmapSlices(numberedContent);
+  assert.equal(slices.length, 3, "should parse 3 slices from numbered H3 headers");
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.title, "Setup Environment");
+  assert.equal(slices[1]?.id, "S02");
+  assert.deepEqual(slices[1]?.depends, ["S01"]);
+  assert.equal(slices[2]?.id, "S03");
+  assert.deepEqual(slices[2]?.depends, ["S01", "S02"]);
+});
+
+test("parseRoadmapSlices: parenthetical-numbered H3 headers (#2567)", () => {
+  const parenContent = `# M002: Milestone
+
+**Vision:** Ship.
+
+## Slices
+
+### (1) S01: Setup
+Setup work.
+
+### (2) S02: Build
+Build work.
+**Depends on:** S01
+`;
+  const slices = parseRoadmapSlices(parenContent);
+  assert.equal(slices.length, 2, "should parse slices with parenthetical numbering");
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.title, "Setup");
+  assert.equal(slices[1]?.id, "S02");
+  assert.deepEqual(slices[1]?.depends, ["S01"]);
+});
+
+test("parseRoadmapSlices: bracketed slice IDs in H3 headers (#2567)", () => {
+  const bracketContent = `# M002: Milestone
+
+**Vision:** Ship.
+
+## Slices
+
+### [S01] Setup Environment
+Setup work.
+
+### [S02] Build Core
+Build work.
+**Depends on:** S01
+`;
+  const slices = parseRoadmapSlices(bracketContent);
+  assert.equal(slices.length, 2, "should parse slices with bracketed IDs");
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.title, "Setup Environment");
+  assert.equal(slices[1]?.id, "S02");
+  assert.deepEqual(slices[1]?.depends, ["S01"]);
+});
+
+test("parseRoadmapSlices: indented H3 headers under ## Slices (#2567)", () => {
+  const indentedContent = `# M002: Milestone
+
+**Vision:** Ship.
+
+## Slices
+
+  ### S01: Setup
+  Setup work.
+
+  ### S02: Build
+  Build work.
+`;
+  const slices = parseRoadmapSlices(indentedContent);
+  assert.equal(slices.length, 2, "should parse slices from indented H3 headers");
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.title, "Setup");
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.title, "Build");
+});