gsd-pi 2.37.1 → 2.38.0-dev.361f5e3

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -22,7 +22,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 { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, } from "./post-unit-hooks.js";
@@ -36,7 +35,7 @@ const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
  *
  * Returns "dispatched" if a signal caused stop/pause, "continue" to proceed.
  */
-export async function postUnitPreVerification(pctx) {
+export async function postUnitPreVerification(pctx, opts) {
     const { s, ctx, pi, buildSnapshotOpts, stopAuto, pauseAuto } = pctx;
     // ── Parallel worker signal check ──
     const milestoneLock = process.env.GSD_MILESTONE_LOCK;
@@ -55,8 +54,10 @@ export async function postUnitPreVerification(pctx) {
     }
     // 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) {
         try {
@@ -71,16 +72,26 @@ export async function postUnitPreVerification(pctx) {
                             const summaryContent = await loadFile(summaryPath);
                             if (summaryContent) {
                                 const summary = parseSummary(summaryContent);
+                                // Look up GitHub issue number for commit linking
+                                let ghIssueNumber;
+                                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) });
                         }
                     }
                 }
@@ -90,57 +101,68 @@ export async function postUnitPreVerification(pctx) {
                 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 scopeParts = s.currentUnit.id.split("/").slice(0, 2);
-            const doctorScope = scopeParts.join("/");
-            const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
-            const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" : "task";
-            const report = await runGSDDoctor(s.basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
-            if (report.fixesApplied.length > 0) {
-                ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
-            }
-            // Proactive health tracking
-            const summary = summarizeDoctorIssues(report.issues);
-            recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
-            // Check if we should escalate to LLM-assisted heal
-            if (summary.errors > 0) {
-                const unresolvedErrors = report.issues
-                    .filter(i => i.severity === "error" && !i.fixable)
-                    .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
-                const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
-                if (escalation.shouldEscalate) {
-                    ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
-                    try {
-                        const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
-                        const { dispatchDoctorHeal } = await import("./commands-handlers.js");
-                        const actionable = report.issues.filter(i => i.severity === "error");
-                        const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
-                        const structuredIssues = formatDoctorIssuesForPrompt(actionable);
-                        dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
-                    }
-                    catch {
-                        // Non-fatal
-                    }
-                }
-            }
+            const { runGitHubSync } = await import("../github-sync/sync.js");
+            await runGitHubSync(s.basePath, s.currentUnit.type, s.currentUnit.id);
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "github-sync", error: String(e) });
         }
-        // Throttled STATE.md rebuild
-        const now = Date.now();
-        if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
+        // Doctor: fix mechanical bookkeeping (skipped for lightweight sidecars)
+        if (!opts?.skipDoctor)
             try {
-                await rebuildState(s.basePath);
-                s.lastStateRebuildAt = now;
-                autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
+                const scopeParts = s.currentUnit.id.split("/").slice(0, 2);
+                const doctorScope = scopeParts.join("/");
+                const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
+                const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" : "task";
+                const report = await runGSDDoctor(s.basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
+                if (report.fixesApplied.length > 0) {
+                    ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
+                }
+                // Proactive health tracking
+                const summary = summarizeDoctorIssues(report.issues);
+                recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
+                // Check if we should escalate to LLM-assisted heal
+                if (summary.errors > 0) {
+                    const unresolvedErrors = report.issues
+                        .filter(i => i.severity === "error" && !i.fixable)
+                        .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
+                    const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
+                    if (escalation.shouldEscalate) {
+                        ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
+                        try {
+                            const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
+                            const { dispatchDoctorHeal } = await import("./commands-handlers.js");
+                            const actionable = report.issues.filter(i => i.severity === "error");
+                            const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
+                            const structuredIssues = formatDoctorIssuesForPrompt(actionable);
+                            dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
+                        }
+                        catch (e) {
+                            debugLog("postUnit", { phase: "doctor-heal-dispatch", error: String(e) });
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                debugLog("postUnit", { phase: "doctor", error: String(e) });
             }
-            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) });
+                }
             }
         }
         // Prune dead bg-shell processes
@@ -148,27 +170,41 @@ export async function postUnitPreVerification(pctx) {
             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) });
             }
         }
         // Rewrite-docs completion
         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) });
             }
         }
         // Post-triage: execute actionable resolutions
@@ -210,8 +246,8 @@ export async function postUnitPreVerification(pctx) {
                     invalidateAllCaches();
                 }
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "artifact-verify", error: String(e) });
             }
         }
         else {
@@ -224,8 +260,8 @@ export async function postUnitPreVerification(pctx) {
                 });
                 clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "hook-finalize", error: String(e) });
             }
         }
     }
@@ -338,8 +374,8 @@ export async function postUnitPostVerification(pctx) {
                 }
             }
         }
-        catch {
-            // Triage check failure is non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "triage-check", error: String(e) });
         }
     }
     // ── Quick-task dispatch ──
@@ -373,8 +409,8 @@ export async function postUnitPostVerification(pctx) {
             ctx.ui.notify(`Executing quick-task: ${capture.id} — "${capture.text}"`, "info");
             return "continue";
         }
-        catch {
-            // Non-fatal — proceed to normal dispatch
+        catch (e) {
+            debugLog("postUnit", { phase: "quick-task-dispatch", error: String(e) });
         }
     }
     // Step mode → show wizard instead of dispatch

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -12,10 +12,7 @@ import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferen
 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 ─────────────────────────────────────────────────────
 /**
  * Format executor context constraints for injection into the plan-slice prompt.
@@ -126,14 +123,10 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
     if (content.length <= threshold || !query) {
         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}`;
 }
 /**
  * Load and inline dependency slice summaries (full content, not just paths).
@@ -165,20 +158,6 @@ export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
     }
     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;
     }
@@ -414,6 +393,35 @@ export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
     })
         .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, sid, currentTid, dependsOn, base) {
+    // 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 ────────────────────────────────────────────
 /**
  * Check if the most recently completed slice needs reassessment.
@@ -688,8 +696,11 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     });
 }
 export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, level) {
-    const inlineLevel = level ?? resolveInlineLevel();
-    const priorSummaries = await getPriorTaskSummaryPaths(mid, sid, tid, base);
+    const opts = typeof level === "object" && level !== null && !Array.isArray(level)
+        ? level
+        : { level: level };
+    const inlineLevel = opts.level ?? resolveInlineLevel();
+    const priorSummaries = opts.carryForwardPaths ?? await getPriorTaskSummaryPaths(mid, sid, tid, base);
     const priorLines = priorSummaries.length > 0
         ? priorSummaries.map(p => `- \`${p}\``).join("\n")
         : "- (no prior tasks)";
@@ -745,15 +756,12 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const contextWindow = resolveExecutorContextWindow(undefined, prefs?.preferences);
     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", {
         overridesSection,
@@ -1090,6 +1098,63 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
         commitInstruction: reassessCommitInstruction,
     });
 }
+// ─── Reactive Execute Prompt ──────────────────────────────────────────────
+export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base) {
+    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 = [];
+    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 = [];
+    const readyTaskListLines = [];
+    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, midTitle, activeSlice, base, overrides) {
     const sid = activeSlice?.id;
     const sTitle = activeSlice?.title ?? "";

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -11,7 +11,7 @@ import { clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { clearParseCache, parseRoadmap, parsePlan } from "./files.js";
 import { isValidationTerminal } from "./state.js";
 import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
-import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, relMilestoneFile, relSliceFile, relSlicePath, relTaskFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, relSlicePath, relTaskFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { markSliceDoneInRoadmap } from "./roadmap-mutations.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
 import { dirname, join } from "node:path";
@@ -73,6 +73,9 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
         }
         case "rewrite-docs":
             return null;
+        case "reactive-execute":
+            // Reactive execute produces multiple task summaries — verified separately
+            return null;
         default:
             return null;
     }
@@ -105,6 +108,39 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         const content = readFileSync(overridesPath, "utf-8");
         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/dist/resources/extensions/gsd/auto-start.js

@@ -11,7 +11,7 @@
 import { deriveState } from "./state.js";
 import { loadFile, getManifestStatus } from "./files.js";
 import { loadEffectiveGSDPreferences, 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 } from "./paths.js";
@@ -63,6 +63,12 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         return false;
     }
     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 = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
@@ -303,11 +309,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // ── Auto-worktree setup ──
         s.originalBasePath = base;
         const isUnderGsdWorktrees = (p) => {
+            // 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 (s.currentMilestoneId &&
             shouldUseWorktreeIsolation() &&

package/dist/resources/extensions/gsd/auto-worktree-sync.js

@@ -13,6 +13,7 @@ import { existsSync, readFileSync, unlinkSync, readdirSync, } from "node:fs";
 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 ─────────────────────────────────────────
 /**
  * Sync milestone artifacts from project root INTO worktree before deriveState.
@@ -75,7 +76,7 @@ export function syncStateToProjectRoot(worktreePath, projectRoot, milestoneId) {
  * doesn't falsely trigger staleness (#804).
  */
 export function readResourceVersion() {
-    const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
+    const agentDir = 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"));
@@ -115,10 +116,17 @@ export function checkResourcesStale(versionOnStart) {
  * Returns the corrected base path.
  */
 export function escapeStaleWorktree(base) {
-    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);
     try {