gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.42ef05fbe

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

@@ -15,6 +15,7 @@ import {
   type SkillsPolicy,
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
+import { ALLOWED_PLANNING_DISPATCH_AGENTS } from "../bootstrap/write-gate.ts";
 
 // ─── Coverage: every known unit type has a manifest ──────────────────────
 
@@ -231,6 +232,11 @@ test('planning-dispatch mode is reserved for slice-level decomposition and compl
     "refine-slice",
     "complete-slice",
     "complete-milestone",
+    // Deep planning mode: research-project orchestrates 4 parallel research
+    // subagents (stack/features/architecture/pitfalls). Subagent dispatch is
+    // the unit's core mechanism — without it, the unit cannot do its job.
+    "research-project",
+    "validate-milestone",
   ]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
@@ -256,6 +262,10 @@ test('planning-dispatch manifests declare non-empty allowedSubagents lists', ()
         typeof agent === "string" && agent.length > 0,
         `manifest "${unitType}" has empty/invalid allowedSubagents entry: ${JSON.stringify(agent)}`,
       );
+      assert.ok(
+        ALLOWED_PLANNING_DISPATCH_AGENTS.has(agent),
+        `manifest "${unitType}" allows "${agent}", but the runtime planning-dispatch registry will hard-block it`,
+      );
     }
   }
 });

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -16,6 +16,7 @@ import type { GSDState, Phase } from "../types.ts";
 import {
   ensurePlanV2Graph,
   hasFinalizedMilestoneContext,
+  isEmptyPlanV2GraphResult,
   isMissingFinalizedContextResult,
 } from "../uok/plan-v2.ts";
 
@@ -113,6 +114,30 @@ test("guided flow routes recoverable missing finalized context to discuss-milest
   );
 });
 
+test("guided flow checks pending deep setup before plan-v2 gate", () => {
+  const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
+  const showSmartEntryIdx = source.indexOf("export async function showSmartEntry");
+  assert.notEqual(showSmartEntryIdx, -1);
+  const deepIdx = source.indexOf("hasPendingDeepStage(prefs, basePath)", showSmartEntryIdx);
+  const planIdx = source.indexOf("runPlanV2Gate(ctx, basePath, state)", showSmartEntryIdx);
+  assert.ok(
+    deepIdx > -1 && planIdx > -1 && deepIdx < planIdx,
+    "foreground deep setup must run before plan-v2 can fail-close guided /gsd",
+  );
+  assert.ok(
+    source.includes("loadEffectiveGSDPreferences(basePath)?.preferences"),
+    "guided plan-v2 gate must load preferences from the target project root",
+  );
+});
+
+test("auto pre-dispatch uses resolved plan-v2 defaults", () => {
+  const source = readFileSync(join(gsdDir, "auto", "phases.ts"), "utf-8");
+  assert.ok(
+    source.includes("uokFlags.planV2 && shouldRunPlanV2Gate(state.phase)"),
+    "auto-mode should honor resolveUokFlags defaults, not only explicit uok.plan_v2.enabled",
+  );
+});
+
 test("plan-v2 gate fails closed for execution phase when finalized context is missing", () => {
   const basePath = createBasePath();
   seedGraphRows();
@@ -204,4 +229,27 @@ test("plan-v2 ensure rejects empty executable graph", () => {
   const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
   assert.equal(compiled.ok, false);
   assert.match(compiled.reason ?? "", /compiled graph is empty/i);
+  assert.equal(isEmptyPlanV2GraphResult(compiled), true);
+});
+
+test("plan-v2 allows empty graph for milestone terminal phases", () => {
+  const basePath = createBasePath();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  insertSlice({
+    id: SLICE_ID,
+    milestoneId: MILESTONE_ID,
+    title: "Slice",
+    status: "complete",
+    sequence: 1,
+  });
+
+  const validating = ensurePlanV2Graph(basePath, buildState("validating-milestone"));
+  assert.equal(validating.ok, true);
+  assert.equal(validating.nodeCount, 0);
+
+  const completing = ensurePlanV2Graph(basePath, buildState("completing-milestone"));
+  assert.equal(completing.ok, true);
+  assert.equal(completing.nodeCount, 0);
 });

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

@@ -43,6 +43,33 @@ test("auto execute-task requires legacy completion alias until prompt contract i
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), ["gsd_complete_task"]);
 });
 
+test("deep project setup units declare required workflow MCP tools", () => {
+  assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("discuss-project"), [
+    "ask_user_questions",
+    "gsd_summary_save",
+  ]);
+  assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("discuss-requirements"), [
+    "ask_user_questions",
+    "gsd_requirement_save",
+    "gsd_summary_save",
+  ]);
+  assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("research-decision"), [
+    "ask_user_questions",
+  ]);
+  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("discuss-project"), [
+    "ask_user_questions",
+    "gsd_summary_save",
+  ]);
+  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("discuss-requirements"), [
+    "ask_user_questions",
+    "gsd_requirement_save",
+    "gsd_summary_save",
+  ]);
+  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("research-decision"), [
+    "ask_user_questions",
+  ]);
+});
+
 test("detectWorkflowMcpLaunchConfig prefers explicit env override", () => {
   const launch = detectWorkflowMcpLaunchConfig("/tmp/project", {
     GSD_WORKFLOW_MCP_NAME: "workflow-tools",
@@ -62,12 +89,29 @@ test("detectWorkflowMcpLaunchConfig prefers explicit env override", () => {
   });
   assert.equal(launch?.env?.FOO, "bar");
   assert.equal(launch?.env?.GSD_CLI_PATH, "/tmp/gsd");
+  assert.equal(launch?.env?.GSD_BIN_PATH, "/tmp/gsd");
   assert.equal(launch?.env?.GSD_PERSIST_WRITE_GATE_STATE, "1");
   assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
   assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
   assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
 });
 
+test("detectWorkflowMcpLaunchConfig normalizes explicit workflow MCP env CLI aliases", () => {
+  const binOnly = detectWorkflowMcpLaunchConfig("/tmp/project", {
+    GSD_WORKFLOW_MCP_COMMAND: "node",
+    GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_BIN_PATH: "/tmp/gsd-bin" }),
+  });
+  assert.equal(binOnly?.env?.GSD_CLI_PATH, "/tmp/gsd-bin");
+  assert.equal(binOnly?.env?.GSD_BIN_PATH, "/tmp/gsd-bin");
+
+  const cliOnly = detectWorkflowMcpLaunchConfig("/tmp/project", {
+    GSD_WORKFLOW_MCP_COMMAND: "node",
+    GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd-cli" }),
+  });
+  assert.equal(cliOnly?.env?.GSD_CLI_PATH, "/tmp/gsd-cli");
+  assert.equal(cliOnly?.env?.GSD_BIN_PATH, "/tmp/gsd-cli");
+});
+
 test("buildWorkflowMcpServers mirrors explicit launch config", () => {
   const servers = buildWorkflowMcpServers("/tmp/project", {
     GSD_WORKFLOW_MCP_COMMAND: "node",
@@ -135,6 +179,7 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server from GSD_BIN_PAT
     env: launch?.env,
   });
   assert.equal(launch?.env?.GSD_CLI_PATH, devCliPath);
+  assert.equal(launch?.env?.GSD_BIN_PATH, devCliPath);
   assert.equal(launch?.env?.GSD_PERSIST_WRITE_GATE_STATE, "1");
   assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, worktreeRoot);
   assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
@@ -149,6 +194,7 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the
   assert.equal(launch?.command, process.execPath);
   assert.equal(launch?.cwd, "/tmp/project");
   assert.equal(launch?.env?.GSD_CLI_PATH, "/tmp/gsd-loader.js");
+  assert.equal(launch?.env?.GSD_BIN_PATH, "/tmp/gsd-loader.js");
   assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
   assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
   assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
@@ -166,6 +212,7 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the
   assert.equal(launch?.command, process.execPath);
   assert.equal(launch?.cwd, "/tmp/project");
   assert.equal(launch?.env?.GSD_CLI_PATH, undefined);
+  assert.equal(launch?.env?.GSD_BIN_PATH, undefined);
   assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
   assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
   assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
@@ -464,11 +511,20 @@ test("usesWorkflowMcpTransport matches local externalCli providers", () => {
   assert.equal(usesWorkflowMcpTransport("oauth", "local://custom"), false);
 });
 
-test("supportsStructuredQuestions stays enabled on workflow MCP transports when ask_user_questions is available", () => {
+test("supportsStructuredQuestions disables local workflow MCP questions unless explicitly enabled", () => {
   assert.equal(
     supportsStructuredQuestions(["ask_user_questions"], {
       authMode: "externalCli",
       baseUrl: "local://claude-code",
+      env: {},
+    }),
+    false,
+  );
+  assert.equal(
+    supportsStructuredQuestions(["mcp__gsd-workflow__ask_user_questions"], {
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+      env: { GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS: "1" } as NodeJS.ProcessEnv,
     }),
     true,
   );

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

@@ -10,8 +10,9 @@ import {
   closeDatabase,
   _getAdapter,
   insertGateRow,
+  upsertRequirement,
 } from "../gsd-db.ts";
-import { markDepthVerified, clearDiscussionFlowState, loadWriteGateSnapshot } from "../bootstrap/write-gate.ts";
+import { markApprovalGateVerified, markDepthVerified, clearDiscussionFlowState, loadWriteGateSnapshot, setPendingGate } from "../bootstrap/write-gate.ts";
 import {
   executeCompleteMilestone,
   executePlanMilestone,
@@ -682,6 +683,248 @@ test("executeSummarySave removes sibling CONTEXT-DRAFT when writing milestone CO
   }
 });
 
+test("executeSummarySave supports root-level deep planning artifacts", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const project = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+    }, base));
+    assert.equal(project.isError, undefined);
+    assert.equal(project.details.path, "PROJECT.md");
+    assert.ok(existsSync(join(base, ".gsd", "PROJECT.md")));
+
+    upsertRequirement({
+      id: "R001",
+      class: "primary-user-loop",
+      status: "active",
+      description: "User can add a task",
+      why: "Core loop",
+      source: "user",
+      primary_owner: "M001/none yet",
+      supporting_slices: "none",
+      validation: "unmapped",
+      notes: "",
+      full_content: "",
+      superseded_by: null,
+    });
+
+    const requirements = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS",
+      content: "# Requirements\n\n## Active\n\n## Validated\n\n## Deferred\n\n## Out of Scope\n\n## Traceability\n\n## Coverage Summary\n",
+    }, base));
+    assert.equal(requirements.isError, undefined);
+    assert.equal(requirements.details.path, "REQUIREMENTS.md");
+    assert.equal(requirements.details.content_source, "requirements_table");
+    assert.ok(existsSync(join(base, ".gsd", "REQUIREMENTS.md")));
+
+    const db = _getAdapter();
+    const rows = db!.prepare(
+      "SELECT path, artifact_type, milestone_id FROM artifacts WHERE path IN ('PROJECT.md', 'REQUIREMENTS.md') ORDER BY path",
+    ).all() as Array<Record<string, unknown>>;
+    assert.deepEqual(
+      rows.map((row) => [row.path, row.artifact_type, row.milestone_id]),
+      [
+        ["PROJECT.md", "PROJECT", null],
+        ["REQUIREMENTS.md", "REQUIREMENTS", null],
+      ],
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave blocks final root artifacts while approval gate is pending", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    await inProjectDir(base, async () => {
+      setPendingGate("depth_verification_requirements_confirm");
+    });
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS",
+      content: "# Requirements\n\n## Active\n",
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.equal(result.details.error, "root_artifact_write_blocked");
+    assert.match(result.content[0].text, /has not been confirmed/);
+    assert.equal(existsSync(join(base, ".gsd", "REQUIREMENTS.md")), false);
+
+    const draft = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS-DRAFT",
+      content: "# Draft Requirements\n",
+    }, base));
+    assert.equal(draft.isError, undefined);
+    assert.ok(existsSync(join(base, ".gsd", "REQUIREMENTS-DRAFT.md")));
+  } finally {
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave requires verified root approval in deep mode", async () => {
+  const base = makeTmpBase();
+  try {
+    writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\nplanning_depth: deep\n---\n");
+    openTestDb(base);
+
+    const blocked = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+    }, base));
+
+    assert.equal(blocked.isError, true);
+    assert.equal(blocked.details.error, "root_artifact_write_blocked");
+    assert.match(blocked.content[0].text, /fail-closed/);
+    assert.equal(existsSync(join(base, ".gsd", "PROJECT.md")), false);
+
+    await inProjectDir(base, async () => {
+      markApprovalGateVerified("depth_verification_project_confirm", base);
+    });
+
+    const unblocked = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+    }, base));
+
+    assert.equal(unblocked.isError, undefined);
+    assert.equal(unblocked.details.path, "PROJECT.md");
+    assert.ok(existsSync(join(base, ".gsd", "PROJECT.md")));
+  } finally {
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave renders final REQUIREMENTS from the DB source of truth", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    await inProjectDir(base, async () => {
+      markApprovalGateVerified("depth_verification_requirements_confirm", base);
+    });
+
+    upsertRequirement({
+      id: "R001",
+      class: "primary-user-loop",
+      status: "active",
+      description: "User can add a task",
+      why: "Core loop",
+      source: "user",
+      primary_owner: "M001/none yet",
+      supporting_slices: "none",
+      validation: "unmapped",
+      notes: "saved through requirement tool",
+      full_content: "",
+      superseded_by: null,
+    });
+
+    const requirementsPath = join(base, ".gsd", "REQUIREMENTS.md");
+    const bloatedMarkdown = [
+      "# Requirements",
+      "",
+      "## Active",
+      "",
+      ...Array.from({ length: 30 }, (_, i) => [
+        `### R${String(i + 100).padStart(3, "0")} — Duplicate`,
+        "- Class: primary-user-loop",
+        "- Status: active",
+        "- Description: Duplicate retry row",
+        "- Why it matters: Retry drift",
+        "- Source: test",
+        "- Primary owning slice: M001/none yet",
+        "- Supporting slices: none",
+        "- Validation: unmapped",
+        "",
+      ].join("\n")),
+    ].join("\n");
+    writeFileSync(requirementsPath, bloatedMarkdown);
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS",
+      content: "# Requirements\n\n## Active\n\n### R999 — Wrong markdown source\n\n- Description: This content must not become canonical.\n",
+    }, base));
+
+    assert.equal(result.isError, undefined);
+    assert.equal(result.details.path, "REQUIREMENTS.md");
+    assert.equal(result.details.content_source, "requirements_table");
+
+    const content = readFileSync(requirementsPath, "utf-8");
+    assert.match(content, /### R001 — User can add a task/);
+    assert.match(content, /## Validated/);
+    assert.match(content, /## Deferred/);
+    assert.match(content, /## Out of Scope/);
+    assert.doesNotMatch(content, /R999|Wrong markdown source|This content must not become canonical/);
+    assert.ok(
+      Buffer.byteLength(content, "utf-8") < Buffer.byteLength(bloatedMarkdown, "utf-8") * 0.5,
+      "test setup proves final DB projection may be much smaller than accumulated retry output",
+    );
+
+    const db = _getAdapter();
+    const reqRows = db!
+      .prepare("SELECT id, description FROM requirements ORDER BY id")
+      .all() as Array<Record<string, unknown>>;
+    assert.deepEqual(
+      reqRows.map((row) => [row.id, row.description]),
+      [["R001", "User can add a task"]],
+      "summary save must not parse markdown back into requirements rows",
+    );
+
+    const artifact = db!
+      .prepare("SELECT full_content FROM artifacts WHERE path = ?")
+      .get("REQUIREMENTS.md") as Record<string, unknown>;
+    assert.equal(artifact.full_content, content);
+  } finally {
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave rejects final REQUIREMENTS when the DB source is empty", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS",
+      content: "# Requirements\n\n## Active\n\n",
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.equal(result.details.error, "no_active_requirements");
+    assert.match(result.content[0].text, /no active requirements found/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave rejects milestone-scoped artifacts without milestone_id", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "CONTEXT",
+      content: "# Context\n",
+    }, base));
+    assert.equal(result.isError, true);
+    assert.equal(result.details.error, "missing_milestone_id");
+    assert.match(result.content[0].text, /milestone_id is required/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSummarySave removes sibling CONTEXT-DRAFT when writing slice CONTEXT (#4442)", async () => {
   const base = makeTmpBase();
   try {

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

@@ -1,5 +1,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
   WorktreeResolver,
   type WorktreeResolverDeps,
@@ -271,6 +274,24 @@ test("enterMilestone is no-op when isolation mode is none", () => {
   assert.equal(findCalls(deps.calls, "enterBranchModeForMilestone").length, 0);
 });
 
+test("enterMilestone passes project root to isolation mode guard", () => {
+  const s = makeSession({ basePath: "/project", originalBasePath: "/project" });
+  let checkedBasePath: string | undefined;
+  const deps = makeDeps({
+    getIsolationMode: (basePath?: string) => {
+      checkedBasePath = basePath;
+      return "none";
+    },
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.enterMilestone("M001", ctx);
+
+  assert.equal(checkedBasePath, "/project");
+  assert.equal(findCalls(deps.calls, "createAutoWorktree").length, 0);
+});
+
 test("enterMilestone does NOT update basePath on creation failure", () => {
   const s = makeSession();
   const deps = makeDeps({
@@ -1142,3 +1163,85 @@ test("mergeAndExit propagates non-MergeConflictError to caller (#4380)", () => {
     "non-MergeConflictError must propagate to the caller, not be swallowed",
   );
 });
+
+// ─── Regression: mergeAndExit anchors cwd at project root before merge work ─
+// (de73fb43d headless `gsd auto` exits-on-task regression)
+//
+// Background: the auto loop runs tasks inside the milestone worktree
+// (process.cwd() === worktreePath). When the milestone completes, the
+// worktree dir is torn down. If cwd was still inside it at that moment,
+// every subsequent process.cwd() throws ENOENT — and after de73fb43d
+// auto/run-unit.ts:50 turns that ENOENT into a session-failed cancel,
+// which in headless mode bubbles up to a "Auto-mode stopped" notify
+// and process.exit(0). mergeAndExit must therefore guarantee cwd is
+// anchored at the project root regardless of which merge path runs.
+
+test("mergeAndExit chdirs to project root before merge work (regression: headless gsd auto exit)", () => {
+  // Set up real dirs so process.chdir actually succeeds. realpathSync
+  // canonicalizes the macOS /var → /private/var symlink so equality holds.
+  const projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsd-resolver-cwd-")));
+  const worktreePath = join(projectRoot, ".gsd/worktrees/M001");
+  mkdirSync(worktreePath, { recursive: true });
+  const previousCwd = process.cwd();
+
+  try {
+    process.chdir(worktreePath);
+    assert.equal(process.cwd(), worktreePath, "precondition: cwd is in worktree");
+
+    const s = makeSession({
+      basePath: worktreePath,
+      originalBasePath: projectRoot,
+    });
+    const deps = makeDeps({
+      isInAutoWorktree: () => true,
+      getIsolationMode: () => "worktree",
+    });
+    const ctx = makeNotifyCtx();
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.mergeAndExit("M001", ctx);
+
+    assert.equal(
+      process.cwd(),
+      projectRoot,
+      "mergeAndExit must leave cwd at the project root, not the (about-to-be-removed) worktree",
+    );
+  } finally {
+    try { process.chdir(previousCwd); } catch { /* best-effort */ }
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("mergeAndExit anchors cwd even on isolation-degraded skip path", () => {
+  // The skip paths (isolation-degraded, mode-none, missing-original-base)
+  // bypass the per-mode merge helpers entirely. They must still leave cwd
+  // at the project root so a subsequent worktree teardown elsewhere does
+  // not strand cwd in a deleted dir.
+  const projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsd-resolver-cwd-degraded-")));
+  const worktreePath = join(projectRoot, ".gsd/worktrees/M001");
+  mkdirSync(worktreePath, { recursive: true });
+  const previousCwd = process.cwd();
+
+  try {
+    process.chdir(worktreePath);
+    const s = makeSession({
+      basePath: worktreePath,
+      originalBasePath: projectRoot,
+    });
+    s.isolationDegraded = true;
+    const deps = makeDeps({ getIsolationMode: () => "worktree" });
+    const ctx = makeNotifyCtx();
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.mergeAndExit("M001", ctx);
+
+    assert.equal(
+      process.cwd(),
+      projectRoot,
+      "isolation-degraded skip must still anchor cwd at project root",
+    );
+  } finally {
+    try { process.chdir(previousCwd); } catch { /* best-effort */ }
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,50 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+import { resolveProjectRoot } from "../worktree.ts";
+
+function makeParentRepo(): string {
+  const parent = join(tmpdir(), `gsd-root-resolution-${randomUUID()}`);
+  mkdirSync(parent, { recursive: true });
+  execFileSync("git", ["init"], { cwd: parent, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: parent });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: parent });
+  return parent;
+}
+
+test("resolveProjectRoot prefers nearest bootstrapped .gsd before parent git root", () => {
+  const parent = makeParentRepo();
+  const child = join(parent, "nested-app");
+  const nested = join(child, "src", "components");
+
+  try {
+    mkdirSync(join(parent, ".gsd", "milestones"), { recursive: true });
+    mkdirSync(join(child, ".gsd"), { recursive: true });
+    mkdirSync(nested, { recursive: true });
+    writeFileSync(join(child, ".gsd", "PREFERENCES.md"), "---\nplanning_depth: deep\n---\n");
+
+    assert.equal(resolveProjectRoot(child), child);
+    assert.equal(resolveProjectRoot(nested), child);
+  } finally {
+    rmSync(parent, { recursive: true, force: true });
+  }
+});
+
+test("resolveProjectRoot ignores zombie .gsd without bootstrap artifacts", () => {
+  const parent = makeParentRepo();
+  const child = join(parent, "nested-app");
+
+  try {
+    mkdirSync(join(parent, ".gsd", "milestones"), { recursive: true });
+    mkdirSync(join(child, ".gsd"), { recursive: true });
+
+    assert.equal(resolveProjectRoot(child), parent);
+  } finally {
+    rmSync(parent, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/write-gate-predicates.test.ts

@@ -84,11 +84,12 @@ test('shouldBlockPendingGate: pending gate → allow ask_user_questions', (t) =>
   assert.strictEqual(r.block, false);
 });
 
-test('shouldBlockPendingGate: pending gate → allow read', (t) => {
+test('shouldBlockPendingGate: pending gate → block read so approval question stays visible', (t) => {
   t.after(() => clearDiscussionFlowState());
   setPendingGate('depth_verification_M001');
   const r = shouldBlockPendingGate('read', 'M001');
-  assert.strictEqual(r.block, false);
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason?.includes('already asked for user confirmation'));
 });
 
 // ─── shouldBlockPendingGateBash ───────────────────────────────────────────
@@ -108,18 +109,19 @@ test('shouldBlockPendingGateBash: pending gate → block mutating bash', (t) =>
   assert.ok(r.reason?.includes('depth_verification_M001'));
 });
 
-test('shouldBlockPendingGateBash: pending gate → allow read-only bash (cat)', (t) => {
+test('shouldBlockPendingGateBash: pending gate → block read-only bash (cat)', (t) => {
   t.after(() => clearDiscussionFlowState());
   setPendingGate('depth_verification_M001');
   const r = shouldBlockPendingGateBash('cat README.md', 'M001');
-  assert.strictEqual(r.block, false);
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason?.includes('already asked for user confirmation'));
 });
 
-test('shouldBlockPendingGateBash: pending gate → allow read-only bash (git log)', (t) => {
+test('shouldBlockPendingGateBash: pending gate → block read-only bash (git log)', (t) => {
   t.after(() => clearDiscussionFlowState());
   setPendingGate('depth_verification_M001');
   const r = shouldBlockPendingGateBash('git log --oneline -10', 'M001');
-  assert.strictEqual(r.block, false);
+  assert.strictEqual(r.block, true);
 });
 
 // ─── shouldBlockContextWrite ──────────────────────────────────────────────