@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

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

@@ -3,11 +3,21 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import {
+  RUN_UAT_BROWSER_TOOL_NAMES,
   buildRunUatResultPresentation,
+  buildRunUatPresentationForType,
   RUN_UAT_READ_ONLY_TOOL_NAMES,
   RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
   RUN_UAT_WORKFLOW_TOOL_NAMES,
 } from "../tool-presentation-plan.ts";
+import {
+  buildMinimalAutoGsdToolSet,
+  MINIMAL_AUTO_BASE_TOOL_NAMES,
+  MINIMAL_GSD_TOOL_NAMES,
+} 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");
@@ -20,6 +30,84 @@ function readTemplate(name: string): string {
   return readFileSync(join(templatesDir, `${name}.md`), "utf-8");
 }
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+const registeredPhaseToolNames = [
+  ...new Set([
+    ...MINIMAL_AUTO_BASE_TOOL_NAMES,
+    ...MINIMAL_GSD_TOOL_NAMES,
+    ...Object.values(UNIT_TOOL_CONTRACTS).flatMap((contract) => contract.allowedGsdTools),
+  ]),
+];
+
+const PHASE_PROMPT_TOOL_CALLS: Record<string, readonly string[]> = {
+  "research-milestone": ["gsd_summary_save"],
+  "plan-milestone": [
+    "gsd_milestone_status",
+    "gsd_plan_milestone",
+    "gsd_plan_slice",
+    "gsd_decision_save",
+  ],
+  "research-slice": ["gsd_summary_save"],
+  "plan-slice": ["gsd_reassess_roadmap", "gsd_plan_slice", "gsd_decision_save"],
+  "refine-slice": ["gsd_plan_slice", "gsd_decision_save"],
+  "replan-slice": ["gsd_replan_slice"],
+  "execute-task": ["gsd_task_complete"],
+  "reactive-execute": ["gsd_summary_save"],
+  "complete-slice": [
+    "gsd_exec",
+    "gsd_task_reopen",
+    "gsd_replan_slice",
+    "gsd_requirement_update",
+    "capture_thought",
+    "gsd_slice_complete",
+    "gsd_summary_save",
+  ],
+  "reassess-roadmap": ["gsd_milestone_status", "gsd_reassess_roadmap"],
+  "validate-milestone": ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap"],
+  "run-uat": ["gsd_uat_exec", "gsd_uat_result_save"],
+  "gate-evaluate": ["gsd_save_gate_result"],
+  "complete-milestone": [
+    "gsd_milestone_status",
+    "gsd_requirement_update",
+    "gsd_summary_save",
+    "capture_thought",
+    "gsd_complete_milestone",
+  ],
+};
+
+test("auto phase prompt tool calls are available in scoped tool surfaces", () => {
+  for (const [unitType, promptTools] of Object.entries(PHASE_PROMPT_TOOL_CALLS)) {
+    const prompt = readPrompt(unitType);
+    const activeTools = buildMinimalAutoGsdToolSet(
+      registeredPhaseToolNames,
+      unitType,
+      registeredPhaseToolNames,
+    );
+
+    for (const toolName of promptTools) {
+      assert.match(
+        prompt,
+        new RegExp(`\\b${escapeRegExp(toolName)}\\b`),
+        `${unitType} prompt should mention ${toolName}`,
+      );
+      assert.ok(
+        activeTools.includes(toolName),
+        `${unitType} prompt mentions ${toolName}, but scoped tools are ${activeTools.join(", ")}`,
+      );
+
+      const scopeResult = shouldBlockAutoUnitToolCall(unitType, toolName);
+      assert.equal(
+        scopeResult.block,
+        false,
+        `${unitType} phase gate blocked ${toolName}: ${scopeResult.reason ?? "unknown reason"}`,
+      );
+    }
+  }
+});
+
 test("reactive-execute prompt keeps task summaries with subagents and avoids batch commits", () => {
   const prompt = readPrompt("reactive-execute");
   assert.match(prompt, /subagent-written summary as authoritative/i);
@@ -81,6 +169,45 @@ test("run-uat prompt gives the complete UAT result-save presentation contract",
   );
 });
 
+test("browser-executable UAT presentation uses direct browser tools", () => {
+  const presentation = buildRunUatPresentationForType("browser-executable");
+
+  assert.equal(presentation.surface, "hybrid");
+  for (const toolName of RUN_UAT_BROWSER_TOOL_NAMES) {
+    assert.ok(presentation.presentedTools.includes(toolName), `presentation should include browser tool ${toolName}`);
+  }
+  assert.ok(!presentation.presentedTools.some((toolName) => toolName.startsWith("mcp__gsd-browser__")));
+});
+
+test("live-runtime and mixed UAT presentations also surface browser tools", () => {
+  // Regression (M001/S03): the run-uat prompt tells live-runtime and mixed to
+  // 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) {
+      assert.ok(
+        presentation.presentedTools.includes(toolName),
+        `${uatType} presentation should include browser tool ${toolName}`,
+      );
+    }
+  }
+});
+
+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(
+      !RUN_UAT_BROWSER_TOOL_NAMES.some((toolName) => presentation.presentedTools.includes(toolName)),
+      `${uatType} presentation should not include browser tools`,
+    );
+  }
+});
+
 test("workflow-start prompt defaults to autonomy instead of per-phase confirmation", () => {
   const prompt = readPrompt("workflow-start");
   assert.match(prompt, /Keep moving by default/i);
@@ -535,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/provider-switch-observer.test.ts

@@ -210,6 +210,61 @@ test("end-to-end: audit event is emitted when an auto trace is active", async ()
   }
 });
 
+test("same-API transform with changes does not fire the observer (no real provider switch)", async () => {
+  const { basePath, cleanup } = withTempBasePath();
+  try {
+    initNotificationStore(basePath);
+    installProviderSwitchObserver();
+
+    // Target api === source api. The conversation ends on an unresolved tool
+    // call, so a synthetic tool result IS backfilled (a non-empty report) — but
+    // this is a within-provider normalization, not a cross-provider switch.
+    // `sourceApi` is omitted (the common case), so fromApi defaults to the
+    // target api and equals toApi. The observer must stay silent.
+    const sameApiModel = {
+      id: "gpt-5",
+      name: "GPT-5",
+      api: "openai-responses",
+      provider: "openai",
+      baseUrl: "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128000,
+      maxTokens: 8192,
+    } as Parameters<typeof transformMessagesWithReport>[1];
+
+    const messages = [
+      {
+        role: "assistant" as const,
+        content: [
+          { type: "toolCall" as const, id: "call_orphan_1", name: "bash", arguments: {} },
+        ],
+        api: "openai-responses",
+        provider: "openai",
+        model: "gpt-5",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+        stopReason: "stop" as const,
+        timestamp: Date.now(),
+      },
+    ];
+
+    transformMessagesWithReport(
+      messages as Parameters<typeof transformMessagesWithReport>[0],
+      sameApiModel,
+    );
+
+    assert.equal(getProviderSwitchStats().totalSwitches, 0, "same→same transform must not count as a provider switch");
+    assert.equal(
+      readNotifications(basePath).filter((n) => n.message.includes("Provider switch")).length,
+      0,
+      "same→same transform must not emit a provider-switch notification",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
 test("empty report does not bump counter or emit a notification", async () => {
   const { basePath, cleanup } = withTempBasePath();
   try {

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", () => {
@@ -108,6 +116,26 @@ test("auto Unit tool scope blocks complete-slice from saving UAT Assessment", ()
   assert.match(result.reason ?? "", /Run UAT owns persisted UAT Assessment/);
 });
 
+test("auto Unit tool scope allows plan-slice to reassess invalid roadmap assumptions", () => {
+  const result = shouldBlockAutoUnitToolCall("plan-slice", "gsd_reassess_roadmap");
+
+  assert.equal(result.block, false);
+});
+
+test("auto Unit tool scope allows status/read helpers named by closeout prompts", () => {
+  for (const unitType of ["plan-milestone", "validate-milestone", "complete-milestone", "reassess-roadmap"]) {
+    const result = shouldBlockAutoUnitToolCall(unitType, "gsd_milestone_status");
+    assert.equal(result.block, false, `${unitType} should be able to call gsd_milestone_status`);
+  }
+});
+
+test("auto Unit tool scope blocks stale per-task planner in slice planning phases", () => {
+  for (const unitType of ["plan-slice", "refine-slice", "replan-slice"]) {
+    const result = shouldBlockAutoUnitToolCall(unitType, "gsd_plan_task");
+    assert.equal(result.block, true, `${unitType} should not call stale gsd_plan_task`);
+  }
+});
+
 test("Recovery Classification covers ADR-015 failure families", () => {
   const cases = [
     ["invalid tool schema enum", "tool-schema", "stop"],

package/src/resources/extensions/gsd/tests/schema-v21-sequence.test.ts

@@ -24,6 +24,7 @@ import {
   openDatabase,
   closeDatabase,
   _getAdapter,
+  SCHEMA_VERSION,
 } from '../gsd-db.ts';
 
 const _require = createRequire(import.meta.url);
@@ -403,9 +404,10 @@ test('schema v21 migration: upgrading from v20 lands on current SCHEMA_VERSION',
     // The DB must reach the current SCHEMA_VERSION.  If the v21 block was
     // skipped (as it would be when SCHEMA_VERSION was still 20), this
     // assertion catches it.
-    assert.ok(
-      maxVersion >= 21,
-      `DB upgraded from v20 must reach at least schema version 21; got ${maxVersion}`,
+    assert.equal(
+      maxVersion,
+      SCHEMA_VERSION,
+      `DB upgraded from v20 must reach schema version ${SCHEMA_VERSION}; got ${maxVersion}`,
     );
   } finally {
     cleanup(base);

package/src/resources/extensions/gsd/tests/schema-v27-v28-sequence.test.ts

@@ -1,16 +1,17 @@
-// gsd-pi / V27 + V28 schema migration regression tests
+// gsd-pi / V27 + V28 + V29 schema migration regression tests
 //
 // Same bug class as #4591 (schema-v21-sequence): a migration block can be
 // added but the SCHEMA_VERSION constant left unchanged, causing fresh-install
-// + upgrade paths to silently skip the column add. This file pins both V27
-// (artifacts.content_hash) and V28 (memories.last_hit_at) at the schema and
-// write-path level on fresh-install DBs.
+// + upgrade paths to silently skip the column add. This file pins V27
+// (artifacts.content_hash), V28 (memories.last_hit_at), and V29
+// (target_repositories) at the schema/write-path level.
 
 import test from "node:test";
 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,
@@ -22,8 +23,10 @@ import {
   SCHEMA_VERSION,
 } from "../gsd-db.ts";
 
+const _require = createRequire(import.meta.url);
+
 function makeTmp(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "gsd-v27v28-"));
+  return fs.mkdtempSync(path.join(os.tmpdir(), "gsd-v27v29-"));
 }
 
 function cleanup(base: string): void {
@@ -31,10 +34,114 @@ function cleanup(base: string): void {
   try { fs.rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
 }
 
-test("SCHEMA_VERSION constant is at least 28 (V28 migration committed)", () => {
+function columnNames(table: string): Set<string> {
+  const db = _getAdapter()!;
+  const cols = db.prepare(`PRAGMA table_info(${table})`).all() as Array<Record<string, unknown>>;
+  return new Set(cols.map((c) => c["name"] as string));
+}
+
+function createV28Db(dbPath: string): void {
+  const sqlite = _require("node:sqlite") as {
+    DatabaseSync: new (p: string) => {
+      exec(sql: string): void;
+      close(): void;
+    };
+  };
+  const db = new sqlite.DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec(`
+    CREATE TABLE schema_version (
+      version INTEGER NOT NULL,
+      applied_at TEXT NOT NULL
+    );
+    INSERT INTO schema_version (version, applied_at) VALUES (28, '2026-01-01T00:00:00.000Z');
+
+    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 '',
+      sequence INTEGER DEFAULT 0
+    );
+    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,
+      replan_triggered_at TEXT DEFAULT NULL,
+      is_sketch INTEGER NOT NULL DEFAULT 0,
+      sketch_scope TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (milestone_id, id),
+      FOREIGN KEY (milestone_id) REFERENCES milestones(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,
+      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,
+      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,
+      PRIMARY KEY (milestone_id, slice_id, id),
+      FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+    );
+  `);
+  db.close();
+}
+
+test("SCHEMA_VERSION constant is at least 29 (V29 migration committed)", () => {
   assert.ok(
-    SCHEMA_VERSION >= 28,
-    `SCHEMA_VERSION must be ≥ 28 after V28 migration; got ${SCHEMA_VERSION}`,
+    SCHEMA_VERSION >= 29,
+    `SCHEMA_VERSION must be ≥ 29 after V29 migration; got ${SCHEMA_VERSION}`,
   );
 });
 
@@ -43,11 +150,8 @@ test("fresh-install DB has artifacts.content_hash column (V27)", () => {
   const dbPath = path.join(base, "gsd.db");
   try {
     openDatabase(dbPath);
-    const db = _getAdapter()!;
-    const cols = db.prepare("PRAGMA table_info(artifacts)").all() as Array<Record<string, unknown>>;
-    const colNames = new Set(cols.map((c) => c["name"] as string));
     assert.ok(
-      colNames.has("content_hash"),
+      columnNames("artifacts").has("content_hash"),
       "V27 must add content_hash column to artifacts on fresh install",
     );
   } finally {
@@ -60,11 +164,8 @@ test("fresh-install DB has memories.last_hit_at column (V28)", () => {
   const dbPath = path.join(base, "gsd.db");
   try {
     openDatabase(dbPath);
-    const db = _getAdapter()!;
-    const cols = db.prepare("PRAGMA table_info(memories)").all() as Array<Record<string, unknown>>;
-    const colNames = new Set(cols.map((c) => c["name"] as string));
     assert.ok(
-      colNames.has("last_hit_at"),
+      columnNames("memories").has("last_hit_at"),
       "V28 must add last_hit_at column to memories on fresh install",
     );
   } finally {
@@ -72,15 +173,58 @@ test("fresh-install DB has memories.last_hit_at column (V28)", () => {
   }
 });
 
-test("fresh-install DB stamps SCHEMA_VERSION (≥28) in schema_version table", () => {
+test("fresh-install DB has target_repositories columns (V29)", () => {
   const base = makeTmp();
   const dbPath = path.join(base, "gsd.db");
   try {
     openDatabase(dbPath);
+    assert.ok(
+      columnNames("slices").has("target_repositories"),
+      "V29 must add target_repositories column to slices on fresh install",
+    );
+    assert.ok(
+      columnNames("tasks").has("target_repositories"),
+      "V29 must add target_repositories column to tasks on fresh install",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("fresh-install DB stamps current SCHEMA_VERSION in schema_version table", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get() as Record<string, unknown> | undefined;
+    const max = (row?.["v"] as number) ?? 0;
+    assert.equal(max, SCHEMA_VERSION, `fresh install must record schema_version ${SCHEMA_VERSION}; got ${max}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("upgrading from V28 adds target_repositories and stamps V29", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  createV28Db(dbPath);
+
+  try {
+    openDatabase(dbPath);
+    assert.ok(
+      columnNames("slices").has("target_repositories"),
+      "V29 migration must add target_repositories column to existing slices table",
+    );
+    assert.ok(
+      columnNames("tasks").has("target_repositories"),
+      "V29 migration must add target_repositories column to existing tasks table",
+    );
+
     const db = _getAdapter()!;
     const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get() as Record<string, unknown> | undefined;
     const max = (row?.["v"] as number) ?? 0;
-    assert.ok(max >= 28, `fresh install must record schema_version ≥ 28; got ${max}`);
+    assert.equal(max, SCHEMA_VERSION, `V28 DB must upgrade to schema_version ${SCHEMA_VERSION}; got ${max}`);
   } finally {
     cleanup(base);
   }