gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1d17f366c

package/src/resources/extensions/gsd/tests/gsd-db.test.ts

@@ -99,7 +99,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 21, 'schema version should be 21');
+    assert.deepStrictEqual(version?.['version'], 22, 'schema version should be 22');
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();
@@ -469,6 +469,301 @@ describe('gsd-db', () => {
     cleanup(dbPath);
   });
 
+  test('gsd-db: pre-v18 DB with memory_sources missing scope opens without crash (issue #4607)', () => {
+    // Regression: initSchema() ran CREATE INDEX on memories.scope and
+    // memory_sources.scope unconditionally, before the v18 migration adds those
+    // columns to existing rows.  Databases at schema v17 that had a
+    // memory_sources table without the scope column crashed on open with
+    // "no such column: scope".
+    // The fix moves those index statements inside the v18 migration guard so
+    // they only execute after the column already exists.
+    const dbPath = tempDbPath();
+    const legacyDb = openRawSqliteForTest(dbPath);
+
+    // Build a realistic v17 schema: full table set that existed before v18,
+    // with memory_sources present but missing the scope column that v18 adds.
+    legacyDb.exec(`
+      CREATE TABLE schema_version (
+        version INTEGER NOT NULL,
+        applied_at TEXT NOT NULL
+      );
+      INSERT INTO schema_version(version, applied_at) VALUES (17, '2026-01-01T00:00:00.000Z');
+
+      CREATE TABLE decisions (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        id TEXT NOT NULL UNIQUE,
+        when_context TEXT NOT NULL DEFAULT '',
+        scope TEXT NOT NULL DEFAULT '',
+        decision TEXT NOT NULL DEFAULT '',
+        choice TEXT NOT NULL DEFAULT '',
+        rationale TEXT NOT NULL DEFAULT '',
+        revisable TEXT NOT NULL DEFAULT '',
+        made_by TEXT NOT NULL DEFAULT 'agent',
+        superseded_by TEXT DEFAULT NULL
+      );
+
+      CREATE TABLE requirements (
+        id TEXT PRIMARY KEY,
+        class TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT '',
+        description TEXT NOT NULL DEFAULT '',
+        why TEXT NOT NULL DEFAULT '',
+        source TEXT NOT NULL DEFAULT '',
+        primary_owner TEXT NOT NULL DEFAULT '',
+        supporting_slices TEXT NOT NULL DEFAULT '',
+        validation TEXT NOT NULL DEFAULT '',
+        notes TEXT NOT NULL DEFAULT '',
+        full_content TEXT NOT NULL DEFAULT '',
+        superseded_by TEXT DEFAULT NULL
+      );
+
+      CREATE TABLE memories (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        id TEXT NOT NULL UNIQUE,
+        category TEXT NOT NULL,
+        content TEXT NOT NULL,
+        confidence REAL NOT NULL DEFAULT 0.8,
+        source_unit_type TEXT,
+        source_unit_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        superseded_by TEXT DEFAULT NULL,
+        hit_count INTEGER NOT NULL DEFAULT 0
+      );
+
+      CREATE TABLE memory_processed_units (
+        unit_key TEXT PRIMARY KEY,
+        activity_file TEXT,
+        processed_at TEXT NOT NULL
+      );
+
+      -- memory_sources existed before v18 but lacked the scope column
+      CREATE TABLE memory_sources (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        uri TEXT,
+        title TEXT,
+        content TEXT NOT NULL,
+        content_hash TEXT NOT NULL UNIQUE,
+        imported_at TEXT NOT NULL
+      );
+
+      CREATE TABLE milestones (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'active',
+        depends_on TEXT NOT NULL DEFAULT '[]',
+        created_at TEXT NOT NULL DEFAULT '',
+        completed_at TEXT DEFAULT NULL,
+        vision TEXT NOT NULL DEFAULT '',
+        success_criteria TEXT NOT NULL DEFAULT '[]',
+        key_risks TEXT NOT NULL DEFAULT '[]',
+        proof_strategy TEXT NOT NULL DEFAULT '[]',
+        verification_contract TEXT NOT NULL DEFAULT '',
+        verification_integration TEXT NOT NULL DEFAULT '',
+        verification_operational TEXT NOT NULL DEFAULT '',
+        verification_uat TEXT NOT NULL DEFAULT '',
+        definition_of_done TEXT NOT NULL DEFAULT '[]',
+        requirement_coverage TEXT NOT NULL DEFAULT '',
+        boundary_map_markdown TEXT NOT NULL DEFAULT ''
+      );
+
+      CREATE TABLE slices (
+        milestone_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        title TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        risk TEXT NOT NULL DEFAULT 'medium',
+        depends TEXT NOT NULL DEFAULT '[]',
+        demo TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL DEFAULT '',
+        completed_at TEXT DEFAULT NULL,
+        full_summary_md TEXT NOT NULL DEFAULT '',
+        full_uat_md TEXT NOT NULL DEFAULT '',
+        goal TEXT NOT NULL DEFAULT '',
+        success_criteria TEXT NOT NULL DEFAULT '',
+        proof_level TEXT NOT NULL DEFAULT '',
+        integration_closure TEXT NOT NULL DEFAULT '',
+        observability_impact TEXT NOT NULL DEFAULT '',
+        sequence INTEGER DEFAULT 0,
+        PRIMARY KEY (milestone_id, id)
+      );
+
+      CREATE TABLE tasks (
+        milestone_id TEXT NOT NULL,
+        slice_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        title TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        one_liner TEXT NOT NULL DEFAULT '',
+        narrative TEXT NOT NULL DEFAULT '',
+        verification_result TEXT NOT NULL DEFAULT '',
+        duration TEXT NOT NULL DEFAULT '',
+        completed_at TEXT DEFAULT NULL,
+        blocker_discovered INTEGER DEFAULT 0,
+        deviations TEXT NOT NULL DEFAULT '',
+        known_issues TEXT NOT NULL DEFAULT '',
+        key_files TEXT NOT NULL DEFAULT '[]',
+        key_decisions TEXT NOT NULL DEFAULT '[]',
+        full_summary_md TEXT NOT NULL DEFAULT '',
+        description TEXT NOT NULL DEFAULT '',
+        estimate TEXT NOT NULL DEFAULT '',
+        files TEXT NOT NULL DEFAULT '[]',
+        verify TEXT NOT NULL DEFAULT '',
+        inputs TEXT NOT NULL DEFAULT '[]',
+        expected_output TEXT NOT NULL DEFAULT '[]',
+        observability_impact TEXT NOT NULL DEFAULT '',
+        full_plan_md TEXT NOT NULL DEFAULT '',
+        sequence INTEGER DEFAULT 0,
+        blocker_source TEXT NOT NULL DEFAULT '',
+        escalation_pending INTEGER NOT NULL DEFAULT 0,
+        escalation_awaiting_review INTEGER NOT NULL DEFAULT 0,
+        escalation_artifact_path TEXT DEFAULT NULL,
+        escalation_override_applied_at TEXT DEFAULT NULL,
+        PRIMARY KEY (milestone_id, slice_id, id)
+      );
+
+      CREATE TABLE replan_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        milestone_id TEXT NOT NULL DEFAULT '',
+        slice_id TEXT DEFAULT NULL,
+        task_id TEXT DEFAULT NULL,
+        summary TEXT NOT NULL DEFAULT '',
+        previous_artifact_path TEXT DEFAULT NULL,
+        replacement_artifact_path TEXT DEFAULT NULL,
+        full_content TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL DEFAULT ''
+      );
+
+      CREATE TABLE quality_gates (
+        milestone_id TEXT NOT NULL,
+        slice_id TEXT NOT NULL,
+        gate_id TEXT NOT NULL,
+        scope TEXT NOT NULL DEFAULT 'slice',
+        task_id TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        verdict TEXT NOT NULL DEFAULT '',
+        rationale TEXT NOT NULL DEFAULT '',
+        findings TEXT NOT NULL DEFAULT '',
+        evaluated_at TEXT DEFAULT NULL,
+        PRIMARY KEY (milestone_id, slice_id, gate_id, task_id)
+      );
+
+      CREATE TABLE verification_evidence (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL DEFAULT '',
+        slice_id TEXT NOT NULL DEFAULT '',
+        milestone_id TEXT NOT NULL DEFAULT '',
+        command TEXT NOT NULL DEFAULT '',
+        exit_code INTEGER DEFAULT 0,
+        verdict TEXT NOT NULL DEFAULT '',
+        duration_ms INTEGER DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT ''
+      );
+
+      CREATE TABLE slice_dependencies (
+        milestone_id TEXT NOT NULL,
+        slice_id TEXT NOT NULL,
+        depends_on_slice_id TEXT NOT NULL,
+        PRIMARY KEY (milestone_id, slice_id, depends_on_slice_id)
+      );
+
+      CREATE TABLE gate_runs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        trace_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        gate_id TEXT NOT NULL,
+        gate_type TEXT NOT NULL DEFAULT '',
+        unit_type TEXT DEFAULT NULL,
+        unit_id TEXT DEFAULT NULL,
+        milestone_id TEXT DEFAULT NULL,
+        slice_id TEXT DEFAULT NULL,
+        task_id TEXT DEFAULT NULL,
+        outcome TEXT NOT NULL DEFAULT 'pass',
+        failure_class TEXT NOT NULL DEFAULT 'none',
+        rationale TEXT NOT NULL DEFAULT '',
+        findings TEXT NOT NULL DEFAULT '',
+        attempt INTEGER NOT NULL DEFAULT 1,
+        max_attempts INTEGER NOT NULL DEFAULT 1,
+        retryable INTEGER NOT NULL DEFAULT 0,
+        evaluated_at TEXT NOT NULL DEFAULT ''
+      );
+
+      CREATE TABLE turn_git_transactions (
+        trace_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        unit_type TEXT DEFAULT NULL,
+        unit_id TEXT DEFAULT NULL,
+        stage TEXT NOT NULL DEFAULT 'turn-start',
+        action TEXT NOT NULL DEFAULT 'status-only',
+        push INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'ok',
+        error TEXT DEFAULT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        updated_at TEXT NOT NULL DEFAULT '',
+        PRIMARY KEY (trace_id, turn_id, stage)
+      );
+
+      CREATE TABLE audit_events (
+        event_id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL,
+        turn_id TEXT DEFAULT NULL,
+        caused_by TEXT DEFAULT NULL,
+        category TEXT NOT NULL,
+        type TEXT NOT NULL,
+        ts TEXT NOT NULL,
+        payload_json TEXT NOT NULL DEFAULT '{}'
+      );
+
+      CREATE TABLE audit_turn_index (
+        trace_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        first_ts TEXT NOT NULL,
+        last_ts TEXT NOT NULL,
+        event_count INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (trace_id, turn_id)
+      );
+
+      CREATE INDEX idx_memories_active ON memories(superseded_by);
+      CREATE INDEX idx_tasks_active ON tasks(milestone_id, slice_id, status);
+      CREATE INDEX idx_slices_active ON slices(milestone_id, status);
+      CREATE INDEX idx_milestones_status ON milestones(status);
+      CREATE INDEX idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status);
+      CREATE INDEX idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id);
+      CREATE INDEX idx_slice_deps_target ON slice_dependencies(milestone_id, depends_on_slice_id);
+      CREATE INDEX idx_tasks_escalation_pending ON tasks(milestone_id, slice_id, escalation_pending);
+    `);
+    legacyDb.close();
+
+    // This must not throw — before the fix, initSchema() crashed with
+    // "no such column: scope" when it tried to CREATE INDEX on memory_sources.scope
+    // before the v18 migration had added that column.
+    assert.doesNotThrow(
+      () => openDatabase(dbPath),
+      'openDatabase must not throw on a v17 DB where memory_sources lacks scope',
+    );
+
+    const adapter = _getAdapter()!;
+
+    // After open+migrate, memories.scope must exist
+    const memCols = adapter.prepare('PRAGMA table_info(memories)').all().map((r) => r['name']);
+    assert.ok(memCols.includes('scope'), 'memories.scope must be present after migration');
+
+    // idx_memories_scope must be created by the v18 migration
+    const scopeIdx = adapter
+      .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_memories_scope'")
+      .get();
+    assert.ok(scopeIdx, 'idx_memories_scope must exist after open on v17 DB');
+
+    // idx_memory_sources_scope must be created by the v18 migration
+    const srcScopeIdx = adapter
+      .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_memory_sources_scope'")
+      .get();
+    assert.ok(srcScopeIdx, 'idx_memory_sources_scope must exist after open on v17 DB');
+
+    cleanup(dbPath);
+  });
+
   test('gsd-db: rowToTask tolerates legacy comma-separated task arrays', () => {
     openDatabase(':memory:');
 

package/src/resources/extensions/gsd/tests/headless-milestone-parity.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Regression tests for the headless vs interactive milestone-bootstrap divergence.
+ *
+ * Two defects were covered here:
+ *   1. `showHeadlessMilestoneCreation` dispatched with `unitType: "plan-milestone"`
+ *      instead of `"discuss-milestone"`. The `discuss-` prefix drives tool
+ *      scoping (`guided-flow.ts:583`) and enables the `checkAutoStartAfterDiscuss`
+ *      guardrails — routing through `plan-milestone` bypassed them even
+ *      though headless is semantically a discuss flow.
+ *   2. The `discuss-headless.md` ready-phrase pre-condition was a prose
+ *      sentence, so models that treated it as advisory could skip ahead to
+ *      the ready phrase without actually writing the artifacts. The checkbox
+ *      format from `discuss.md` has lower abstraction cost and is harder to
+ *      rationalize past.
+ */
+
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
+const DISCUSS_HEADLESS_PATH = join(__dirname, "..", "prompts", "discuss-headless.md");
+
+function getGuidedFlowSource(): string {
+  return readFileSync(GUIDED_FLOW_PATH, "utf-8");
+}
+
+function getHeadlessPromptSource(): string {
+  return readFileSync(DISCUSS_HEADLESS_PATH, "utf-8");
+}
+
+describe("headless milestone bootstrap — parity with interactive flow", () => {
+  test("showHeadlessMilestoneCreation dispatches as discuss-milestone, not plan-milestone", () => {
+    const source = getGuidedFlowSource();
+    const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
+    assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist");
+
+    // Scope: from the function start to the next top-level export (or EOF).
+    const nextExport = source.indexOf("\nexport ", fnStart + 1);
+    const fnBody = source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
+
+    // Match only the actual dispatchWorkflow call — comments in the body
+    // may mention "plan-milestone" as part of the fix rationale.
+    const dispatchMatches = [...fnBody.matchAll(/dispatchWorkflow\([^)]*,\s*"([^"]+)"\s*\)/g)];
+    assert.strictEqual(
+      dispatchMatches.length,
+      1,
+      `expected exactly one dispatchWorkflow call, found ${dispatchMatches.length}`,
+    );
+    assert.strictEqual(
+      dispatchMatches[0][1],
+      "discuss-milestone",
+      `showHeadlessMilestoneCreation must dispatch as "discuss-milestone" so tool scoping and discuss-flow guardrails apply; got "${dispatchMatches[0][1]}"`,
+    );
+  });
+
+  test("discuss-headless single-milestone pre-condition uses the non-bypassable checkbox format", () => {
+    const source = getHeadlessPromptSource();
+    const section = source.split("### Multi-Milestone")[0];
+    assert.ok(
+      /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(section),
+      "single-milestone ready-phrase section must be present",
+    );
+    // All four required artifacts must appear as checkboxes, not a prose list.
+    for (const artifact of [
+      "`.gsd/PROJECT.md`",
+      "`.gsd/REQUIREMENTS.md`",
+      "`{{contextPath}}`",
+      "`gsd_plan_milestone`",
+    ]) {
+      assert.ok(
+        new RegExp(`- \\[ \\] [A-Za-z]+ ${artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(section),
+        `single-milestone pre-condition must include a checkbox for ${artifact}`,
+      );
+    }
+    assert.ok(
+      /If ANY box is unchecked, \*\*STOP\*\*/.test(section),
+      "single-milestone pre-condition must include the 'If ANY box is unchecked, STOP' sentinel",
+    );
+    assert.ok(
+      /Do not announce the ready phrase as something you are "about to" do/.test(section),
+      "single-milestone pre-condition must include the 'do not announce intent' guard",
+    );
+  });
+
+  test("discuss-headless multi-milestone pre-condition uses the non-bypassable checkbox format", () => {
+    const source = getHeadlessPromptSource();
+    const multiIdx = source.indexOf("### Multi-Milestone");
+    assert.ok(multiIdx > -1, "multi-milestone section must be present");
+    const multiSection = source.slice(multiIdx);
+
+    assert.ok(
+      /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(multiSection),
+      "multi-milestone ready-phrase section must be present",
+    );
+    for (const artifact of [
+      "`.gsd/PROJECT.md`",
+      "`.gsd/REQUIREMENTS.md`",
+      "`gsd_plan_milestone`",
+      "`.gsd/DISCUSSION-MANIFEST.json`",
+    ]) {
+      const escaped = artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      assert.ok(
+        new RegExp(`- \\[ \\] [\\s\\S]*?${escaped}`).test(multiSection),
+        `multi-milestone pre-condition must include a checkbox referencing ${artifact}`,
+      );
+    }
+    assert.ok(
+      /gates_completed === total/.test(multiSection),
+      "multi-milestone pre-condition must still enforce gates_completed === total",
+    );
+  });
+});

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

@@ -854,4 +854,34 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be true when real code files were merged");
     assert.ok(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
   });
+
+  // #2505 regression: when a per-entry restore of the milestone shelter fails,
+  // the shelter must be retained so the queued milestone files (whose sources
+  // were deleted during the shelter step) remain recoverable. Deleting the
+  // shelter unconditionally would permanently lose that data.
+  test("#2505: shelter retained when restore fails; cleaned up on success", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M200");
+
+    addSliceToMilestone(repo, wtPath, "M200", "S01", "Feature", [
+      { file: "feature.ts", content: "export const f = 1;\n", message: "add feature" },
+    ]);
+
+    // Seed a queued (non-target) milestone in .gsd/milestones/ that will be
+    // sheltered during the merge and restored afterwards.
+    const queuedDir = join(repo, ".gsd", "milestones", "M201");
+    mkdirSync(queuedDir, { recursive: true });
+    writeFileSync(join(queuedDir, "CONTEXT.md"), "# queued\n");
+
+    const roadmap = makeRoadmap("M200", "Milestone w/ queued sibling", [
+      { id: "S01", title: "Feature" },
+    ]);
+
+    const result = mergeMilestoneToMain(repo, "M200", roadmap);
+
+    // Normal success path: queued milestone restored, shelter cleaned up.
+    assert.ok(existsSync(join(queuedDir, "CONTEXT.md")), "queued milestone restored from shelter");
+    assert.ok(!existsSync(join(repo, ".gsd", ".milestone-shelter")), "shelter removed on successful restore");
+    assert.ok(result.commitMessage.length > 0, "merge completed");
+  });
 });

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -248,12 +248,13 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    15,
-    "exactly 15 runtime exclusion paths"
+    16,
+    "exactly 16 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",
@@ -1235,6 +1236,7 @@ describe('git-service', async () => {
     const content = readFileSync(join(repo, ".gitignore"), "utf-8");
     const lines = content.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
     assert.ok(lines.includes(".gsd"), "ensureGitignore: .gitignore contains .gsd");
+    assert.ok(lines.includes(".mcp.json"), "ensureGitignore: .gitignore contains .mcp.json");
 
     // Idempotent — calling again doesn't add duplicates
     const modified2 = ensureGitignore(repo);

package/src/resources/extensions/gsd/tests/integration/gitignore-tracked-gsd.test.ts

@@ -107,6 +107,7 @@ test("ensureGitignore does NOT add .gsd when .gsd/ has tracked files (#1364)", (
     // Other baseline patterns should still be present
     assert.ok(lines.includes(".DS_Store"), "Expected .DS_Store in .gitignore");
     assert.ok(lines.includes("node_modules/"), "Expected node_modules/ in .gitignore");
+    assert.ok(lines.includes(".mcp.json"), "Expected .mcp.json in .gitignore");
   } finally {
     cleanup(dir);
   }

package/src/resources/extensions/gsd/tests/integration/idle-recovery.test.ts

@@ -442,3 +442,33 @@ test('writeBlockerPlaceholder: updates DB slice status for complete-slice (#2653
     cleanup(base);
   }
 });
+
+test('writeBlockerPlaceholder: inserts placeholder slice for plan-milestone so deriveState exits pre-planning (#4378)', async () => {
+  const base = createFixtureBase();
+  try {
+    const { openDatabase, closeDatabase, insertMilestone, getMilestoneSlices, isDbAvailable } =
+      await import("../../gsd-db.ts");
+
+    const dbPath = join(base, ".gsd", "gsd.db");
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+    openDatabase(dbPath);
+    try {
+      insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+      // Before fix: writeBlockerPlaceholder wrote the placeholder ROADMAP.md but
+      // never updated the DB, so activeMilestoneSlices.length === 0 on next deriveState
+      // call → state.phase stays 'pre-planning' → plan-milestone dispatches again → infinite loop
+      writeBlockerPlaceholder("plan-milestone", "M001", base, "idle recovery exhausted");
+
+      const slices = getMilestoneSlices("M001");
+      assert.ok(slices.length > 0,
+        "writeBlockerPlaceholder must insert a placeholder slice for plan-milestone so " +
+        "deriveState sees activeMilestoneSlices.length > 0 and exits pre-planning phase (#4378)");
+    } finally {
+      if (isDbAvailable()) closeDatabase();
+    }
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/integration/worktree-e2e.test.ts

@@ -200,6 +200,17 @@ Test
 
 ## Boundary Map
 _None_
+`);
+      writeFileSync(join(msDir, "M001-SUMMARY.md"), `---
+id: M001
+title: "Test Milestone"
+status: complete
+completed_at: 2026-04-18T00:00:00Z
+---
+
+# M001: Test Milestone
+
+Completed.
 `);
       run("git add -A", repo);
       run("git commit -m \"add milestone\"", repo);