gsd-pi 2.37.1 → 2.38.0-dev.4d4d14a

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -33,7 +33,6 @@ import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.j
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
-import { resetRewriteCircuitBreaker } from "./auto-dispatch.js";
 import { isDbAvailable } from "./gsd-db.js";
 import { consumeSignal } from "./session-status-io.js";
 import {
@@ -56,6 +55,13 @@ import { join } from "node:path";
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 
+export interface PreVerificationOpts {
+  skipSettleDelay?: boolean;
+  skipDoctor?: boolean;
+  skipStateRebuild?: boolean;
+  skipWorktreeSync?: boolean;
+}
+
 export interface PostUnitContext {
   s: AutoSession;
   ctx: ExtensionContext;
@@ -73,7 +79,7 @@ export interface PostUnitContext {
  *
  * Returns "dispatched" if a signal caused stop/pause, "continue" to proceed.
  */
-export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"dispatched" | "continue"> {
+export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreVerificationOpts): Promise<"dispatched" | "continue"> {
   const { s, ctx, pi, buildSnapshotOpts, stopAuto, pauseAuto } = pctx;
 
   // ── Parallel worker signal check ──
@@ -95,8 +101,10 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
   // Invalidate all caches
   invalidateAllCaches();
 
-  // Small delay to let files settle
-  await new Promise(r => setTimeout(r, 500));
+  // Small delay to let files settle (skipped for sidecars where latency matters more)
+  if (!opts?.skipSettleDelay) {
+    await new Promise(r => setTimeout(r, 100));
+  }
 
   // Auto-commit
   if (s.currentUnit) {
@@ -113,15 +121,25 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
               const summaryContent = await loadFile(summaryPath);
               if (summaryContent) {
                 const summary = parseSummary(summaryContent);
+                // Look up GitHub issue number for commit linking
+                let ghIssueNumber: number | undefined;
+                try {
+                  const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                  ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
+                } catch {
+                  // GitHub sync not available — skip
+                }
+
                 taskContext = {
                   taskId: `${sid}/${tid}`,
                   taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
                   oneLiner: summary.oneLiner || undefined,
                   keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                  issueNumber: ghIssueNumber,
                 };
               }
-            } catch {
-              // Non-fatal
+            } catch (e) {
+              debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
             }
           }
         }
@@ -131,12 +149,20 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
       if (commitMsg) {
         ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
       }
-    } catch {
-      // Non-fatal
+    } catch (e) {
+      debugLog("postUnit", { phase: "auto-commit", error: String(e) });
     }
 
-    // Doctor: fix mechanical bookkeeping
+    // GitHub sync (non-blocking, opt-in)
     try {
+      const { runGitHubSync } = await import("../github-sync/sync.js");
+      await runGitHubSync(s.basePath, s.currentUnit.type, s.currentUnit.id);
+    } catch (e) {
+      debugLog("postUnit", { phase: "github-sync", error: String(e) });
+    }
+
+    // Doctor: fix mechanical bookkeeping (skipped for lightweight sidecars)
+    if (!opts?.skipDoctor) try {
       const scopeParts = s.currentUnit.id.split("/").slice(0, 2);
       const doctorScope = scopeParts.join("/");
       const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
@@ -168,24 +194,27 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
             const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
             const structuredIssues = formatDoctorIssuesForPrompt(actionable);
             dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
-          } catch {
-            // Non-fatal
+            return "dispatched";
+          } catch (e) {
+            debugLog("postUnit", { phase: "doctor-heal-dispatch", error: String(e) });
           }
         }
       }
-    } catch {
-      // Non-fatal
+    } catch (e) {
+      debugLog("postUnit", { phase: "doctor", error: String(e) });
     }
 
-    // Throttled STATE.md rebuild
-    const now = Date.now();
-    if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
-      try {
-        await rebuildState(s.basePath);
-        s.lastStateRebuildAt = now;
-        autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
-      } catch {
-        // Non-fatal
+    // Throttled STATE.md rebuild (skipped for lightweight sidecars)
+    if (!opts?.skipStateRebuild) {
+      const now = Date.now();
+      if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
+        try {
+          await rebuildState(s.basePath);
+          s.lastStateRebuildAt = now;
+          autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
+        } catch (e) {
+          debugLog("postUnit", { phase: "state-rebuild", error: String(e) });
+        }
       }
     }
 
@@ -193,16 +222,16 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
     try {
       const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
       pruneDeadProcesses();
-    } catch {
-      // Non-fatal
+    } catch (e) {
+      debugLog("postUnit", { phase: "prune-bg-shell", error: String(e) });
     }
 
-    // Sync worktree state back to project root
-    if (s.originalBasePath && s.originalBasePath !== s.basePath) {
+    // Sync worktree state back to project root (skipped for lightweight sidecars)
+    if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
       try {
         syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
-      } catch {
-        // Non-fatal
+      } catch (e) {
+        debugLog("postUnit", { phase: "worktree-sync", error: String(e) });
       }
     }
 
@@ -210,10 +239,24 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
     if (s.currentUnit.type === "rewrite-docs") {
       try {
         await resolveAllOverrides(s.basePath);
-        resetRewriteCircuitBreaker();
+        s.rewriteAttemptCount = 0;
         ctx.ui.notify("Override(s) resolved — rewrite-docs completed.", "info");
-      } catch {
-        // Non-fatal
+      } catch (e) {
+        debugLog("postUnit", { phase: "rewrite-docs-resolve", error: String(e) });
+      }
+    }
+
+    // Reactive state cleanup on slice completion
+    if (s.currentUnit.type === "complete-slice") {
+      try {
+        const parts = s.currentUnit.id.split("/");
+        const [mid, sid] = parts;
+        if (mid && sid) {
+          const { clearReactiveState } = await import("./reactive-graph.js");
+          clearReactiveState(s.basePath, mid, sid);
+        }
+      } catch (e) {
+        debugLog("postUnit", { phase: "reactive-state-cleanup", error: String(e) });
       }
     }
 
@@ -266,8 +309,8 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
         if (triggerArtifactVerified) {
           invalidateAllCaches();
         }
-      } catch {
-        // Non-fatal
+      } catch (e) {
+        debugLog("postUnit", { phase: "artifact-verify", error: String(e) });
       }
     } else {
       // Hook unit completed — finalize its runtime record
@@ -278,8 +321,8 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
           lastProgressKind: "hook-completed",
         });
         clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
-      } catch {
-        // Non-fatal
+      } catch (e) {
+        debugLog("postUnit", { phase: "hook-finalize", error: String(e) });
       }
     }
   }
@@ -415,8 +458,8 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           }
         }
       }
-    } catch {
-      // Triage check failure is non-fatal
+    } catch (e) {
+      debugLog("postUnit", { phase: "triage-check", error: String(e) });
     }
   }
 
@@ -461,8 +504,8 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
       );
 
       return "continue";
-    } catch {
-      // Non-fatal — proceed to normal dispatch
+    } catch (e) {
+      debugLog("postUnit", { phase: "quick-task-dispatch", error: String(e) });
     }
   }
 

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -21,10 +21,7 @@ import type { GSDPreferences } from "./preferences.js";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
-import { compressToTarget } from "./prompt-compressor.js";
-import { distillSummaries } from "./summary-distiller.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
-import { chunkByRelevance, formatChunks } from "./semantic-chunker.js";
 
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 
@@ -159,16 +156,10 @@ export async function inlineFileSmart(
     return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
   }
 
-  // Use semantic chunking for large files
-  const result = chunkByRelevance(content, query, { maxChunks: 5, minScore: 0.05 });
-
-  // If chunking didn't save much (< 20%), just include full content
-  if (result.savingsPercent < 20) {
-    return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
-  }
-
-  const formatted = formatChunks(result, relPath);
-  return `### ${label} (${result.omittedChunks} sections omitted for relevance)\nSource: \`${relPath}\`\n\n${formatted}`;
+  // For large files, truncate at section boundary
+  const { truncateAtSectionBoundary } = await import("./context-budget.js");
+  const truncated = truncateAtSectionBoundary(content, threshold).content;
+  return `### ${label}\nSource: \`${relPath}\`\n\n${truncated}`;
 }
 
 /**
@@ -202,20 +193,6 @@ export async function inlineDependencySummaries(
 
   const result = sections.join("\n\n");
   if (budgetChars !== undefined && result.length > budgetChars) {
-    // For 3+ summaries, try distillation first (preserves more information)
-    if (sections.length >= 3) {
-      const rawSummaries = sections.map(s => {
-        // Extract content after the header line
-        const lines = s.split("\n");
-        const contentStart = lines.findIndex(l => l.startsWith("Source:"));
-        return contentStart >= 0 ? lines.slice(contentStart + 1).join("\n").trim() : s;
-      });
-      const distilled = distillSummaries(rawSummaries, budgetChars);
-      if (distilled.content.length <= budgetChars) {
-        return distilled.content;
-      }
-    }
-    // Fall back to section-boundary truncation
     const { truncateAtSectionBoundary } = await import("./context-budget.js");
     return truncateAtSectionBoundary(result, budgetChars).content;
   }
@@ -485,6 +462,41 @@ export async function getPriorTaskSummaryPaths(
     .map(f => `${sRel}/tasks/${f}`);
 }
 
+/**
+ * Get carry-forward summary paths scoped to a task's derived dependencies.
+ *
+ * Instead of all prior tasks (order-based), returns only summaries for task
+ * IDs in `dependsOn`. Used by reactive-execute to give each subagent only
+ * the context it actually needs — not sibling tasks from a parallel batch.
+ *
+ * Falls back to order-based when dependsOn is empty (root tasks still get
+ * any available prior summaries for continuity).
+ */
+export async function getDependencyTaskSummaryPaths(
+  mid: string, sid: string, currentTid: string,
+  dependsOn: string[], base: string,
+): Promise<string[]> {
+  // If no dependencies, fall back to order-based for root tasks
+  if (dependsOn.length === 0) {
+    return getPriorTaskSummaryPaths(mid, sid, currentTid, base);
+  }
+
+  const tDir = resolveTasksDir(base, mid, sid);
+  if (!tDir) return [];
+
+  const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
+  const sRel = relSlicePath(base, mid, sid);
+  const depSet = new Set(dependsOn.map((d) => d.toUpperCase()));
+
+  return summaryFiles
+    .filter((f) => {
+      // Extract task ID from filename: "T02-SUMMARY.md" → "T02"
+      const tid = f.replace(/-SUMMARY\.md$/i, "").toUpperCase();
+      return depSet.has(tid);
+    })
+    .map((f) => `${sRel}/tasks/${f}`);
+}
+
 // ─── Adaptive Replanning Checks ────────────────────────────────────────────
 
 /**
@@ -772,13 +784,24 @@ export async function buildPlanSlicePrompt(
   });
 }
 
+/** Options for customizing execute-task prompt construction. */
+export interface ExecuteTaskPromptOptions {
+  level?: InlineLevel;
+  /** Override carry-forward paths (dependency-based instead of order-based). */
+  carryForwardPaths?: string[];
+}
+
 export async function buildExecuteTaskPrompt(
   mid: string, sid: string, sTitle: string,
-  tid: string, tTitle: string, base: string, level?: InlineLevel,
+  tid: string, tTitle: string, base: string,
+  level?: InlineLevel | ExecuteTaskPromptOptions,
 ): Promise<string> {
-  const inlineLevel = level ?? resolveInlineLevel();
+  const opts: ExecuteTaskPromptOptions = typeof level === "object" && level !== null && !Array.isArray(level)
+    ? level
+    : { level: level as InlineLevel | undefined };
+  const inlineLevel = opts.level ?? resolveInlineLevel();
 
-  const priorSummaries = await getPriorTaskSummaryPaths(mid, sid, tid, base);
+  const priorSummaries = opts.carryForwardPaths ?? await getPriorTaskSummaryPaths(mid, sid, tid, base);
   const priorLines = priorSummaries.length > 0
     ? priorSummaries.map(p => `- \`${p}\``).join("\n")
     : "- (no prior tasks)";
@@ -854,15 +877,12 @@ export async function buildExecuteTaskPrompt(
   const budgets = computeBudgets(contextWindow);
   const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
 
-  // Compress carry-forward section when it exceeds 40% of inline context budget.
-  // Only compress when compression_strategy is "compress" (budget/balanced profiles).
+  // Truncate carry-forward section when it exceeds 40% of inline context budget.
   const carryForwardBudget = Math.floor(budgets.inlineContextBudgetChars * 0.4);
   let finalCarryForward = carryForwardSection;
   if (carryForwardSection.length > carryForwardBudget) {
-    const { resolveCompressionStrategy } = await import("./preferences.js");
-    if (resolveCompressionStrategy() === "compress") {
-      finalCarryForward = compressToTarget(carryForwardSection, carryForwardBudget).content;
-    }
+    const { truncateAtSectionBoundary } = await import("./context-budget.js");
+    finalCarryForward = truncateAtSectionBoundary(carryForwardSection, carryForwardBudget).content;
   }
 
   return loadPrompt("execute-task", {
@@ -1234,6 +1254,82 @@ export async function buildReassessRoadmapPrompt(
   });
 }
 
+// ─── Reactive Execute Prompt ──────────────────────────────────────────────
+
+export async function buildReactiveExecutePrompt(
+  mid: string, midTitle: string, sid: string, sTitle: string,
+  readyTaskIds: string[], base: string,
+): Promise<string> {
+  const { loadSliceTaskIO, deriveTaskGraph, graphMetrics } = await import("./reactive-graph.js");
+
+  // Build graph for context
+  const taskIO = await loadSliceTaskIO(base, mid, sid);
+  const graph = deriveTaskGraph(taskIO);
+  const metrics = graphMetrics(graph);
+
+  // Build graph context section
+  const graphLines: string[] = [];
+  for (const node of graph) {
+    const status = node.done ? "✅ done" : readyTaskIds.includes(node.id) ? "🟢 ready" : "⏳ waiting";
+    const deps = node.dependsOn.length > 0 ? ` (depends on: ${node.dependsOn.join(", ")})` : "";
+    graphLines.push(`- **${node.id}: ${node.title}** — ${status}${deps}`);
+    if (node.outputFiles.length > 0) {
+      graphLines.push(`  - Outputs: ${node.outputFiles.map(f => `\`${f}\``).join(", ")}`);
+    }
+  }
+  const graphContext = [
+    `Tasks: ${metrics.taskCount}, Edges: ${metrics.edgeCount}, Ready: ${metrics.readySetSize}`,
+    "",
+    ...graphLines,
+  ].join("\n");
+
+  // Build individual subagent prompts for each ready task
+  const subagentSections: string[] = [];
+  const readyTaskListLines: string[] = [];
+
+  for (const tid of readyTaskIds) {
+    const node = graph.find((n) => n.id === tid);
+    const tTitle = node?.title ?? tid;
+    readyTaskListLines.push(`- **${tid}: ${tTitle}**`);
+
+    // Build dependency-scoped carry-forward paths for this task
+    const depPaths = await getDependencyTaskSummaryPaths(
+      mid, sid, tid, node?.dependsOn ?? [], base,
+    );
+
+    // Build a full execute-task prompt with dependency-based carry-forward
+    const taskPrompt = await buildExecuteTaskPrompt(
+      mid, sid, sTitle, tid, tTitle, base,
+      { carryForwardPaths: depPaths },
+    );
+
+    subagentSections.push([
+      `### ${tid}: ${tTitle}`,
+      "",
+      "Use this as the prompt for a `subagent` call:",
+      "",
+      "```",
+      taskPrompt,
+      "```",
+    ].join("\n"));
+  }
+
+  const inlinedTemplates = inlineTemplate("task-summary", "Task Summary");
+
+  return loadPrompt("reactive-execute", {
+    workingDirectory: base,
+    milestoneId: mid,
+    milestoneTitle: midTitle,
+    sliceId: sid,
+    sliceTitle: sTitle,
+    graphContext,
+    readyTaskCount: String(readyTaskIds.length),
+    readyTaskList: readyTaskListLines.join("\n"),
+    subagentPrompts: subagentSections.join("\n\n---\n\n"),
+    inlinedTemplates,
+  });
+}
+
 export async function buildRewriteDocsPrompt(
   mid: string, midTitle: string,
   activeSlice: { id: string; title: string } | null,

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -26,6 +26,7 @@ import {
   resolveSlicePath,
   resolveSliceFile,
   resolveTasksDir,
+  resolveTaskFiles,
   relMilestoneFile,
   relSliceFile,
   relSlicePath,
@@ -110,6 +111,9 @@ export function resolveExpectedArtifactPath(
     }
     case "rewrite-docs":
       return null;
+    case "reactive-execute":
+      // Reactive execute produces multiple task summaries — verified separately
+      return null;
     default:
       return null;
   }
@@ -148,6 +152,44 @@ export function verifyExpectedArtifact(
     return !content.includes("**Scope:** active");
   }
 
+  // Reactive-execute: verify that each dispatched task's summary exists.
+  // The unitId encodes the batch: "{mid}/{sid}/reactive+T02,T03"
+  if (unitType === "reactive-execute") {
+    const parts = unitId.split("/");
+    const mid = parts[0];
+    const sidAndBatch = parts[1];
+    const batchPart = parts[2]; // "reactive+T02,T03"
+    if (!mid || !sidAndBatch || !batchPart) return false;
+
+    const sid = sidAndBatch;
+    const plusIdx = batchPart.indexOf("+");
+    if (plusIdx === -1) {
+      // Legacy format "reactive" without batch IDs — fall back to "any summary"
+      const tDir = resolveTasksDir(base, mid, sid);
+      if (!tDir) return false;
+      const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
+      return summaryFiles.length > 0;
+    }
+
+    const batchIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
+    if (batchIds.length === 0) return false;
+
+    const tDir = resolveTasksDir(base, mid, sid);
+    if (!tDir) return false;
+
+    const existingSummaries = new Set(
+      resolveTaskFiles(tDir, "SUMMARY").map((f) =>
+        f.replace(/-SUMMARY\.md$/i, "").toUpperCase(),
+      ),
+    );
+
+    // Every dispatched task must have a summary file
+    for (const tid of batchIds) {
+      if (!existingSummaries.has(tid.toUpperCase())) return false;
+    }
+    return true;
+  }
+
   const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
   // For unit types with no verifiable artifact (null path), the parent directory
   // is missing on disk — treat as stale completion state so the key gets evicted (#313).

package/src/resources/extensions/gsd/auto-start.ts

@@ -20,7 +20,7 @@ import {
   resolveSkillDiscoveryMode,
   getIsolationMode,
 } from "./preferences.js";
-import { ensureGsdSymlink } from "./repo-identity.js";
+import { ensureGsdSymlink, validateProjectId } from "./repo-identity.js";
 import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import { gsdRoot, resolveMilestoneFile, milestonesDir } from "./paths.js";
@@ -130,6 +130,16 @@ export async function bootstrapAutoSession(
   }
 
   try {
+    // Validate GSD_PROJECT_ID early so the user gets immediate feedback
+    const customProjectId = process.env.GSD_PROJECT_ID;
+    if (customProjectId && !validateProjectId(customProjectId)) {
+      ctx.ui.notify(
+        `GSD_PROJECT_ID must contain only alphanumeric characters, hyphens, and underscores. Got: "${customProjectId}"`,
+        "error",
+      );
+      return releaseLockAndReturn();
+    }
+
     // Ensure git repo exists
     if (!nativeIsRepo(base)) {
       const mainBranch =
@@ -429,10 +439,16 @@ export async function bootstrapAutoSession(
     s.originalBasePath = base;
 
     const isUnderGsdWorktrees = (p: string): boolean => {
+      // Direct layout: /.gsd/worktrees/
       const marker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
       if (p.includes(marker)) return true;
       const worktreesSuffix = `${pathSep}.gsd${pathSep}worktrees`;
-      return p.endsWith(worktreesSuffix);
+      if (p.endsWith(worktreesSuffix)) return true;
+      // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/
+      const symlinkRe = new RegExp(
+        `\\${pathSep}\\.gsd\\${pathSep}projects\\${pathSep}[a-f0-9]+\\${pathSep}worktrees(?:\\${pathSep}|$)`,
+      );
+      return symlinkRe.test(p);
     };
 
     if (

package/src/resources/extensions/gsd/auto-worktree-sync.ts

@@ -22,6 +22,8 @@ import { join, sep as pathSep } from "node:path";
 import { homedir } from "node:os";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+
 // ─── Project Root → Worktree Sync ─────────────────────────────────────────
 
 /**
@@ -111,7 +113,7 @@ export function syncStateToProjectRoot(
  */
 export function readResourceVersion(): string | null {
   const agentDir =
-    process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
+    process.env.GSD_CODING_AGENT_DIR || join(gsdHome, "agent");
   const manifestPath = join(agentDir, "managed-resources.json");
   try {
     const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -153,9 +155,18 @@ export function checkResourcesStale(
  * Returns the corrected base path.
  */
 export function escapeStaleWorktree(base: string): string {
-  const marker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
-  const idx = base.indexOf(marker);
-  if (idx === -1) return base;
+  // Direct layout: /.gsd/worktrees/
+  const directMarker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
+  let idx = base.indexOf(directMarker);
+  if (idx === -1) {
+    // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/
+    const symlinkRe = new RegExp(
+      `\\${pathSep}\\.gsd\\${pathSep}projects\\${pathSep}[a-f0-9]+\\${pathSep}worktrees\\${pathSep}`,
+    );
+    const match = base.match(symlinkRe);
+    if (!match || match.index === undefined) return base;
+    idx = match.index;
+  }
 
   // base is inside .gsd/worktrees/<something> — extract the project root
   const projectRoot = base.slice(0, idx);