gsd-pi 2.80.0 → 2.81.0

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -11,7 +11,6 @@ import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSliceP
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { logWarning } from "./workflow-logger.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "./workflow-mcp.js";
 export async function dispatchDirectPhase(ctx, pi, phase, base) {
     const state = await deriveState(base);
@@ -231,36 +230,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         return;
     }
     ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
-    const originalCwd = process.cwd();
-    try {
-        // Ensure cwd matches dispatchBase BEFORE newSession() captures it. Synchronous —
-        // no awaits between chdir and newSession.
-        try {
-            if (process.cwd() !== dispatchBase) {
-                process.chdir(dispatchBase);
-            }
-        }
-        catch (err) {
-            const msg = `Failed to chdir before direct-dispatch newSession (basePath: ${dispatchBase}): ${err instanceof Error ? err.message : String(err)}`;
-            logWarning("engine", msg, { file: "auto-direct-dispatch.ts", basePath: dispatchBase, error: err instanceof Error ? err.message : String(err) });
-            ctx.ui.notify(`${msg}. Cancelling dispatch to avoid running in the wrong directory.`, "error");
-            return;
-        }
-        const result = await ctx.newSession();
-        if (result.cancelled) {
-            ctx.ui.notify("Session creation cancelled.", "warning");
-            return;
-        }
-        pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
-    }
-    finally {
-        try {
-            if (process.cwd() !== originalCwd) {
-                process.chdir(originalCwd);
-            }
-        }
-        catch (err) {
-            logWarning("engine", `Failed to restore cwd after direct dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto-direct-dispatch.ts", basePath: originalCwd });
-        }
+    const result = await ctx.newSession({ workspaceRoot: dispatchBase });
+    if (result.cancelled) {
+        ctx.ui.notify("Session creation cancelled.", "warning");
+        return;
     }
+    pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
 }

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

@@ -93,6 +93,16 @@ export function hasPendingDeepStage(prefs, basePath) {
     const gate = getDeepStageGate(prefs, basePath);
     return gate.status === "pending" || gate.status === "blocked";
 }
+export function shouldRunDeepProjectSetup(state, prefs, basePath, options = {}) {
+    if (options.hasSurvivorBranch === true)
+        return false;
+    if (state.phase !== "pre-planning" &&
+        state.phase !== "needs-discussion" &&
+        state.phase !== "planning") {
+        return false;
+    }
+    return hasPendingDeepStage(prefs, basePath);
+}
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -781,6 +791,22 @@ export const DISPATCH_RULES = [
             const unitId = `${mid}/${sid}`;
             let priorPreExecFailure;
             if (session?.lastPreExecFailure?.unitId === unitId) {
+                // Circuit breaker: stop re-dispatching after 2 failed retries. The
+                // planner has had multiple attempts with injected failure context and
+                // still cannot produce a valid plan — human review is required.
+                const MAX_PRE_EXEC_RETRIES = 2;
+                const retryCount = session.preExecRetryCount?.get(unitId) ?? 0;
+                if (retryCount >= MAX_PRE_EXEC_RETRIES) {
+                    const findings = session.lastPreExecFailure.blockingFindings.join("; ");
+                    session.lastPreExecFailure = null;
+                    session.preExecRetryCount?.delete(unitId);
+                    return {
+                        action: "stop",
+                        reason: `Pre-execution checks failed ${retryCount} times for ${unitId} — manual intervention required. Blocking findings: ${findings}. Fix the plan manually, then run /gsd auto to resume.`,
+                        level: "error",
+                        matchedRule: "planning → plan-slice",
+                    };
+                }
                 priorPreExecFailure = {
                     blockingFindings: session.lastPreExecFailure.blockingFindings,
                     verdictExcerpt: session.lastPreExecFailure.verdictExcerpt,

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode post-unit git, verification, projection, and hook processing.
 /**
  * Post-unit processing for auto-loop — auto-commit, doctor run,
  * state rebuild, projection checks, DB tool closeout, hooks, triage, and
@@ -23,9 +25,10 @@ import { closeoutUnit } from "./auto-unit-closeout.js";
 import { runTurnGitAction, } from "./git-service.js";
 import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
-import { syncStateToProjectRoot } from "./auto-worktree.js";
+import { WorktreeStateProjection } from "./worktree-state-projection.js";
+import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
-import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter, getVerificationEvidence } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
@@ -57,6 +60,8 @@ import { validateArtifact } from "./schemas/validate.js";
 function isSamePathLocal(a, b) {
     return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
+/** Stateless WorktreeStateProjection — methods are pure functions of MilestoneScope. */
+const _worktreeProjection = new WorktreeStateProjection();
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
 /** Keep failure toasts short while still showing concrete examples. */
@@ -70,6 +75,62 @@ function formatPreExecutionCheckDetail(check) {
 }
 const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
 const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
+function stripKnownIdPrefix(value, id) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        return undefined;
+    const lower = raw.toLowerCase();
+    const idLower = id.toLowerCase();
+    if (lower.startsWith(`${idLower}:`))
+        return raw.slice(id.length + 1).trim() || undefined;
+    return raw;
+}
+async function buildTaskCommitContextForUnit(basePath, unitId) {
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid || !tid)
+        return undefined;
+    const milestone = isDbAvailable() ? getMilestone(mid) : null;
+    const slice = isDbAvailable() ? getSlice(mid, sid) : null;
+    const task = isDbAvailable() ? getTask(mid, sid, tid) : null;
+    let summary = null;
+    const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+    if (summaryPath) {
+        try {
+            const summaryContent = await loadFile(summaryPath);
+            if (summaryContent)
+                summary = parseSummary(summaryContent);
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+        }
+    }
+    if (!summary && !task)
+        return undefined;
+    let ghIssueNumber;
+    try {
+        const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+        ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+    }
+    catch (err) {
+        logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {
+        taskId: `${sid}/${tid}`,
+        taskDisplayId: tid,
+        taskTitle: stripKnownIdPrefix(summary?.title, tid) ??
+            stripKnownIdPrefix(task?.title, tid) ??
+            tid,
+        milestoneId: mid,
+        milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+        sliceId: sid,
+        sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+        oneLiner: summary?.oneLiner || task?.one_liner || undefined,
+        keyFiles: summary?.frontmatter.key_files?.filter(f => !f.includes("{{")) ??
+            task?.key_files ??
+            undefined,
+        issueNumber: ghIssueNumber,
+    };
+}
 async function waitForMilestoneDbClose(mid) {
     const deadline = Date.now() + COMPLETE_MILESTONE_DB_SETTLE_MS;
     while (Date.now() < deadline) {
@@ -96,6 +157,19 @@ function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
         ctx.ui.notify(notification, "info");
     return "continue";
 }
+export function _shouldDispatchTriageForTest(state) {
+    return !state.stepMode &&
+        !!state.currentUnit &&
+        !state.currentUnit.type.startsWith("hook/") &&
+        state.currentUnit.type !== "triage-captures" &&
+        state.currentUnit.type !== "quick-task";
+}
+export function _shouldDispatchQuickTaskForTest(state) {
+    return !state.stepMode &&
+        state.pendingQuickTasks.length > 0 &&
+        !!state.currentUnit &&
+        state.currentUnit.type !== "quick-task";
+}
 /** Unit types that only touch `.gsd/` internal state files (no code changes).
  *  Auto-commit is skipped for these — their state files are picked up by the
  *  next actual task commit via `smartStage()`. */
@@ -216,7 +290,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
  * in auto-verification.ts. Exceeding this limit pauses auto-mode instead of
  * looping indefinitely (#2007).
  */
-const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
+export const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
 export const STEP_COMPLETE_FALLBACK_MESSAGE = "Step complete. Run /clear, then /gsd to continue (or /gsd auto to run continuously).";
 export function buildStepCompleteMessage(nextState) {
     if (nextState.phase === "complete") {
@@ -267,36 +341,7 @@ export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
     try {
         let taskContext;
         if (unitType === "execute-task") {
-            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-            if (mid && sid && tid) {
-                const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
-                if (summaryPath) {
-                    try {
-                        const summaryContent = await loadFile(summaryPath);
-                        if (summaryContent) {
-                            const summary = parseSummary(summaryContent);
-                            let ghIssueNumber;
-                            try {
-                                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
-                            }
-                            catch (err) {
-                                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                            }
-                            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 (e) {
-                        debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                    }
-                }
-            }
+            taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
         }
         _resetHasChangesCache();
         if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
@@ -359,38 +404,7 @@ export async function postUnitPreVerification(pctx, opts) {
         try {
             let taskContext;
             if (turnAction === "commit" && s.currentUnit.type === "execute-task") {
-                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
-                if (mid && sid && tid) {
-                    const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
-                    if (summaryPath) {
-                        try {
-                            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 (err) {
-                                    // GitHub sync not available — skip
-                                    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                                }
-                                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 (e) {
-                            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                        }
-                    }
-                }
+                taskContext = await buildTaskCommitContextForUnit(s.basePath, s.currentUnit.id);
             }
             // Invalidate the nativeHasChanges cache before auto-commit (#1853).
             // The cache has a 10-second TTL and is keyed by basePath.  A stale
@@ -518,7 +532,20 @@ export async function postUnitPreVerification(pctx, opts) {
         // Sync worktree state back to project root (skipped for lightweight sidecars)
         if (!opts?.skipWorktreeSync && s.originalBasePath && !isSamePathLocal(s.originalBasePath, s.basePath)) {
             await runSafely("postUnit", "worktree-sync", () => {
-                syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
+                let scope = s.scope;
+                if (!scope && s.currentMilestoneId) {
+                    try {
+                        scope = scopeMilestone(createWorkspace(s.basePath), s.currentMilestoneId);
+                    }
+                    catch {
+                        // Non-fatal: scope construction can fail on synthetic test paths;
+                        // skipping the projection mirrors the prior path-string variant's
+                        // early-return behaviour for missing milestone/path inputs.
+                        scope = null;
+                    }
+                }
+                if (scope)
+                    _worktreeProjection.projectWorktreeToRoot(scope);
             });
         }
         // Rewrite-docs completion
@@ -719,21 +746,21 @@ export async function postUnitPreVerification(pctx, opts) {
                     }
                 }
                 // Evidence cross-reference (execute-task only)
-                // Verification evidence is passed via the complete-task tool call and
-                // stored in the SUMMARY.md on disk — not available as structured data
-                // in the DB. The evidence collector tracks actual bash tool calls, so
-                // we can still detect units that claimed success but ran no commands.
+                // Only compare against concrete command evidence persisted by the task
+                // completion tool. A prose Verify field can be satisfied later by the
+                // host verification gate, so it is not enough to accuse the unit.
                 if (safetyConfig.evidence_cross_reference && s.currentUnit.type === "execute-task") {
                     try {
                         const actual = getEvidence();
                         const bashCalls = actual.filter(e => e.kind === "bash");
-                        // If the task is marked complete but zero bash commands were run,
-                        // it's suspicious — the LLM may have fabricated results.
                         if (sMid && sSid && sTid && isDbAvailable()) {
                             const taskRow = getTask(sMid, sSid, sTid);
-                            if (taskRow?.status === "complete" && taskRow.verify && bashCalls.length === 0) {
-                                logWarning("safety", "task marked complete with verification commands but no bash calls were executed");
-                                ctx.ui.notify(`Safety: task ${sTid} has verification commands but no bash calls were recorded`, "warning");
+                            const claimedCommands = getVerificationEvidence(sMid, sSid, sTid)
+                                .map((row) => row.command)
+                                .filter((command) => typeof command === "string" && command.trim().length > 0);
+                            if (taskRow?.status === "complete" && claimedCommands.length > 0 && bashCalls.length === 0) {
+                                logWarning("safety", "task claimed verification command evidence but no execution tool calls were recorded");
+                                ctx.ui.notify(`Safety: task ${sTid} claimed command evidence but no execution tool calls were recorded`, "warning");
                             }
                         }
                     }
@@ -1123,8 +1150,12 @@ export async function postUnitPostVerification(pctx) {
                     return;
                 }
                 const strictMode = prefs?.enhanced_verification_strict === true;
-                // Run pre-execution checks
-                const result = await runPreExecutionChecks(tasks, s.basePath);
+                // Run pre-execution checks against s.basePath — the actual checkout
+                // where prior-slice files were created.  In worktree isolation,
+                // s.canonicalProjectRoot is the project root and lacks files that a
+                // prior slice wrote to the worktree but hasn't merged to main yet.
+                const preExecutionBasePath = s.basePath;
+                const result = await runPreExecutionChecks(tasks, preExecutionBasePath);
                 // Log summary to stderr in existing verification output format
                 const emoji = result.status === "pass" ? "✅" : result.status === "warn" ? "⚠️" : "❌";
                 process.stderr.write(`gsd-pre-exec: ${emoji} Pre-execution checks ${result.status} for ${mid}/${sid} (${result.durationMs}ms)\n`);
@@ -1134,12 +1165,12 @@ export async function postUnitPostVerification(pctx) {
                     process.stderr.write(`gsd-pre-exec:   ${checkEmoji} [${check.category}] ${check.target}: ${check.message}\n`);
                 }
                 // Write evidence JSON to slice artifacts directory
-                const slicePath = resolveSlicePath(s.basePath, mid, sid);
+                const slicePath = resolveSlicePath(preExecutionBasePath, mid, sid);
                 const evidenceFileName = `${sid}-PRE-EXEC-VERIFY.json`;
                 let evidencePath = join(".gsd", "milestones", mid, "slices", sid, evidenceFileName);
                 if (slicePath) {
                     writePreExecutionEvidence(result, slicePath, mid, sid);
-                    evidencePath = relative(s.basePath, join(slicePath, evidenceFileName)) || evidenceFileName;
+                    evidencePath = relative(preExecutionBasePath, join(slicePath, evidenceFileName)) || evidenceFileName;
                 }
                 if (uokFlags.gates) {
                     const failedChecks = result.checks
@@ -1187,6 +1218,9 @@ export async function postUnitPostVerification(pctx) {
                         blockingFindings: blockingChecks.map(c => `[${c.category}] ${c.target}: ${c.message}`),
                         verdictExcerpt: `status=${result.status}; ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} detected`,
                     };
+                    // Track consecutive pre-exec failures per slice for loop detection.
+                    const retryKey = currentUnit.id;
+                    s.preExecRetryCount.set(retryKey, (s.preExecRetryCount.get(retryKey) ?? 0) + 1);
                     preExecPauseNeeded = true;
                 }
                 else if (result.status === "warn") {
@@ -1199,9 +1233,16 @@ export async function postUnitPostVerification(pctx) {
                             blockingFindings: warnChecks.map(c => `[${c.category}] ${c.target}: ${c.message}`),
                             verdictExcerpt: `status=${result.status} (strict mode); ${warnChecks.length} warning${warnChecks.length === 1 ? "" : "s"} treated as blocking`,
                         };
+                        const retryKey = currentUnit.id;
+                        s.preExecRetryCount.set(retryKey, (s.preExecRetryCount.get(retryKey) ?? 0) + 1);
                         preExecPauseNeeded = true;
                     }
                 }
+                // Reset the retry counter when checks pass — a successful re-plan
+                // should not carry over a stale failure count into future slices.
+                if (result.status === "pass") {
+                    s.preExecRetryCount.delete(currentUnit.id);
+                }
                 debugLog("postUnitPostVerification", {
                     phase: "pre-execution-checks",
                     status: result.status,
@@ -1253,11 +1294,7 @@ export async function postUnitPostVerification(pctx) {
         }
     }
     // ── Triage check ──
-    if (!s.stepMode &&
-        s.currentUnit &&
-        !s.currentUnit.type.startsWith("hook/") &&
-        s.currentUnit.type !== "triage-captures" &&
-        s.currentUnit.type !== "quick-task") {
+    if (_shouldDispatchTriageForTest(s)) {
         try {
             if (hasPendingCaptures(s.basePath)) {
                 const pending = loadPendingCaptures(s.basePath);
@@ -1295,10 +1332,7 @@ export async function postUnitPostVerification(pctx) {
         }
     }
     // ── Quick-task dispatch ──
-    if (!s.stepMode &&
-        s.pendingQuickTasks.length > 0 &&
-        s.currentUnit &&
-        s.currentUnit.type !== "quick-task") {
+    if (_shouldDispatchQuickTaskForTest(s)) {
         try {
             const capture = s.pendingQuickTasks.shift();
             const { buildQuickTaskPrompt } = await import("./triage-resolution.js");