@opengsd/gsd-pi 1.0.2-dev.e70300c → 1.0.2-dev.fb7ddf1

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -5,7 +5,8 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
-import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
+import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, requestHasGsdCustomType, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
+import { applyUnitSkillVisibility } from "../skill-scope.ts";
 
 test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
   const result = buildMinimalGsdToolSet([
@@ -54,6 +55,17 @@ test("buildMinimalGsdToolSet always preserves ToolSearch shim", () => {
   assert.ok(result.includes("ToolSearch"));
 });
 
+test("requestHasGsdCustomType detects GSD-driven requests (drives interactive default scoping)", () => {
+  // Plain interactive chat → no gsd-* customType → scoped to the minimal set.
+  assert.equal(requestHasGsdCustomType(undefined), false);
+  assert.equal(requestHasGsdCustomType([]), false);
+  assert.equal(requestHasGsdCustomType([{ customType: "user" }, {}]), false);
+  // GSD workflow commands carry a gsd-* customType → keep their full surface.
+  assert.equal(requestHasGsdCustomType([{ customType: "gsd-quick-task" }]), true);
+  assert.equal(requestHasGsdCustomType([{}, { customType: "gsd-workflow-template" }]), true);
+  assert.equal(requestHasGsdCustomType([{ customType: "gsd-run" }]), true);
+});
+
 test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without aliases", () => {
   const result = buildMinimalAutoGsdToolSet([
     "ask_user_questions",
@@ -86,6 +98,24 @@ test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without al
   assert.ok(!result.includes("gsd_complete_slice"));
 });
 
+test("buildMinimalAutoGsdToolSet re-resolves run-uat browser tools from the registry when dropped from the active set", () => {
+  // B2 drops the browser surface from the advertised interactive set, but the
+  // tools stay registered. run-uat must still get them: resolution reads the
+  // full registry, not just the (browser-stripped) active set.
+  const active = ["ask_user_questions", "bash", "read", "gsd_summary_save"];
+  const registered = [
+    ...active,
+    "browser_navigate",
+    "browser_click",
+    "browser_snapshot_refs",
+    "gsd_exec",
+  ];
+  const result = buildMinimalAutoGsdToolSet(active, "run-uat", registered);
+  assert.ok(result.includes("browser_navigate"), "run-uat needs browser_navigate");
+  assert.ok(result.includes("browser_click"), "run-uat needs browser_click");
+  assert.ok(result.includes("gsd_summary_save"));
+});
+
 test("buildMinimalAutoGsdToolSet keeps only the auto base non-GSD tools", () => {
   const result = buildMinimalAutoGsdToolSet([
     "ask_user_questions",
@@ -171,6 +201,24 @@ test("buildMinimalAutoGsdToolSet preserves browser tools for run-uat", () => {
   assert.ok(!result.includes("gsd_task_complete"));
 });
 
+test("buildMinimalAutoGsdToolSet includes discuss-slice persistence tools", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "gsd_summary_save",
+    "gsd_decision_save",
+    "gsd_plan_slice",
+    "gsd_task_complete",
+    "memory_query",
+    "capture_thought",
+  ], "discuss-slice");
+
+  assert.ok(result.includes("gsd_summary_save"));
+  assert.ok(result.includes("gsd_decision_save"));
+  assert.ok(!result.includes("gsd_plan_slice"));
+  assert.ok(!result.includes("gsd_task_complete"));
+});
+
 test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", () => {
   const result = buildMinimalAutoGsdToolSet([
     "bash",
@@ -435,3 +483,21 @@ test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visib
   assert.deepEqual(visibleSkills, ["previous-skill"]);
   assert.equal(calls.filter((call) => call.kind === "skills").length, 2);
 });
+
+test("applyUnitSkillVisibility sets manifest or clears for wildcard", () => {
+  const calls: Array<string[] | undefined> = [];
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      calls.push(names);
+    },
+  }, "plan-milestone");
+  assert.ok(Array.isArray(calls[0]));
+  assert.ok(calls[0]!.includes("tdd"));
+
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      calls.push(names);
+    },
+  }, "execute-task");
+  assert.equal(calls[1], undefined);
+});

package/src/resources/extensions/gsd/tests/tool-param-optionality.test.ts

@@ -235,12 +235,16 @@ test("gsd_task_complete — enrichment arrays are optional", () => {
     "milestoneId",
     "oneLiner",
     "narrative",
-    "verification",
   ];
   for (const field of coreRequired) {
     assert.ok(required.has(field), `core field "${field}" must be required`);
   }
 
+  assert.ok(
+    !required.has("verification"),
+    "verification must be optional at the schema layer so step-mode can recover when verificationEvidence is present",
+  );
+
   // Enrichment fields must be optional
   const enrichmentFields = [
     "keyFiles",
@@ -272,6 +276,25 @@ test("gsd_task_complete — validates with only core params", () => {
   assert.strictEqual(errors.length, 0, `Minimal params should validate but got errors: ${errors.join(", ")}`);
 });
 
+test("gsd_task_complete — accepts evidence-only verification at schema layer", () => {
+  const tool = getTool("gsd_task_complete");
+  assert.ok(tool, "gsd_task_complete must be registered");
+
+  const params = {
+    taskId: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    oneLiner: "Implemented the feature",
+    narrative: "Created the module and wired it up.",
+    verificationEvidence: [
+      { command: "npm test", exitCode: 0, verdict: "pass", durationMs: 1234 },
+    ],
+  };
+
+  const errors = validateSchema(tool, params);
+  assert.strictEqual(errors.length, 0, `Evidence-only params should validate but got errors: ${errors.join(", ")}`);
+});
+
 // ─── gsd_complete_milestone: enrichment arrays must be optional ──────────────
 
 test("gsd_complete_milestone — enrichment arrays are optional", () => {

package/src/resources/extensions/gsd/tests/tui-border-assertions.ts

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
+
+const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+function stripAnsi(text: string): string {
+  return text.replace(ANSI_PATTERN, "");
+}
+
+export function assertFullOuterBorder(lines: string[], width: number): void {
+  assert.ok(lines.length >= 2, "dialog must include top and bottom borders");
+
+  for (const [index, line] of lines.entries()) {
+    assert.equal(visibleWidth(line), width, `line ${index} must fill dialog width`);
+  }
+
+  const top = stripAnsi(lines[0] ?? "");
+  const bottom = stripAnsi(lines.at(-1) ?? "");
+  assert.match(top, /^[╭┌].*[╮┐]$/, `top border missing full corners: ${top}`);
+  assert.match(bottom, /^[╰└].*[╯┘]$/, `bottom border missing full corners: ${bottom}`);
+
+  for (let index = 1; index < lines.length - 1; index++) {
+    const line = stripAnsi(lines[index] ?? "");
+    assert.match(line, /^[│┃├]/, `line ${index} missing left border: ${line}`);
+    assert.match(line, /[│┃┤]$/, `line ${index} missing right border: ${line}`);
+  }
+}

package/src/resources/extensions/gsd/tests/tui-render-kit.test.ts

@@ -5,8 +5,10 @@ import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
 import { visibleWidth } from "@gsd/pi-tui";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 import {
   padRightVisible,
+  renderDialogFrame,
   renderFrame,
   renderKeyHints,
   renderPanel,
@@ -60,6 +62,18 @@ describe("tui render kit", () => {
     }
   });
 
+  test("renderDialogFrame draws a full titled modal border with footer", () => {
+    const lines = renderDialogFrame(theme, "Dialog", ["row", "long ".repeat(40)], 40, {
+      footer: renderKeyHints(theme, ["esc close"], 36),
+    });
+    assertWidth(lines, 40);
+    assertFullOuterBorder(lines, 40);
+    assert.match(lines[0] ?? "", /^╭─ Dialog ─+╮$/);
+    assert.ok(lines.some((line) => line.startsWith("│") && line.endsWith("│")));
+    assert.ok(lines.some((line) => line.startsWith("├") && line.endsWith("┤")));
+    assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
+  });
+
   test("renderPanel stays within width and draws no vertical borders", () => {
     for (const width of [3, 40, 80]) {
       const lines = renderPanel(theme, "Title", ["row", "long ".repeat(40)], width);

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -14,6 +14,7 @@ import {
   type SkillsPolicy,
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
+import { resolveSkillManifest } from "../skill-manifest.ts";
 import {
   ALLOWED_PLANNING_DISPATCH_AGENTS,
   shouldBlockPlanningUnit,
@@ -148,6 +149,23 @@ test("#4782 phase 1: skills policy shapes are valid discriminated-union members"
   }
 });
 
+test("#4782 phase 1b: allowlist skills policy matches skill-manifest resolver", () => {
+  for (const unitType of KNOWN_UNIT_TYPES) {
+    const manifest = UNIT_MANIFESTS[unitType];
+    const allowlist = resolveSkillManifest(unitType);
+    if (allowlist) {
+      assert.strictEqual(manifest.skills.mode, "allowlist", unitType);
+      assert.deepEqual(
+        [...(manifest.skills as Extract<SkillsPolicy, { mode: "allowlist" }>).skills].sort(),
+        [...allowlist].sort(),
+        unitType,
+      );
+    } else {
+      assert.notStrictEqual(manifest.skills.mode, "allowlist", unitType);
+    }
+  }
+});
+
 // ─── Lookup helper ────────────────────────────────────────────────────────
 
 test("#4782 phase 1: resolveManifest returns null for an unknown unit type", () => {

package/src/resources/extensions/gsd/tests/user-input-boundary.test.ts

@@ -0,0 +1,26 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import * as userInputBoundary from "../user-input-boundary.ts";
+
+test("lastAssistantText extracts the latest assistant text block content", () => {
+  const lastAssistantText = (userInputBoundary as {
+    lastAssistantText?: (messages: unknown[] | null | undefined) => string;
+  }).lastAssistantText;
+
+  assert.equal(typeof lastAssistantText, "function");
+  assert.equal(
+    lastAssistantText?.([
+      { role: "assistant", content: "Older message" },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "First line" },
+          { type: "text", text: "Second line" },
+        ],
+      },
+    ]),
+    "First line\nSecond line",
+  );
+  assert.equal(lastAssistantText?.(null), "");
+});

package/src/resources/extensions/gsd/tests/vision-ask.test.ts

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { chooseVisionAskVariant, VISION_ASK_VARIANTS } from "../vision-ask.ts";
+
+test("vision ask variants stay varied and conversational", () => {
+  assert.ok(VISION_ASK_VARIANTS.length >= 6, "keep enough openers to avoid repetition");
+  assert.equal(new Set(VISION_ASK_VARIANTS).size, VISION_ASK_VARIANTS.length, "openers should be unique");
+
+  for (const opener of VISION_ASK_VARIANTS) {
+    assert.ok(opener.length <= 72, `opener should stay short: ${opener}`);
+    assert.doesNotMatch(opener, /\n/, "opener should be a single line");
+    assert.doesNotMatch(opener, /\bstakeholders?|key success metrics?|business objectives?\b/i, "avoid corporate wording");
+    assert.notEqual(opener, "What's the vision?", "do not keep the old fixed opener in rotation");
+  }
+});
+
+test("chooseVisionAskVariant picks from the configured opener list", () => {
+  assert.equal(chooseVisionAskVariant(() => 0), VISION_ASK_VARIANTS[0]);
+  assert.equal(
+    chooseVisionAskVariant((exclusiveMax) => exclusiveMax - 1),
+    VISION_ASK_VARIANTS[VISION_ASK_VARIANTS.length - 1],
+  );
+});

package/src/resources/extensions/gsd/tests/visualizer-overlay.test.ts

@@ -14,6 +14,7 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 
 import { GSDVisualizerOverlay, TAB_COUNT } from "../visualizer-overlay.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 function makeTui() {
   const renders: number[] = [];
@@ -50,7 +51,11 @@ test("overlay renders 10 tabs (Progress, Timeline, Deps, Metrics, Health, Agent,
   overlay.loading = true; // body shows loading text, but tab bar renders regardless
 
   // Use a very wide terminal so the tab bar is not truncated.
-  const lines = overlay.render(200).map(stripAnsi);
+  const rawLines = overlay.render(200);
+  assertFullOuterBorder(rawLines, 200);
+  const lines = rawLines.map(stripAnsi);
+  assert.match(lines[0] ?? "", /^╭─ GSD Visualizer /);
+  assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
   const tabBar = lines.find((l) => l.includes("Progress") && l.includes("Export"));
   assert.ok(tabBar, `expected a tab-bar line containing all labels, got:\n${lines.slice(0, 5).join("\n")}`);
   for (const label of ["Progress", "Timeline", "Deps", "Metrics", "Health", "Agent", "Changes", "Knowledge", "Captures", "Export"]) {

package/src/resources/extensions/gsd/tests/workflow-mcp-auto-prep.test.ts

@@ -1,6 +1,12 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { GSD_WORKFLOW_MCP_SERVER_NAME } from "../mcp-project-config.ts";
+import { clearSkillSnapshot, snapshotSkills } from "../skill-discovery.js";
 import { prepareWorkflowMcpForProject, shouldAutoPrepareWorkflowMcp } from "../workflow-mcp-auto-prep.ts";
 
 test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport", () => {
@@ -74,3 +80,130 @@ test("prepareWorkflowMcpForProject warns with /gsd mcp init guidance when prep f
   assert.equal(notifications[0].level, "warning");
   assert.match(notifications[0].message, /Please run \/gsd mcp init \./);
 });
+
+test("before_agent_start auto-prepares project workflow MCP for Claude Code CLI", async (t) => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-before-agent-"));
+  const originalCwd = process.cwd();
+  const notifications: string[] = [];
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+    getActiveTools: () => [],
+    getAllTools: () => [],
+    setActiveTools() {},
+  };
+
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(projectRoot, { recursive: true, force: true });
+  });
+
+  process.chdir(projectRoot);
+  registerHooks(pi as any, []);
+
+  const beforeAgentStart = handlers.get("before_agent_start")?.[0];
+  assert.ok(beforeAgentStart, "before_agent_start hook should be registered");
+
+  await beforeAgentStart(
+    { prompt: "hello", systemPrompt: "base" },
+    {
+      cwd: projectRoot,
+      model: { provider: "claude-code", baseUrl: "local://claude-code" },
+      modelRegistry: {
+        getProviderAuthMode: () => "externalCli",
+        isProviderRequestReady: () => true,
+      },
+      ui: {
+        notify(message: string) {
+          notifications.push(message);
+        },
+        setWidget() {},
+      },
+    },
+  );
+
+  const configPath = join(projectRoot, ".mcp.json");
+  assert.equal(existsSync(configPath), true, "Claude Code CLI turns should create project MCP config");
+
+  const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as {
+    mcpServers?: Record<string, unknown>;
+  };
+  assert.ok(parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME]);
+  assert.match(notifications.join("\n"), /Claude Code MCP prepared/);
+});
+
+test("before_agent_start returns discovered skill fallback without project .gsd", async (t) => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-skill-before-agent-"));
+  const skillHome = mkdtempSync(join(tmpdir(), "gsd-skill-home-"));
+  const originalCwd = process.cwd();
+  const originalHome = process.env.HOME;
+  const originalGsdHome = process.env.GSD_HOME;
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+    getActiveTools: () => [],
+    getAllTools: () => [],
+    setActiveTools() {},
+  };
+
+  t.after(() => {
+    process.chdir(originalCwd);
+    clearSkillSnapshot();
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    if (originalGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = originalGsdHome;
+    }
+    rmSync(projectRoot, { recursive: true, force: true });
+    rmSync(skillHome, { recursive: true, force: true });
+  });
+
+  process.env.HOME = skillHome;
+  process.env.GSD_HOME = join(skillHome, ".gsd");
+  process.chdir(projectRoot);
+  snapshotSkills();
+
+  const skillDir = join(skillHome, ".agents", "skills", "late-skill");
+  mkdirSync(skillDir, { recursive: true });
+  const skillPath = join(skillDir, "SKILL.md");
+  writeFileSync(skillPath, "---\nname: late-skill\ndescription: Use for late skill.\n---\n\n# late-skill\n");
+
+  registerHooks(pi as any, []);
+  const beforeAgentStart = handlers.get("before_agent_start")?.[0];
+  assert.ok(beforeAgentStart, "before_agent_start hook should be registered");
+
+  const result = await beforeAgentStart(
+    { prompt: "hello", systemPrompt: "event system prompt" },
+    {
+      cwd: projectRoot,
+      model: { provider: "openai", baseUrl: "https://api.openai.com" },
+      modelRegistry: {
+        getProviderAuthMode: () => "apiKey",
+        isProviderRequestReady: () => false,
+      },
+      getSystemPrompt: () => "context system prompt",
+      reload: async () => {},
+      ui: {
+        notify() {},
+        setWidget() {},
+      },
+    },
+  );
+
+  assert.match(result?.systemPrompt ?? "", /<newly_discovered_skills>/);
+  assert.match(result?.systemPrompt ?? "", /late-skill/);
+  assert.equal(result?.systemPrompt?.includes(skillPath), true);
+});

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -108,6 +108,34 @@ test("executeSummarySave persists artifact and returns computed path", async ()
   }
 });
 
+test("executeSummarySave mirrors milestone artifacts into the active worktree projection", async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  try {
+    mkdirSync(join(worktree, ".gsd"), { recursive: true });
+    writeFileSync(join(worktree, ".git"), "gitdir: ../../../.git/worktrees/M001\n");
+    openTestDb(base);
+
+    const result = await inProjectDir(worktree, () => executeSummarySave({
+      milestone_id: "M001",
+      slice_id: "S02",
+      artifact_type: "RESEARCH",
+      content: "# S02 Research\n\ncanonical and worktree",
+    }, worktree));
+
+    assert.equal(result.details.operation, "save_summary");
+    const relPath = "milestones/M001/slices/S02/S02-RESEARCH.md";
+    const projectPath = join(base, ".gsd", relPath);
+    const worktreePath = join(worktree, ".gsd", relPath);
+    assert.equal(existsSync(projectPath), true, "canonical artifact should be written");
+    assert.equal(existsSync(worktreePath), true, "active worktree projection should be mirrored");
+    assert.match(readFileSync(worktreePath, "utf-8"), /S02 Research/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeTaskComplete coerces string verificationEvidence entries", async () => {
   const base = makeTmpBase();
   try {
@@ -148,6 +176,60 @@ test("executeTaskComplete coerces string verificationEvidence entries", async ()
   }
 });
 
+test("executeTaskComplete derives missing verification from evidence", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    const planDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(planDir, { recursive: true });
+    writeFileSync(join(planDir, "S01-PLAN.md"), "# S01\n\n- [ ] **T01: Demo** `est:5m`\n");
+
+    const result = await inProjectDir(base, () => executeTaskComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      taskId: "T01",
+      oneLiner: "Completed task",
+      narrative: "Did the work",
+      verificationEvidence: [
+        { command: "npm test", exitCode: 0, verdict: "pass", durationMs: 1234 },
+      ],
+    }, base));
+
+    assert.equal(result.details.operation, "complete_task");
+    const db = _getAdapter();
+    assert.ok(db, "DB should be open");
+    const row = db!.prepare(
+      "SELECT verification_result FROM tasks WHERE milestone_id = ? AND slice_id = ? AND id = ?",
+    ).get("M001", "S01", "T01") as Record<string, unknown> | undefined;
+
+    assert.match(String(row?.verification_result), /Verification evidence recorded/);
+    assert.match(String(row?.verification_result), /`npm test` exited 0 \(pass\)/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeTaskComplete returns a tool error when verification cannot be derived", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    const result = await inProjectDir(base, () => executeTaskComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      taskId: "T01",
+      oneLiner: "Completed task",
+      narrative: "Did the work",
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.match(String(result.content[0]?.text), /verification is required/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSliceComplete preserves omitted optional requirement arrays", async () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/workspace-git-preflight.test.ts

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import { probeGitConflictState } from "../git-conflict-state.js";
 import { ensureWorkspaceGitReadyForPath } from "../workspace-git-preflight.js";
 import { isWorkspaceGitAllowedCommand } from "../workspace-git-guard.js";
-import { cleanup, git, makeTempRepo } from "./test-utils.ts";
+import { cleanup, git, makeTempDir, makeTempRepo } from "./test-utils.ts";
 
 function seedGsdConflict(base: string): void {
   mkdirSync(join(base, ".gsd"), { recursive: true });
@@ -60,6 +60,21 @@ test("probeGitConflictState reports clean repo", () => {
   }
 });
 
+test("ensureWorkspaceGitReadyForPath allows fresh non-git project setup folders", async () => {
+  const base = makeTempDir("gsd-ws-git-non-repo-");
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    const probe = probeGitConflictState(base);
+    assert.equal(probe.status, "clean");
+
+    const ready = await ensureWorkspaceGitReadyForPath(base);
+    assert.equal(ready.ok, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("ensureWorkspaceGitReadyForPath auto-resolves .gsd/ conflicts", async () => {
   const base = makeTempRepo("gsd-ws-git-heal-");
   try {

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

@@ -212,6 +212,34 @@ test("enterMilestone returns ok:true mode:none when isolation disabled", () => {
   assert.equal(s.basePath, "/project");
 });
 
+test("adoptStrandedMilestone forces branch recovery even when normal preferences differ", (t) => {
+  const previousCwd = process.cwd();
+  const base = makeGitRepoBase({ isolation: "worktree" });
+  t.after(() => cleanupRepoBase(base, previousCwd));
+
+  const s = makeSession({ basePath: base, originalBasePath: base });
+  const deps = makeDeps();
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.adoptStrandedMilestone("M001", base, ctx, {
+    mode: "branch",
+  });
+
+  assert.equal(result.ok, true, `expected ok:true, got: ${JSON.stringify(result)}`);
+  if (result.ok) {
+    assert.equal(result.mode, "branch");
+    assert.equal(result.path, base);
+  }
+  assert.equal(s.basePath, base);
+  assert.equal(s.strandedRecoveryIsolationMode, "branch");
+  const currentBranch = execFileSync("git", ["branch", "--show-current"], {
+    cwd: base,
+    encoding: "utf-8",
+  }).trim();
+  assert.equal(currentBranch, "milestone/M001");
+});
+
 test("enterMilestone returns ok:false reason:isolation-degraded when session degraded", () => {
   const s = makeSession({ isolationDegraded: true });
   const deps = makeDeps({ getIsolationMode: () => "branch" });

package/src/resources/extensions/gsd/tests/worktree-state-projection.test.ts

@@ -2,7 +2,7 @@
 // File Purpose: Worktree State Projection Module — typed-Interface contract tests for projectRootToWorktree (ADR-016).
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
@@ -60,6 +60,43 @@ test("projectRootToWorktree is idempotent — repeated calls do not throw", () =
   }
 });
 
+test("projectRootToWorktree forwards root PROJECT.md into isolated worktrees", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const worktree = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    mkdirSync(join(worktree, ".gsd"), { recursive: true });
+
+    const projectContent = [
+      "# Project",
+      "",
+      "## Milestone Sequence",
+      "",
+      "- [ ] M001: Foundation — Establish the runnable slice.",
+      "",
+    ].join("\n");
+    writeFileSync(join(dir, ".gsd", "PROJECT.md"), projectContent);
+    writeFileSync(join(dir, ".gsd", "REQUIREMENTS.md"), "# Requirements\n");
+    writeFileSync(join(dir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+
+    const workspace = createWorkspace(worktree);
+    const scope = scopeMilestone(workspace, "M001");
+    const projection = new WorktreeStateProjection();
+
+    projection.projectRootToWorktree(scope);
+
+    const projectedProject = join(worktree, ".gsd", "PROJECT.md");
+    assert.ok(existsSync(projectedProject), "PROJECT.md is available to worktree-bound units");
+    assert.equal(readFileSync(projectedProject, "utf-8"), projectContent);
+    assert.ok(
+      existsSync(join(worktree, ".gsd", "milestones", "M001", "M001-ROADMAP.md")),
+      "milestone artifacts still project into the worktree",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
 // ─── projectWorktreeToRoot — Module contract ────────────────────────────────
 
 test("projectWorktreeToRoot exists and accepts a MilestoneScope", () => {