gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

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

@@ -3,12 +3,14 @@ import assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { createRequire } from 'node:module';
 import {
   openDatabase,
   closeDatabase,
   isDbAvailable,
   wasDbOpenAttempted,
   getDbProvider,
+  getDbStatus,
   insertDecision,
   getDecisionById,
   insertRequirement,
@@ -26,6 +28,8 @@ import {
   checkpointDatabase,
 } from '../gsd-db.ts';
 
+const _require = createRequire(import.meta.url);
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Helper: create a temp file path for file-backed DB tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -59,6 +63,20 @@ function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
   }
 }
 
+function openRawSqliteForTest(dbPath: string): { exec(sql: string): void; close(): void } {
+  try {
+    const mod = _require('node:sqlite') as { DatabaseSync: new (path: string) => { exec(sql: string): void; close(): void } };
+    return new mod.DatabaseSync(dbPath);
+  } catch {
+    type SqliteCtor = new (path: string) => { exec(sql: string): void; close(): void };
+    const mod = _require('better-sqlite3') as
+      | SqliteCtor
+      | { default: SqliteCtor };
+    const DatabaseCtor: SqliteCtor = typeof mod === 'function' ? mod : mod.default;
+    return new DatabaseCtor(dbPath);
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // gsd-db tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -81,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'], 20, 'schema version should be 20');
+    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();
@@ -404,6 +422,348 @@ describe('gsd-db', () => {
     cleanup(dbPath);
   });
 
+  test('gsd-db: legacy DB missing memories.scope opens and bootstraps index columns', () => {
+    const dbPath = tempDbPath();
+    const legacyDb = openRawSqliteForTest(dbPath);
+    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-04-20T00:00:00.000Z');
+      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
+      );
+      INSERT INTO memories(id, category, content, created_at, updated_at)
+      VALUES ('legacy-memory', 'note', 'legacy row', '2026-04-20T00:00:00.000Z', '2026-04-20T00:00:00.000Z');
+    `);
+    legacyDb.close();
+
+    assert.equal(openDatabase(dbPath), true, 'openDatabase should succeed for legacy DB missing memories.scope');
+
+    const adapter = _getAdapter()!;
+    const columns = adapter.prepare('PRAGMA table_info(memories)').all();
+    const names = columns.map((row) => row['name']);
+    assert.ok(names.includes('scope'), 'memories.scope should be added during bootstrap');
+    assert.ok(names.includes('tags'), 'memories.tags should be added during bootstrap');
+
+    const row = adapter.prepare(`SELECT scope, tags FROM memories WHERE id = 'legacy-memory'`).get();
+    assert.equal(row?.['scope'], 'project', 'legacy rows should receive default scope');
+    assert.equal(row?.['tags'], '[]', 'legacy rows should receive default tags');
+
+    const index = adapter.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_memories_scope'",
+    ).get();
+    assert.equal(index?.['name'], 'idx_memories_scope', 'scope index should be created after bootstrap columns are present');
+
+    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:');
 
@@ -561,6 +921,92 @@ describe('gsd-db', () => {
     });
   });
 
+  // ─── getDbStatus ───────────────────────────────────────────────────────────
+
+  describe('getDbStatus', () => {
+    test('getDbStatus: initial state before any open', () => {
+      closeDatabase();
+      const status = getDbStatus();
+      assert.strictEqual(status.available, false, 'available false before open');
+      assert.strictEqual(status.attempted, false, 'attempted false before open');
+      assert.strictEqual(status.lastError, null, 'lastError null before open');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase null before open');
+    });
+
+    test('getDbStatus: available after successful open', () => {
+      openDatabase(':memory:');
+      const status = getDbStatus();
+      assert.strictEqual(status.available, true, 'available true after open');
+      assert.strictEqual(status.attempted, true, 'attempted true after open');
+      assert.ok(status.provider !== null, 'provider set after open');
+      assert.strictEqual(status.lastError, null, 'lastError null on success');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase null on success');
+      closeDatabase();
+    });
+
+    test('getDbStatus: resets lastError/lastPhase after closeDatabase', () => {
+      // Simulate a failed open to set error state
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try {
+        openDatabase(corruptPath);
+      } catch {
+        // expected
+      }
+      assert.ok(getDbStatus().lastError !== null, 'lastError set after failed open');
+
+      // closeDatabase should clear it even though no DB was opened
+      closeDatabase();
+      const status = getDbStatus();
+      assert.strictEqual(status.lastError, null, 'lastError cleared by closeDatabase');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase cleared by closeDatabase');
+      assert.strictEqual(status.attempted, false, 'attempted reset by closeDatabase');
+      fs.unlinkSync(corruptPath);
+    });
+
+    test('getDbStatus: captures open-phase error on corrupt file', () => {
+      closeDatabase();
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try {
+        openDatabase(corruptPath);
+      } catch {
+        // expected — both providers should reject a non-SQLite file
+      }
+      const status = getDbStatus();
+      if (!status.available) {
+        // open failed (expected in most environments)
+        assert.strictEqual(status.attempted, true, 'attempted true after failed open');
+        // provider may reject at raw-open level ("open") or at SQL init level ("initSchema")
+        assert.ok(
+          status.lastPhase === 'open' || status.lastPhase === 'initSchema',
+          `lastPhase should be "open" or "initSchema", got: ${status.lastPhase}`,
+        );
+        assert.ok(status.lastError instanceof Error, 'lastError is an Error');
+      }
+      // If somehow it succeeded (unlikely with garbage content), that's also fine
+      closeDatabase();
+      try { fs.unlinkSync(corruptPath); } catch { /* best effort */ }
+    });
+
+    test('getDbStatus: error state resets on next successful open', () => {
+      closeDatabase();
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try { openDatabase(corruptPath); } catch { /* expected */ }
+      assert.ok(!getDbStatus().available, 'DB unavailable after corrupt open');
+
+      // Now open a valid in-memory DB — error state should clear
+      openDatabase(':memory:');
+      const status = getDbStatus();
+      assert.strictEqual(status.available, true, 'available after valid open');
+      assert.strictEqual(status.lastError, null, 'lastError cleared on successful open');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase cleared on successful open');
+      closeDatabase();
+      try { fs.unlinkSync(corruptPath); } catch { /* best effort */ }
+    });
+  });
+
   // ─── Final Report ──────────────────────────────────────────────────────────
 
 });

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/hook-key-parsing.test.ts

@@ -1,11 +1,5 @@
 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, "..");
 
 /**
  * Regression tests for #2826: hook/* completed-unit keys were parsed
@@ -15,17 +9,13 @@ const gsdDir = join(__dirname, "..");
  * The root cause: `key.indexOf("/")` splits "hook/telegram-progress/M007/S01"
  * into unitType="hook" + unitId="telegram-progress/M007/S01" instead of
  * unitType="hook/telegram-progress" + unitId="M007/S01".
+ *
+ * These tests exercise the real `splitCompletedKey` helper — the previous
+ * source-grep "does not use indexOf" blocks were dropped under #4825 as
+ * they over-specified implementation shape.
  */
 
 describe("splitCompletedKey (#2826)", () => {
-  it("is exported from forensics.ts", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(
-      source.includes("export function splitCompletedKey"),
-      "forensics.ts must export splitCompletedKey helper",
-    );
-  });
-
   it("splits simple unit types correctly", async () => {
     const { splitCompletedKey } = await import("../forensics.ts");
     const result = splitCompletedKey("execute-task/M007/S01/T01");
@@ -64,44 +54,3 @@ describe("splitCompletedKey (#2826)", () => {
     assert.strictEqual(splitCompletedKey("hook/someName"), null);
   });
 });
-
-describe("forensics detectMissingArtifacts uses splitCompletedKey (#2826)", () => {
-  it("does not use indexOf for key splitting", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    // Extract only the detectMissingArtifacts function body
-    const fnStart = source.indexOf("function detectMissingArtifacts");
-    assert.ok(fnStart !== -1, "detectMissingArtifacts must exist");
-    const fnBody = source.slice(fnStart, source.indexOf("\n}\n", fnStart) + 3);
-
-    assert.ok(
-      !fnBody.includes('key.indexOf("/")'),
-      "detectMissingArtifacts must not use key.indexOf('/') — use splitCompletedKey instead",
-    );
-    assert.ok(
-      fnBody.includes("splitCompletedKey"),
-      "detectMissingArtifacts must use splitCompletedKey helper",
-    );
-  });
-});
-
-describe("doctor-runtime-checks uses splitCompletedKey (#2826)", () => {
-  it("does not use indexOf for key splitting in orphaned-key check", () => {
-    const source = readFileSync(
-      join(gsdDir, "doctor-runtime-checks.ts"),
-      "utf-8",
-    );
-    // Find the orphaned completed-units section
-    const sectionStart = source.indexOf("Orphaned completed-units");
-    assert.ok(sectionStart !== -1, "orphaned completed-units section must exist");
-    const sectionBody = source.slice(sectionStart, source.indexOf("} catch", sectionStart));
-
-    assert.ok(
-      !sectionBody.includes('key.indexOf("/")'),
-      "doctor orphaned-key check must not use key.indexOf('/') — use splitCompletedKey instead",
-    );
-    assert.ok(
-      sectionBody.includes("splitCompletedKey"),
-      "doctor orphaned-key check must use splitCompletedKey helper",
-    );
-  });
-});