gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

package/src/resources/extensions/gsd/repo-identity.ts

@@ -427,22 +427,38 @@ function hasProjectState(externalPath: string): boolean {
  *
  * Returns the resolved external path (may differ from the computed identity).
  */
-function resolveExternalPathWithRecovery(projectPath: string): string {
-  const computedPath = externalGsdRoot(projectPath);
+function resolveExternalPathWithRecovery(projectPath: string): { path: string; identity: string } {
+  const base = process.env.GSD_STATE_DIR || gsdHome();
   const computedId = repoIdentity(projectPath);
+  const computedPath = join(base, "projects", computedId);
+  const computedHasState = hasProjectState(computedPath);
+  const markerId = readGsdIdMarker(projectPath);
+  const markerPath = markerId ? join(base, "projects", markerId) : null;
+  const markerHasState = markerPath ? hasProjectState(markerPath) : false;
+
+  // Split-brain guard: when marker and computed identities disagree and both
+  // directories contain state, prefer the marker-backed directory. This keeps
+  // all writers anchored to a single canonical project identity even if a
+  // transient identity computation produced a stale computed hash.
+  if (
+    markerId
+    && markerPath
+    && markerId !== computedId
+    && markerHasState
+    && computedHasState
+  ) {
+    return { path: markerPath, identity: markerId };
+  }
 
   // Check if computed path already has state — fast path, no recovery needed.
-  if (hasProjectState(computedPath)) {
-    return computedPath;
+  if (computedHasState) {
+    return { path: computedPath, identity: computedId };
   }
 
   // Check for .gsd-id marker from a previous location.
-  const markerId = readGsdIdMarker(projectPath);
-  if (markerId && markerId !== computedId) {
+  if (markerId && markerPath && markerId !== computedId) {
     // The marker points to a different identity — the repo was likely moved.
-    const base = process.env.GSD_STATE_DIR || gsdHome();
-    const markerPath = join(base, "projects", markerId);
-    if (hasProjectState(markerPath)) {
+    if (markerHasState) {
       // Recover: use the old state directory and update the marker to the new identity.
       // Move the state from the old hash dir to the new one so future lookups work
       // without the marker.
@@ -465,12 +481,12 @@ function resolveExternalPathWithRecovery(projectPath: string): string {
         try { rmSync(markerPath, { recursive: true, force: true }); } catch { /* non-fatal */ }
       } catch {
         // If migration fails, just point at the old directory.
-        return markerPath;
+        return { path: markerPath, identity: markerId };
       }
     }
   }
 
-  return computedPath;
+  return { path: computedPath, identity: computedId };
 }
 
 // ─── Symlink Management ─────────────────────────────────────────────────────
@@ -489,20 +505,21 @@ function resolveExternalPathWithRecovery(projectPath: string): string {
  * Returns the resolved external path.
  */
 export function ensureGsdSymlink(projectPath: string): string {
-  const result = ensureGsdSymlinkCore(projectPath);
+  const { path: result, identity } = ensureGsdSymlinkCore(projectPath);
 
   // Write .gsd-id marker so future relocations can recover this state (#2750).
   // Only write for the project root (not subdirectories or worktrees that
   // delegate to a parent .gsd).
   if (!isInsideWorktree(projectPath)) {
-    writeGsdIdMarker(projectPath, repoIdentity(projectPath));
+    writeGsdIdMarker(projectPath, identity);
   }
 
   return result;
 }
 
-function ensureGsdSymlinkCore(projectPath: string): string {
-  const externalPath = resolveExternalPathWithRecovery(projectPath);
+function ensureGsdSymlinkCore(projectPath: string): { path: string; identity: string } {
+  const resolved = resolveExternalPathWithRecovery(projectPath);
+  const externalPath = resolved.path;
   const localGsd = join(projectPath, ".gsd");
   const inWorktree = isInsideWorktree(projectPath);
 
@@ -519,7 +536,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
   const localGsdNormalized = normalizeForGuard(localGsd);
   const gsdHomeNorm = normalizeForGuard(gsdHome());
   if (localGsdNormalized === gsdHomeNorm) {
-    return localGsd;
+    return { path: localGsd, identity: resolved.identity };
   }
 
   // Guard: If projectPath is a plain subdirectory (not a worktree) of a git
@@ -538,7 +555,10 @@ function ensureGsdSymlinkCore(projectPath: string): string {
           try {
             const rootStat = lstatSync(rootGsd);
             if (rootStat.isSymbolicLink() || rootStat.isDirectory()) {
-              return rootStat.isSymbolicLink() ? realpathSync(rootGsd) : rootGsd;
+              return {
+                path: rootStat.isSymbolicLink() ? realpathSync(rootGsd) : rootGsd,
+                identity: resolved.identity,
+              };
             }
           } catch {
             // Fall through to normal logic if we can't stat root .gsd
@@ -560,12 +580,12 @@ function ensureGsdSymlinkCore(projectPath: string): string {
   // Write repo metadata once so cleanup commands can identify this directory later.
   writeRepoMeta(externalPath, getRemoteUrl(projectPath), resolveGitRoot(projectPath));
 
-  const replaceWithSymlink = (): string => {
+  const replaceWithSymlink = (): { path: string; identity: string } => {
     rmSync(localGsd, { recursive: true, force: true });
     // Defensive: remove any residual entry (e.g. dangling symlink) before creating.
     try { unlinkSync(localGsd); } catch { /* already gone */ }
     symlinkSync(externalPath, localGsd, "junction");
-    return externalPath;
+    return resolved;
   };
 
   // Check for dangling symlinks (e.g. after relocation recovery removed the old
@@ -585,7 +605,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
     // Defensive: remove any residual entry to avoid EEXIST race (#2750).
     try { unlinkSync(localGsd); } catch { /* nothing to remove */ }
     symlinkSync(externalPath, localGsd, "junction");
-    return externalPath;
+    return resolved;
   }
 
   try {
@@ -595,7 +615,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
       // Already a symlink — verify it points to the right place
       const target = realpathSync(localGsd);
       if (target === externalPath) {
-        return externalPath; // correct symlink, no-op
+        return resolved; // correct symlink, no-op
       }
       // In a worktree, mismatched symlinks are always stale. Heal them so
       // the worktree points at the same external state dir as the main repo.
@@ -620,11 +640,11 @@ function ensureGsdSymlinkCore(projectPath: string): string {
           return replaceWithSymlink();
         } catch {
           // Migration failed — preserve old symlink
-          return target;
+          return { path: target, identity: resolved.identity };
         }
       }
       // Outside worktrees, preserve custom overrides or legacy symlinks.
-      return target;
+      return { path: target, identity: resolved.identity };
     }
 
     if (stat.isDirectory()) {
@@ -632,13 +652,13 @@ function ensureGsdSymlinkCore(projectPath: string): string {
       // In worktrees, keep the directory in place and let syncGsdStateToWorktree
       // refresh its contents. Replacing a git-tracked .gsd directory with a
       // symlink makes git think tracked planning files were deleted.
-      return localGsd;
+      return { path: localGsd, identity: resolved.identity };
     }
   } catch {
     // lstat failed — path exists but we can't stat it
   }
 
-  return localGsd;
+  return { path: localGsd, identity: resolved.identity };
 }
 
 // ─── Worktree Detection ─────────────────────────────────────────────────────

package/src/resources/extensions/gsd/repository-registry.ts

@@ -0,0 +1,77 @@
+// GSD-2 + Repository registry seam for parent workspace multi-repo resolution.
+
+import { isAbsolute, relative, resolve } from "node:path";
+import type { GSDPreferences, WorkspacePreferences, WorkspaceRepositoryPreference } from "./preferences-types.js";
+import { resolveGsdPathContract } from "./paths.js";
+
+export interface RegisteredRepository {
+  id: string;
+  root: string;
+  role?: string;
+  verification?: string[];
+  commitPolicy?: "auto" | "skip";
+}
+
+export interface RepositoryRegistry {
+  projectRoot: string;
+  mode: "project" | "parent";
+  repositories: RegisteredRepository[];
+  byId: ReadonlyMap<string, RegisteredRepository>;
+}
+
+function assertInsideProjectRoot(projectRoot: string, candidateRoot: string, repoId: string): void {
+  const rel = relative(projectRoot, candidateRoot);
+  if (rel === "") return;
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`workspace.repositories.${repoId}.path resolves outside project root: ${candidateRoot}`);
+  }
+}
+
+function resolveRepositoryRoot(
+  projectRoot: string,
+  repoId: string,
+  repo: WorkspaceRepositoryPreference,
+): RegisteredRepository {
+  const root = resolve(projectRoot, repo.path);
+  assertInsideProjectRoot(projectRoot, root, repoId);
+  return {
+    id: repoId,
+    root,
+    role: repo.role,
+    verification: repo.verification,
+    commitPolicy: repo.commit_policy,
+  };
+}
+
+export function createRepositoryRegistry(
+  basePath: string,
+  workspacePrefs?: WorkspacePreferences,
+): RepositoryRegistry {
+  const contract = resolveGsdPathContract(basePath);
+  const projectRoot = contract.projectRoot;
+  const mode = workspacePrefs?.mode ?? "project";
+  const repoMap = new Map<string, RegisteredRepository>();
+
+  // Backward-compatible default for single-repo projects.
+  // Explicit workspacePrefs?.repositories entries can override "project"
+  // via resolveRepositoryRoot to customize role/verification/commit policy.
+  repoMap.set("project", { id: "project", root: projectRoot });
+
+  for (const [repoId, repoConfig] of Object.entries(workspacePrefs?.repositories ?? {})) {
+    repoMap.set(repoId, resolveRepositoryRoot(projectRoot, repoId, repoConfig));
+  }
+
+  return {
+    projectRoot,
+    mode,
+    repositories: Array.from(repoMap.values()),
+    byId: repoMap,
+  };
+}
+
+export function createRepositoryRegistryFromPreferences(
+  basePath: string,
+  preferences?: Pick<GSDPreferences, "workspace">,
+): RepositoryRegistry {
+  return createRepositoryRegistry(basePath, preferences?.workspace);
+}

package/src/resources/extensions/gsd/safety/evidence-collector.ts

@@ -53,6 +53,8 @@ export type EvidenceEntry = BashEvidence | FileWriteEvidence | FileEditEvidence;
 const EXECUTION_TOOL_NAMES = new Set([
   "bash",
   "Bash",
+  "PowerShell",
+  "async_bash",
   "gsd_exec",
   "gsd_exec_search",
   "mcp__gsd-workflow__gsd_exec",

package/src/resources/extensions/gsd/safety/evidence-cross-ref.ts

@@ -1,3 +1,4 @@
+
 /**
  * Evidence cross-reference for auto-mode safety harness.
  * Compares the LLM's claimed verification evidence (command + exitCode)
@@ -14,6 +15,7 @@ export interface ClaimedEvidence {
   command: string;
   exitCode: number;
   verdict: string;
+  createdAt?: string;
 }
 
 export interface EvidenceMismatch {
@@ -40,7 +42,7 @@ export function crossReferenceEvidence(
   );
   const mismatches: EvidenceMismatch[] = [];
 
-  for (const claimed of claimedEvidence) {
+  for (const claimed of latestClaimBatch(claimedEvidence)) {
     // Skip coerced entries — they're already flagged with exitCode: -1
     // and verdict: "unknown (coerced from string)" by db-tools.ts
     if (claimed.verdict?.includes("coerced from string")) continue;
@@ -49,10 +51,12 @@ export function crossReferenceEvidence(
     // Skip entries with empty or generic commands
     if (!claimed.command || claimed.command.length < 3) continue;
 
-    // Find matching bash call by command substring match
-    const match = findBestMatch(claimed.command, bashCalls);
+    // Find matching bash calls by command similarity. A command may be retried
+    // after a failed first run; the newest matching execution is the one that
+    // supports or rejects a claimed pass.
+    const matches = findMatches(claimed.command, bashCalls);
 
-    if (!match) {
+    if (matches.length === 0) {
       mismatches.push({
         severity: "warning",
         claimed,
@@ -63,6 +67,7 @@ export function crossReferenceEvidence(
     }
 
     // Exit code mismatch: LLM claims success but actual command failed
+    const match = latestMatch(matches);
     if (claimed.exitCode === 0 && match.exitCode !== 0) {
       mismatches.push({
         severity: "error",
@@ -79,42 +84,72 @@ export function crossReferenceEvidence(
 // ─── Internals ──────────────────────────────────────────────────────────────
 
 /**
- * Find the best matching bash evidence entry for a claimed command.
+ * Verification evidence rows are append-only across retries, but a task
+ * completion inserts one batch at a single created_at timestamp. When that
+ * timestamp is present, safety should judge the newest completion claim only.
+ */
+function latestClaimBatch(
+  claimedEvidence: readonly ClaimedEvidence[],
+): readonly ClaimedEvidence[] {
+  const dated = claimedEvidence
+    .map((claim) => ({
+      claim,
+      time: typeof claim.createdAt === "string" ? Date.parse(claim.createdAt) : Number.NaN,
+    }))
+    .filter((entry) => Number.isFinite(entry.time));
+
+  if (dated.length === 0) return claimedEvidence;
+
+  const latestTime = Math.max(...dated.map((entry) => entry.time));
+  return claimedEvidence.filter((claim) => (
+    typeof claim.createdAt === "string" && Date.parse(claim.createdAt) === latestTime
+  ));
+}
+
+/**
+ * Find bash evidence entries matching a claimed command.
  * Uses substring matching — the claimed command may be a shortened version
  * of the actual command, or vice versa.
  */
-function findBestMatch(
+function findMatches(
   claimedCommand: string,
   bashCalls: readonly BashEvidence[],
-): BashEvidence | null {
+): BashEvidence[] {
   const normalized = claimedCommand.trim();
 
-  // Exact match first
-  const exact = bashCalls.find(b => b.command.trim() === normalized);
-  if (exact) return exact;
+  // Exact matches first
+  const exact = bashCalls.filter(b => b.command.trim() === normalized);
+  if (exact.length > 0) return exact;
 
   // Substring match: claimed is contained in actual or actual in claimed
-  const substring = bashCalls.find(
+  const substring = bashCalls.filter(
     b => b.command.includes(normalized) || normalized.includes(b.command),
   );
-  if (substring) return substring;
+  if (substring.length > 0) return substring;
 
   // Token match: split on whitespace and check significant overlap
   const claimedTokens = normalized.split(/\s+/).filter(t => t.length > 2);
-  if (claimedTokens.length === 0) return null;
+  if (claimedTokens.length === 0) return [];
 
-  let bestMatch: BashEvidence | null = null;
-  let bestScore = 0;
+  const scoredMatches: Array<{ call: BashEvidence; score: number }> = [];
 
   for (const call of bashCalls) {
     const callTokens = new Set(call.command.split(/\s+/));
     const matchCount = claimedTokens.filter(t => callTokens.has(t)).length;
     const score = matchCount / claimedTokens.length;
-    if (score > bestScore && score >= 0.5) {
-      bestScore = score;
-      bestMatch = call;
+    if (score >= 0.5) {
+      scoredMatches.push({ call, score });
     }
   }
 
-  return bestMatch;
+  const bestScore = Math.max(0, ...scoredMatches.map((match) => match.score));
+  return scoredMatches
+    .filter((match) => match.score === bestScore)
+    .map((match) => match.call);
+}
+
+function latestMatch(matches: readonly BashEvidence[]): BashEvidence {
+  return matches.reduce((latest, match) => (
+    match.timestamp > latest.timestamp ? match : latest
+  ));
 }

package/src/resources/extensions/gsd/session-lock.ts

@@ -19,8 +19,9 @@
 import { createRequire } from "node:module";
 import { existsSync, readFileSync, readdirSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
-import { gsdRoot } from "./paths.js";
+import { gsdRoot, normalizeRealPath } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { markWorkerStoppingByPid } from "./db/auto-workers.js";
 
 const _require = createRequire(import.meta.url);
 
@@ -281,6 +282,13 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   // Clean up numbered lock file variants from cloud sync conflicts (#1315)
   cleanupStrayLockFiles(basePath);
 
+  // If lock metadata points to a dead PID, mark that worker row stopping so
+  // crash diagnostics do not keep surfacing it as active.
+  const existingPreflight = readExistingLockData(lp);
+  if (existingPreflight?.pid && !isPidAlive(existingPreflight.pid)) {
+    markWorkerStoppingByPid(normalizeRealPath(basePath), existingPreflight.pid);
+  }
+
   // Write our lock data first (the content is informational; the OS lock is the real guard)
   const lockData: SessionLockData = {
     pid: process.pid,
@@ -308,7 +316,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   const lockDir = lockTarget + ".lock";
   if (existsSync(lockDir)) {
     const existingData = readExistingLockData(lp);
-    const isOrphan = !existingData || (existingData.pid && !isPidAlive(existingData.pid));
+    const deadPid = existingData?.pid && !isPidAlive(existingData.pid) ? existingData.pid : null;
+    if (deadPid) markWorkerStoppingByPid(normalizeRealPath(basePath), deadPid);
+    const isOrphan = !existingData || !!deadPid;
     if (isOrphan) {
       try { rmSync(lockDir, { recursive: true, force: true }); } catch { /* best-effort */ }
       try { if (existsSync(lp)) unlinkSync(lp); } catch { /* best-effort */ }
@@ -344,6 +354,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     // Check: if auto.lock is gone and no process is alive, the lock dir is stale.
     const existingData = readExistingLockData(lp);
     const existingPid = existingData?.pid;
+    if (existingPid && !isPidAlive(existingPid)) {
+      markWorkerStoppingByPid(normalizeRealPath(basePath), existingPid);
+    }
 
     // If no lock file or no alive process, try to clean up and re-acquire (#1245)
     if (!existingData || (existingPid && !isPidAlive(existingPid))) {

package/src/resources/extensions/gsd/slice-parallel-conflict.ts

@@ -55,8 +55,8 @@ export function hasFileConflict(
   sliceA: string,
   sliceB: string,
 ): boolean {
-  const planPathA = join(basePath, ".gsd", "milestones", mid, sliceA, "PLAN.md");
-  const planPathB = join(basePath, ".gsd", "milestones", mid, sliceB, "PLAN.md");
+  const planPathA = join(basePath, ".gsd", "milestones", mid, "slices", sliceA, `${sliceA}-PLAN.md`);
+  const planPathB = join(basePath, ".gsd", "milestones", mid, "slices", sliceB, `${sliceB}-PLAN.md`);
 
   // Conservative: missing PLAN = block
   if (!existsSync(planPathA) || !existsSync(planPathB)) {

package/src/resources/extensions/gsd/slice-parallel-orchestrator.ts

@@ -18,13 +18,15 @@ import { randomUUID } from "node:crypto";
 import {
   appendFileSync,
   existsSync,
+  lstatSync,
+  rmSync,
   writeFileSync,
   readFileSync,
   mkdirSync,
   renameSync,
   unlinkSync,
 } from "node:fs";
-import { join, dirname } from "node:path";
+import { isAbsolute, join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
@@ -105,6 +107,37 @@ export function _buildSliceWorkerEnvForTest(
   };
 }
 
+function isValidSliceWorktreePath(basePath: string, wtPath: string): boolean {
+  if (!existsSync(wtPath)) return false;
+  const gitPath = join(wtPath, ".git");
+  if (!existsSync(gitPath)) return false;
+  try {
+    if (!lstatSync(gitPath).isFile()) return false;
+    const content = readFileSync(gitPath, "utf8").trim();
+    if (!content.startsWith("gitdir: ")) return false;
+    const rawGitdir = content.slice("gitdir: ".length).trim();
+    if (!rawGitdir) return false;
+    const resolvedGitdir = isAbsolute(rawGitdir) ? rawGitdir : resolve(wtPath, rawGitdir);
+    const expectedPrefix = join(basePath, ".git", "worktrees").replaceAll("\\", "/");
+    const normalized = resolvedGitdir.replaceAll("\\", "/");
+    return normalized === expectedPrefix || normalized.startsWith(`${expectedPrefix}/`);
+  } catch {
+    return false;
+  }
+}
+
+function isWorkerPidAlive(pid: number): boolean {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException)?.code;
+    if (code === "ESRCH") return false;
+    return true;
+  }
+}
+
 interface PersistedSliceWorker {
   milestoneId: string;
   sliceId: string;
@@ -334,7 +367,24 @@ export function restoreSliceState(basePath: string): PersistedSliceState | null
  * crash followed by a fresh process is detectable. (Issue #4980 HIGH-8)
  */
 export function isSliceParallelActive(basePath?: string): boolean {
-  if (sliceState?.active === true) return true;
+  const hasRunningWorkers = (): boolean => {
+    if (!sliceState) return false;
+    for (const worker of sliceState.workers.values()) {
+      if (worker.state === "running") {
+        if (worker.process) return true;
+        if (isRecoveredSliceWorkerAlive(worker)) return true;
+      }
+    }
+    return false;
+  };
+
+  if (sliceState?.active === true) {
+    if (hasRunningWorkers()) return true;
+    sliceState.active = false;
+    removeSliceStateFile(sliceState.basePath);
+    return false;
+  }
+
   if (!basePath) return false;
   const restored = restoreSliceState(basePath);
   if (!restored || restored.workers.length === 0) return false;
@@ -365,7 +415,11 @@ export function isSliceParallelActive(basePath?: string): boolean {
       cost: w.cost,
     });
   }
-  return true;
+
+  if (hasRunningWorkers()) return true;
+  sliceState.active = false;
+  removeSliceStateFile(sliceState.basePath);
+  return false;
 }
 
 /**
@@ -427,6 +481,9 @@ export async function startSliceParallel(
       const wtName = `${milestoneId}-${slice.id}`;
       const wtPath = worktreePath(basePath, wtName);
 
+      if (existsSync(wtPath) && !isValidSliceWorktreePath(basePath, wtPath)) {
+        rmSync(wtPath, { recursive: true, force: true });
+      }
       if (!existsSync(wtPath)) {
         createWorktree(basePath, wtName, { branch: wtBranch });
       }
@@ -470,6 +527,21 @@ export async function startSliceParallel(
     }
   }
 
+  // Guard: if workers died immediately, treat as failed start so callers
+  // don't exit auto-mode and re-dispatch in a rapid loop.
+  for (let i = started.length - 1; i >= 0; i--) {
+    const sid = started[i];
+    const worker = sliceState.workers.get(sid);
+    if (worker && isWorkerPidAlive(worker.pid)) continue;
+    started.splice(i, 1);
+    errors.push({ sid, error: "Worker exited immediately after spawn" });
+    sliceState.workers.delete(sid);
+    const wtName = `${milestoneId}-${sid}`;
+    try {
+      removeWorktree(basePath, wtName, { deleteBranch: true, force: true });
+    } catch { /* ignore cleanup failures */ }
+  }
+
   // If nothing started, deactivate
   if (started.length === 0) {
     sliceState.active = false;

package/src/resources/extensions/gsd/smart-entry-routing.ts

@@ -0,0 +1,77 @@
+// GSD-2 — Smart entry routing decisions.
+// Pure route selection for /gsd guided wizard choices.
+
+export type SmartEntryIsolationMode = "worktree" | "branch" | "none";
+
+export type ActiveTaskChoice =
+  | "execute"
+  | "auto"
+  | "status"
+  | "milestone_actions";
+
+export type ActiveTaskRoute =
+  | {
+      kind: "auto-bootstrap";
+      verboseMode: false;
+      options?: {
+        step?: true;
+        milestoneLock?: string;
+      };
+    }
+  | {
+      kind: "guided-dispatch";
+      unitType: "execute-task";
+    }
+  | {
+      kind: "status";
+    }
+  | {
+      kind: "milestone-actions";
+    };
+
+export function resolveGuidedExecuteLaunchMode(
+  isolationMode: SmartEntryIsolationMode,
+): "auto-step" | "guided-dispatch" {
+  return isolationMode === "worktree" ? "auto-step" : "guided-dispatch";
+}
+
+export function resolveActiveTaskChoiceRoute(input: {
+  choice: ActiveTaskChoice;
+  isolationMode: SmartEntryIsolationMode;
+  milestoneId: string;
+}): ActiveTaskRoute {
+  if (input.choice === "auto") {
+    return {
+      kind: "auto-bootstrap",
+      verboseMode: false,
+    };
+  }
+
+  if (input.choice === "execute") {
+    if (resolveGuidedExecuteLaunchMode(input.isolationMode) === "auto-step") {
+      return {
+        kind: "auto-bootstrap",
+        verboseMode: false,
+        options: {
+          step: true,
+          milestoneLock: input.milestoneId,
+        },
+      };
+    }
+
+    return {
+      kind: "guided-dispatch",
+      unitType: "execute-task",
+    };
+  }
+
+  if (input.choice === "status") {
+    return { kind: "status" };
+  }
+
+  if (input.choice === "milestone_actions") {
+    return { kind: "milestone-actions" };
+  }
+
+  throw new Error(`Invalid ActiveTaskChoice: ${input.choice}`);
+}

package/src/resources/extensions/gsd/state-reconciliation/drift/merge-state.ts

@@ -23,6 +23,7 @@ import {
 } from "../../native-git-bridge.js";
 import type { GSDState } from "../../types.js";
 import { logError, logWarning } from "../../workflow-logger.js";
+import { isGsdWorktreePath } from "../../worktree-root.js";
 import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
 
 export type MergeReconcileResult = "clean" | "reconciled" | "blocked";
@@ -46,7 +47,13 @@ function resolveGitDir(basePath: string): string {
       return isAbsolute(gitDir) ? gitDir : resolve(basePath, gitDir);
     }
   } catch (err) {
-    logWarning("recovery", `gitdir resolution failed: ${getErrorMessage(err)}`);
+    const message = getErrorMessage(err);
+    logWarning("recovery", `gitdir resolution failed: ${message}`);
+    if (isGsdWorktreePath(basePath)) {
+      throw new Error(
+        `Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${message.split("\n")[0]}). Repair or recreate the worktree before retrying.`,
+      );
+    }
   }
 
   return join(basePath, ".git");