gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/auto/workflow-dispatch-claim.ts

@@ -9,6 +9,16 @@ export type DispatchClaimOutcome =
   | { kind: "skip"; reason: "already-active" | "stale-lease"; existingId?: number; existingWorker?: string }
   | { kind: "degraded" };
 
+export type DispatchLeaseOutcome =
+  | { kind: "ready"; token: number; recovered: boolean }
+  | { kind: "degraded"; reason: "missing-worker" | "missing-milestone" }
+  | { kind: "blocked"; reason: string }
+  | { kind: "failed"; reason: string };
+
+type ClaimMilestoneLeaseResult =
+  | { ok: true; token: number; expiresAt: string }
+  | { ok: false; error: "held_by"; byWorker: string; expiresAt: string };
+
 interface RecentDispatch {
   attempt_n?: number | null;
 }
@@ -44,6 +54,58 @@ export interface OpenDispatchClaimDeps {
   logClaimFailed: (err: unknown) => void;
 }
 
+export interface EnsureDispatchLeaseDeps {
+  claimMilestoneLease: (workerId: string, milestoneId: string) => ClaimMilestoneLeaseResult;
+  logLeaseRecovered: (details: {
+    milestoneId: string;
+    workerId: string;
+    token: number;
+    recovered: boolean;
+  }) => void;
+  logLeaseRecoveryFailed: (details: {
+    milestoneId?: string;
+    workerId?: string;
+    reason: string;
+  }) => void;
+}
+
+export function ensureDispatchLease(
+  s: AutoSession,
+  milestoneId: string | undefined,
+  deps: EnsureDispatchLeaseDeps,
+  opts: { forceReclaim?: boolean } = {},
+): DispatchLeaseOutcome {
+  if (!s.workerId) return { kind: "degraded", reason: "missing-worker" };
+  if (!milestoneId) return { kind: "degraded", reason: "missing-milestone" };
+  if (!opts.forceReclaim && typeof s.milestoneLeaseToken === "number") {
+    return { kind: "ready", token: s.milestoneLeaseToken, recovered: false };
+  }
+
+  s.milestoneLeaseToken = null;
+  try {
+    const claim = deps.claimMilestoneLease(s.workerId, milestoneId);
+    if (!claim.ok) {
+      const reason = `Milestone ${milestoneId} is held by worker ${claim.byWorker} until ${claim.expiresAt}.`;
+      deps.logLeaseRecoveryFailed({ milestoneId, workerId: s.workerId, reason });
+      return { kind: "blocked", reason };
+    }
+
+    s.currentMilestoneId = milestoneId;
+    s.milestoneLeaseToken = claim.token;
+    deps.logLeaseRecovered({
+      milestoneId,
+      workerId: s.workerId,
+      token: claim.token,
+      recovered: opts.forceReclaim === true,
+    });
+    return { kind: "ready", token: claim.token, recovered: opts.forceReclaim === true };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    deps.logLeaseRecoveryFailed({ milestoneId, workerId: s.workerId, reason });
+    return { kind: "failed", reason };
+  }
+}
+
 export function openDispatchClaim(
   s: AutoSession,
   flowId: string,
@@ -51,7 +113,7 @@ export function openDispatchClaim(
   iterData: IterationData,
   deps: OpenDispatchClaimDeps,
 ): DispatchClaimOutcome {
-  if (!s.workerId || s.milestoneLeaseToken === null) return { kind: "degraded" };
+  if (!s.workerId || typeof s.milestoneLeaseToken !== "number") return { kind: "degraded" };
   const mid = iterData.mid;
   if (!mid) return { kind: "degraded" };
 

package/src/resources/extensions/gsd/auto/workflow-worker-heartbeat.ts

@@ -15,6 +15,11 @@ export interface MaintainWorkerHeartbeatDeps {
     fencingToken: number,
   ) => boolean;
   logHeartbeatFailure: (err: unknown) => void;
+  logLeaseRefreshMiss?: (details: {
+    workerId: string;
+    milestoneId: string;
+    fencingToken: number;
+  }) => void;
 }
 
 export function maintainWorkerHeartbeat(
@@ -26,11 +31,19 @@ export function maintainWorkerHeartbeat(
   try {
     deps.heartbeatAutoWorker(session.workerId);
     if (session.currentMilestoneId && session.milestoneLeaseToken) {
-      deps.refreshMilestoneLease(
+      const refreshed = deps.refreshMilestoneLease(
         session.workerId,
         session.currentMilestoneId,
         session.milestoneLeaseToken,
       );
+      if (!refreshed) {
+        deps.logLeaseRefreshMiss?.({
+          workerId: session.workerId,
+          milestoneId: session.currentMilestoneId,
+          fencingToken: session.milestoneLeaseToken,
+        });
+        session.milestoneLeaseToken = null;
+      }
     }
   } catch (err) {
     deps.logHeartbeatFailure(err);

package/src/resources/extensions/gsd/auto-direct-dispatch.ts

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

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -938,6 +938,22 @@ export const DISPATCH_RULES: DispatchRule[] = [
       const unitId = `${mid}/${sid}`;
       let priorPreExecFailure: { blockingFindings: string[]; verdictExcerpt: string } | undefined;
       if (session?.lastPreExecFailure?.unitId === unitId) {
+        // Circuit breaker: stop re-dispatching after 2 failed retries. The
+        // planner has had multiple attempts with injected failure context and
+        // still cannot produce a valid plan — human review is required.
+        const MAX_PRE_EXEC_RETRIES = 2;
+        const retryCount = session.preExecRetryCount?.get(unitId) ?? 0;
+        if (retryCount >= MAX_PRE_EXEC_RETRIES) {
+          const findings = session.lastPreExecFailure.blockingFindings.join("; ");
+          session.lastPreExecFailure = null;
+          session.preExecRetryCount?.delete(unitId);
+          return {
+            action: "stop",
+            reason: `Pre-execution checks failed ${retryCount} times for ${unitId} — manual intervention required. Blocking findings: ${findings}. Fix the plan manually, then run /gsd auto to resume.`,
+            level: "error",
+            matchedRule: "planning → plan-slice",
+          };
+        }
         priorPreExecFailure = {
           blockingFindings: session.lastPreExecFailure.blockingFindings,
           verdictExcerpt: session.lastPreExecFailure.verdictExcerpt,

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -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
@@ -103,6 +105,67 @@ function formatPreExecutionCheckDetail(check: PreExecutionCheckJSON): string {
 const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
 const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
 
+function stripKnownIdPrefix(value: string | undefined | null, id: string): string | undefined {
+  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: string,
+  unitId: string,
+): Promise<TaskCommitContext | undefined> {
+  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: ReturnType<typeof parseSummary> | null = 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: number | undefined;
+  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: string): Promise<boolean> {
   const deadline = Date.now() + COMPLETE_MILESTONE_DB_SETTLE_MS;
   while (Date.now() < deadline) {
@@ -134,6 +197,26 @@ function enqueueSidecar(
   if (notification) ctx.ui.notify(notification, "info");
   return "continue";
 }
+
+export function _shouldDispatchTriageForTest(
+  state: Pick<AutoSession, "stepMode" | "currentUnit">,
+): boolean {
+  return !state.stepMode &&
+    !!state.currentUnit &&
+    !state.currentUnit.type.startsWith("hook/") &&
+    state.currentUnit.type !== "triage-captures" &&
+    state.currentUnit.type !== "quick-task";
+}
+
+export function _shouldDispatchQuickTaskForTest(
+  state: Pick<AutoSession, "stepMode" | "currentUnit" | "pendingQuickTasks">,
+): boolean {
+  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()`. */
@@ -276,7 +359,7 @@ export function detectRogueFileWrites(
  * 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).";
@@ -357,35 +440,7 @@ export async function autoCommitUnit(
     let taskContext: TaskCommitContext | undefined;
 
     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: number | undefined;
-              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();
@@ -457,37 +512,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       let taskContext: TaskCommitContext | undefined;
 
       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: number | undefined;
-                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).
@@ -1320,8 +1345,12 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
 
         const strictMode = prefs?.enhanced_verification_strict === true;
 
-        // Run pre-execution checks
-        const result: PreExecutionResult = 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: PreExecutionResult = await runPreExecutionChecks(tasks, preExecutionBasePath);
 
         // Log summary to stderr in existing verification output format
         const emoji = result.status === "pass" ? "✅" : result.status === "warn" ? "⚠️" : "❌";
@@ -1338,12 +1367,12 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
         }
 
         // 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) {
@@ -1398,6 +1427,9 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
             ),
             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") {
           ctx.ui.notify(
@@ -1414,10 +1446,18 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
               ),
               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,
@@ -1473,13 +1513,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
   }
 
   // ── 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);
@@ -1527,12 +1561,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
   }
 
   // ── 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/src/resources/extensions/gsd/auto-prompts.ts

@@ -45,12 +45,12 @@ import { classifyProject, type ProjectClassification } 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.
@@ -185,8 +185,8 @@ function formatCloseoutReviewInstructions(validationContent: string | null, vali
 }
 
 function capPreamble(preamble: string): string {
-  // 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);
@@ -636,10 +636,83 @@ export async function buildSliceSummaryExcerpt(
     return lines.join("\n");
   } 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: string | null, relPath: string, tid: string, options?: { blocker?: boolean },
+): Promise<string> {
+  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: string[] = [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: string): string => {
+      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: string, relPath: string): string {
+  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).
  */
@@ -914,7 +987,7 @@ export async function inlineKnowledgeScoped(
  * 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.
  */
@@ -923,7 +996,7 @@ export async function inlineKnowledgeBudgeted(
   keywords: string[],
   options?: { maxChars?: number },
 ): Promise<string | null> {
-  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)
@@ -2085,8 +2158,17 @@ export async function buildPlanSlicePrompt(
       `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({
@@ -2369,10 +2451,9 @@ export async function buildCompleteSlicePrompt(
         const blocks: string[] = [];
         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;
       }
@@ -2749,7 +2830,7 @@ export async function buildReplanSlicePrompt(
       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 }));
       }
     }
   }