gsd-pi 2.80.0-dev.2be7caf18 → 2.80.0-dev.3065f7bfa

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

@@ -0,0 +1,291 @@
+// Project/App: GSD-2
+// File Purpose: Tests for opt-in GSD tool surface reduction.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
+
+test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
+  const result = buildMinimalGsdToolSet([
+    "bash",
+    "read",
+    "browser_open",
+    "gsd_plan_milestone",
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+    "gsd_graph",
+  ]);
+
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("browser_open"));
+  for (const toolName of MINIMAL_GSD_TOOL_NAMES) {
+    assert.ok(result.includes(toolName), `expected ${toolName}`);
+  }
+  assert.ok(!result.includes("gsd_plan_milestone"));
+  assert.ok(!result.includes("gsd_task_complete"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildMinimalGsdToolSet deduplicates preserved and minimal tools", () => {
+  const result = buildMinimalGsdToolSet(["bash", "bash", "memory_query"]);
+
+  assert.deepEqual(result.filter((toolName) => toolName === "bash"), ["bash"]);
+  assert.deepEqual(result.filter((toolName) => toolName === "memory_query"), ["memory_query"]);
+});
+
+test("buildMinimalGsdToolSet does not reintroduce provider-filtered GSD tools", () => {
+  const result = buildMinimalGsdToolSet(["bash", "read", "memory_query"]);
+
+  assert.deepEqual(result, ["bash", "read", "memory_query"]);
+  assert.ok(!result.includes("gsd_exec"));
+});
+
+test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without aliases", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "read",
+    "lsp",
+    "browser_click",
+    "gsd_task_complete",
+    "gsd_complete_task",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_slice_complete",
+    "gsd_complete_slice",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task");
+
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("memory_query"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("browser_click"));
+  assert.ok(!result.includes("gsd_complete_task"));
+  assert.ok(!result.includes("gsd_slice_complete"));
+  assert.ok(!result.includes("gsd_complete_slice"));
+});
+
+test("buildMinimalAutoGsdToolSet keeps only the auto base non-GSD tools", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "browser_wait_for",
+    "edit",
+    "glob",
+    "grep",
+    "lsp",
+    "ls",
+    "mac_find",
+    "read",
+    "subagent",
+    "write",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task");
+
+  for (const toolName of MINIMAL_AUTO_BASE_TOOL_NAMES) {
+    assert.ok(result.includes(toolName), `expected ${toolName}`);
+  }
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("mac_find"));
+  assert.ok(!result.includes("subagent"));
+});
+
+test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "subagent",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_task_complete",
+    "gsd_slice_complete",
+    "gsd_complete_slice",
+    "memory_query",
+    "capture_thought",
+  ], "complete-slice");
+
+  assert.ok(result.includes("gsd_slice_complete"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(result.includes("capture_thought"));
+  assert.ok(!result.includes("gsd_task_complete"));
+  assert.ok(!result.includes("gsd_complete_slice"));
+});
+
+test("buildMinimalAutoGsdToolSet covers execute-task-simple", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "gsd_task_complete",
+    "gsd_decision_save",
+    "gsd_plan_task",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task-simple");
+
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("gsd_decision_save"));
+  assert.ok(!result.includes("gsd_plan_task"));
+});
+
+test("buildMinimalGsdWorkflowToolSet keeps workflow GSD tools but drops broad non-GSD tools", () => {
+  const result = buildMinimalGsdWorkflowToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "browser_wait_for",
+    "edit",
+    "lsp",
+    "mac_find",
+    "read",
+    "subagent",
+    "write",
+    "gsd_plan_milestone",
+    "gsd_complete_milestone",
+    "gsd_task_complete",
+    "gsd_summary_save",
+    "memory_query",
+    "capture_thought",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_graph",
+  ]);
+
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("bg_shell"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("write"));
+  assert.ok(result.includes("gsd_plan_milestone"));
+  assert.ok(result.includes("gsd_complete_milestone"));
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("mac_find"));
+  assert.ok(!result.includes("subagent"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildRequestScopedGsdToolSet scopes queued workflow custom-message requests", () => {
+  const result = buildRequestScopedGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "browser_wait_for",
+    "lsp",
+    "read",
+    "write",
+    "gsd_plan_milestone",
+    "gsd_complete_milestone",
+    "gsd_task_complete",
+    "gsd_graph",
+    "memory_query",
+    "capture_thought",
+  ], [{ customType: "gsd-run" }, { customType: "gsd-memory" }]);
+
+  assert.ok(result);
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("write"));
+  assert.ok(result.includes("gsd_plan_milestone"));
+  assert.ok(result.includes("gsd_complete_milestone"));
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildRequestScopedGsdToolSet ignores stale workflow messages outside the current request tail", () => {
+  assert.equal(buildRequestScopedGsdToolSet(["bash", "gsd_plan_milestone"], []), undefined);
+});
+
+test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visibility", () => {
+  const calls: Array<{ kind: "tools" | "skills"; value: string[] | undefined }> = [];
+  let activeTools = [
+    "bash",
+    "read",
+    "lsp",
+    "gsd_plan_milestone",
+    "gsd_decision_save",
+    "memory_query",
+    "capture_thought",
+  ];
+  let visibleSkills: string[] | undefined = ["previous-skill"];
+
+  const state = scopeGsdWorkflowToolsForDispatch({
+    getActiveTools: () => activeTools,
+    setActiveTools: (names) => {
+      activeTools = names;
+      calls.push({ kind: "tools", value: names });
+    },
+    getVisibleSkills: () => visibleSkills,
+    setVisibleSkills: (names) => {
+      visibleSkills = names;
+      calls.push({ kind: "skills", value: names });
+    },
+  }, "plan-milestone");
+
+  assert.ok(state);
+  assert.deepEqual(visibleSkills, [
+    "write-milestone-brief",
+    "decompose-into-slices",
+    "design-an-interface",
+    "grill-me",
+    "write-docs",
+    "api-design",
+    "tdd",
+    "verify-before-complete",
+  ]);
+  assert.ok(!activeTools.includes("lsp"));
+
+  restoreGsdWorkflowTools({
+    setActiveTools: (names) => {
+      activeTools = names;
+      calls.push({ kind: "tools", value: names });
+    },
+    setVisibleSkills: (names) => {
+      visibleSkills = names;
+      calls.push({ kind: "skills", value: names });
+    },
+  }, state);
+
+  assert.deepEqual(activeTools, [
+    "bash",
+    "read",
+    "lsp",
+    "gsd_plan_milestone",
+    "gsd_decision_save",
+    "memory_query",
+    "capture_thought",
+  ]);
+  assert.deepEqual(visibleSkills, ["previous-skill"]);
+  assert.equal(calls.filter((call) => call.kind === "skills").length, 2);
+});

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

@@ -21,6 +21,7 @@ import {
   markFailed,
   markStuck,
   markCanceled,
+  markLatestActiveForWorkerCanceled,
   getRecentForUnit,
   getLatestForUnit,
 } from "../db/unit-dispatches.ts";
@@ -196,6 +197,35 @@ test("markStuck and markCanceled set their respective statuses", (t) => {
   assert.equal(getLatestForUnit("M001/S01/T01")!.status, "canceled");
 });
 
+test("markLatestActiveForWorkerCanceled cancels only the latest active dispatch for a worker", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const first = recordDispatchClaim({
+    traceId: "tc-1", workerId, milestoneLeaseToken: leaseToken,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "M001/S01",
+  });
+  assert.equal(first.ok, true);
+  if (!first.ok) return;
+  markCompleted(first.dispatchId);
+
+  const second = recordDispatchClaim({
+    traceId: "tc-2", workerId, milestoneLeaseToken: leaseToken,
+    milestoneId: "M001", unitType: "run-task", unitId: "M001/S01/T01",
+  });
+  assert.equal(second.ok, true);
+  if (!second.ok) return;
+  markRunning(second.dispatchId);
+
+  assert.equal(markLatestActiveForWorkerCanceled(workerId, "signal-exit"), true);
+  assert.equal(getLatestForUnit("M001/S01")!.status, "completed");
+  const latest = getLatestForUnit("M001/S01/T01")!;
+  assert.equal(latest.status, "canceled");
+  assert.equal(latest.exit_reason, "signal-exit");
+  assert.equal(markLatestActiveForWorkerCanceled(workerId, "signal-exit"), false);
+});
+
 test("terminal transitions do not overwrite an already terminal dispatch", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

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

@@ -9,6 +9,7 @@ import {
   readUnitRuntimeRecord,
   writeUnitRuntimeRecord,
 } from "../unit-runtime.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { clearPathCache } from '../paths.ts';
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
@@ -72,6 +73,35 @@ console.log("\n=== runtime record cleanup ===");
   assert.deepStrictEqual(loaded, null, "record removed");
 }
 
+console.log("\n=== execute-task durability trusts closed DB task status ===");
+{
+  const dbBase = mkdtempSync(join(tmpdir(), "gsd-unit-runtime-db-test-"));
+  mkdirSync(join(dbBase, ".gsd", "milestones", "M300", "slices", "S01", "tasks"), { recursive: true });
+  try {
+    openDatabase(join(dbBase, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M300", title: "DB Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M300", title: "DB Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M300", sliceId: "S01", title: "DB Task", status: "complete" });
+    writeFileSync(
+      join(dbBase, ".gsd", "milestones", "M300", "slices", "S01", "S01-PLAN.md"),
+      "# S01\n\n## Tasks\n\n- [ ] **T01: DB Task** `est:10m`\n",
+      "utf-8",
+    );
+    writeFileSync(join(dbBase, ".gsd", "STATE.md"), "## Next Action\nExecute T01 for S01: DB task\n", "utf-8");
+
+    const status = await inspectExecuteTaskDurability(dbBase, "M300/S01/T01");
+    assert.ok(status !== null, "db-complete: status exists");
+    assert.equal(status!.dbComplete, true, "db-complete: closed DB status is captured");
+    assert.equal(status!.summaryExists, false, "db-complete: summary can still be missing");
+    assert.equal(status!.taskChecked, false, "db-complete: checkbox can still be unchecked");
+    assert.equal(status!.nextActionAdvanced, false, "db-complete: next action can still point at task");
+    assert.equal(formatExecuteTaskRecoveryStatus(status!), "DB task status is closed");
+  } finally {
+    closeDatabase();
+    rmSync(dbBase, { recursive: true, force: true });
+  }
+}
+
 console.log("\n=== hook unit type sanitization (slash in unitType) ===");
 {
   // Hook units have unitType like "hook/code-review" with a slash

package/src/resources/extensions/gsd/tests/unstructured-continue-context-injection.test.ts

@@ -1,4 +1,5 @@
-// GSD-2 — Regression test for #3615: unstructured "continue" must inject task context
+// Project/App: GSD-2
+// File Purpose: Regression test for unstructured continue task-context injection.
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 /**
@@ -55,12 +56,12 @@ describe("#3615 — structural: fallback exists with correct guards", () => {
     );
   });
 
-  test("fallback is intent-gated via RESUME_INTENT_PATTERNS", () => {
+  test("fallback is intent-gated via isLowEntropyResumePrompt", () => {
     const afterFallback = fnBody.indexOf("// Fallback:");
     const fallbackSection = fnBody.slice(afterFallback);
     assert.ok(
-      fallbackSection.includes("RESUME_INTENT_PATTERNS"),
-      "fallback must check RESUME_INTENT_PATTERNS before deriveState",
+      fallbackSection.includes("isLowEntropyResumePrompt(prompt)"),
+      "fallback must check isLowEntropyResumePrompt before deriveState",
     );
   });
 

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

@@ -0,0 +1,99 @@
+// Project/App: GSD-2
+// File Purpose: Tests for capped GSD workflow protocol and doctor-heal payload helpers.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  buildDoctorHealIssuePayload,
+  buildDoctorHealSummary,
+  buildWorkflowDispatchContent,
+  buildWorkflowProtocolExcerpt,
+} from "../workflow-protocol.ts";
+
+test("workflow protocol helper emits capped excerpt plus source path", () => {
+  const workflow = `# Protocol\n${"FULL_WORKFLOW_BODY ".repeat(500)}`;
+  const excerpt = buildWorkflowProtocolExcerpt(workflow, "/tmp/GSD-WORKFLOW.md", { maxChars: 1200 });
+
+  assert.match(excerpt, /Source: `\/tmp\/GSD-WORKFLOW\.md`/);
+  assert.match(excerpt, /\[Workflow Protocol Truncated\]/);
+  assert.ok(excerpt.length < workflow.length);
+  assert.ok(excerpt.length < 1600);
+});
+
+test("workflow dispatch uses excerpt instead of full workflow body", () => {
+  const workflow = `# Protocol\n${"FULL_WORKFLOW_BODY ".repeat(500)}`;
+  const content = buildWorkflowDispatchContent({
+    workflow,
+    workflowPath: "/tmp/GSD-WORKFLOW.md",
+    task: "Run the selected unit.",
+    maxProtocolChars: 1200,
+  });
+
+  assert.match(content, /## GSD Workflow Protocol Excerpt/);
+  assert.match(content, /## Your Task/);
+  assert.match(content, /Run the selected unit/);
+  assert.ok(content.length < workflow.length);
+});
+
+test("workflow protocol excerpt includes late verification and advance rules", () => {
+  const workflow = [
+    "# GSD Workflow",
+    "intro",
+    "## Quick Start",
+    "quick",
+    "## File Format Reference",
+    "format ".repeat(400),
+    "## The Phases",
+    "phase overview",
+    "### Phase 4: Execute",
+    "execute rules",
+    "### Phase 5: Verify",
+    "verification rules",
+    "### Phase 7: Advance",
+    "advance rules",
+  ].join("\n");
+
+  const excerpt = buildWorkflowProtocolExcerpt(workflow, "/tmp/GSD-WORKFLOW.md", { maxChars: 1300 });
+
+  assert.match(excerpt, /Quick Start/);
+  assert.match(excerpt, /Phase 5: Verify/);
+  assert.match(excerpt, /Phase 7: Advance/);
+  assert.doesNotMatch(excerpt, /format format format format format/);
+});
+
+test("doctor heal summary omits duplicated full report body", () => {
+  const report = [
+    "# GSD doctor heal prep.",
+    "Scope: M001",
+    "Status: warning",
+    "Warnings: 9",
+    "",
+    "VERY_LONG_FULL_REPORT_BODY ".repeat(300),
+  ].join("\n");
+
+  const summary = buildDoctorHealSummary(report, { maxChars: 900 });
+
+  assert.match(summary, /GSD doctor heal prep/);
+  assert.match(summary, /Warnings: 9/);
+  assert.ok(summary.length <= 900);
+  assert.doesNotMatch(summary, /VERY_LONG_FULL_REPORT_BODY VERY_LONG_FULL_REPORT_BODY VERY_LONG_FULL_REPORT_BODY/);
+});
+
+test("doctor heal issue payload keeps top actionable issues and caps detail", () => {
+  const issues = Array.from({ length: 20 }, (_, index) =>
+    `### Issue ${index + 1}\n${`detail ${index + 1} `.repeat(80)}`,
+  ).join("\n");
+
+  const payload = buildDoctorHealIssuePayload(issues, {
+    maxIssues: 3,
+    maxIssueChars: 180,
+    maxChars: 900,
+  });
+
+  assert.match(payload, /Issue 1/);
+  assert.match(payload, /Issue 3/);
+  assert.doesNotMatch(payload, /Issue 4/);
+  assert.match(payload, /17 additional actionable issue/);
+  assert.ok(payload.length <= 900);
+});

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

@@ -165,6 +165,9 @@ test("executeMilestoneStatus returns milestone metadata and slice counts", async
     assert.equal(parsed.sliceCount, 1);
     assert.equal(parsed.slices[0].id, "S01");
     assert.equal(parsed.slices[0].taskCounts.pending, 1);
+    assert.equal(result.details.status, "active");
+    assert.equal(result.details.title, "Milestone One");
+    assert.deepEqual(result.details.slices, parsed.slices);
   } finally {
     closeDatabase();
     cleanup(base);

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

@@ -39,6 +39,7 @@ function makeDeps(
     getAutoWorktreePath: () => null,
     autoCommitCurrentBranch: () => {},
     getCurrentBranch: () => "main",
+    checkoutBranch: () => {},
     autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
     resolveMilestoneFile: (_basePath: string, milestoneId: string) =>
       `/project/.gsd/milestones/${milestoneId}/${milestoneId}-ROADMAP.md`,

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

@@ -79,7 +79,7 @@ async function waitFor(condition: () => boolean, label: string): Promise<void> {
   assert.fail(`Timed out waiting for ${label} after ${timeoutMs}ms`);
 }
 
-test("runUnit changes cwd to basePath before creating a new session", async (t) => {
+test("runUnit passes basePath as workspaceRoot without changing process cwd", async (t) => {
   _resetPendingResolve();
 
   const originalCwd = process.cwd();
@@ -93,13 +93,15 @@ test("runUnit changes cwd to basePath before creating a new session", async (t)
 
   process.chdir(drifted);
 
+  let newSessionWorkspaceRoot: string | undefined;
   let cwdAtNewSession: string | undefined;
   const session = {
     active: true,
     basePath: base,
     verbose: false,
     cmdCtx: {
-      newSession: () => {
+      newSession: (options?: { workspaceRoot?: string }) => {
+        newSessionWorkspaceRoot = options?.workspaceRoot;
         cwdAtNewSession = process.cwd();
         return Promise.resolve({ cancelled: false });
       },
@@ -119,10 +121,12 @@ test("runUnit changes cwd to basePath before creating a new session", async (t)
 
   const result = await resultPromise;
   assert.equal(result.status, "completed");
-  assert.equal(cwdAtNewSession, base);
+  assert.equal(newSessionWorkspaceRoot, base);
+  assert.equal(cwdAtNewSession, drifted);
+  assert.equal(process.cwd(), drifted);
 });
 
-test("runUnit cancels before creating a session when basePath chdir fails", async (t) => {
+test("runUnit does not chdir or cancel when basePath is not a live directory", async (t) => {
   _resetPendingResolve();
 
   const originalCwd = process.cwd();
@@ -136,14 +140,14 @@ test("runUnit cancels before creating a session when basePath chdir fails", asyn
 
   process.chdir(drifted);
 
-  let newSessionCalled = false;
+  let newSessionWorkspaceRoot: string | undefined;
   const session = {
     active: true,
     basePath: base,
     verbose: false,
     cmdCtx: {
-      newSession: () => {
-        newSessionCalled = true;
+      newSession: (options?: { workspaceRoot?: string }) => {
+        newSessionWorkspaceRoot = options?.workspaceRoot;
         return Promise.resolve({ cancelled: false });
       },
     },
@@ -156,15 +160,14 @@ test("runUnit cancels before creating a session when basePath chdir fails", asyn
   } as any;
   const ctx = { ui: { notify: () => {} }, model: { id: "test-model" } } as any;
 
-  const result = await runUnit(ctx, pi, session, "task", "T01", "prompt");
+  const resultPromise = runUnit(ctx, pi, session, "task", "T01", "prompt");
+  await waitFor(() => pi.calls.length === 1, "runUnit dispatch");
+  resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
-  assert.equal(result.status, "cancelled");
-  assert.equal(result.errorContext?.category, "session-failed");
-  assert.equal(result.errorContext?.isTransient, true);
-  assert.match(result.errorContext?.message ?? "", /Failed to chdir to basePath before newSession/);
-  assert.ok(result.errorContext?.message.includes(base), "error should include the failed basePath");
-  assert.equal(newSessionCalled, false, "newSession must not run after chdir failure");
-  assert.equal(pi.calls.length, 0, "unit must not dispatch after chdir failure");
+  const result = await resultPromise;
+  assert.equal(result.status, "completed");
+  assert.equal(newSessionWorkspaceRoot, base);
+  assert.equal(process.cwd(), drifted);
 });
 
 test("direct dispatch redirects to the canonical milestone worktree before newSession", async (t) => {
@@ -185,12 +188,12 @@ test("direct dispatch redirects to the canonical milestone worktree before newSe
 
   process.chdir(drifted);
 
-  let cwdAtNewSession: string | undefined;
+  let newSessionWorkspaceRoot: string | undefined;
   let sentPrompt: string | undefined;
   const ctx = {
     ui: { notify: () => {} },
-    newSession: async () => {
-      cwdAtNewSession = process.cwd();
+    newSession: async (options?: { workspaceRoot?: string }) => {
+      newSessionWorkspaceRoot = options?.workspaceRoot;
       return { cancelled: false };
     },
   } as any;
@@ -202,7 +205,7 @@ test("direct dispatch redirects to the canonical milestone worktree before newSe
 
   await dispatchDirectPhase(ctx, pi, "research-milestone", base);
 
-  assert.equal(cwdAtNewSession, worktreeRoot);
+  assert.equal(newSessionWorkspaceRoot, worktreeRoot);
   assert.equal(process.cwd(), drifted);
   assert.ok(sentPrompt?.includes(worktreeRoot), "prompt should name the canonical worktree root");
 });