@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

package/src/resources/extensions/gsd/validation-block-guard.ts

@@ -5,6 +5,7 @@ import { existsSync } from "node:fs";
 
 import { getAutoWorktreePath, isInAutoWorktree } from "./auto-worktree.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
+import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getIsolationMode } from "./preferences.js";
 import { deriveState } from "./state.js";
 import type { GSDState } from "./types.js";
@@ -91,6 +92,7 @@ export async function getValidationBlockMessageForBase(
   attemptedCommand = "",
 ): Promise<string | null> {
   await ensureDbOpen(base);
+  refreshWorkflowDatabaseFromDisk();
   let state = await deriveState(base);
 
   if (

package/src/resources/extensions/gsd/web-app-uat.ts

@@ -0,0 +1,101 @@
+// Project/App: gsd-pi
+// File Purpose: Web-app detection and Playwright/UAT guidance for planning and slice closeout.
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { detectWebApp } from "../browser-tools/web-app-detect.js";
+
+export { detectWebApp };
+
+interface MinimalPackageJson {
+  dependencies?: Record<string, unknown>;
+  devDependencies?: Record<string, unknown>;
+  scripts?: Record<string, unknown>;
+}
+
+function readPackageJson(projectRoot: string): MinimalPackageJson | null {
+  const packageJsonPath = resolve(projectRoot, "package.json");
+  if (!existsSync(packageJsonPath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as unknown;
+    return parsed && typeof parsed === "object" ? (parsed as MinimalPackageJson) : null;
+  } catch {
+    return null;
+  }
+}
+
+export function hasPlaywrightTestDependency(projectRoot: string): boolean {
+  const pkg = readPackageJson(projectRoot);
+  if (!pkg) return false;
+  const names = [
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {}),
+  ];
+  return names.some((name) => name === "playwright" || name === "@playwright/test");
+}
+
+export function findPlaywrightTestScript(projectRoot: string): string | null {
+  const pkg = readPackageJson(projectRoot);
+  if (!pkg?.scripts) return null;
+  for (const [name, value] of Object.entries(pkg.scripts)) {
+    if (typeof value !== "string") continue;
+    if (/\bplaywright\s+test\b/.test(value)) {
+      return `npm run ${name}`;
+    }
+  }
+  return null;
+}
+
+/**
+ * Markdown block injected into plan/complete-slice prompts when the project
+ * looks browser-facing. Returns null for CLI/library-only repos.
+ */
+export function buildWebAppUatGuidanceBlock(projectRoot: string): string | null {
+  if (!detectWebApp(projectRoot)) return null;
+
+  const playwrightScript = findPlaywrightTestScript(projectRoot);
+  const hasPlaywright = hasPlaywrightTestDependency(projectRoot) || playwrightScript !== null;
+  const lines = [
+    "### Web App UAT (detected)",
+    "",
+    "This project looks browser-facing. GSD exposes Playwright-backed `browser_*` tools by default for run-uat.",
+    "",
+    "**UAT modes (pick one per slice — do not use `artifact-driven` for browser steps):**",
+    "- `browser-executable` — navigate to `http://localhost:…`, click, screenshot, assert via `browser_*` tools during run-uat",
+    "- `runtime-executable` — run an automated browser test command via `gsd_uat_exec` (for example `npx playwright test`)",
+    "- `mixed` / `live-runtime` — combine runtime startup checks with interactive browser verification",
+    "",
+    "**Planning / closeout rules:**",
+    "- Preconditions must name the dev-server command and URL (for example `npm run dev` → `http://localhost:3000`)",
+    "- Slice Verification and UAT test cases must not say \"open in browser\" under `artifact-driven` — complete-slice rejects that",
+    "- Milestone `Verification Classes` → UAT row must describe browser-observable acceptance, not \"manual spot check\" alone",
+  ];
+
+  if (hasPlaywright) {
+    lines.push(
+      "",
+      "**Playwright:** dependency detected.",
+    );
+    if (playwrightScript) {
+      lines.push(
+        `- Prefer slice verification and runtime-executable UAT referencing \`${playwrightScript}\` or a focused \`npx playwright test <spec>\` command`,
+      );
+    } else {
+      lines.push(
+        "- Prefer runtime-executable UAT with `npx playwright test` (or a focused spec path) when UI behavior is covered by specs",
+      );
+    }
+    lines.push("- Name concrete spec paths in slice Verification (for example `e2e/smoke.spec.ts`)");
+  } else {
+    lines.push(
+      "",
+      "**Playwright scaffolding (first UI slice):** no `playwright` / `@playwright/test` dependency yet.",
+      "- Add a planning task that installs Playwright, adds `playwright.config.ts`, and creates a minimal smoke spec (for example `e2e/smoke.spec.ts`)",
+      "- Task `verify` should run `npx playwright test` (or the focused spec) with a safe, simple command",
+      "- Until specs exist, use `browser-executable` UAT with localhost preconditions and interactive `browser_*` checks at slice closeout",
+    );
+  }
+
+  return lines.join("\n");
+}

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

@@ -1,8 +1,19 @@
 import { execSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
-import { dirname, resolve, sep } from "node:path";
+import { basename, dirname, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { getRequiredWorkflowToolsForUnit } from "./unit-tool-contracts.js";
+import { mcpToolMatchesBaseName } from "./mcp-tool-name.js";
+import {
+  supportsStructuredQuestions,
+  usesWorkflowMcpTransport,
+} from "./question-transport.js";
+import {
+  WORKFLOW_TOOL_SURFACE_NAMES,
+  isWorkflowToolSurfaceName,
+} from "./workflow-tool-surface.js";
+
+export { supportsStructuredQuestions, usesWorkflowMcpTransport };
 
 type WorkflowExecutorsModule = typeof import("./tools/workflow-tool-executors.js");
 
@@ -42,73 +53,9 @@ export function resolveWorkflowMcpProjectRoot(sessionCwd: string): string {
   return resolved;
 }
 
-const MCP_WORKFLOW_TOOL_SURFACE = new Set([
-  "gsd_cancel",
-  "gsd_captures",
-  "ask_user_questions",
-  "gsd_capture_thought",
-  "gsd_doctor",
-  "gsd_execute",
-  "gsd_memory_query",
-  "gsd_memory_graph",
-  "gsd_decision_save",
-  "gsd_exec",
-  "gsd_exec_search",
-  "gsd_graph",
-  "gsd_history",
-  "gsd_knowledge",
-  "gsd_progress",
-  "gsd_query",
-  "gsd_resume",
-  "gsd_result",
-  "gsd_resolve_blocker",
-  "gsd_roadmap",
-  "gsd_status",
-  "gsd_complete_milestone",
-  "gsd_complete_task",
-  "gsd_complete_slice",
-  "gsd_generate_milestone_id",
-  "gsd_journal_query",
-  "gsd_milestone_complete",
-  "gsd_milestone_generate_id",
-  "gsd_milestone_reopen",
-  "gsd_checkpoint_db",
-  "gsd_milestone_plan",
-  "gsd_milestone_status",
-  "gsd_milestone_validate",
-  "gsd_plan_task",
-  "gsd_plan_milestone",
-  "gsd_plan_slice",
-  "gsd_replan_slice",
-  "gsd_reassess_roadmap",
-  "gsd_reopen_milestone",
-  "gsd_reopen_slice",
-  "gsd_reopen_task",
-  "gsd_requirement_save",
-  "gsd_requirement_update",
-  "gsd_roadmap_reassess",
-  "gsd_save_decision",
-  "gsd_save_gate_result",
-  "gsd_save_requirement",
-  "gsd_save_summary",
-  "gsd_skip_slice",
-  "gsd_slice_plan",
-  "gsd_slice_replan",
-  "gsd_slice_complete",
-  "gsd_slice_reopen",
-  "gsd_summary_save",
-  "gsd_task_plan",
-  "gsd_task_complete",
-  "gsd_task_reopen",
-  "gsd_update_requirement",
-  "gsd_uat_exec",
-  "gsd_uat_result_save",
-  "gsd_validate_milestone",
-]);
-
 /** Workflow MCP tools are validated by transport compatibility, not pi tool-compat profiles. */
 export function isWorkflowMcpSurfaceTool(toolName: string): boolean {
-  return MCP_WORKFLOW_TOOL_SURFACE.has(toolName);
+  return isWorkflowToolSurfaceName(toolName);
 }
 
 function parseLookupOutput(output: Buffer | string): string {
@@ -276,8 +223,12 @@ function getBundledWorkflowWriteGateModulePath(): string | null {
 
 function getResolveTsHookPath(): string | null {
   const repoRoot = findGsdPiRepoRoot(dirname(fileURLToPath(import.meta.url)));
+  const sourceRepoRoot = repoRoot && basename(repoRoot) === "dist-test" ? dirname(repoRoot) : repoRoot;
   return firstExistingPath([
-    ...(repoRoot
+    ...(sourceRepoRoot
+      ? [resolve(sourceRepoRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs")]
+      : []),
+    ...(repoRoot && repoRoot !== sourceRepoRoot
       ? [resolve(repoRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs")]
       : []),
     resolve(fileURLToPath(new URL("./tests/resolve-ts.mjs", import.meta.url))),
@@ -421,52 +372,13 @@ export function getRequiredWorkflowToolsForAutoUnit(unitType: string): string[]
   return getRequiredWorkflowToolsForUnit(unitType);
 }
 
-export function usesWorkflowMcpTransport(
-  authMode: WorkflowCapabilityOptions["authMode"],
-  baseUrl: string | undefined,
-): boolean {
-  return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");
-}
-
-function hasAskUserQuestionsTool(activeTools: string[]): boolean {
-  return activeTools.some((toolName) => {
-    if (toolName === "ask_user_questions") return true;
-    if (!toolName.startsWith("mcp__")) return false;
-    const toolSeparator = toolName.indexOf("__", "mcp__".length);
-    return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === "ask_user_questions";
-  });
-}
-
 function hasRequiredTool(requiredTool: string, activeTools: string[]): boolean {
   return activeTools.some((toolName) => {
     if (toolName === requiredTool) return true;
-    if (!toolName.startsWith("mcp__")) return false;
-    const toolSeparator = toolName.indexOf("__", "mcp__".length);
-    return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === requiredTool;
+    return mcpToolMatchesBaseName(toolName, requiredTool);
   });
 }
 
-function workflowMcpStructuredQuestionsOptIn(env: NodeJS.ProcessEnv = process.env): boolean {
-  const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS;
-  return value === "1" || value === "true";
-}
-
-export function supportsStructuredQuestions(
-  activeTools: string[],
-  options: Pick<WorkflowCapabilityOptions, "authMode" | "baseUrl" | "env"> = {},
-): boolean {
-  if (!hasAskUserQuestionsTool(activeTools)) return false;
-  if (usesWorkflowMcpTransport(options.authMode, options.baseUrl)) {
-    // Claude Code local workflow-MCP exposes ask_user_questions, but form
-    // elicitation can return an immediate cancel outside GSD's chat turn. Keep
-    // checkpoints in plain chat unless a caller deliberately opts into testing
-    // that transport.
-    return workflowMcpStructuredQuestionsOptIn(options.env);
-  }
-
-  return true;
-}
-
 export function getWorkflowTransportSupportError(
   provider: string | undefined,
   requiredTools: string[],
@@ -488,13 +400,13 @@ export function getWorkflowTransportSupportError(
 
   const uniqueRequired = [...new Set(requiredTools)];
   const missing = (options.activeTools && options.activeTools.length > 0)
-    ? uniqueRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools!))
-    : uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
+    ? uniqueRequired.filter((tool) => !isWorkflowToolSurfaceName(tool) && !hasRequiredTool(tool, options.activeTools!))
+    : uniqueRequired.filter((tool) => !isWorkflowToolSurfaceName(tool));
   if (missing.length === 0) return null;
 
   if (options.activeTools && options.activeTools.length > 0) {
     return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the active runtime toolset currently exposes only ${options.activeTools.slice().sort().join(", ")}.`;
   }
 
-  return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the workflow MCP transport currently exposes only ${Array.from(MCP_WORKFLOW_TOOL_SURFACE).sort().join(", ")}.`;
+  return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the workflow MCP transport currently exposes only ${[...WORKFLOW_TOOL_SURFACE_NAMES].sort().join(", ")}.`;
 }

package/src/resources/extensions/gsd/workflow-reconcile.ts

@@ -13,11 +13,11 @@ import {
   getMilestoneSlices,
   insertVerificationEvidence,
   upsertDecision,
-  openDatabase,
   setTaskBlockerDiscovered,
   insertOrIgnoreSlice,
   insertOrIgnoreTask,
 } from "./gsd-db.js";
+import { openWorkflowDatabasePath } from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache, resolveGsdPathContract } from "./paths.js";
@@ -500,7 +500,7 @@ function _reconcileWorktreeLogsInner(
   atomicWriteSync(join(mainBasePath, ".gsd", "event-log.jsonl"), logContent);
 
   // Step 8: Replay into DB (wrapped in a transaction by replayEvents)
-  openDatabase(resolveGsdPathContract(mainBasePath).projectDb);
+  openWorkflowDatabasePath(resolveGsdPathContract(mainBasePath).projectDb);
   replayEvents(merged);
 
   // Step 9: Write manifest
@@ -655,7 +655,7 @@ export function resolveConflict(
   writeEventLog(targetBasePath, targetBaseEvents.concat(rewrittenTargetEvents));
 
   // Replay resolved events through the DB (updates DB state)
-  openDatabase(resolveGsdPathContract(basePath).projectDb);
+  openWorkflowDatabasePath(resolveGsdPathContract(basePath).projectDb);
   replayEvents(eventsToReplay);
   invalidateStateCache();
   clearPathCache();

package/src/resources/extensions/gsd/workflow-tool-surface.ts

@@ -0,0 +1,73 @@
+// Project/App: gsd-pi
+// File Purpose: Adapts shared workflow tool contracts into the extension runtime surface.
+
+import {
+  CANONICAL_WORKFLOW_TOOL_NAMES as CONTRACT_CANONICAL_WORKFLOW_TOOL_NAMES,
+  WORKFLOW_TOOL_ALIAS_NAMES as CONTRACT_WORKFLOW_TOOL_ALIAS_NAMES,
+  WORKFLOW_TOOL_CONTRACTS as CONTRACT_WORKFLOW_TOOL_CONTRACTS,
+  WORKFLOW_TOOL_NAMES as CONTRACT_WORKFLOW_TOOL_NAMES,
+} from "@opengsd/contracts";
+import { stripMcpToolPrefix } from "./mcp-tool-name.js";
+
+export interface WorkflowToolAliasPair {
+  canonical: string;
+  alias: string;
+}
+
+export const WORKFLOW_TOOL_CONTRACTS = CONTRACT_WORKFLOW_TOOL_CONTRACTS;
+
+export const CANONICAL_WORKFLOW_TOOL_NAMES = CONTRACT_CANONICAL_WORKFLOW_TOOL_NAMES;
+export const WORKFLOW_TOOL_ALIAS_NAMES = CONTRACT_WORKFLOW_TOOL_ALIAS_NAMES;
+export const DB_WORKFLOW_TOOL_NAMES = CONTRACT_WORKFLOW_TOOL_NAMES;
+
+export const WORKFLOW_TOOL_ALIAS_PAIRS: readonly WorkflowToolAliasPair[] =
+  WORKFLOW_TOOL_CONTRACTS.flatMap((tool) =>
+    tool.aliases.map((alias) => ({ canonical: tool.canonicalName, alias })),
+  );
+
+export const WORKFLOW_TOOL_ALIAS_TO_CANONICAL: Readonly<Record<string, string>> =
+  Object.fromEntries(WORKFLOW_TOOL_ALIAS_PAIRS.map(({ alias, canonical }) => [alias, canonical]));
+
+const WORKFLOW_MCP_ADAPTER_TOOL_NAMES = [
+  "gsd_cancel",
+  "gsd_captures",
+  "ask_user_questions",
+  "gsd_doctor",
+  "gsd_execute",
+  "gsd_graph",
+  "gsd_history",
+  "gsd_knowledge",
+  "gsd_progress",
+  "gsd_query",
+  "gsd_result",
+  "gsd_resolve_blocker",
+  "gsd_roadmap",
+  "gsd_status",
+] as const;
+
+export const WORKFLOW_TOOL_SURFACE_NAMES = [
+  ...WORKFLOW_MCP_ADAPTER_TOOL_NAMES,
+  ...DB_WORKFLOW_TOOL_NAMES,
+] as readonly string[];
+
+const WORKFLOW_TOOL_SURFACE_NAME_SET = new Set(WORKFLOW_TOOL_SURFACE_NAMES);
+
+export { stripMcpToolPrefix } from "./mcp-tool-name.js";
+
+export function canonicalWorkflowSurfaceToolName(toolName: string): string {
+  const baseName = stripMcpToolPrefix(toolName);
+  return WORKFLOW_TOOL_ALIAS_TO_CANONICAL[baseName] ?? baseName;
+}
+
+export function isWorkflowSurfaceAliasTool(toolName: string): boolean {
+  const baseName = stripMcpToolPrefix(toolName);
+  return WORKFLOW_TOOL_ALIAS_TO_CANONICAL[baseName] !== undefined;
+}
+
+export function isWorkflowToolSurfaceName(toolName: string): boolean {
+  return WORKFLOW_TOOL_SURFACE_NAME_SET.has(stripMcpToolPrefix(toolName));
+}
+
+export function aliasesForWorkflowTool(canonicalName: string): readonly string[] {
+  return WORKFLOW_TOOL_CONTRACTS.find((tool) => tool.canonicalName === canonicalName)?.aliases ?? [];
+}

package/src/resources/extensions/gsd/workspace-git-guard.ts

@@ -14,6 +14,7 @@ export function isWorkspaceGitAllowedCommand(trimmed: string): boolean {
 
   const [name, subcommand] = command.split(/\s+/, 2);
   if (name === "doctor") return true;
+  if (name === "forensics") return true;
   if (name === "closeout" || command.startsWith("closeout")) return true;
   if (name === "dispatch") {
     return subcommand === "complete" || subcommand === "complete-milestone";

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

@@ -79,6 +79,7 @@ import {
   teardownAutoWorktree,
 } from "./auto-worktree.js";
 import { resolveRoadmapForMilestoneMerge } from "./milestone-merge-roadmap.js";
+import type { MilestoneMergeTransactionRunner } from "./milestone-merge-transaction.js";
 
 const recentWorktreeMergeFailures = new Map<string, number>();
 const MERGE_FAILURE_DEDUPE_MS = 60_000;
@@ -147,25 +148,15 @@ export interface WorktreeLifecycleDeps {
    */
   worktreeProjection: WorktreeStateProjection;
 
-  // ── Merge primitive ──────────────────────────────────────────────────
+  // ── Merge transaction ────────────────────────────────────────────────
   /**
-   * Inner squash-merge primitive (`auto-worktree.ts:mergeMilestoneToMain`).
+   * Milestone Merge Transaction Module runner.
    *
-   * **Module-internal seam — do not construct your own.** Only the wiring
-   * factory `auto.ts:buildWorktreeLifecycleDeps()` is permitted to populate
-   * this field. The primitive is `@internal`; production callers reach the
-   * merge body through `WorktreeLifecycle.exitMilestone({ merge: true })`,
-   * never by calling this dep directly.
+   * The field name is preserved for existing test fixtures, but production
+   * wiring now supplies the named transaction wrapper rather than the raw
+   * squash-merge primitive directly.
    */
-  mergeMilestoneToMain: (
-    basePath: string,
-    milestoneId: string,
-    roadmapContent: string,
-  ) => {
-    pushed: boolean;
-    codeFilesChanged: boolean;
-    commitMessage?: string;
-  };
+  mergeMilestoneToMain: MilestoneMergeTransactionRunner;
 
   // ADR-016 phase 2 / C1 + C2 + C3 + C4 inlined the following fields as
   // direct imports — leaf primitives that did not vary across callers:

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

@@ -74,6 +74,30 @@ const VERDICT_RE = /verdict:\s*[\w-]+/i;
  * Only overwrites when the source has a verdict — never clobbers a
  * worktree ASSESSMENT with a verdictless project-root copy.
  */
+function forceOverwriteValidationWithVerdict(
+  srcMilestoneDir: string,
+  dstMilestoneDir: string,
+  milestoneId: string,
+): void {
+  if (!existsSync(srcMilestoneDir) || !milestoneId) return;
+
+  const srcFile = join(srcMilestoneDir, `${milestoneId}-VALIDATION.md`);
+  if (!existsSync(srcFile)) return;
+
+  try {
+    const srcContent = readFileSync(srcFile, "utf-8");
+    if (!VERDICT_RE.test(srcContent)) return;
+
+    mkdirSync(dstMilestoneDir, { recursive: true });
+    safeCopy(srcFile, join(dstMilestoneDir, `${milestoneId}-VALIDATION.md`), { force: true });
+  } catch (err) {
+    logWarning(
+      "worktree",
+      `validation force-copy failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
 function forceOverwriteAssessmentsWithVerdict(
   srcMilestoneDir: string,
   dstMilestoneDir: string,
@@ -260,10 +284,10 @@ export function _projectRootToWorktreeImpl(
   // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
   // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
   // run-uat indefinitely (stuck-loop ×9).
-  forceOverwriteAssessmentsWithVerdict(
-    join(prGsd, "milestones", milestoneId),
-    join(wtGsd, "milestones", milestoneId),
-  );
+  const prMilestoneDir = join(prGsd, "milestones", milestoneId);
+  const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
+  forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
+  forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
 
   // Forward-sync completed-units.json from project root to worktree.
   // Project root is authoritative for completion state after crash recovery;
@@ -442,25 +466,41 @@ export class WorktreeStateProjection {
    * any Unit dispatches.
    */
   projectRootToWorktree(scope: MilestoneScope): void {
-    _projectRootToWorktreeImpl(
+    this.projectRootToWorktreePaths(
       scope.workspace.projectRoot,
       scope.workspace.worktreeRoot ?? scope.workspace.projectRoot,
       scope.milestoneId,
     );
   }
 
+  projectRootToWorktreePaths(
+    projectRoot: string,
+    worktreePath: string,
+    milestoneId: string | null,
+  ): void {
+    _projectRootToWorktreeImpl(projectRoot, worktreePath, milestoneId);
+  }
+
   /**
    * Project state from the auto-worktree back onto the project root for `scope`.
    * Called by the post-unit pipeline between Units.
    */
   projectWorktreeToRoot(scope: MilestoneScope): void {
-    _projectWorktreeToRootImpl(
+    this.projectWorktreeToRootPaths(
       scope.workspace.worktreeRoot ?? scope.workspace.projectRoot,
       scope.workspace.projectRoot,
       scope.milestoneId,
     );
   }
 
+  projectWorktreeToRootPaths(
+    worktreePath: string,
+    projectRoot: string,
+    milestoneId: string | null,
+  ): void {
+    _projectWorktreeToRootImpl(worktreePath, projectRoot, milestoneId);
+  }
+
   /**
    * Final projection from the auto-worktree to the project root before
    * teardown. Called by Lifecycle's exit path after a successful merge,
@@ -471,10 +511,18 @@ export class WorktreeStateProjection {
    * telemetry on what crossed the boundary.
    */
   finalizeProjectionForMerge(scope: MilestoneScope): { synced: string[] } {
-    return _finalizeProjectionForMergeImpl(
+    return this.finalizeProjectionForMergePaths(
       scope.workspace.projectRoot,
       scope.workspace.worktreeRoot ?? scope.workspace.projectRoot,
       scope.milestoneId,
     );
   }
+
+  finalizeProjectionForMergePaths(
+    projectRoot: string,
+    worktreePath: string,
+    milestoneId: string,
+  ): { synced: string[] } {
+    return _finalizeProjectionForMergeImpl(projectRoot, worktreePath, milestoneId);
+  }
 }

package/src/resources/extensions/gsd/worktree-telemetry.ts

@@ -22,6 +22,7 @@
 import { randomUUID } from "node:crypto";
 import { emitJournalEvent, queryJournal } from "./journal.js";
 import type { JournalEntry } from "./journal.js";
+import type { AutoTerminalOutcome } from "./auto/contracts.js";
 
 function now(): string {
   return new Date().toISOString();
@@ -91,6 +92,21 @@ export function normalizeAutoExitReason(rawReason?: string): AutoExitReason {
                             : "other";
 }
 
+export function autoExitReasonForTerminalOutcome(
+  outcome: AutoTerminalOutcome | undefined,
+): AutoExitReason | null {
+  switch (outcome?.code) {
+    case "all-complete":
+      return "all-complete";
+    case "settlement-blocked":
+      return "blocked";
+    case "no-remaining-units":
+      return "stop";
+    default:
+      return null;
+  }
+}
+
 // ─── Emitters ────────────────────────────────────────────────────────────
 
 export function emitWorktreeCreated(

package/src/resources/extensions/shared/interview-ui.ts

@@ -62,6 +62,13 @@ export interface RoundResult {
 	/** Always false — end is handled by showWrapUpScreen, not per-question */
 	endInterview: false;
 	answers: Record<string, { selected: string | string[]; notes: string }>;
+	/**
+	 * Set to true only when the round ended because the external AbortSignal
+	 * fired (e.g. a system/host teardown), as distinct from a deliberate user
+	 * dismissal. Consumers use this to avoid laundering a system teardown into a
+	 * clean user-declined cancel. Additive/optional — native consumers ignore it.
+	 */
+	interrupted?: boolean;
 }
 
 export interface WrapUpResult {
@@ -97,6 +104,12 @@ export interface InterviewRoundOptions {
 	 * Defaults to "end interview".
 	 */
 	exitLabel?: string;
+	/**
+	 * Render as a floating overlay instead of replacing the editor. Use when the
+	 * interview must stay visible during an in-flight agent stream (e.g. claude-code-cli
+	 * MCP elicitation).
+	 */
+	overlay?: boolean;
 }
 
 export interface WrapUpOptions {
@@ -240,7 +253,7 @@ export async function showInterviewRound(
 
 		// External cancellation (e.g. remote channel won the race)
 		if (opts.signal) {
-			const onAbort = () => finish({ endInterview: false, answers: {} });
+			const onAbort = () => finish({ endInterview: false, answers: {}, interrupted: true });
 			if (opts.signal.aborted) { onAbort(); }
 			else {
 				opts.signal.addEventListener("abort", onAbort, { once: true });
@@ -845,5 +858,5 @@ export async function showInterviewRound(
 			invalidate: () => { cachedLines = undefined; },
 			handleInput,
 		};
-	});
+	}, opts.overlay ? { overlay: true } : undefined);
 }