gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

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

@@ -12,7 +12,6 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { extractSourceRegion } from "./test-helpers.ts";
 
 test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
   const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
@@ -41,22 +40,9 @@ test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)",
   );
 });
 
-test("copyPlanningArtifacts prefers canonical PREFERENCES.md with lowercase fallback", () => {
-  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const src = readFileSync(srcPath, "utf-8");
-
-  // Find the copyPlanningArtifacts function body
-  const fnIdx = src.indexOf("function copyPlanningArtifacts");
-  assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
-
-  // Extract function body (up to the next top-level function)
-  const fnBody = extractSourceRegion(src, "function copyPlanningArtifacts");
-
-  assert.ok(
-    fnBody.includes("PROJECT_PREFERENCES_FILE") && fnBody.includes("LEGACY_PROJECT_PREFERENCES_FILE"),
-    "copyPlanningArtifacts should prefer canonical PREFERENCES.md and retain lowercase fallback via the shared constants",
-  );
-});
+// Phase C: copyPlanningArtifacts was deleted. Worktrees no longer
+// maintain a parallel .gsd/ projection; preference seeding is now
+// handled exclusively by syncGsdStateToWorktree() (covered below).
 
 test("syncGsdStateToWorktree copies canonical PREFERENCES.md", async () => {
   // Functional test: create a mock source and destination, call the sync

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

@@ -4,11 +4,16 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
+const templatesDir = join(process.cwd(), "src/resources/extensions/gsd/templates");
 
 function readPrompt(name: string): string {
   return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
 }
 
+function readTemplate(name: string): string {
+  return readFileSync(join(templatesDir, `${name}.md`), "utf-8");
+}
+
 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);
@@ -174,15 +179,15 @@ test("guided-resume-task prompt preserves recovery state until work is supersede
 
 // ─── Prompt migration: execute-task → gsd_complete_task ───────────────
 
-test("execute-task prompt references gsd_complete_task tool", () => {
+test("execute-task prompt references gsd_task_complete tool", () => {
   const prompt = readPrompt("execute-task");
-  assert.match(prompt, /gsd_complete_task/);
+  assert.match(prompt, /gsd_task_complete/);
 });
 
-test("execute-task prompt uses gsd_complete_task as canonical summary write path", () => {
+test("execute-task prompt uses gsd_task_complete as canonical summary write path", () => {
   const prompt = readPrompt("execute-task");
   assert.match(prompt, /\{\{taskSummaryPath\}\}/);
-  assert.match(prompt, /gsd_complete_task/);
+  assert.match(prompt, /gsd_task_complete/);
   assert.match(prompt, /DB-backed tool is the canonical write path/i);
   assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{taskSummaryPath\}\}`?/i);
   assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{taskSummaryPath\}\}`?\s*$/m);
@@ -202,9 +207,9 @@ test("execute-task prompt still contains template variables for context", () =>
 
 // ─── Prompt migration: complete-slice → gsd_complete_slice ────────────
 
-test("complete-slice prompt references gsd_complete_slice tool", () => {
+test("complete-slice prompt references gsd_slice_complete tool", () => {
   const prompt = readPrompt("complete-slice");
-  assert.match(prompt, /gsd_complete_slice/);
+  assert.match(prompt, /gsd_slice_complete/);
 });
 
 test("complete-slice prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -216,7 +221,7 @@ test("complete-slice prompt instructs writing summary and UAT files before tool
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
   assert.match(prompt, /\{\{sliceUatPath\}\}/);
-  assert.match(prompt, /gsd_complete_slice/);
+  assert.match(prompt, /gsd_slice_complete/);
   assert.match(prompt, /DB-backed tool is the canonical write path/i);
   assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{sliceSummaryPath\}\}`?/i);
   assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{sliceUatPath\}\}`?/i);
@@ -398,3 +403,141 @@ test("reactive-execute prompt references tool calls instead of checkbox updates"
   assert.doesNotMatch(prompt, /checkbox edits/);
   assert.match(prompt, /completion tool calls/);
 });
+
+// ─── 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", () => {
+  const prompt = readPrompt("guided-discuss-project");
+  assert.match(prompt, /Classify project shape/i, "must include the classifier section");
+  assert.match(prompt, /`simple`/);
+  assert.match(prompt, /`complex`/);
+  assert.match(prompt, /Default to `complex` when uncertain/i);
+  assert.match(prompt, /## Project Shape/, "must reference the persisted PROJECT.md section");
+  assert.match(prompt, /\*\*Complexity:\*\*\s*simple/);
+  assert.match(prompt, /\*\*Complexity:\*\*\s*complex/);
+});
+
+test("guided-discuss prompts require 3-or-4 options plus Other-let-me-discuss in complex mode", () => {
+  for (const name of [
+    "guided-discuss-project",
+    "guided-discuss-milestone",
+    "guided-discuss-slice",
+  ]) {
+    const prompt = readPrompt(name);
+    assert.match(
+      prompt,
+      /3 or 4 concrete, researched options/i,
+      `${name} must require 3 or 4 grounded options in complex mode`,
+    );
+    assert.match(
+      prompt,
+      /"Other — let me discuss"/,
+      `${name} must include the "Other — let me discuss" escape hatch`,
+    );
+    assert.match(
+      prompt,
+      /grounded in (the |your |)investigation/i,
+      `${name} must require options grounded in prior investigation`,
+    );
+  }
+});
+
+test("guided-discuss-requirements scopes the 3-or-4-options rule to free-form questions only", () => {
+  const prompt = readPrompt("guided-discuss-requirements");
+  assert.match(prompt, /3 or 4 concrete, researched options/i);
+  assert.match(prompt, /"Other — let me discuss"/);
+  // Class-assignment and status questions have fixed enumerations, so the rule must exempt them.
+  assert.match(prompt, /class-assignment.*status.*exempt/i);
+});
+
+test("downstream discuss prompts read project shape verdict from PROJECT.md", () => {
+  for (const name of [
+    "guided-discuss-milestone",
+    "guided-discuss-requirements",
+    "guided-discuss-slice",
+  ]) {
+    const prompt = readPrompt(name);
+    assert.match(
+      prompt,
+      /Project Shape/,
+      `${name} must reference Project Shape from PROJECT.md`,
+    );
+    assert.match(
+      prompt,
+      /default to `complex`/i,
+      `${name} must default to complex when the verdict is missing`,
+    );
+  }
+});
+
+test("project template includes the Project Shape section so the verdict has a home", () => {
+  const template = readTemplate("project");
+  assert.match(template, /## Project Shape/);
+  assert.match(template, /\*\*Complexity:\*\*/);
+});
+
+// ─── Project shape verdict — end-to-end propagation contract (F7 / #5267) ──
+// The verdict is propagated from discuss-project to downstream stages via
+// PROJECT.md text only, with no parser. These tests pin the round-trip:
+// the format the upstream stage is told to write must be discoverable by
+// the regex pattern the downstream stage is told to look for.
+
+/**
+ * Render the project.md template with a concrete complexity verdict so we
+ * can assert on a realistic PROJECT.md (the placeholder is filled the way
+ * an LLM following the prompt would fill it).
+ */
+function renderProjectMd(verdict: "simple" | "complex"): string {
+  return readTemplate("project")
+    .replace("{{simple | complex}}", verdict)
+    .replace("{{one-line rationale citing the signals that decided it}}", "Test fixture rationale.");
+}
+
+test("project shape verdict survives the discuss-project → discuss-milestone round trip", () => {
+  for (const verdict of ["simple", "complex"] as const) {
+    const projectMd = renderProjectMd(verdict);
+
+    // Upstream contract: the PROJECT.md the discuss-project prompt writes
+    // must contain the section header and the bolded `**Complexity:** <verdict>`
+    // marker that downstream stages are told to grep for.
+    assert.match(projectMd, /## Project Shape/, `rendered ${verdict} PROJECT.md must keep the section header`);
+    const complexityMarker = new RegExp(`\\*\\*Complexity:\\*\\*\\s*${verdict}\\b`);
+    assert.match(
+      projectMd,
+      complexityMarker,
+      `rendered ${verdict} PROJECT.md must expose the bolded Complexity marker the downstream regex looks for`,
+    );
+
+    // Downstream contract: discuss-milestone, discuss-requirements, and
+    // discuss-slice must each instruct the LLM to look at the same section
+    // header AND the same `**Complexity:**` marker the template writes.
+    // Without this, the upstream verdict is silently dropped.
+    for (const downstream of ["guided-discuss-milestone", "guided-discuss-requirements", "guided-discuss-slice"]) {
+      const prompt = readPrompt(downstream);
+      assert.match(
+        prompt,
+        /## Project Shape/,
+        `${downstream} must direct the LLM to the same section header the template writes`,
+      );
+      assert.match(
+        prompt,
+        /\*\*Complexity:\*\*/,
+        `${downstream} must direct the LLM to the same **Complexity:** marker the template writes`,
+      );
+    }
+  }
+});
+
+test("downstream discuss prompts default to complex when PROJECT.md lacks the verdict", () => {
+  // Safe-by-default: if upstream omits the section (existing projects, LLM
+  // drift, future template change), each downstream stage must explicitly
+  // fall back to complex so behavior is conservative rather than stuck.
+  for (const downstream of ["guided-discuss-milestone", "guided-discuss-requirements", "guided-discuss-slice"]) {
+    const prompt = readPrompt(downstream);
+    assert.match(
+      prompt,
+      /default to `complex`/i,
+      `${downstream} must default to complex when the upstream verdict is missing`,
+    );
+  }
+});

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

@@ -25,12 +25,15 @@ test("register-hooks unlocks milestone depth verification from question id witho
   const dir = makeTempDir("manual");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
@@ -101,12 +104,15 @@ test("register-hooks clears depth gate when remote (Telegram/Slack/Discord) answ
   const dir = makeTempDir("remote");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
@@ -167,12 +173,15 @@ test("register-hooks returns hard blocker when depth question is cancelled", asy
   const dir = makeTempDir("cancelled");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
@@ -222,18 +231,131 @@ test("register-hooks returns hard blocker when depth question is cancelled", asy
     patch?.content?.[0]?.text ?? "",
     /Do not infer approval from earlier or prior messages/,
   );
+  // Regression for milestone-hang: the cancelled-gate instruction must direct
+  // the agent toward the most reliable recovery path — re-calling
+  // ask_user_questions with the same gate id. The plain-text path also clears
+  // the gate via isExplicitApprovalResponse on the next before_agent_start,
+  // but the structured re-ask is more deterministic, so the message points
+  // there and avoids the prior dead-end "ask in plain chat, then stop" wording.
+  assert.match(
+    patch?.content?.[0]?.text ?? "",
+    /Re-call ask_user_questions with the same gate question id/,
+    "must instruct the agent to re-ask via ask_user_questions",
+  );
+  assert.doesNotMatch(
+    patch?.content?.[0]?.text ?? "",
+    /confirm in plain chat, then stop/,
+    "must not direct the agent down the prior dead-end plain-chat-and-stop path",
+  );
+});
+
+test("register-hooks recovers from a cancelled depth question via re-asked ask_user_questions (milestone-hang regression)", async (t) => {
+  const dir = makeTempDir("recovery");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState(dir);
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  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);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_M001_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Did I capture the project correctly?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Not quite — let me clarify" },
+      ],
+    },
+  ];
+
+  // 1. Initial ask sets the gate.
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({ toolName: "ask_user_questions", input: { questions } });
+  }
+  assert.equal(getPendingGate(), questionId, "initial ask must set the gate");
+
+  // 2. User cancels (simulates the trap from the screenshot: question never
+  //    answered through the structured channel). Gate must stay pending.
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: { cancelled: true, response: null },
+    });
+  }
+  assert.equal(getPendingGate(), questionId, "cancelled response must leave gate pending");
+
+  // 3. Recovery path: immediately re-call ask_user_questions with the same
+  //    gate id and identical input. This must not be blocked by the strict
+  //    duplicate-call loop guard, because the hard-block instruction above
+  //    tells the agent to do exactly this and not to interleave other tools.
+  const reaskBlocks: any[] = [];
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({ toolName: "ask_user_questions", input: { questions } });
+    if (result?.block) reaskBlocks.push(result);
+  }
+  assert.equal(
+    reaskBlocks.length,
+    0,
+    "immediate identical re-ask must not be blocked by the tool-call loop guard",
+  );
+
+  // 4. The re-asked question receives a confirming response, which clears the
+  //    gate and unlocks the milestone context save.
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: {
+        response: {
+          answers: {
+            [questionId]: { selected: "Yes, you got it (Recommended)" },
+          },
+        },
+      },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "confirming re-ask must clear the gate");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M001").block,
+    false,
+    "context save must unlock after recovery",
+  );
 });
 
 test("register-hooks gates MCP ask_user_questions cancellation before requirement saves", async (t) => {
   const dir = makeTempDir("mcp-cancelled");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();

package/src/resources/extensions/gsd/tests/resume-missing-worktree-warning.test.ts

@@ -0,0 +1,209 @@
+// GSD-2 + Regression tests for missing-worktree warning on resume (M4 fix)
+//
+// When paused-session.json records a worktreePath that no longer exists on disk,
+// the resume path must emit a logWarning("session", ...) describing the situation
+// rather than silently falling back to project-root mode.
+//
+// Strategy: drive the exported _warnIfWorktreeMissingForTest seam directly
+// (mirrors the exact conditional used at the two resume sites in auto.ts),
+// and independently verify the scope fallback via createWorkspace/scopeMilestone
+// as in auto-session-scope.test.ts.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  logWarning,
+  peekLogs,
+  _resetLogs,
+  setStderrLoggingEnabled,
+} from "../workflow-logger.ts";
+import { _warnIfWorktreeMissingForTest } from "../auto.ts";
+import { AutoSession } from "../auto/session.ts";
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-resume-warn-test-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// Mirror the rebuildScope() fallback from auto.ts when worktree is missing.
+function applyProjectRootScope(
+  s: AutoSession,
+  projectDir: string,
+  milestoneId: string,
+): void {
+  const workspace = createWorkspace(projectDir);
+  s.scope = scopeMilestone(workspace, milestoneId);
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("resume: missing worktree warning emission", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    _resetLogs();
+    setStderrLoggingEnabled(false);
+  });
+
+  afterEach(() => {
+    setStderrLoggingEnabled(true);
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("logWarning is called when worktreePath is set but directory is missing", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M001-nonexistent");
+    // missingPath was never created — existsSync returns false
+
+    const warned = _warnIfWorktreeMissingForTest(missingPath, "M001");
+
+    assert.equal(warned, true, "_warnIfWorktreeMissingForTest should return true when path is missing");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1, "exactly one warning should be emitted");
+    assert.equal(logs[0].severity, "warn");
+    assert.equal(logs[0].component, "session");
+    assert.ok(
+      logs[0].message.includes(missingPath),
+      `warning message should include the missing path; got: ${logs[0].message}`,
+    );
+    assert.ok(
+      logs[0].message.includes("missing"),
+      "warning message should mention 'missing'",
+    );
+  });
+
+  test("logWarning message includes milestone ID", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M042-gone");
+    _warnIfWorktreeMissingForTest(missingPath, "M042");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1);
+    assert.equal(logs[0].context?.milestoneId, "M042");
+  });
+
+  test("logWarning is NOT called when worktreePath is null", () => {
+    const warned = _warnIfWorktreeMissingForTest(null, "M001");
+
+    assert.equal(warned, false);
+    assert.equal(peekLogs().length, 0, "no warning when worktreePath is null");
+  });
+
+  test("logWarning is NOT called when worktreePath is undefined", () => {
+    const warned = _warnIfWorktreeMissingForTest(undefined, "M001");
+
+    assert.equal(warned, false);
+    assert.equal(peekLogs().length, 0, "no warning when worktreePath is undefined");
+  });
+
+  test("logWarning is NOT called when worktreePath exists on disk", () => {
+    const existingWorktree = join(projectDir, ".gsd", "worktrees", "M001");
+    mkdirSync(existingWorktree, { recursive: true });
+
+    const warned = _warnIfWorktreeMissingForTest(existingWorktree, "M001");
+
+    assert.equal(warned, false, "no warning when path exists");
+    assert.equal(peekLogs().length, 0);
+  });
+
+  test("warning message mentions project-root fallback action", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M099-deleted");
+    _warnIfWorktreeMissingForTest(missingPath, "M099");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1);
+    assert.ok(
+      logs[0].message.includes("project-root mode"),
+      "warning should mention project-root mode fallback",
+    );
+    assert.ok(
+      logs[0].message.includes("gsd-debug"),
+      "warning should suggest /gsd-debug recovery action",
+    );
+  });
+});
+
+describe("resume: scope fallback to project-root mode when worktree is missing", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+    _resetLogs();
+    setStderrLoggingEnabled(false);
+  });
+
+  afterEach(() => {
+    setStderrLoggingEnabled(true);
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope.workspace.mode is 'project' after fallback from missing worktree", () => {
+    const mid = "M001";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    // Simulate auto.ts resume path: worktreePath is set but missing → use projectDir
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    // Fallback: use originalBasePath (project root)
+    applyProjectRootScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set after fallback");
+    assert.equal(s.scope.workspace.mode, "project");
+  });
+
+  test("scope.milestoneId is preserved after project-root fallback", () => {
+    const mid = "M002";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    applyProjectRootScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+
+  test("does not throw when worktree path is missing and scope fallback is applied", () => {
+    const mid = "M003";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+
+    assert.doesNotThrow(() => {
+      _warnIfWorktreeMissingForTest(missingPath, mid);
+      applyProjectRootScope(s, projectDir, mid);
+    }, "resume with missing worktree must not throw");
+  });
+
+  test("warning is emitted once per missing worktree — no double-emission", () => {
+    const mid = "M004";
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    // Simulating the second call as would happen if the resume-re-entry site
+    // also fires (e.g. pausedSession and freshStartAssessment both carry the path)
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    const logs = peekLogs();
+    // Two calls → two warnings (one per site — consistent with the two sites in auto.ts)
+    assert.equal(logs.length, 2, "each call to the seam emits one warning");
+    assert.equal(logs[0].component, "session");
+    assert.equal(logs[1].component, "session");
+  });
+});