gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

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,7 +25,8 @@ 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, getVerificationEvidence } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
@@ -52,11 +55,14 @@ import { detectAbandonMilestone } from "./abandon-detect.js";
 import { isDeterministicPolicyError } from "./auto-tool-tracking.js";
 import { clearProjectResearchInflightMarker, finalizeProjectResearchTimeout, } from "./project-research-policy.js";
 import { validateArtifact } from "./schemas/validate.js";
+import { verificationRetryKey } from "./auto/verification-retry-policy.js";
 // ─── Path Comparison Helper ───────────────────────────────────────────────
 /** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
 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 +76,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 +158,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 +291,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 +342,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 +405,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 +533,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
@@ -838,6 +866,7 @@ export async function postUnitPreVerification(pctx, opts) {
                 const outcome = finalizeProjectResearchTimeout(s.basePath, "Project research unit ended before all required dimensions produced durable files.");
                 s.pendingVerificationRetry = null;
                 s.verificationRetryCount.delete(retryKey);
+                s.verificationRetryFailureHashes.delete(retryKey);
                 triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
                 if (triggerArtifactVerified) {
                     invalidateAllCaches();
@@ -888,6 +917,7 @@ export async function postUnitPreVerification(pctx, opts) {
                 s.lastToolInvocationError = null;
                 s.pendingVerificationRetry = null;
                 s.verificationRetryCount.delete(retryKey);
+                s.verificationRetryFailureHashes.delete(retryKey);
                 writeBlockerPlaceholder(s.currentUnit.type, s.currentUnit.id, s.basePath, reason);
                 ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} — deterministic policy rejection, wrote blocker placeholder (no retries) (#4973)`, "warning");
                 // Fall through to "continue" — do NOT enter the retry or db-unavailable paths.
@@ -916,6 +946,7 @@ export async function postUnitPreVerification(pctx, opts) {
                     const failureDetails = describeArtifactVerificationFailure(s.currentUnit.type, s.currentUnit.id, s.basePath);
                     if (attempt > MAX_ARTIFACT_VERIFICATION_RETRIES) {
                         s.verificationRetryCount.delete(retryKey);
+                        s.verificationRetryFailureHashes.delete(retryKey);
                         debugLog("postUnit", { phase: "artifact-verify-exhausted", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
                         ctx.ui.notify(`${failureDetails} Pausing auto-mode after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries.`, "error");
                         await pauseAuto(ctx, pi);
@@ -935,7 +966,9 @@ export async function postUnitPreVerification(pctx, opts) {
             // Verification succeeded — clear the retry counter so a future failure
             // of the same unit gets a full retry budget instead of the stale count.
             if (triggerArtifactVerified) {
-                s.verificationRetryCount.delete(`${s.currentUnit.type}:${s.currentUnit.id}`);
+                const retryKey = verificationRetryKey(s.currentUnit.type, s.currentUnit.id);
+                s.verificationRetryCount.delete(retryKey);
+                s.verificationRetryFailureHashes.delete(retryKey);
             }
         }
         else {
@@ -1123,8 +1156,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 +1171,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 +1224,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 +1239,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 +1300,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 +1338,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");

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

@@ -21,6 +21,7 @@ import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { composeContextModeInstructions, composeInlinedContext } from "./unit-context-composer.js";
+import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
 import { inlineGraphSubgraph } from "./graph-context.js";
 import { buildExtractionStepsBlock } from "./commands-extract-learnings.js";
@@ -28,12 +29,12 @@ import { resolveSkillManifest, warnIfManifestHasMissingSkills } from "./skill-ma
 import { classifyProject } from "./detection.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 /**
- * Historical static ceiling for the preamble cap. Kept as an upper bound even
+ * Static ceiling for the preamble cap. Kept as an upper bound even
  * after context-window-aware sizing so large-window users don't suddenly see
- * 10× looser caps than before. Small-window users get a tighter cap derived
+ * 10× looser caps than needed. Small-window users get a tighter cap derived
  * from their configured executor window.
  */
-const MAX_PREAMBLE_CHARS = 30_000;
+const MAX_PREAMBLE_CHARS = 20_000;
 /**
  * Resolve prompt budgets from the configured executor context window.
  *
@@ -162,8 +163,8 @@ function formatCloseoutReviewInstructions(validationContent, validationRel, curr
     ].join("\n");
 }
 function capPreamble(preamble) {
-    // Cap inlined context at min(historical 30K ceiling, scaled inline budget).
-    // The ceiling preserves pre-fix behavior for large-window users; the scaled
+    // Cap inlined context at min(static ceiling, scaled inline budget).
+    // The ceiling bounds repeated auto prompt payloads; the scaled
     // budget tightens the cap for small-window users whose true safe limit is
     // below 30K. `computeBudgets` allocates 40% of total chars to inline context.
     const budget = Math.min(MAX_PREAMBLE_CHARS, resolvePromptBudgets().inlineContextBudgetChars);
@@ -178,8 +179,19 @@ function renderContextModeForPrompt(unitType, base, renderMode = "standalone") {
         renderMode,
     });
 }
-function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
+function renderContextModeBlockForPrompt(unitType, base, renderMode = "standalone") {
     const contextMode = renderContextModeForPrompt(unitType, base, renderMode);
+    if (!contextMode)
+        return "";
+    if (renderMode === "nested")
+        return contextMode;
+    const snapshot = readCompactionSnapshot(base);
+    if (!snapshot?.trim())
+        return contextMode;
+    return `${contextMode}\n\n## Context Snapshot\nSource: \`.gsd/last-snapshot.md\`\n\n${snapshot.trimEnd()}`;
+}
+function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
+    const contextMode = renderContextModeBlockForPrompt(unitType, base, renderMode);
     if (!contextMode)
         return block;
     if (!block.trim())
@@ -559,9 +571,77 @@ export async function buildSliceSummaryExcerpt(absPath, relPath, sid) {
     }
     catch {
         // Defensive — any parse failure falls back to full inline.
-        return `### ${sid} Summary\nSource: \`${relPath}\`\n\n${content.trim()}`;
+        return `### ${sid} Summary\nSource: \`${relPath}\`\n\n${capMalformedSummary(content, relPath)}`;
     }
 }
+export async function buildTaskSummaryExcerpt(absPath, relPath, tid, options) {
+    const label = options?.blocker ? "Blocker Task Summary" : "Task Summary";
+    const header = `### ${label}: ${tid} (excerpt)\nSource: \`${relPath}\``;
+    const content = absPath ? await loadFile(absPath) : null;
+    if (!content) {
+        return `${header}\n\n_(not found — file does not exist yet)_`;
+    }
+    try {
+        const s = parseSummary(content);
+        if (!s.frontmatter.id) {
+            return `### ${label}: ${tid}\nSource: \`${relPath}\`\n\n${capMalformedSummary(content, relPath)}`;
+        }
+        const lines = [header, ""];
+        if (s.title)
+            lines.push(`**Title:** ${s.title}`);
+        if (s.oneLiner)
+            lines.push(`**One-liner:** ${s.oneLiner}`);
+        if (s.frontmatter.verification_result) {
+            lines.push(`**Verification:** \`${s.frontmatter.verification_result}\``);
+        }
+        lines.push(`**Blocker discovered:** ${s.frontmatter.blocker_discovered ? "yes — read full summary if blocker details are insufficient" : "no"}`);
+        if (s.frontmatter.provides.length > 0)
+            lines.push(`**Provides:** ${s.frontmatter.provides.slice(0, 4).join("; ")}`);
+        if (s.frontmatter.key_decisions.length > 0)
+            lines.push(`**Key decisions:** ${s.frontmatter.key_decisions.slice(0, 4).join("; ")}`);
+        if (s.frontmatter.patterns_established.length > 0)
+            lines.push(`**Patterns established:** ${s.frontmatter.patterns_established.slice(0, 4).join("; ")}`);
+        if (s.frontmatter.key_files.length > 0) {
+            const files = s.frontmatter.key_files.slice(0, 6);
+            const more = s.frontmatter.key_files.length > files.length ? ` (+${s.frontmatter.key_files.length - files.length} more)` : "";
+            lines.push(`**Key files:** ${files.join(", ")}${more}`);
+        }
+        const SECTION_CAP_CHARS = 500;
+        const capSection = (body) => {
+            const trimmed = body.trim();
+            if (trimmed.length <= SECTION_CAP_CHARS)
+                return trimmed;
+            return `${trimmed.slice(0, SECTION_CAP_CHARS)}\n… (truncated — see full \`${relPath}\`)`;
+        };
+        const verification = extractMarkdownSection(content, "Verification");
+        const diagnostics = extractMarkdownSection(content, "Diagnostics");
+        const knownIssues = extractMarkdownSection(content, "Known Issues");
+        if (verification && verification.trim()) {
+            lines.push("", "#### Verification", capSection(verification));
+        }
+        if (diagnostics && diagnostics.trim()) {
+            lines.push("", "#### Diagnostics", capSection(diagnostics));
+        }
+        if (s.deviations && s.deviations.trim()) {
+            lines.push("", "#### Deviations", capSection(s.deviations));
+        }
+        if (knownIssues && knownIssues.trim()) {
+            lines.push("", "#### Known issues", capSection(knownIssues));
+        }
+        lines.push("", `> **On-demand:** read \`${relPath}\` only when this excerpt is absent/truncated or you need fuller blocker, implementation, or file-change evidence.`);
+        return lines.join("\n");
+    }
+    catch {
+        return `### ${label}: ${tid}\nSource: \`${relPath}\`\n\n${capMalformedSummary(content, relPath)}`;
+    }
+}
+function capMalformedSummary(content, relPath) {
+    const trimmed = content.trim();
+    const limit = 1_500;
+    if (trimmed.length <= limit)
+        return trimmed;
+    return `${trimmed.slice(0, limit).trimEnd()}\n\n[Truncated malformed summary — read \`${relPath}\` for full details.]`;
+}
 /**
  * Load and inline dependency slice summaries (full content, not just paths).
  */
@@ -814,12 +894,12 @@ export async function inlineKnowledgeScoped(base, keywords) {
  * plan-milestone, complete-slice, complete-milestone, validate-milestone,
  * reassess-roadmap) previously injected the full KNOWLEDGE.md (~226KB for a
  * real project) on every invocation. This helper scopes by caller-supplied
- * keywords and caps the payload at `maxChars` (default 30,000 chars).
+ * keywords and caps the payload at `maxChars` (default 12,000 chars).
  *
  * Returns null when no KNOWLEDGE.md exists or no entries match any keyword.
  */
 export async function inlineKnowledgeBudgeted(base, keywords, options) {
-    const DEFAULT_MAX_CHARS = 30_000;
+    const DEFAULT_MAX_CHARS = 12_000;
     const HARD_MAX_CHARS = 100_000;
     const raw = Number(options?.maxChars ?? DEFAULT_MAX_CHARS);
     const maxChars = Number.isFinite(raw)
@@ -1812,8 +1892,17 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
             `The previous plan-slice attempt was blocked by pre-execution validation.\n` +
             `Gate verdict: ${verdictExcerpt}\n\n` +
             `Blocked references that must be resolved in this plan:\n${findingsList}\n\n` +
-            `Revise the plan so that every reference listed above is satisfied before execution begins. ` +
-            `Do not reproduce the same file paths, package names, or task ordering that caused these failures.`);
+            `**How to fix each type of issue:**\n` +
+            `- **"[file] X doesn't exist and isn't created by prior or same-task outputs"**: ` +
+            `Either (a) add an earlier task that creates X on disk before the task that needs it, ` +
+            `or (b) if this task IS the one that creates X, move X from inputs to expected_output. ` +
+            `Do NOT put X in a task's expected_output if that task only reads or verifies X — only tasks that actually write X to disk should list it in expected_output.\n` +
+            `- **"[file] X: Task T_early reads X but it's created by task T_late (sequence violation)"**: ` +
+            `Either (a) reorder tasks so T_late (the creator) runs before T_early (the reader), ` +
+            `or (b) if T_late doesn't actually create X (it only reads/tests it), remove X from T_late's expected_output entirely.\n` +
+            `- **"[package] P not found on npm"**: Either remove the npm install for P, or use the correct package name.\n\n` +
+            `Every file listed in a task's inputs must either exist on disk already or appear in an earlier task's expected_output. ` +
+            `A task's expected_output must only list files it actually writes to disk.`);
     }
     return renderSlicePrompt({
         mid, sid, sTitle, base,
@@ -2036,11 +2125,9 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                 const blocks = [];
                 for (const file of summaryFiles) {
                     const absPath = join(tDir, file);
-                    const content = await loadFile(absPath);
-                    if (!content)
-                        continue;
                     const relPath = `${sRel}/tasks/${file}`;
-                    blocks.push(`### Task Summary: ${file.replace(/-SUMMARY\.md$/i, "")}\nSource: \`${relPath}\`\n\n${content.trim()}`);
+                    const taskId = file.replace(/-SUMMARY\.md$/i, "");
+                    blocks.push(await buildTaskSummaryExcerpt(absPath, relPath, taskId));
                 }
                 return blocks.length > 0 ? blocks.join("\n\n---\n\n") : null;
             }
@@ -2387,7 +2474,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
             const relPath = `${sRel}/tasks/${file}`;
             if (summary.frontmatter.blocker_discovered) {
                 blockerTaskId = summary.frontmatter.id || file.replace(/-SUMMARY\.md$/i, "");
-                inlined.push(`### Blocker Task Summary: ${blockerTaskId}\nSource: \`${relPath}\`\n\n${content.trim()}`);
+                inlined.push(await buildTaskSummaryExcerpt(absPath, relPath, blockerTaskId, { blocker: true }));
             }
         }
     }

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

@@ -30,7 +30,49 @@ import { getProjectResearchStatus } from "./project-research-policy.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
-// ─── Artifact Resolution & Verification ───────────────────────────────────────
+export function refreshRecoveryDbForArtifact(unitType, unitId) {
+    if (unitType !== "plan-slice" && unitType !== "execute-task")
+        return { ok: true };
+    if (!isDbAvailable())
+        return { ok: true };
+    if (!refreshOpenDatabaseFromDisk()) {
+        return {
+            ok: false,
+            fatal: unitType === "execute-task",
+            reason: `${unitType}-db-refresh-failed`,
+            message: `Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed.`,
+        };
+    }
+    if (unitType !== "execute-task")
+        return { ok: true };
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid || !tid) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-invalid-unit-id",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but the unit id could not be parsed for DB verification.`,
+        };
+    }
+    const task = getTask(mid, sid, tid);
+    if (!task) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-artifact-db-missing",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but no matching DB task row exists after refresh.`,
+        };
+    }
+    if (!isClosedStatus(task.status)) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-artifact-db-mismatch",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but the DB task status is still '${task.status}' after refresh.`,
+        };
+    }
+    return { ok: true };
+}
 function hasCapturedWorkflowPrefs(base) {
     const prefsPath = resolveExpectedArtifactPath("workflow-preferences", "WORKFLOW-PREFS", base);
     if (!prefsPath || !existsSync(prefsPath))

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -33,3 +33,8 @@ export function recordToolInvocationError(toolName, errorMsg) {
         autoSession.lastToolInvocationError = `${toolName}: ${errorMsg}`;
     }
 }
+export function clearToolInvocationError() {
+    if (!autoSession.active)
+        return;
+    autoSession.lastToolInvocationError = null;
+}