@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

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

@@ -502,7 +502,9 @@ describe('gsd-recover', async () => {
       insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
 
       const { ctx, notes } = makeCtx();
-      await handleRecover(ctx, base, '--confirm');
+      // M999 is in the DB but not in the markdown, so recover would delete it:
+      // a data-loss recover now requires explicit --allow-data-loss.
+      await handleRecover(ctx, base, '--confirm --allow-data-loss');
 
       assert.equal(getMilestone('M999'), null, 'confirmed recover clears old hierarchy rows');
       assert.ok(getMilestone('M001'), 'confirmed recover imports markdown hierarchy');
@@ -512,4 +514,63 @@ describe('gsd-recover', async () => {
       cleanup(base);
     }
   });
+
+  test('handleRecover refuses to delete DB rows markdown lacks without --allow-data-loss', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx();
+      await handleRecover(ctx, base, '--confirm');
+
+      // --confirm alone must NOT clear authoritative DB rows the markdown lacks.
+      assert.ok(getMilestone('M999'), 'data-loss recover is refused, DB row preserved');
+      assert.equal(getMilestone('M001'), null, 'markdown not imported on refusal');
+      assert.equal(notes.at(-1)?.kind, 'error');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('handleRecover interactive data-loss requires a second explicit acknowledgement', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      // First confirm (proceed?) = yes; second confirm (delete rows?) = no.
+      let call = 0;
+      const { ctx, notes } = makeCtx(async () => { call += 1; return call === 1; });
+      await handleRecover(ctx, base, '');
+
+      assert.ok(getMilestone('M999'), 'declining the data-loss ack preserves DB rows');
+      assert.equal(getMilestone('M001'), null, 'markdown not imported when data-loss ack declined');
+      assert.match(notes.at(-1)?.message ?? '', /cancelled/);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('handleRecover interactive proceeds when the data-loss deletion is acknowledged', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx } = makeCtx(async () => true); // both confirms accepted
+      await handleRecover(ctx, base, '');
+
+      assert.equal(getMilestone('M999'), null, 'acknowledged data-loss recover clears old rows');
+      assert.ok(getMilestone('M001'), 'acknowledged data-loss recover imports markdown');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
 });

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

@@ -30,6 +30,7 @@ import {
   insertTask,
   openDatabase,
 } from "../gsd-db.js";
+import { SourceObservationStore } from "../source-observations.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -186,6 +187,7 @@ function makeSession() {
     currentMilestoneId: "M001",
     currentUnit: null,
     currentUnitRouting: null,
+    sourceObservations: new SourceObservationStore(),
     completedUnits: [],
     resourceVersionOnStart: null,
     lastPromptCharCount: undefined,
@@ -207,6 +209,19 @@ function makeSession() {
       newSession: () => Promise.resolve({ cancelled: false }),
       getContextUsage: () => ({ percent: 10, tokens: 1000, limit: 10000 }),
     },
+    setCurrentUnit(this: any, unit: any) {
+      this.currentUnit = unit;
+      this.sourceObservations.beginUnit({
+        unitType: unit.type,
+        unitId: unit.id,
+        startedAt: unit.startedAt,
+        basePath: unit.workspaceRoot ?? this.basePath,
+      });
+    },
+    clearCurrentUnit(this: any) {
+      this.currentUnit = null;
+      this.sourceObservations.clear();
+    },
     clearTimers: () => {},
   } as any;
 }

package/src/resources/extensions/gsd/tests/markdown-renderer.test.ts

@@ -393,6 +393,48 @@ test('── markdown-renderer: renderPlanCheckboxes round-trip ──', async (
   }
 });
 
+test('── markdown-renderer: renderPlanCheckboxes re-renders DB tasks added after the plan artifact ──', async () => {
+  // Regression for the lossy-projection root cause: renderPlanCheckboxes used to
+  // patch the cached PLAN artifact in place, silently dropping tasks added to
+  // the DB after the artifact was first written (the 4S/0T-vs-5S/13T drift).
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  clearAllCaches();
+
+  try {
+    scaffoldDirs(tmpDir, 'M001', ['S01']);
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice', status: 'pending' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'First task', status: 'pending' });
+
+    // PLAN.md on disk reflects an earlier state with only T01.
+    const planPath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+    fs.writeFileSync(planPath, makePlanContent('S01', [{ id: 'T01', title: 'First task', done: false }]));
+    clearAllCaches();
+
+    // Two more tasks are written to the DB after the artifact already exists.
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Second task', status: 'done' });
+    insertTask({ id: 'T03', sliceId: 'S01', milestoneId: 'M001', title: 'Third task', status: 'pending' });
+
+    const ok = await renderPlanCheckboxes(tmpDir, 'M001', 'S01');
+    assert.ok(ok, 'renderPlanCheckboxes returns true');
+
+    const parsed = parsePlan(fs.readFileSync(planPath, 'utf-8'));
+    clearAllCaches();
+    assert.deepStrictEqual(
+      parsed.tasks.map(t => t.id).sort(),
+      ['T01', 'T02', 'T03'],
+      'full re-render must include tasks added after the artifact was written',
+    );
+    assert.ok(parsed.tasks.find(t => t.id === 'T02')!.done, 'T02 reflects done status from DB');
+    assert.ok(!parsed.tasks.find(t => t.id === 'T03')!.done, 'T03 reflects pending status from DB');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+});
+
 test('── markdown-renderer: renderPlanCheckboxes bidirectional ──', async () => {
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');

package/src/resources/extensions/gsd/tests/migration-auto-check.test.ts

@@ -151,6 +151,105 @@ test("migration auto-check leaves matching DB hierarchy alone", async () => {
   }
 });
 
+test("migration auto-check flags a populated DB with missing markdown and points at rebuild (not recover)", async () => {
+  const base = makeBase();
+  try {
+    // A project with no milestone markdown: simulate lost/empty projections
+    // over a populated DB. The previous early return treated all-zero markdown
+    // as 'no project' and never even opened the DB, silently hiding the rows.
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    assert.deepEqual(countMarkdownHierarchy(base), { milestones: 0, slices: 0, tasks: 0 });
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Legacy Slice", status: "pending", risk: "medium", depends: [], demo: "Legacy slice demo", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "recovery-required");
+    assert.equal(result.reason, "markdown-missing");
+    // The DB is the richer side, so recover (md → DB) would DELETE rows. The
+    // safe repair is to re-project from the DB.
+    assert.equal(result.recoveryCommand, "/gsd rebuild markdown");
+    assert.match(result.message ?? "", /rebuild markdown/);
+    assert.match(result.message ?? "", /Do NOT run/);
+    // The check must not mutate the DB.
+    assert.equal(getAllMilestones().length, 1);
+    assert.equal(getSliceTasks("M001", "S01").length, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check detects identity drift even when counts match", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    // Same cardinalities (1M/1S/1T) but a DIFFERENT slice identity (S99 vs S01).
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S99", milestoneId: "M001", title: "Other Slice", status: "pending", risk: "medium", depends: [], demo: "d", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S99", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    // Counts are equal on both sides, so the old count-only comparison reported
+    // 'in-sync'. Identity comparison must catch the divergence instead.
+    assert.equal(result.action, "recovery-required");
+    assert.notEqual(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 1 });
+    // The DB holds S99 (which markdown lacks), so recover would DELETE it. Even
+    // at equal counts the safe recommendation must be rebuild, not recover.
+    assert.equal(result.recoveryCommand, "/gsd rebuild markdown");
+    assert.match(result.message ?? "", /Do NOT run/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("recoverWouldDeleteDbRows flags identity drift the markdown lacks (even at equal counts)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    // DB row identity (S99) differs from markdown (S01) at the same count.
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S99", milestoneId: "M001", title: "Other Slice", status: "pending", risk: "medium", depends: [], demo: "d", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S99", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    const { recoverWouldDeleteDbRows } = await import("../migration-auto-check.ts");
+    assert.equal(recoverWouldDeleteDbRows(base), true, "DB S99 is absent from markdown — recover would delete it");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check canonicalizes a legacy descriptor milestone dir (no false drift)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // creates .gsd/milestones/M001
+    // Rename the dir to a legacy descriptor form while the DB id stays "M001".
+    // scanMarkdownHierarchy must canonicalize "M001-old" → "M001" so the
+    // identity sets line up with scanDbHierarchy (which uses milestone.id).
+    const milestonesRoot = join(base, ".gsd", "milestones");
+    renameSync(join(milestonesRoot, "M001"), join(milestonesRoot, "M001-old"));
+
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Legacy Slice", status: "pending", risk: "medium", depends: [], demo: "Legacy slice demo", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    // Must be in-sync: the raw dir name "M001-old" would otherwise mismatch the
+    // DB id "M001" and be flagged as false drift.
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("migration auto-check refreshes a stale open DB handle before comparing", async () => {
   const base = makeBase();
   try {

package/src/resources/extensions/gsd/tests/plan-slice.test.ts

@@ -133,6 +133,36 @@ test('handlePlanSlice persists explicit slice/task target repositories', async (
   }
 });
 
+test('handlePlanSlice honors configured gate-evaluation gate sets', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    writeFileSync(
+      join(base, '.gsd', 'PREFERENCES.md'),
+      [
+        '---',
+        'gate_evaluation:',
+        '  enabled: true',
+        '  slice_gates:',
+        '    - Q3',
+        '  task_gates: false',
+        '---',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const gateIds = getGateResults('M001', 'S02').map((gate) => gate.gate_id).sort();
+    assert.deepEqual(gateIds, ['Q3', 'Q8']);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects unknown target repositories', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -196,6 +226,50 @@ test('handlePlanSlice enforces absolute path scope to declared target repositori
   }
 });
 
+test('handlePlanSlice resolves relative task IO paths against declared target repository roots', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    mkdirSync(join(base, 'frontend'), { recursive: true });
+    writeFileSync(join(base, 'frontend', 'app.js'), 'export {};\n', 'utf-8');
+    writeFileSync(
+      join(base, '.gsd', 'PREFERENCES.md'),
+      [
+        '---',
+        'workspace:',
+        '  mode: parent',
+        '  repositories:',
+        '    frontend:',
+        '      path: frontend',
+        '---',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    const params = validParams();
+    const result = await handlePlanSlice({
+      ...params,
+      targetRepositories: ['frontend'],
+      tasks: [
+        {
+          ...params.tasks[0],
+          files: ['app.js'],
+          inputs: ['app.js'],
+          expectedOutput: ['app.js'],
+          targetRepositories: ['frontend'],
+        },
+      ],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.deepEqual(getSliceTasks('M001', 'S02').map((task) => task.id), ['T01']);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects relative traversal outside declared target repositories', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -749,7 +823,7 @@ test('regression: validateTasks surfaces clean per-field errors for non-array IO
   }
 });
 
-test('handlePlanSlice skips prose and sentinel values in planning path scope', async () => {
+test('handlePlanSlice skips prose and sentinel input values in planning path scope', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
 
@@ -760,7 +834,7 @@ test('handlePlanSlice skips prose and sentinel values in planning path scope', a
       tasks: [{
         ...validParams().tasks[0],
         inputs: ['Current enum shape in codebase', 'None'],
-        expectedOutput: ['Updated planning-path-scope.ts — validates paths only'],
+        expectedOutput: ['src/resources/extensions/gsd/planning-path-scope.ts'],
       }],
     }, base);
 
@@ -771,6 +845,29 @@ test('handlePlanSlice skips prose and sentinel values in planning path scope', a
   }
 });
 
+test('handlePlanSlice rejects prose expectedOutput entries before path-scope validation', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [{
+        ...validParams().tasks[0],
+        expectedOutput: ['Browser UI supports due-date add/edit flows and mixed-list urgency rendering.'],
+      }],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /expectedOutput must contain only file paths/);
+    assert.doesNotMatch(result.error, /outside allowed repository roots/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid output contract must not persist tasks');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice resolves relative task IO paths against worktree roots', async () => {
   const base = makeTmpBase();
   const worktree = join(base, '.gsd', 'worktrees', 'M001');

package/src/resources/extensions/gsd/tests/plan-task.test.ts

@@ -96,6 +96,25 @@ test('handlePlanTask explains string IO fields must be arrays', async () => {
   }
 });
 
+test('handlePlanTask rejects prose expectedOutput entries', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      expectedOutput: ['Browser UI supports due-date add/edit flows and mixed-list urgency rendering.'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: expectedOutput must contain only file paths/);
+    assert.doesNotMatch(result.error, /outside allowed repository roots/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid output contract must not persist the task');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanTask rejects absolute task IO paths outside the active worktree', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -467,6 +467,20 @@ test("notification fields validate correctly", () => {
   assert.equal(preferences.notifications?.on_complete, false);
 });
 
+test("gate_evaluation slice_gates only accepts gate-evaluate-owned gates", () => {
+  const valid = validatePreferences({
+    gate_evaluation: { enabled: true, slice_gates: ["Q3", "Q4"], task_gates: false },
+  });
+  assert.equal(valid.errors.length, 0);
+  assert.deepEqual(valid.preferences.gate_evaluation?.slice_gates, ["Q3", "Q4"]);
+  assert.equal(valid.preferences.gate_evaluation?.task_gates, false);
+
+  const invalid = validatePreferences({
+    gate_evaluation: { enabled: true, slice_gates: ["Q3", "Q8"] },
+  });
+  assert.ok(invalid.errors.some((error) => error.includes("gate_evaluation.slice_gates")));
+});
+
 test("cmux fields validate correctly", () => {
   const { preferences, errors } = validatePreferences({
     cmux: {

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -18,6 +18,7 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   skill_rules: [{ when: "unit:execute-task", use: ["test-writer-fixer"] }],
   custom_instructions: ["Keep changes focused."],
   models: { execution: "openai/gpt-5" },
+  thinking: { planning: "xhigh", execution: "low" },
   skill_discovery: "auto",
   skill_staleness_days: 7,
   auto_supervisor: { soft_timeout_minutes: 20, idle_timeout_minutes: 10, hard_timeout_minutes: 30 },

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -17,6 +17,7 @@ import {
 } from "../bootstrap/register-hooks.ts";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.ts";
 import { UNIT_TOOL_CONTRACTS } from "../unit-tool-contracts.ts";
+import { uatTypeIncludesBrowser } from "../uat-policy.ts";
 
 const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
 const templatesDir = join(process.cwd(), "src/resources/extensions/gsd/templates");
@@ -183,6 +184,7 @@ test("live-runtime and mixed UAT presentations also surface browser tools", () =
   // drive a browser, so the runner must actually receive the browser tools and
   // a hybrid surface — otherwise live checks silently downgrade to NEEDS-HUMAN.
   for (const uatType of ["live-runtime", "mixed", "human-experience"] as const) {
+    assert.equal(uatTypeIncludesBrowser(uatType), true, `${uatType} policy should include browser tools`);
     const presentation = buildRunUatPresentationForType(uatType);
     assert.equal(presentation.surface, "hybrid", `${uatType} should use the hybrid surface`);
     for (const toolName of RUN_UAT_BROWSER_TOOL_NAMES) {
@@ -196,6 +198,7 @@ test("live-runtime and mixed UAT presentations also surface browser tools", () =
 
 test("artifact-driven and runtime-executable UAT presentations stay browser-free", () => {
   for (const uatType of ["artifact-driven", "runtime-executable"] as const) {
+    assert.equal(uatTypeIncludesBrowser(uatType), false, `${uatType} policy should stay browser-free`);
     const presentation = buildRunUatPresentationForType(uatType);
     assert.equal(presentation.surface, "mcp", `${uatType} should use the mcp surface`);
     assert.ok(
@@ -659,6 +662,12 @@ test("parallel subagent prompts forbid serialized tasks arrays", () => {
   }
 });
 
+test("gate-evaluate prompt requires gate result findings field", () => {
+  const prompt = readPrompt("gate-evaluate");
+  assert.match(prompt, /`findings`/);
+  assert.match(prompt, /empty string if none/i);
+});
+
 // ─── Project-shape classifier + 3-or-4-options-with-Other-hatch contract ──
 
 test("guided-discuss-project classifies project shape and persists the verdict to PROJECT.md", () => {

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -1,10 +1,16 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  clearPendingAutoStart,
+  setPendingAutoStart,
+} from "../guided-flow.ts";
+import { closeDatabase, getMilestone } from "../gsd-db.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
 import {
   getPendingGate,
   resetWriteGateState,
@@ -186,6 +192,100 @@ test("register-hooks unlocks milestone depth verification from question id witho
   );
 });
 
+test("register-hooks persists first structured question round for new milestone re-entry", async (t) => {
+  const dir = makeTempDir("question-draft");
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState(dir);
+  clearPendingAutoStart(dir);
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+      clearPendingAutoStart(dir);
+      closeDatabase();
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<void> | void) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+  const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;
+
+  registerHooks(pi, []);
+  setPendingAutoStart(dir, {
+    basePath: dir,
+    milestoneId: "M004",
+    ctx,
+    pi: { sendMessage: () => undefined } as any,
+  });
+
+  const questions = [
+    {
+      id: "m004_shape",
+      header: "M004 Shape",
+      question: "What are you picturing for M004?",
+      options: [
+        { label: "Planning metadata (Recommended)", description: "Plan the next metadata layer." },
+        { label: "Find and organize", description: "Improve searching and organizing." },
+      ],
+    },
+    {
+      id: "boundary",
+      header: "Boundary",
+      question: "Which boundary should I plan around?",
+      options: [
+        { label: "No new dependencies (Recommended)", description: "Keep implementation vanilla." },
+        { label: "Browser APIs OK", description: "Use browser-native capabilities." },
+      ],
+    },
+  ];
+
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: {
+        response: {
+          answers: {
+            m004_shape: { selected: "Planning metadata (Recommended)" },
+            boundary: { selected: "No new dependencies (Recommended)" },
+          },
+        },
+      },
+    }, ctx);
+  }
+
+  const milestoneDir = join(dir, ".gsd", "milestones", "M004");
+  const draftPath = join(milestoneDir, "M004-CONTEXT-DRAFT.md");
+  const discussionPath = join(milestoneDir, "M004-DISCUSSION.md");
+
+  assert.equal(existsSync(draftPath), true, "first answer round should create a resumable context draft");
+  assert.equal(existsSync(discussionPath), true, "first answer round should create a discussion log");
+
+  const draft = readFileSync(draftPath, "utf-8");
+  assert.match(draft, /What are you picturing for M004\?/);
+  assert.match(draft, /Planning metadata \(Recommended\)/);
+  assert.match(draft, /No new dependencies \(Recommended\)/);
+
+  const row = getMilestone("M004");
+  assert.equal(row?.status, "queued", "new milestone shell should be registered in the DB");
+
+  invalidateStateCache();
+  const state = await deriveState(dir);
+  assert.equal(state.activeMilestone?.id, "M004");
+  assert.equal(state.phase, "needs-discussion");
+});
+
 test("register-hooks clears depth gate when remote (Telegram/Slack/Discord) answer is normalized (#4406)", async (t) => {
   const dir = makeTempDir("remote");
   const originalCwd = process.cwd();

package/src/resources/extensions/gsd/tests/repository-registry.test.ts

@@ -2,7 +2,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execFileSync } from "node:child_process";
@@ -117,7 +117,7 @@ test("repository registry keeps project root anchored to .gsd project in monorep
 });
 
 test("repository registry uses external-state worktree checkout as project root", (t) => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-external-"));
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-repo-registry-external-")));
   t.after(() => rmSync(base, { recursive: true, force: true }));
   const worktree = join(base, ".gsd", "projects", "abc123", "worktrees", "M001");
   mkdirSync(worktree, { recursive: true });

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -67,6 +67,14 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   assert.deepEqual(result.ok && result.contract.forbiddenWorkflowTools, []);
   assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
   assert.ok(result.ok && result.contract.validationRules.includes("closeout-tool-present"));
+  assert.ok(result.ok && result.contract.validationRules.includes("source-observation-contract-present"));
+  assert.deepEqual(result.ok && result.contract.sourceObservations, {
+    mode: "whole-file-active-unit",
+    seedFields: ["task.files", "task.inputs"],
+    excludedFields: ["expectedOutput"],
+    maxBytes: 50 * 1024,
+    maxLines: 2000,
+  });
 });
 
 test("Tool Contract records high-risk cross-phase tool boundaries without single-owning every tool", () => {