@navels/neal 0.5.0 → 0.6.0

package/dist/neal/prompts/specialized.js

@@ -1,5 +1,5 @@
 import { guardStructuredJsonOutputFormatLines } from '../agents/structured-json.js';
-import { renderInlinedRangeDiffSection } from '../context/inline-review-context.js';
+import { AGENT_FREE_TEXT_SECTION_MAX_CHARS, boundChangedFileList, boundCommitSubjectList, boundFreeTextValues, GIT_SUMMARY_SECTION_MAX_CHARS, renderInlinedRangeDiffSection, truncateInlineSectionBody, } from '../context/inline-review-context.js';
 import { assertPromptBuilder } from './assert-builder.js';
 import { getUserGuidanceLines } from './guidance.js';
 import { getAdversarialReviewDoctrineLines, getCodeReviewFalsificationLines, getFindingQualityLines, getPreexistingFailureContractLines, getRegressionPreservationLines, getVerificationSkepticismLines, } from './review-doctrine.js';
@@ -28,9 +28,8 @@ export function buildFinalCompletionSummaryPrompt(args) {
     if (!finalCompletionVariant) {
         throw new Error('Prompt spec completion_coder is missing a final_completion variant');
     }
-    const lastImplementationScope = args.packet.lastNonEmptyImplementationScope
-        ? JSON.stringify(args.packet.lastNonEmptyImplementationScope, null, 2)
-        : 'null';
+    const boundedLastScope = boundLastImplementationScope(args.packet.lastNonEmptyImplementationScope);
+    const lastImplementationScope = boundedLastScope ? JSON.stringify(boundedLastScope, null, 2) : 'null';
     return [
         `Summarize whether the execute-mode plan at ${args.planDoc} is complete as a whole.`,
         '',
@@ -52,19 +51,19 @@ export function buildFinalCompletionSummaryPrompt(args) {
             currentScopeLabel: args.packet.currentScopeLabel,
             acceptedScopeRecordCount: args.packet.acceptedScopeCount,
             blockedScopeCount: args.packet.blockedScopeCount,
-            scopeAccountingSummary: args.packet.scopeAccountingSummary,
+            scopeAccountingSummary: boundScopeAccountingSummary(args.packet.scopeAccountingSummary),
             verificationOnlyCompletion: args.packet.verificationOnlyCompletion,
-            aggregateReviewContext: args.packet.aggregateReviewContext,
-            completedScopeSummary: args.packet.completedScopeSummary,
+            aggregateReviewContext: boundAggregateReviewContext(args.packet.aggregateReviewContext),
+            completedScopeSummary: boundCompletedScopeSummary(args.packet.completedScopeSummary),
             terminalChangedFilesSummary: args.packet.terminalChangedFilesSummary,
             planChangedFilesSummary: args.packet.planChangedFilesSummary,
-            verificationCommandResults: args.packet.verificationCommandResults,
-            verificationSummary: args.packet.verificationSummary,
-            lastNonEmptyImplementationScope: args.packet.lastNonEmptyImplementationScope,
+            verificationTally: args.packet.verificationTally,
+            lastNonEmptyImplementationScope: boundedLastScope,
             continueExecutionCount: args.packet.continueExecutionCount,
             continueExecutionMax: args.packet.continueExecutionMax,
         }, null, 2),
         '',
+        '`verificationTally` is a bounded summary of the run\'s recorded verification commands; the complete per-command record is in the run directory\'s events.ndjson.',
         'If the completion is verification-only, say so directly in `whatChangedOverall` or `remainingKnownGaps` instead of pretending there was a terminal implementation diff.',
         ...getUserGuidanceLines('coder'),
         '',
@@ -72,6 +71,71 @@ export function buildFinalCompletionSummaryPrompt(args) {
         lastImplementationScope,
     ].join('\n');
 }
+// Maximum remaining-known-gap entries rendered per completion prompt. Gaps
+// beyond the limit collapse to one explicit overflow entry so the rendered
+// list stays bounded as the gap count grows. Also keeps the summary's
+// free-text value count far under boundFreeTextValues' cardinality bound.
+const REMAINING_GAPS_PROMPT_ITEM_LIMIT = 100;
+// Render-only view of the coder's completion summary: planGoalSatisfied is
+// copied exactly, the free-text fields and the first
+// REMAINING_GAPS_PROMPT_ITEM_LIMIT gap entries share the fixed aggregate
+// free-text budget, and any further gaps collapse to one explicit overflow
+// entry. The stored summary keeps its full text.
+function boundCompletionSummaryForPrompt(summary) {
+    const gaps = summary.remainingKnownGaps.slice(0, REMAINING_GAPS_PROMPT_ITEM_LIMIT);
+    const bounded = boundFreeTextValues([summary.whatChangedOverall, summary.verificationSummary, ...gaps]);
+    const remainingKnownGaps = bounded.slice(2);
+    const omittedGaps = summary.remainingKnownGaps.length - gaps.length;
+    if (omittedGaps > 0) {
+        remainingKnownGaps.push(`(+${omittedGaps} more remaining known gaps omitted from this prompt)`);
+    }
+    return {
+        planGoalSatisfied: summary.planGoalSatisfied,
+        whatChangedOverall: bounded[0],
+        verificationSummary: bounded[1],
+        remainingKnownGaps,
+    };
+}
+// Prompt-render view of the completion packet's aggregate review context with
+// its run-scaling fields bounded: the commit-subject and changed-file lists
+// collapse past their limits and the diff stat truncates with a marker. The
+// packet keeps the full values for non-prompt consumers.
+function boundAggregateReviewContext(context) {
+    return {
+        ...context,
+        commitSubjects: boundCommitSubjectList(context.commitSubjects),
+        diffStat: truncateInlineSectionBody(context.diffStat, GIT_SUMMARY_SECTION_MAX_CHARS),
+        changedFiles: boundChangedFileList(context.changedFiles),
+    };
+}
+// Prompt-render view of the packet's completed-scope summary. The summary
+// carries agent-authored blocker and residual-debt text for every completed
+// scope, so it shares the fixed agent free-text cap; the packet keeps the full
+// string for non-prompt consumers.
+function boundCompletedScopeSummary(summary) {
+    return truncateInlineSectionBody(summary, AGENT_FREE_TEXT_SECTION_MAX_CHARS);
+}
+// Prompt-render view of the packet's last non-empty implementation scope: the
+// changed-file list is bounded, and the agent-authored commit subject gets the
+// fixed free-text cap while a null subject stays null. The packet keeps the
+// full values for non-prompt consumers.
+function boundLastImplementationScope(scope) {
+    if (!scope) {
+        return null;
+    }
+    return {
+        ...scope,
+        commitSubject: scope.commitSubject === null ? null : boundFreeTextValues([scope.commitSubject])[0],
+        changedFiles: boundChangedFileList(scope.changedFiles),
+    };
+}
+// Prompt-render view of the packet's scope-accounting summary. The summary
+// grows with derived-plan replacements (one path per replaced parent scope),
+// so it shares the fixed agent free-text cap; the packet keeps the full string
+// for non-prompt consumers.
+function boundScopeAccountingSummary(summary) {
+    return truncateInlineSectionBody(summary, AGENT_FREE_TEXT_SECTION_MAX_CHARS);
+}
 export function buildFinalCompletionReviewerPrompt(args) {
     const spec = assertPromptBuilder('completion_reviewer', 'buildFinalCompletionReviewerPrompt', PROMPT_MODULE_PATH);
     const finalCompletionVariant = spec.variants.find((variant) => variant.kind === 'final_completion');
@@ -85,9 +149,8 @@ export function buildFinalCompletionReviewerPrompt(args) {
     // instead of falling back to git_diff-tool phrasing the reviewer cannot use.
     const rangeDiffInlined = accessMode === 'read-only' && args.inlinedRangeDiff !== null && args.inlinedRangeDiff !== undefined;
     const completionSummary = args.summary;
-    const lastImplementationScope = args.packet.lastNonEmptyImplementationScope
-        ? JSON.stringify(args.packet.lastNonEmptyImplementationScope, null, 2)
-        : 'null';
+    const boundedLastScope = boundLastImplementationScope(args.packet.lastNonEmptyImplementationScope);
+    const lastImplementationScope = boundedLastScope ? JSON.stringify(boundedLastScope, null, 2) : 'null';
     const aggregateRange = args.packet.aggregateReviewContext.range;
     const falsificationLines = getCodeReviewFalsificationLines({
         rangeLabel: aggregateRange ? `aggregate range ${aggregateRange}` : null,
@@ -166,7 +229,7 @@ export function buildFinalCompletionReviewerPrompt(args) {
         '- Invalid example: subject "Finish scope 4 cleanup"; bullets ["Summarize per-scope plan work", "Describe reviewer process"].',
         '',
         'Coder whole-plan completion summary:',
-        JSON.stringify(completionSummary, null, 2),
+        JSON.stringify(boundCompletionSummaryForPrompt(completionSummary), null, 2),
         '',
         'Whole-plan completion packet:',
         JSON.stringify({
@@ -174,20 +237,20 @@ export function buildFinalCompletionReviewerPrompt(args) {
             currentScopeLabel: args.packet.currentScopeLabel,
             acceptedScopeRecordCount: args.packet.acceptedScopeCount,
             blockedScopeCount: args.packet.blockedScopeCount,
-            scopeAccountingSummary: args.packet.scopeAccountingSummary,
+            scopeAccountingSummary: boundScopeAccountingSummary(args.packet.scopeAccountingSummary),
             verificationOnlyCompletion: args.packet.verificationOnlyCompletion,
-            aggregateReviewContext: args.packet.aggregateReviewContext,
+            aggregateReviewContext: boundAggregateReviewContext(args.packet.aggregateReviewContext),
             finalCommit: args.packet.finalCommit,
-            completedScopeSummary: args.packet.completedScopeSummary,
+            completedScopeSummary: boundCompletedScopeSummary(args.packet.completedScopeSummary),
             terminalChangedFilesSummary: args.packet.terminalChangedFilesSummary,
             planChangedFilesSummary: args.packet.planChangedFilesSummary,
-            verificationCommandResults: args.packet.verificationCommandResults,
-            verificationSummary: args.packet.verificationSummary,
-            lastNonEmptyImplementationScope: args.packet.lastNonEmptyImplementationScope,
+            verificationTally: args.packet.verificationTally,
+            lastNonEmptyImplementationScope: boundedLastScope,
             continueExecutionCount: args.packet.continueExecutionCount,
             continueExecutionMax: args.packet.continueExecutionMax,
         }, null, 2),
         '',
+        '`verificationTally` is a bounded summary of the run\'s recorded verification commands; the complete per-command record is in the run directory\'s events.ndjson.',
         'If this was a verification-only terminal scope, judge the whole-plan result directly instead of pretending there was a final implementation diff.',
         ...getUserGuidanceLines('reviewer'),
         '',

package/dist/neal/prompts/specs.js

@@ -88,7 +88,7 @@ const CONSULTANT_CONTEXT = context('ConsultantPromptContext', [
 export const PROMPT_SPECS = [
     {
         id: 'plan_author',
-        version: 4,
+        version: 5,
         changelog: [
             {
                 version: 1,
@@ -106,6 +106,10 @@ export const PROMPT_SPECS = [
                 version: 4,
                 renderSha: 'e9f5b2dd5f66df87986b2e2f884c560d02a235db053b544221dcb43512e057a4',
             },
+            {
+                version: 5,
+                renderSha: '148ed793be3f39c4a5505289ab3045ff124d8c44a53bf5fa9ccc8c3c5f20d408',
+            },
         ],
         role: 'coder',
         purpose: 'Author or revise concise, human-reviewable Neal-executable plans at moderate-to-high-level implementation detail.',
@@ -505,12 +509,16 @@ export const PROMPT_SPECS = [
     },
     {
         id: 'completion_coder',
-        version: 1,
+        version: 2,
         changelog: [
             {
                 version: 1,
                 renderSha: 'f88b43d206de28212ad7f6f3ae84576718934b0a5e36953e35afee89c4d7ce5e',
             },
+            {
+                version: 2,
+                renderSha: '85f36db1245090baa3c8f74e5fe2d3de774664dcb6a3b1b84dcc49425cc3c646',
+            },
         ],
         role: 'coder',
         purpose: 'Summarize whole-plan completion state in compact structured JSON.',
@@ -565,7 +573,7 @@ export const PROMPT_SPECS = [
     },
     {
         id: 'completion_reviewer',
-        version: 3,
+        version: 4,
         changelog: [
             {
                 version: 1,
@@ -579,6 +587,10 @@ export const PROMPT_SPECS = [
                 version: 3,
                 renderSha: '127097db4b0d06cba8943681d12d93fbb07e577e078c99c1d81036399bedb66a',
             },
+            {
+                version: 4,
+                renderSha: 'c47009016178fc29c34440e06636ba7b21c6beb59202dd3fe63e365cb32a75cf',
+            },
         ],
         role: 'reviewer',
         purpose: 'Judge whole-plan completion and decide whether Neal should accept completion, continue execution, or block for operator input.',

package/dist/neal/providers/input-budget.js

@@ -0,0 +1,80 @@
+import { NealProviderError } from './types.js';
+const REPORTED_SECTION_COUNT = 3;
+const SECTION_NAME_MAX_CHARS = 60;
+// Measures the prompt as contiguous sections split on `## ` headings, the
+// heading level Neal's prompt builders use for top-level sections. Text before
+// the first heading is labeled "instructions". Section sizes include the
+// heading line and sum exactly to the prompt length.
+export function measurePromptSections(prompt) {
+    const boundaries = [];
+    for (const match of prompt.matchAll(/^## (.*)$/gm)) {
+        boundaries.push({
+            index: match.index,
+            name: match[1].trim() === '' ? 'untitled section' : match[1].trim(),
+        });
+    }
+    const sections = [];
+    const leadingChars = boundaries.length === 0 ? prompt.length : boundaries[0].index;
+    if (leadingChars > 0) {
+        sections.push({ name: 'instructions', chars: leadingChars });
+    }
+    for (const [position, boundary] of boundaries.entries()) {
+        const end = position + 1 < boundaries.length ? boundaries[position + 1].index : prompt.length;
+        sections.push({ name: boundary.name, chars: end - boundary.index });
+    }
+    if (sections.length === 0) {
+        sections.push({ name: 'instructions', chars: prompt.length });
+    }
+    return sections;
+}
+function formatChars(value) {
+    return value.toLocaleString('en-US');
+}
+function formatSectionName(name) {
+    return name.length > SECTION_NAME_MAX_CHARS
+        ? `${name.slice(0, SECTION_NAME_MAX_CHARS - 3)}...`
+        : name;
+}
+export function buildInputTooLargeMessage(args) {
+    const largest = [...args.sections]
+        .sort((a, b) => b.chars - a.chars)
+        .slice(0, REPORTED_SECTION_COUNT);
+    const sectionReport = largest
+        .map((section) => `"${formatSectionName(section.name)}" ${formatChars(section.chars)} chars`)
+        .join('; ');
+    return [
+        `Prompt is ${formatChars(args.promptChars)} chars; ${args.provider} accepts at most ${formatChars(args.maxInputChars)} input chars per turn.`,
+        `Largest sections: ${sectionReport}.`,
+    ].join('\n');
+}
+// Reads the largest section name back out of a message produced by
+// buildInputTooLargeMessage, so `neal status` can name the input to shrink in
+// its Next Action. Provider-authored input_too_large rejections carry no
+// section report, so this returns null for them and the caller falls back to
+// generic wording. Kept next to the builder so the format and its one parser
+// stay in lockstep.
+export function largestSectionNameFromInputTooLargeMessage(message) {
+    const match = message.match(/Largest sections: "([^"]+)"/);
+    return match ? match[1] : null;
+}
+// No-op when the role declares no budget or the prompt fits. Throws before any
+// SDK work otherwise; the error is non-retryable by construction, so it never
+// consumes API-retry budget.
+export function assertPromptWithinInputBudget(args) {
+    if (args.maxInputChars === undefined || args.prompt.length <= args.maxInputChars) {
+        return;
+    }
+    throw new NealProviderError({
+        message: buildInputTooLargeMessage({
+            provider: args.provider,
+            promptChars: args.prompt.length,
+            maxInputChars: args.maxInputChars,
+            sections: measurePromptSections(args.prompt),
+        }),
+        provider: args.provider,
+        role: args.role,
+        sessionHandle: args.sessionHandle ?? null,
+        kind: 'input_too_large',
+        retryable: false,
+    });
+}

package/dist/neal/providers/openai-codex.js

@@ -1,10 +1,25 @@
 import { Codex } from '@openai/codex-sdk';
-import { runStructuredJsonProtocol } from '../agents/structured-json.js';
+import { buildStructuredJsonPrompt, runStructuredJsonProtocol } from '../agents/structured-json.js';
 import { agentSettingsIsolated } from './agent-settings-isolation.js';
 import { agentSubprocessEnv } from './git-config-isolation.js';
+import { assertPromptWithinInputBudget } from './input-budget.js';
 import { resolveRateCost } from './pricing.js';
 import { isContentSafetyRefusalMessage, NealProviderError } from './types.js';
 const OPENAI_CODEX_PROVIDER_ID = 'openai-codex';
+// Codex's app-server rejects any single turn whose input exceeds this size
+// (JSON-RPC code -32602, input_error_code `input_too_large`). Declared as
+// `maxInputChars` on both role capabilities and enforced by the preflight at
+// every turn/round entry point below.
+const OPENAI_CODEX_MAX_INPUT_CHARS = 1_048_576;
+function assertCodexInputBudget(args) {
+    assertPromptWithinInputBudget({
+        prompt: args.prompt,
+        maxInputChars: OPENAI_CODEX_MAX_INPUT_CHARS,
+        provider: OPENAI_CODEX_PROVIDER_ID,
+        role: args.role,
+        sessionHandle: args.sessionHandle,
+    });
+}
 class CodexInactivityTimeoutError extends Error {
     constructor(timeoutMs) {
         super(`Codex timed out after ${Math.round(timeoutMs / 1000)}s without progress`);
@@ -76,6 +91,12 @@ function inferCodexErrorKind(error, message, fallback) {
     if (isContentSafetyRefusalMessage(message)) {
         return 'content_refused';
     }
+    // Codex's app-server rejects an over-limit turn with JSON-RPC code -32602
+    // and input_error_code `input_too_large`; matching the stable error code
+    // means a limit the preflight did not predict still classifies correctly.
+    if (text.includes('input_too_large')) {
+        return 'input_too_large';
+    }
     if (text.includes('permission') || text.includes('denied') || text.includes('forbidden') || text.includes('not authorized')) {
         return 'permission_denied';
     }
@@ -568,6 +589,11 @@ class OpenAICodexCoderAdapter {
     async runPrompt(args) {
         let thread = null;
         try {
+            assertCodexInputBudget({
+                prompt: args.prompt,
+                role: 'coder',
+                sessionHandle: args.resumeHandle ?? null,
+            });
             const createThread = this.options.createThread ?? createCodexThread;
             thread = createThread({
                 cwd: args.cwd,
@@ -620,6 +646,16 @@ class OpenAICodexCoderAdapter {
         while (true) {
             let thread = null;
             try {
+                // Preflight the exact text the initial SDK turn will send: the
+                // protocol-wrapped prompt. buildStructuredJsonPrompt is the same pure
+                // builder runStructuredJsonProtocol applies to the same inputs below,
+                // so the checked text is byte-identical to the sent text. Repair
+                // prompts are checked in runRepair before their thread is created.
+                assertCodexInputBudget({
+                    prompt: buildStructuredJsonPrompt(args.prompt, args.structuredJsonProtocol),
+                    role: 'coder',
+                    sessionHandle: args.resumeHandle ?? null,
+                });
                 const createThread = this.options.createThread ?? createCodexThread;
                 thread = createThread({
                     cwd: args.cwd,
@@ -650,6 +686,14 @@ class OpenAICodexCoderAdapter {
                         };
                     },
                     runRepair: async (prompt) => {
+                        // A generated repair prompt embeds the invalid payload and the
+                        // original response, so it can exceed the budget even when the
+                        // initial prompt fit; preflight it before creating its thread.
+                        assertCodexInputBudget({
+                            prompt,
+                            role: 'coder',
+                            sessionHandle: thread.id ?? args.resumeHandle ?? null,
+                        });
                         // Repair runs on a fresh prompt-only thread whose prompt forbids
                         // tool use entirely, so nothing in the repair flow needs write
                         // access; the read-only sandbox enforces that mechanically
@@ -740,6 +784,20 @@ class OpenAICodexStructuredAdvisorAdapter {
         while (true) {
             let thread = null;
             try {
+                // Preflight the exact text the initial SDK turn will send: the
+                // protocol-wrapped prompt on the local-JSON path
+                // (buildStructuredJsonPrompt is the same pure builder
+                // runStructuredJsonProtocol applies to the same inputs below, so the
+                // checked text is byte-identical to the sent text), the bare prompt on
+                // the provider-native path. Repair prompts are checked in runRepair
+                // before their thread is created.
+                assertCodexInputBudget({
+                    prompt: args.structuredJsonProtocol?.protocol === 'neal-json-block-v1'
+                        ? buildStructuredJsonPrompt(args.prompt, args.structuredJsonProtocol)
+                        : args.prompt,
+                    role: 'structured-advisor',
+                    sessionHandle: args.resumeHandle ?? null,
+                });
                 thread = createThread({
                     cwd: args.cwd,
                     sessionHandle: args.resumeHandle,
@@ -770,6 +828,14 @@ class OpenAICodexStructuredAdvisorAdapter {
                             };
                         },
                         runRepair: async (prompt) => {
+                            // A generated repair prompt embeds the invalid payload and the
+                            // original response, so it can exceed the budget even when the
+                            // initial prompt fit; preflight it before creating its thread.
+                            assertCodexInputBudget({
+                                prompt,
+                                role: 'structured-advisor',
+                                sessionHandle: thread.id ?? args.resumeHandle ?? null,
+                            });
                             const repairThread = createThread({
                                 cwd: args.cwd,
                                 model: this.options.model ?? undefined,
@@ -875,6 +941,7 @@ export const openAICodexProviderDefinition = {
                 write: true,
                 shell: true,
             },
+            maxInputChars: OPENAI_CODEX_MAX_INPUT_CHARS,
             supportsSessionResume: true,
             supportsModelOverride: true,
             supportsStructuredOutput: true,
@@ -891,6 +958,7 @@ export const openAICodexProviderDefinition = {
                 write: false,
                 shell: false,
             },
+            maxInputChars: OPENAI_CODEX_MAX_INPUT_CHARS,
             supportsSessionResume: true,
             supportsModelOverride: true,
             supportsStructuredOutput: true,

package/dist/neal/scopes.js

@@ -1,4 +1,5 @@
 import { readFile, stat } from 'node:fs/promises';
+import { boundChangedFileList } from './context/inline-review-context.js';
 import { validatePlanDocument } from './plan-validation.js';
 import { getDerivedPlanIdentityView } from './state-views.js';
 export const DEFAULT_PARENT_OBJECTIVE_HISTORY_WINDOW = 5;
@@ -390,14 +391,13 @@ export function renderRecentAcceptedScopesSummary(state, parentScopeLabel, windo
     }
     const concentrationSummary = touchedFileCounts.size === 0
         ? '(no changed files recorded)'
-        : [...touchedFileCounts.entries()]
+        : boundChangedFileList([...touchedFileCounts.entries()]
             .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
-            .map(([file, touches]) => `${file} (${touches}/${recentScopes.length} scopes)`)
-            .join(', ');
+            .map(([file, touches]) => `${file} (${touches}/${recentScopes.length} scopes)`)).join(', ');
     return [
         `Accepted scope history for parent objective ${parentScopeLabel} (oldest to newest, last ${window} max):`,
         ...recentScopes.map((scope) => {
-            const changedFiles = scope.changedFiles.length > 0 ? scope.changedFiles.join(', ') : '(no changed files)';
+            const changedFiles = scope.changedFiles.length > 0 ? boundChangedFileList(scope.changedFiles).join(', ') : '(no changed files)';
             return [
                 `- Scope ${scope.number}`,
                 `  commit: ${scope.finalCommit ?? 'pending'}`,

package/dist/neal/status.js

@@ -10,6 +10,7 @@ import { listRuns } from './run-registry.js';
 import { formatPublicRunStatus, getRunDisplayStatus } from './run-status.js';
 import { getRunStatePath, loadState } from './state.js';
 import { getDerivedPlanView } from './state-views.js';
+import { largestSectionNameFromInputTooLargeMessage } from './providers/input-budget.js';
 import { getNealBuildMetadata } from './version.js';
 export { formatPublicPhase } from './phase-display.js';
 const EVENT_TAIL_BYTES = 256 * 1024;
@@ -25,6 +26,7 @@ const PROVIDER_ERROR_KINDS = new Set([
     'permission_denied',
     'session_unavailable',
     'content_refused',
+    'input_too_large',
     'provider_failed',
     'unknown',
 ]);
@@ -104,16 +106,21 @@ export async function buildStatusSnapshot(args) {
     const health = classifyHealth(state, eventSummary, nowMs, finalCompletionStaleness);
     const publicStatus = formatPublicStatusForDisplayStatus(displayStatus, health);
     const publicPhase = formatPublicPhase(state.phase);
+    const providerError = summarizeProviderError(tail.events);
     const nextAction = formatNextAction({
         manualGate,
         resumeDecision,
         finalCompletionStaleness,
         runId,
         blockedGuidance,
+        // The Next Action must reflect the run's current failure, not history: the
+        // provider-error summary stays on the snapshot as historical information,
+        // but it only drives the Next Action while no later provider turn or phase
+        // has completed successfully after it.
+        providerError: providerError && isProviderErrorActive(tail.events) ? providerError : null,
     });
     const commits = summarizeCommits(state);
     const squash = await summarizeSquashArtifact(state.runDir);
-    const providerError = summarizeProviderError(tail.events);
     const build = await summarizeBuild(state);
     const patch = await summarizePatch(state, displayStatus, squash);
     return {
@@ -372,6 +379,24 @@ function formatNextAction(snapshot) {
     if (snapshot.finalCompletionStaleness.stale && snapshot.resumeDecision.kind === 'continue') {
         return `Final completion appears stale after reviewer output. Inspect artifacts and recover explicitly after confirming the branch state: neal status --run ${snapshot.runId}`;
     }
+    // An input_too_large failure keeps the resume decision at `continue` on
+    // purpose: the adapter-boundary preflight re-measures the actual rebuilt
+    // prompt against the provider budget on every attempt, so resume is always
+    // executable and an unchanged oversized prompt fails fast before any
+    // provider call. This branch only redirects the operator to shrink the named
+    // input before that resume. Every lever it names works on an existing run:
+    // operator guidance files are re-read at every prompt build, and upgrading
+    // neal applies the current prompt bounds on resume. Per-run provider
+    // rebinding does not exist, so a prompt that cannot fit needs a new run on a
+    // provider with a larger or no declared limit.
+    if (snapshot.providerError?.kind === 'input_too_large' && snapshot.resumeDecision.kind === 'continue') {
+        const largestSection = largestSectionNameFromInputTooLargeMessage(snapshot.providerError.message);
+        const namedInput = largestSection ? `the "${largestSection}" prompt section` : 'the oversized prompt input';
+        return (`The last attempt failed because the prompt exceeded the provider's input limit. ` +
+            `Shrink ${namedInput} first (trim operator guidance files, or upgrade neal so the current prompt bounds apply), ` +
+            `then resume this run: ${snapshot.resumeDecision.resumeCommand}. ` +
+            `If the prompt cannot fit under the limit, start a new run with a provider that has a larger or no input limit.`);
+    }
     if (snapshot.resumeDecision.kind === 'needs_message' && snapshot.blockedGuidance) {
         const firstOption = snapshot.blockedGuidance.options[0]?.command;
         if (firstOption) {
@@ -401,6 +426,9 @@ export function formatStatusNextActionForState(state) {
         },
         runId,
         blockedGuidance: buildBlockedGuidance({ state, runId }),
+        // This state-only path has no events access, so it cannot see provider
+        // errors and renders the plain decision-based action.
+        providerError: null,
     });
 }
 function formatNextActionForDecision(decision) {
@@ -1026,6 +1054,29 @@ function parseSquashArtifact(value) {
         originalFinalCommit,
     };
 }
+// Events that prove the run progressed past a provider failure: a provider
+// turn or structured round finished, or a whole phase completed. A provider
+// error followed by any of these is resolved history, not the active failure.
+const PROVIDER_ERROR_RESOLUTION_EVENT_TYPES = new Set([
+    'provider.turn_completed',
+    'provider.structured_output_received',
+    'phase.complete',
+]);
+// True while the latest provider_error event has no later resolution event
+// after it in the tail, so conditional guidance keyed off the error (the
+// input_too_large Next Action) stops as soon as a retry or resume succeeds.
+function isProviderErrorActive(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const type = events[index].type;
+        if (type === 'provider.provider_error') {
+            return true;
+        }
+        if (PROVIDER_ERROR_RESOLUTION_EVENT_TYPES.has(type)) {
+            return false;
+        }
+    }
+    return false;
+}
 function summarizeProviderError(events) {
     for (let index = events.length - 1; index >= 0; index -= 1) {
         const event = events[index];

package/dist/neal/verification-events.js

@@ -1,3 +1,4 @@
+import { truncateInlineSectionBody } from './context/inline-review-context.js';
 function stringValue(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
@@ -56,6 +57,54 @@ function renderCommandStatus(result) {
     }
     return 'unknown';
 }
+// Bounds for the final-completion verification tally: at most this many recent
+// failing commands, each command string capped so one pathological command
+// cannot inflate the tally.
+export const VERIFICATION_TALLY_RECENT_FAILURE_LIMIT = 10;
+export const VERIFICATION_TALLY_COMMAND_MAX_CHARS = 300;
+// Builds the bounded verification tally the final-completion prompts embed:
+// pass/fail/unknown counts over the latest result per distinct command, plus
+// the last few failing commands with their exit codes. Distinct commands are
+// ordered by their latest event position (not first appearance), so a repeated
+// command that failed at the end of the run counts as recent. The complete
+// per-command record stays in events.ndjson.
+export function buildVerificationTally(results) {
+    const latestByCommand = new Map();
+    results.forEach((result, index) => {
+        latestByCommand.set(result.command, { result, lastIndex: index });
+    });
+    const latestResults = [...latestByCommand.values()]
+        .sort((a, b) => a.lastIndex - b.lastIndex)
+        .map((entry) => entry.result);
+    let passed = 0;
+    let failed = 0;
+    let unknown = 0;
+    const failures = [];
+    for (const result of latestResults) {
+        const status = renderCommandStatus(result);
+        if (status === 'passed') {
+            passed += 1;
+        }
+        else if (status === 'failed') {
+            failed += 1;
+            failures.push({
+                command: truncateInlineSectionBody(result.command, VERIFICATION_TALLY_COMMAND_MAX_CHARS),
+                exitCode: result.exitCode,
+            });
+        }
+        else {
+            unknown += 1;
+        }
+    }
+    return {
+        totalRuns: results.length,
+        distinctCommands: latestResults.length,
+        passed,
+        failed,
+        unknown,
+        recentFailures: failures.slice(-VERIFICATION_TALLY_RECENT_FAILURE_LIMIT),
+    };
+}
 export function summarizeVerificationCommandResults(results) {
     if (results.length === 0) {
         return 'No verification commands were recorded in events.ndjson.';