gsd-pi 2.62.1 → 2.63.0-dev.351157b

package/dist/resources/extensions/gsd/auto/phases.js

@@ -13,13 +13,17 @@ import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { PROJECT_FILES } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
-import { join, basename } from "node:path";
-import { existsSync, cpSync } from "node:fs";
+import { join, basename, dirname, parse as parsePath } from "node:path";
+import { existsSync, cpSync, readdirSync } from "node:fs";
 import { logWarning, logError } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
-import { verifyExpectedArtifact } from "../auto-recovery.js";
+import { verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.js";
 import { writeUnitRuntimeRecord } from "../unit-runtime.js";
+import { withTimeout, FINALIZE_POST_TIMEOUT_MS } from "./finalize-timeout.js";
+import { getEligibleSlices } from "../slice-parallel-eligibility.js";
+import { startSliceParallel } from "../slice-parallel-orchestrator.js";
+import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
  * Resolve the base path for milestone reports.
@@ -116,7 +120,7 @@ export async function runPreDispatch(ic, loopState) {
             ctx.ui.notify(`Pre-dispatch: ${healthGate.fixesApplied.join(", ")}`, "info");
         }
         if (!healthGate.proceed) {
-            ctx.ui.notify(healthGate.reason ?? "Pre-dispatch health check failed.", "error");
+            ctx.ui.notify(healthGate.reason || "Pre-dispatch health check failed — run /gsd doctor for details.", "error");
             await deps.pauseAuto(ctx, pi);
             debugLog("autoLoop", { phase: "exit", reason: "health-gate-failed" });
             return { action: "break", reason: "health-gate-failed" };
@@ -142,6 +146,50 @@ export async function runPreDispatch(ic, loopState) {
         mid,
         statePhase: state.phase,
     });
+    // ── Slice-level parallelism gate (#2340) ─────────────────────────────
+    // When slice_parallel is enabled, check if multiple slices are eligible
+    // for parallel execution. If so, dispatch them in parallel and stop the
+    // sequential loop. Workers are spawned via slice-parallel-orchestrator.ts.
+    if (prefs?.slice_parallel?.enabled &&
+        mid &&
+        !process.env.GSD_PARALLEL_WORKER &&
+        isDbAvailable()) {
+        try {
+            const dbSlices = getMilestoneSlices(mid);
+            if (dbSlices.length > 0) {
+                const doneIds = new Set(dbSlices.filter(sl => sl.status === "complete" || sl.status === "done").map(sl => sl.id));
+                const sliceInputs = dbSlices.map(sl => ({
+                    id: sl.id,
+                    done: doneIds.has(sl.id),
+                    depends: sl.depends ?? [],
+                }));
+                const eligible = getEligibleSlices(sliceInputs, doneIds);
+                if (eligible.length > 1) {
+                    debugLog("autoLoop", {
+                        phase: "slice-parallel-dispatch",
+                        iteration: ic.iteration,
+                        mid,
+                        eligibleSlices: eligible.map(e => e.id),
+                    });
+                    ctx.ui.notify(`Slice-parallel: dispatching ${eligible.length} eligible slices for ${mid}.`, "info");
+                    const result = await startSliceParallel(s.basePath, mid, eligible, { maxWorkers: prefs.slice_parallel.max_workers ?? 2 });
+                    if (result.started.length > 0) {
+                        ctx.ui.notify(`Slice-parallel: started ${result.started.length} worker(s): ${result.started.join(", ")}.`, "info");
+                        await deps.stopAuto(ctx, pi, `Slice-parallel dispatched for ${mid}`);
+                        return { action: "break", reason: "slice-parallel-dispatched" };
+                    }
+                    // Fall through to sequential if no workers started
+                }
+            }
+        }
+        catch (err) {
+            debugLog("autoLoop", {
+                phase: "slice-parallel-check-error",
+                error: err instanceof Error ? err.message : String(err),
+            });
+            // Non-fatal — fall through to sequential dispatch
+        }
+    }
     // ── Milestone transition ────────────────────────────────────────────
     if (mid && s.currentMilestoneId && mid !== s.currentMilestoneId) {
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "milestone-transition", data: { from: s.currentMilestoneId, to: mid } });
@@ -431,8 +479,15 @@ export async function runDispatch(ic, preData, loopState) {
                     unitId,
                     reason: stuckSignal.reason,
                 });
+                const stuckDiag = diagnoseExpectedArtifact(unitType, unitId, s.basePath);
+                const stuckRemediation = buildLoopRemediationSteps(unitType, unitId, s.basePath);
+                const stuckParts = [`Stuck on ${unitType} ${unitId} — ${stuckSignal.reason}.`];
+                if (stuckDiag)
+                    stuckParts.push(`Expected: ${stuckDiag}`);
+                if (stuckRemediation)
+                    stuckParts.push(`To recover:\n${stuckRemediation}`);
+                ctx.ui.notify(stuckParts.join(" "), "error");
                 await deps.stopAuto(ctx, pi, `Stuck: ${stuckSignal.reason}`);
-                ctx.ui.notify(`Stuck on ${unitType} ${unitId} — ${stuckSignal.reason}. The expected artifact was not written.`, "error");
                 return { action: "break", reason: "stuck-detected" };
             }
         }
@@ -662,11 +717,40 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
         const hasProjectFile = PROJECT_FILES.some((f) => deps.existsSync(join(s.basePath, f)));
         const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
-        if (!hasProjectFile && !hasSrcDir) {
+        // Xcode bundles have project-specific names (*.xcodeproj, *.xcworkspace)
+        // that cannot be matched by exact filename — scan the directory by suffix.
+        let hasXcodeBundle = false;
+        try {
+            const entries = deps.existsSync(s.basePath) ? readdirSync(s.basePath) : [];
+            hasXcodeBundle = entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"));
+        }
+        catch (err) {
+            debugLog("runUnitPhase", { phase: "xcode-bundle-scan-failed", basePath: s.basePath, error: String(err) });
+        }
+        // Monorepo support (#2347): if no project files in the worktree directory,
+        // walk parent directories up to the filesystem root. In monorepos,
+        // package.json / Cargo.toml etc. live in a parent directory.
+        let hasProjectFileInParent = false;
+        if (!hasProjectFile && !hasSrcDir && !hasXcodeBundle) {
+            let checkDir = dirname(s.basePath);
+            const { root } = parsePath(checkDir);
+            while (checkDir !== root) {
+                // Stop at git repository boundary — ancestors above the repo root
+                // (e.g. ~ or /usr/local) may contain unrelated project files.
+                if (deps.existsSync(join(checkDir, ".git")))
+                    break;
+                if (PROJECT_FILES.some((f) => deps.existsSync(join(checkDir, f)))) {
+                    hasProjectFileInParent = true;
+                    break;
+                }
+                checkDir = dirname(checkDir);
+            }
+        }
+        if (!hasProjectFile && !hasSrcDir && !hasXcodeBundle && !hasProjectFileInParent) {
             // Greenfield projects won't have project files yet — the first task creates them.
             // Log a warning but allow execution to proceed. The .git check above is sufficient
             // to ensure we're in a valid working directory.
-            debugLog("runUnitPhase", { phase: "worktree-health-warn-greenfield", basePath: s.basePath, hasProjectFile, hasSrcDir });
+            debugLog("runUnitPhase", { phase: "worktree-health-warn-greenfield", basePath: s.basePath, hasProjectFile, hasSrcDir, hasXcodeBundle });
             ctx.ui.notify(`Warning: ${s.basePath} has no recognized project files — proceeding as greenfield project`, "warning");
         }
     }
@@ -676,6 +760,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+    s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
     const unitStartSeq = ic.nextSeq();
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
     deps.captureAvailableSkills();
@@ -688,18 +773,10 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         lastProgressKind: "dispatch",
         recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
     });
-    // Select and apply model (with tier escalation on retry — normal units only)
-    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
-    s.currentUnitRouting =
-        modelResult.routing;
-    s.currentUnitModel =
-        modelResult.appliedModel;
-    // Status bar + progress widget
+    // Status bar (widget + preconditions deferred until after model selection — see #2899)
     ctx.ui.setStatus("gsd-auto", "auto");
     if (mid)
         deps.updateSliceProgressCache(s.basePath, mid, state.activeSlice?.id);
-    deps.updateProgressWidget(ctx, unitType, unitId, state);
-    deps.ensurePreconditions(unitType, unitId, s.basePath, state);
     // Prompt injection
     let finalPrompt = prompt;
     if (s.pendingVerificationRetry) {
@@ -757,6 +834,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         const msg = reorderErr instanceof Error ? reorderErr.message : String(reorderErr);
         logWarning("engine", "Prompt reorder failed", { error: msg });
     }
+    // Select and apply model (with tier escalation on retry — normal units only)
+    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
+    s.currentUnitRouting =
+        modelResult.routing;
+    s.currentUnitModel =
+        modelResult.appliedModel;
     // Apply sidecar/pre-dispatch hook model override (takes priority over standard model selection)
     const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;
     if (hookModelOverride) {
@@ -777,6 +860,15 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                 `Ensure the model is defined in models.json and has auth configured.`, "warning");
         }
     }
+    // Store the final dispatched model ID so the dashboard can read it (#2899).
+    // This accounts for hook model overrides applied after selectAndApplyModel.
+    s.currentDispatchedModelId = s.currentUnitModel
+        ? `${s.currentUnitModel.provider ?? ""}/${s.currentUnitModel.id ?? ""}`
+        : null;
+    // Progress widget + preconditions — deferred to after model selection so the
+    // widget's first render tick shows the correct model (#2899).
+    deps.updateProgressWidget(ctx, unitType, unitId, state);
+    deps.ensurePreconditions(unitType, unitId, s.basePath, state);
     // Start unit supervision
     deps.clearUnitTimeout();
     deps.startUnitSupervision({
@@ -853,11 +945,13 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     if (s.currentUnit) {
         await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
     }
-    // ── Zero tool-call guard (#1833) ──────────────────────────────────
-    // An execute-task agent that completes with 0 tool calls made no
-    // real changes — its summary is hallucinated. Treat as failed so
-    // the task is retried instead of silently marked complete.
-    if (unitType === "execute-task") {
+    // ── Zero tool-call guard (#1833, #2653) ──────────────────────────
+    // Any unit that completes with 0 tool calls made no real progress —
+    // likely context exhaustion where all tool calls errored out. Treat
+    // as failed so the unit is retried in a fresh context instead of
+    // silently passing through to artifact verification (which loops
+    // forever when the unit never produced its artifact).
+    {
         const currentLedger = deps.getLedger();
         if (currentLedger?.units) {
             const lastUnit = [...currentLedger.units].reverse().find((u) => u.type === unitType && u.id === unitId && u.startedAt === s.currentUnit?.startedAt);
@@ -866,11 +960,11 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                     phase: "zero-tool-calls",
                     unitType,
                     unitId,
-                    warning: "Task completed with 0 tool calls — likely hallucinated, marking as failed",
+                    warning: "Unit completed with 0 tool calls — likely context exhaustion, marking as failed",
                 });
-                ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — hallucinated summary, will retry`, "warning");
+                ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
                 // Fall through to next iteration where dispatch will re-derive
-                // and re-dispatch this task.
+                // and re-dispatch this unit.
                 return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
             }
         }
@@ -986,7 +1080,21 @@ export async function runFinalize(ic, iterData, sidecarItem) {
         }
     }
     // Post-verification processing (DB dual-write, hooks, triage, quick-tasks)
-    const postResult = await deps.postUnitPostVerification(postUnitCtx);
+    // Timeout guard: if postUnitPostVerification hangs (e.g., module import
+    // deadlock, SQLite transaction hang), force-continue after timeout so the
+    // auto-loop is not permanently frozen (#2344).
+    const postResultGuard = await withTimeout(deps.postUnitPostVerification(postUnitCtx), FINALIZE_POST_TIMEOUT_MS, "postUnitPostVerification");
+    if (postResultGuard.timedOut) {
+        debugLog("autoLoop", {
+            phase: "post-verification-timeout",
+            iteration: ic.iteration,
+            unitType: iterData.unitType,
+            unitId: iterData.unitId,
+        });
+        ctx.ui.notify(`postUnitPostVerification timed out after ${FINALIZE_POST_TIMEOUT_MS / 1000}s for ${iterData.unitType} ${iterData.unitId} — continuing to next iteration`, "warning");
+        return { action: "next", data: undefined };
+    }
+    const postResult = postResultGuard.value;
     if (postResult === "stopped") {
         debugLog("autoLoop", {
             phase: "exit",

package/dist/resources/extensions/gsd/auto/session.js

@@ -50,6 +50,8 @@ export class AutoSession {
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
     currentUnitModel = null;
+    /** Fully-qualified model ID (provider/id) set after selectAndApplyModel + hook overrides (#2899). */
+    currentDispatchedModelId = null;
     originalModelId = null;
     originalModelProvider = null;
     lastBudgetAlertLevel = 0;
@@ -62,6 +64,10 @@ export class AutoSession {
     lastStateRebuildAt = 0;
     // ── Sidecar queue ─────────────────────────────────────────────────────
     sidecarQueue = [];
+    // ── Tool invocation errors (#2883) ──────────────────────────────────
+    /** Set when a GSD tool execution ends with isError due to malformed/truncated
+     *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
+    lastToolInvocationError = null;
     // ── Isolation degradation ────────────────────────────────────────────
     /** Set to true when worktree creation fails; prevents merge of nonexistent branch. */
     isolationDegraded = false;
@@ -132,6 +138,7 @@ export class AutoSession {
         // Model
         this.autoModeStartModel = null;
         this.currentUnitModel = null;
+        this.currentDispatchedModelId = null;
         this.originalModelId = null;
         this.originalModelProvider = null;
         this.lastBudgetAlertLevel = 0;
@@ -149,6 +156,7 @@ export class AutoSession {
         this.pendingQuickTasks = [];
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
+        this.lastToolInvocationError = null;
         this.isolationDegraded = false;
         this.milestoneMergedInPhases = false;
         // Signal handler

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

@@ -516,9 +516,15 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 const cxWindow = cxUsage?.contextWindow ?? cmdCtx?.model?.contextWindow ?? 0;
                 const cxPctVal = cxUsage?.percent ?? 0;
                 const cxPct = cxUsage?.percent !== null ? cxPctVal.toFixed(1) : "?";
-                // Model display — shown in context section, not stats
-                const modelId = cmdCtx?.model?.id ?? "";
-                const modelProvider = cmdCtx?.model?.provider ?? "";
+                // Model display — prefer dispatched model ID (set after selectAndApplyModel
+                // + hook overrides) over cmdCtx?.model which can be stale (#2899).
+                const dispatchedModelId = accessors.getCurrentDispatchedModelId();
+                const modelId = dispatchedModelId
+                    ? dispatchedModelId.split("/").slice(1).join("/") || dispatchedModelId
+                    : (cmdCtx?.model?.id ?? "");
+                const modelProvider = dispatchedModelId
+                    ? dispatchedModelId.split("/")[0] || ""
+                    : (cmdCtx?.model?.provider ?? "");
                 const tierIcon = resolveServiceTierIcon(effectiveServiceTier, modelId);
                 const modelDisplay = (modelProvider && modelId
                     ? `${modelProvider}/${modelId}`

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

@@ -19,7 +19,7 @@ import { invalidateAllCaches } from "./cache.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
-import { verifyExpectedArtifact, resolveExpectedArtifactPath, } from "./auto-recovery.js";
+import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { syncStateToProjectRoot } from "./auto-worktree.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
@@ -29,6 +29,8 @@ import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookSta
 import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
+/** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
+const MAX_VERIFICATION_RETRIES = 3;
 /** Enqueue a sidecar item (hook, triage, or quick-task) for the main loop to
  *  drain via runUnit. Logs the enqueue event and notifies the UI. */
 function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
@@ -374,6 +376,8 @@ export async function postUnitPreVerification(pctx, opts) {
             // When artifact verification fails for a unit type that has a known expected
             // artifact, return "retry" so the caller re-dispatches with failure context
             // instead of blindly re-dispatching the same unit (#1571).
+            // After MAX_VERIFICATION_RETRIES, escalate to writeBlockerPlaceholder so the
+            // pipeline can advance instead of looping forever (#2653).
             //
             // HOWEVER, if the DB is unavailable (db_unavailable), the artifact was never
             // written because the completion tool failed at the infra level. Retrying
@@ -383,22 +387,55 @@ export async function postUnitPreVerification(pctx, opts) {
                 // db_unavailable so the artifact was never written. Retrying would
                 // produce an infinite re-dispatch loop (#2517).
                 debugLog("postUnit", { phase: "artifact-verify-skip-db-unavailable", unitType: s.currentUnit.type, unitId: s.currentUnit.id });
-                ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} but DB is unavailable — skipping retry to avoid loop (#2517)`, "error");
+                const dbSkipDiag = diagnoseExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — DB unavailable, skipping retry.${dbSkipDiag ? ` Expected: ${dbSkipDiag}` : ""}`, "error");
             }
             else if (!triggerArtifactVerified) {
+                // #2883: If the artifact is missing because the tool invocation itself
+                // failed (malformed/truncated JSON arguments), retrying will produce the
+                // same failure. Pause auto-mode instead of entering a stuck retry loop.
+                if (s.lastToolInvocationError) {
+                    const errMsg = `Tool invocation failed for ${s.currentUnit.type}: ${s.lastToolInvocationError}. Structured argument generation failed — pausing auto-mode.`;
+                    debugLog("postUnit", { phase: "tool-invocation-error-pause", unitType: s.currentUnit.type, unitId: s.currentUnit.id, error: s.lastToolInvocationError });
+                    ctx.ui.notify(errMsg, "error");
+                    s.lastToolInvocationError = null;
+                    await pauseAuto(ctx, pi);
+                    return "dispatched";
+                }
                 const hasExpectedArtifact = resolveExpectedArtifactPath(s.currentUnit.type, s.currentUnit.id, s.basePath) !== null;
                 if (hasExpectedArtifact) {
                     const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
                     s.verificationRetryCount.set(retryKey, attempt);
-                    s.pendingVerificationRetry = {
-                        unitId: s.currentUnit.id,
-                        failureContext: `Artifact verification failed: expected artifact for ${s.currentUnit.type} "${s.currentUnit.id}" was not found on disk after unit execution (attempt ${attempt}).`,
-                        attempt,
-                    };
-                    debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
-                    ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — retrying (attempt ${attempt})`, "warning");
-                    return "retry";
+                    if (attempt > MAX_VERIFICATION_RETRIES) {
+                        // Retries exhausted — write a blocker placeholder so the pipeline
+                        // can advance past this stuck unit (#2653).
+                        debugLog("postUnit", {
+                            phase: "artifact-verify-escalate",
+                            unitType: s.currentUnit.type,
+                            unitId: s.currentUnit.id,
+                            attempt,
+                            maxRetries: MAX_VERIFICATION_RETRIES,
+                        });
+                        const reason = `Artifact verification failed after ${MAX_VERIFICATION_RETRIES} retries for ${s.currentUnit.type} "${s.currentUnit.id}".`;
+                        writeBlockerPlaceholder(s.currentUnit.type, s.currentUnit.id, s.basePath, reason);
+                        ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} — verification retries exhausted (${MAX_VERIFICATION_RETRIES}), wrote blocker placeholder to advance pipeline`, "warning");
+                        // Reset retry count and fall through to "continue" so the loop
+                        // re-derives state with the placeholder in place.
+                        s.verificationRetryCount.delete(retryKey);
+                        s.pendingVerificationRetry = null;
+                        // Do NOT return "retry" — fall through to "continue" below.
+                    }
+                    else {
+                        s.pendingVerificationRetry = {
+                            unitId: s.currentUnit.id,
+                            failureContext: `Artifact verification failed: expected artifact for ${s.currentUnit.type} "${s.currentUnit.id}" was not found on disk after unit execution (attempt ${attempt}).`,
+                            attempt,
+                        };
+                        debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
+                        ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — retrying (attempt ${attempt})`, "warning");
+                        return "retry";
+                    }
                 }
             }
         }

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

@@ -880,11 +880,16 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const contextRel = relMilestoneFile(base, mid, "CONTEXT");
     const milestoneResearchPath = resolveMilestoneFile(base, mid, "RESEARCH");
     const milestoneResearchRel = relMilestoneFile(base, mid, "RESEARCH");
+    const sliceContextPath = resolveSliceFile(base, mid, sid, "CONTEXT");
+    const sliceContextRel = relSliceFile(base, mid, sid, "CONTEXT");
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
     if (contextInline)
         inlined.push(contextInline);
+    const sliceCtxInline = await inlineFileOptional(sliceContextPath, sliceContextRel, "Slice Context (from discussion)");
+    if (sliceCtxInline)
+        inlined.push(sliceCtxInline);
     const researchInline = await inlineFileOptional(milestoneResearchPath, milestoneResearchRel, "Milestone Research");
     if (researchInline)
         inlined.push(researchInline);
@@ -931,12 +936,17 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
     const researchRel = relSliceFile(base, mid, sid, "RESEARCH");
+    const sliceContextPath = resolveSliceFile(base, mid, sid, "CONTEXT");
+    const sliceContextRel = relSliceFile(base, mid, sid, "CONTEXT");
     const inlined = [];
     // Inject phase handoff anchor from research phase (if available)
     const researchSliceAnchor = readPhaseAnchor(base, mid, "research-slice");
     if (researchSliceAnchor)
         inlined.push(formatAnchorForPrompt(researchSliceAnchor));
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+    const sliceCtxInline = await inlineFileOptional(sliceContextPath, sliceContextRel, "Slice Context (from discussion)");
+    if (sliceCtxInline)
+        inlined.push(sliceCtxInline);
     const researchInline = await inlineFileOptional(researchPath, researchRel, "Slice Research");
     if (researchInline)
         inlined.push(researchInline);
@@ -1097,8 +1107,13 @@ export async function buildCompleteSlicePrompt(mid, _midTitle, sid, sTitle, base
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const slicePlanPath = resolveSliceFile(base, mid, sid, "PLAN");
     const slicePlanRel = relSliceFile(base, mid, sid, "PLAN");
+    const sliceContextPath = resolveSliceFile(base, mid, sid, "CONTEXT");
+    const sliceContextRel = relSliceFile(base, mid, sid, "CONTEXT");
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+    const sliceCtxInline = await inlineFileOptional(sliceContextPath, sliceContextRel, "Slice Context (from discussion)");
+    if (sliceCtxInline)
+        inlined.push(sliceCtxInline);
     inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Slice Plan"));
     if (inlineLevel !== "minimal") {
         const requirementsInline = await inlineRequirementsFromDb(base, sid, inlineLevel);
@@ -1351,8 +1366,13 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const slicePlanPath = resolveSliceFile(base, mid, sid, "PLAN");
     const slicePlanRel = relSliceFile(base, mid, sid, "PLAN");
+    const sliceContextPath = resolveSliceFile(base, mid, sid, "CONTEXT");
+    const sliceContextRel = relSliceFile(base, mid, sid, "CONTEXT");
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+    const sliceCtxInline = await inlineFileOptional(sliceContextPath, sliceContextRel, "Slice Context (from discussion)");
+    if (sliceCtxInline)
+        inlined.push(sliceCtxInline);
     inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Current Slice Plan"));
     // Find the blocker task summary — the completed task with blocker_discovered: true
     let blockerTaskId = "";
@@ -1454,8 +1474,13 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const summaryPath = resolveSliceFile(base, mid, completedSliceId, "SUMMARY");
     const summaryRel = relSliceFile(base, mid, completedSliceId, "SUMMARY");
+    const sliceContextPath = resolveSliceFile(base, mid, completedSliceId, "CONTEXT");
+    const sliceContextRel = relSliceFile(base, mid, completedSliceId, "CONTEXT");
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Current Roadmap"));
+    const sliceCtxInline = await inlineFileOptional(sliceContextPath, sliceContextRel, "Slice Context (from discussion)");
+    if (sliceCtxInline)
+        inlined.push(sliceCtxInline);
     inlined.push(await inlineFile(summaryPath, summaryRel, `${completedSliceId} Summary`));
     if (inlineLevel !== "minimal") {
         const projectInline = await inlineProjectFromDb(base);

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

@@ -9,7 +9,7 @@
 import { parseUnitId } from "./unit-id.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -377,17 +377,25 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
         `Review and replace this file before relying on downstream artifacts.`,
     ].join("\n");
     writeFileSync(absPath, content, "utf-8");
-    // Mark the task as complete in the DB so verifyExpectedArtifact passes.
+    // Mark the task/slice as complete in the DB so verifyExpectedArtifact passes.
     // Without this, the DB status stays "pending" and the dispatch loop
-    // re-derives the same task indefinitely (#2531).
-    if (unitType === "execute-task" && isDbAvailable()) {
+    // re-derives the same unit indefinitely (#2531, #2653).
+    if (isDbAvailable()) {
         const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-        if (mid && sid && tid) {
+        if (unitType === "execute-task" && mid && sid && tid) {
             try {
                 updateTaskStatus(mid, sid, tid, "complete", new Date().toISOString());
             }
-            catch (err) { /* non-fatal */
-                logError("recovery", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
+            catch (e) {
+                logWarning("recovery", `updateTaskStatus failed during context exhaustion: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        if (unitType === "complete-slice" && mid && sid) {
+            try {
+                updateSliceStatus(mid, sid, "complete", new Date().toISOString());
+            }
+            catch (e) {
+                logWarning("recovery", `updateSliceStatus failed during context exhaustion: ${e instanceof Error ? e.message : String(e)}`);
             }
         }
     }

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

@@ -30,7 +30,7 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, openDatabase } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -48,34 +48,23 @@ import { resolveDefaultSessionModel } from "./preferences-models.js";
  * Returns false if the bootstrap aborted (e.g., guided flow returned,
  * concurrent session detected). Returns true when ready to dispatch.
  */
-/**
- * Open the project-root DB before the first deriveState call (#2841).
- * When auto-mode starts cold (no prior DB handle), state derivation that
- * touches DB-backed helpers (queue-order, task status) silently falls back
- * to markdown-only data, producing stale or incomplete state.  Opening the
- * DB first ensures deriveState sees the full picture on its very first run.
- */
-async function openProjectDbIfPresent(basePath) {
+/** Guard: tracks consecutive bootstrap attempts that found phase === "complete".
+ *  Prevents the recursive dialog loop described in #1348 where
+ *  bootstrapAutoSession → showSmartEntry → checkAutoStartAfterDiscuss → startAuto
+ *  cycles indefinitely when the discuss workflow doesn't produce a milestone. */
+let _consecutiveCompleteBootstraps = 0;
+const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
+export async function openProjectDbIfPresent(basePath) {
     const gsdDbPath = resolveProjectRootDbPath(basePath);
-    if (!existsSync(gsdDbPath))
-        return;
-    if (isDbAvailable())
+    if (!existsSync(gsdDbPath) || isDbAvailable())
         return;
     try {
-        const { openDatabase } = await import("./gsd-db.js");
         openDatabase(gsdDbPath);
     }
     catch (err) {
-        /* non-fatal — DB lifecycle block below will retry */
-        logWarning("engine", `DB open failed: ${err instanceof Error ? err.message : String(err)}`);
+        logWarning("engine", `gsd-db: failed to open existing database: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-/** Guard: tracks consecutive bootstrap attempts that found phase === "complete".
- *  Prevents the recursive dialog loop described in #1348 where
- *  bootstrapAutoSession → showSmartEntry → checkAutoStartAfterDiscuss → startAuto
- *  cycles indefinitely when the discuss workflow doesn't produce a milestone. */
-let _consecutiveCompleteBootstraps = 0;
-const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
 export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps) {
     const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase, buildResolver, } = deps;
     const lockResult = acquireSessionLock(base);

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -75,3 +75,20 @@ export function hasInteractiveToolInFlight() {
 export function clearInFlightTools() {
     inFlightTools.clear();
 }
+// ─── Tool invocation error classification (#2883) ────────────────────────
+/**
+ * Patterns that indicate a tool invocation failed due to malformed or truncated
+ * JSON arguments — as opposed to a normal business-logic error from the tool
+ * handler. When these errors occur, retrying the same unit will produce the same
+ * failure, so the retry loop must be broken.
+ */
+const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Expected ',' or '\}' in JSON|Unexpected end of JSON|Unexpected token.*in JSON/i;
+/**
+ * Returns true if the error message indicates a tool invocation failure due to
+ * malformed/truncated arguments (as opposed to a normal tool execution error).
+ */
+export function isToolInvocationError(errorMsg) {
+    if (!errorMsg)
+        return false;
+    return TOOL_INVOCATION_ERROR_RE.test(errorMsg);
+}

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

@@ -142,16 +142,27 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                 failureContext: formatFailureContext(result),
                 attempt: nextAttempt,
             };
-            ctx.ui.notify(`Verification failed — auto-fix attempt ${nextAttempt}/${maxRetries}`, "warning");
+            const failedCmds = result.checks
+                .filter((c) => c.exitCode !== 0)
+                .map((c) => c.command);
+            const cmdSummary = failedCmds.length <= 3
+                ? failedCmds.join(", ")
+                : `${failedCmds.slice(0, 3).join(", ")}... and ${failedCmds.length - 3} more`;
+            ctx.ui.notify(`Verification failed (${cmdSummary}) — auto-fix attempt ${nextAttempt}/${maxRetries}`, "warning");
             // Return "retry" — the autoLoop while loop will re-iterate with the retry context
             return "retry";
         }
         else {
             // Gate failed, retries exhausted
-            const exhaustedAttempt = attempt + 1;
             s.verificationRetryCount.delete(s.currentUnit.id);
             s.pendingVerificationRetry = null;
-            ctx.ui.notify(`Verification gate FAILED after ${exhaustedAttempt > maxRetries ? exhaustedAttempt - 1 : exhaustedAttempt} retries — pausing for human review`, "error");
+            const exhaustedFails = result.checks
+                .filter((c) => c.exitCode !== 0)
+                .map((c) => c.command);
+            const exhaustedSummary = exhaustedFails.length <= 3
+                ? exhaustedFails.join(", ")
+                : `${exhaustedFails.slice(0, 3).join(", ")}... and ${exhaustedFails.length - 3} more`;
+            ctx.ui.notify(`Verification gate FAILED after ${attempt} ${attempt === 1 ? "retry" : "retries"} (${exhaustedSummary}) — pausing for human review`, "error");
             await pauseAuto(ctx, pi);
             return "pause";
         }