gsd-pi 2.63.0 → 2.64.0-dev.9c14bd0

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

@@ -14,12 +14,12 @@ import { deriveState } from "./state.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
-import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
+import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 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, diagnoseExpectedArtifact, } 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,19 @@ import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookSta
 import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
+import { getEvidence } from "./safety/evidence-collector.js";
+import { validateFileChanges } from "./safety/file-change-validator.js";
+// crossReferenceEvidence available for future use when verification_evidence is stored in DB
+// import { crossReferenceEvidence, type ClaimedEvidence } from "./safety/evidence-cross-ref.js";
+import { validateContent } from "./safety/content-validator.js";
+import { resolveSafetyHarnessConfig } from "./safety/safety-harness.js";
+import { resolveExpectedArtifactPath as resolveArtifactForContent } from "./auto-artifact-paths.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { getSliceTasks } from "./gsd-db.js";
+import { runPreExecutionChecks } from "./pre-execution-checks.js";
+import { writePreExecutionEvidence } from "./verification-evidence.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) {
@@ -339,6 +352,78 @@ export async function postUnitPreVerification(pctx, opts) {
         catch (e) {
             debugLog("postUnit", { phase: "rogue-detection", error: String(e) });
         }
+        // ── Safety harness: post-unit validation ──
+        try {
+            const { loadEffectiveGSDPreferences } = await import("./preferences.js");
+            const prefs = loadEffectiveGSDPreferences()?.preferences;
+            const safetyConfig = resolveSafetyHarnessConfig(prefs?.safety_harness);
+            if (safetyConfig.enabled) {
+                const { milestone: sMid, slice: sSid, task: sTid } = parseUnitId(s.currentUnit.id);
+                // File change validation (execute-task only, after auto-commit)
+                if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid && isDbAvailable()) {
+                    try {
+                        const taskRow = getTask(sMid, sSid, sTid);
+                        if (taskRow) {
+                            const expectedOutput = taskRow.expected_output ?? [];
+                            const plannedFiles = taskRow.files ?? [];
+                            const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles);
+                            if (audit && audit.violations.length > 0) {
+                                const warnings = audit.violations.filter(v => v.severity === "warning");
+                                for (const v of warnings) {
+                                    logWarning("safety", `file-change: ${v.file} — ${v.reason}`);
+                                }
+                                if (warnings.length > 0) {
+                                    ctx.ui.notify(`Safety: ${warnings.length} unexpected file change(s) outside task plan`, "warning");
+                                }
+                            }
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "safety-file-change", error: String(e) });
+                    }
+                }
+                // 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.
+                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");
+                            }
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "safety-evidence-xref", error: String(e) });
+                    }
+                }
+                // Content validation (plan-slice, plan-milestone)
+                if (safetyConfig.content_validation) {
+                    try {
+                        const artifactPath = resolveArtifactForContent(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                        const contentViolations = validateContent(s.currentUnit.type, artifactPath);
+                        for (const v of contentViolations) {
+                            logWarning("safety", `content: ${v.reason}`);
+                            ctx.ui.notify(`Content validation: ${v.reason}`, "warning");
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "safety-content-validation", error: String(e) });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "safety-harness", error: String(e) });
+        }
         // Artifact verification
         let triggerArtifactVerified = false;
         if (!s.currentUnit.type.startsWith("hook/")) {
@@ -374,6 +459,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
@@ -387,20 +474,51 @@ export async function postUnitPreVerification(pctx, opts) {
                 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);
-                    const retryDiag = diagnoseExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
-                    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}).${retryDiag ? ` Expected: ${retryDiag}` : ""}`,
-                        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}).${retryDiag ? ` Expected: ${retryDiag}` : ""}`, "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";
+                    }
                 }
             }
         }
@@ -520,6 +638,99 @@ export async function postUnitPostVerification(pctx) {
             debugLog("postUnit", { phase: "capture-protection-error", error: String(e) });
         }
     }
+    // ── Pre-execution checks (after plan-slice completes) ──
+    if (s.currentUnit &&
+        s.currentUnit.type === "plan-slice") {
+        let preExecPauseNeeded = false;
+        await runSafely("postUnitPostVerification", "pre-execution-checks", async () => {
+            try {
+                // Check preferences — respect enhanced_verification and enhanced_verification_pre
+                const prefs = loadEffectiveGSDPreferences()?.preferences;
+                const enhancedEnabled = prefs?.enhanced_verification !== false; // default true
+                const preEnabled = prefs?.enhanced_verification_pre !== false; // default true
+                if (!enhancedEnabled || !preEnabled) {
+                    debugLog("postUnitPostVerification", {
+                        phase: "pre-execution-checks",
+                        skipped: true,
+                        reason: "disabled by preferences",
+                    });
+                    return;
+                }
+                // Parse the unit ID to get milestone/slice IDs
+                const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
+                if (!mid || !sid) {
+                    debugLog("postUnitPostVerification", {
+                        phase: "pre-execution-checks",
+                        skipped: true,
+                        reason: "could not parse milestone/slice from unit ID",
+                    });
+                    return;
+                }
+                // Get tasks for this slice from DB
+                const tasks = getSliceTasks(mid, sid);
+                if (tasks.length === 0) {
+                    debugLog("postUnitPostVerification", {
+                        phase: "pre-execution-checks",
+                        skipped: true,
+                        reason: "no tasks found for slice",
+                    });
+                    return;
+                }
+                // Run pre-execution checks
+                const result = await runPreExecutionChecks(tasks, s.basePath);
+                // 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`);
+                // Log individual check results
+                for (const check of result.checks) {
+                    const checkEmoji = check.passed ? "✓" : check.blocking ? "✗" : "⚠";
+                    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);
+                if (slicePath) {
+                    writePreExecutionEvidence(result, slicePath, mid, sid);
+                }
+                // Notify UI
+                if (result.status === "fail") {
+                    const blockingCount = result.checks.filter(c => !c.passed && c.blocking).length;
+                    ctx.ui.notify(`Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found`, "error");
+                    preExecPauseNeeded = true;
+                }
+                else if (result.status === "warn") {
+                    ctx.ui.notify(`Pre-execution checks passed with warnings`, "warning");
+                    // Strict mode: treat warnings as blocking
+                    if (prefs?.enhanced_verification_strict === true) {
+                        preExecPauseNeeded = true;
+                    }
+                }
+                debugLog("postUnitPostVerification", {
+                    phase: "pre-execution-checks",
+                    status: result.status,
+                    checkCount: result.checks.length,
+                    durationMs: result.durationMs,
+                });
+            }
+            catch (preExecError) {
+                // Fail-closed: if runPreExecutionChecks throws, pause auto-mode instead of silently continuing
+                const errorMessage = preExecError instanceof Error ? preExecError.message : String(preExecError);
+                debugLog("postUnitPostVerification", {
+                    phase: "pre-execution-checks",
+                    error: errorMessage,
+                    failClosed: true,
+                });
+                logError("engine", `gsd-pre-exec: Pre-execution checks threw an error: ${errorMessage}`);
+                ctx.ui.notify(`Pre-execution checks error: ${errorMessage} — pausing for human review`, "error");
+                preExecPauseNeeded = true;
+            }
+        });
+        // Check for blocking failures after runSafely completes
+        if (preExecPauseNeeded) {
+            debugLog("postUnitPostVerification", { phase: "pre-execution-checks", pausing: true, reason: "blocking failures detected" });
+            await pauseAuto(ctx, pi);
+            return "stopped";
+        }
+    }
     // ── Triage check ──
     if (!s.stepMode &&
         s.currentUnit &&

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-timers.js

@@ -77,8 +77,9 @@ export function startUnitSupervision(sctx) {
         }
     }
     const estimateMinutes = taskEstimate ? parseEstimateMinutes(taskEstimate) : null;
+    const MAX_TIMEOUT_SCALE = 6; // Cap at 6x (60min task). Prevents 2h+ tasks from creating 120min+ timeout windows.
     const timeoutScale = estimateMinutes && estimateMinutes > 0
-        ? Math.max(1, estimateMinutes / 10) // 10min task = 1x, 30min = 3x, 2h = 12x
+        ? Math.min(MAX_TIMEOUT_SCALE, Math.max(1, estimateMinutes / 10))
         : 1;
     const softTimeoutMs = (supervisor.soft_timeout_minutes ?? 0) * 60 * 1000 * timeoutScale;
     const idleTimeoutMs = (supervisor.idle_timeout_minutes ?? 0) * 60 * 1000; // idle not scaled — idle is idle

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);
+}