@navels/neal 0.5.1 → 0.6.1

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/state-invariants.js

@@ -169,8 +169,14 @@ function assertValidInteractiveBlockedRecoveryState(args) {
     if (recovery.lastHandledTurn > recovery.turns.length) {
         throwStateInvariant(context, `${fieldPath}.lastHandledTurn`, `must not exceed recorded turn count ${recovery.turns.length}`);
     }
-    if (recovery.turns.length > recovery.maxTurns) {
-        throwStateInvariant(context, `${fieldPath}.turns`, `recorded turn count ${recovery.turns.length} exceeds maxTurns ${recovery.maxTurns}`);
+    // A recovery that reaches the turn cap and is then resolved by a turn-cap
+    // terminal directive records one terminal-resolution turn beyond `maxTurns`,
+    // so the recorded count may be `maxTurns + 1`. That extra turn is only ever
+    // the terminal resolution: past the cap, new guidance becomes a
+    // `pendingDirective` rather than an appended turn, so nothing else can push
+    // the count higher.
+    if (recovery.turns.length > recovery.maxTurns + 1) {
+        throwStateInvariant(context, `${fieldPath}.turns`, `recorded turn count ${recovery.turns.length} exceeds maxTurns ${recovery.maxTurns} by more than the one terminal-resolution turn`);
     }
     if (recovery.pendingDirective) {
         assertNonEmptyString(recovery.pendingDirective.recordedAt, `${fieldPath}.pendingDirective.recordedAt`, context);

package/dist/neal/state.js

@@ -11,6 +11,7 @@ import { refreshActiveRunLock } from './run-lock.js';
 import { validateReviewerSquashMessageDraft } from './squash-message.js';
 import { assertOrchestrationPhase, assertOrchestrationStatus, assertValidOrchestrationState, } from './state-invariants.js';
 const TOP_LEVEL_MODES = new Set(['plan', 'execute']);
+const INTERACTIVE_BLOCKED_RECOVERY_TURN_ORIGINS = ['operator', 'consultant'];
 const INTERACTIVE_BLOCKED_RECOVERY_SOURCE_PHASES = new Set([
     'coder_plan',
     'reviewer_plan',
@@ -257,6 +258,16 @@ function readNullableString(record, key, fieldPath = key) {
     }
     throwInvalidState(fieldPath, `expected string or null, received ${formatStateValue(value)}`);
 }
+function readOptionalString(record, key, fieldPath = key) {
+    if (!hasOwn(record, key)) {
+        return undefined;
+    }
+    const value = record[key];
+    if (typeof value === 'string') {
+        return value;
+    }
+    throwInvalidState(fieldPath, `expected string, received ${formatStateValue(value)}`);
+}
 function readOptionalBoolean(record, key, fieldPath = key) {
     if (!hasOwn(record, key)) {
         return undefined;
@@ -646,6 +657,8 @@ function hydrateInteractiveBlockedRecoveryTurnDisposition(value, fieldPath) {
         rationale: readString(disposition, 'rationale', `${fieldPath}.rationale`),
         blocker: readString(disposition, 'blocker', `${fieldPath}.blocker`),
         replacementPlan: readString(disposition, 'replacementPlan', `${fieldPath}.replacementPlan`),
+        laterScopeNumber: readOptionalSafeInteger(disposition, 'laterScopeNumber', `${fieldPath}.laterScopeNumber`) ?? 0,
+        laterScopeBody: readOptionalString(disposition, 'laterScopeBody', `${fieldPath}.laterScopeBody`) ?? '',
         resultingPhase: readOrchestrationPhase(disposition, 'resultingPhase', `${fieldPath}.resultingPhase`),
     };
 }
@@ -655,6 +668,7 @@ function hydrateInteractiveBlockedRecoveryTurn(value, fieldPath) {
         number: readSafeInteger(turn, 'number', `${fieldPath}.number`),
         recordedAt: readString(turn, 'recordedAt', `${fieldPath}.recordedAt`),
         operatorGuidance: readString(turn, 'operatorGuidance', `${fieldPath}.operatorGuidance`),
+        origin: readOptionalNullableEnum(turn, 'origin', INTERACTIVE_BLOCKED_RECOVERY_TURN_ORIGINS, `${fieldPath}.origin`) ?? null,
         disposition: hydrateInteractiveBlockedRecoveryTurnDisposition(readRequired(turn, 'disposition', `${fieldPath}.disposition`), `${fieldPath}.disposition`),
     };
 }
@@ -667,6 +681,7 @@ function hydrateInteractiveBlockedRecoveryDirective(value, fieldPath) {
         recordedAt: readString(directive, 'recordedAt', `${fieldPath}.recordedAt`),
         operatorGuidance: readString(directive, 'operatorGuidance', `${fieldPath}.operatorGuidance`),
         terminalOnly: readBoolean(directive, 'terminalOnly', `${fieldPath}.terminalOnly`),
+        origin: readOptionalNullableEnum(directive, 'origin', INTERACTIVE_BLOCKED_RECOVERY_TURN_ORIGINS, `${fieldPath}.origin`) ?? null,
     };
 }
 const CONSULTANT_TRIAGE_CATEGORIES = [

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/support.js

@@ -17,9 +17,13 @@ function appendInteractiveBlockedRecoverySection(lines, title, recovery, options
         return;
     }
     for (const turn of recovery.turns) {
-        lines.push(`- Recovery turn ${turn.number} at ${turn.recordedAt}: ${turn.operatorGuidance}`);
+        lines.push(`- Recovery turn ${turn.number} at ${turn.recordedAt} (${turn.origin ?? 'unrecorded'} origin): ${turn.operatorGuidance}`);
         if (turn.disposition) {
-            lines.push(`- Recovery turn ${turn.number} coder action: ${turn.disposition.action}`, `- Recovery turn ${turn.number} coder summary: ${turn.disposition.summary}`, `- Recovery turn ${turn.number} coder blocker: ${turn.disposition.blocker || 'n/a'}`, `- Recovery turn ${turn.number} coder rationale: ${turn.disposition.rationale}`, `- Recovery turn ${turn.number} resulting step: ${formatPublicPhase(turn.disposition.resultingPhase)}`);
+            lines.push(`- Recovery turn ${turn.number} coder action: ${turn.disposition.action}`, `- Recovery turn ${turn.number} coder summary: ${turn.disposition.summary}`, `- Recovery turn ${turn.number} coder blocker: ${turn.disposition.blocker || 'n/a'}`, `- Recovery turn ${turn.number} coder rationale: ${turn.disposition.rationale}`);
+            if (turn.disposition.laterScopeNumber > 0) {
+                lines.push(`- Recovery turn ${turn.number} revised later scope: ${turn.disposition.laterScopeNumber}`, `- Recovery turn ${turn.number} revised scope text:`, ...turn.disposition.laterScopeBody.split('\n').map((line) => `  ${line}`));
+            }
+            lines.push(`- Recovery turn ${turn.number} resulting step: ${formatPublicPhase(turn.disposition.resultingPhase)}`);
         }
         else {
             lines.push(`- Recovery turn ${turn.number} coder response: pending`);

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.';

package/docs/plan-format.md

@@ -74,6 +74,16 @@ declares and owns its own execution shape. Plans authored `multi_scope` or
 `multi_scope_unknown` are unaffected. Refinement may adjust their scope
 content as usual.
 
+### Revising a later scope mid-run
+
+Operator guidance during a block can revise a later scope. When a
+`neal resume --message` directive calls for changing a scope after the current
+one, the coder returns replacement text for that one scope, and neal splices it
+into the plan, checks it still parses, and writes it. neal reads the plan fresh
+from disk each turn, so the next scope runs against the revised text. The coder
+can only revise a scope after the one it's working on, never the current or an
+earlier scope, and a consultant-injected directive can't trigger it.
+
 ## Multi-scope format
 
 `executionShape: multi_scope` must include a literal `## Execution Queue`

package/docs/prompt-specs.md

@@ -175,6 +175,84 @@ older run state.
 
 If a prompt change would force validator or retained parser behavior to change, treat that as a contract change and review the prompt spec, prompt builder, schema builder, and tests together.
 
+## Prompt size bounds
+
+Prompt inputs that grow with run length are either capped at render time or
+deliberately left unbounded with the provider input budget as their backstop,
+and each section below says which. The contract has four parts.
+
+**The completion packet carries a verification tally, not the history.**
+`buildFinalCompletionPacket()` embeds `verificationTally`
+(`buildVerificationTally` in `src/neal/verification-events.ts`): total command
+runs, distinct commands, passed/failed/unknown counts over the latest result
+per distinct command, and the last 10 failing commands with exit codes, each
+command string capped at 300 characters. Both completion prompts embed the
+tally and point at the run directory's `events.ndjson` for the complete
+per-command record. The events file is the source of truth; the packet never
+carries the full history and no extra artifact is written.
+
+**Run-scaling sections are capped where they enter a prompt.** The shared
+helpers live in `src/neal/context/inline-review-context.ts` and truncation is
+render-time only: stored state, persisted artifacts, and schema-validated
+coder outputs are never mutated to satisfy a bound.
+
+- Inlined range-diff sections: `INLINE_SECTION_MAX_CHARS` (200,000
+  characters) via `truncateInlineSectionBody`, with an explicit truncation
+  marker.
+- Operator guidance: `USER_GUIDANCE_MAX_CHARS` (20,000 characters) applies
+  per role file (`src/neal/prompts/guidance.ts`; `neal check` warns when a
+  guidance file exceeds the cap), to the persisted plan-review recovery
+  guidance message, and to the latest blocked-recovery guidance line.
+- Agent-authored free text (completion summaries, finding claims, round
+  summaries, blocked reasons, the last implementation scope's commit
+  subject): `boundFreeTextValues` shares
+  `AGENT_FREE_TEXT_SECTION_MAX_CHARS` (20,000 characters) across each fixed
+  group of values, markers included. The completion packet's completed-scope
+  summary, its scope-accounting summary, and the scope reviewer's recent
+  accepted-scope history are single strings capped at the same constant via
+  `truncateInlineSectionBody`.
+- Changed-file lists: `boundChangedFileList` renders the first
+  `CHANGED_FILE_LIST_LIMIT` (20) paths and collapses the rest to a
+  `(+N more)` entry; the underlying arrays keep every path for non-prompt
+  consumers.
+- Commit-subject lists (the aggregate completion range and the scope
+  review's commits-in-scope list): `boundCommitSubjectList` renders the
+  first `COMMIT_SUBJECT_LIST_LIMIT` (20) subjects under the shared free-text
+  budget and collapses the rest to a `(+N more)` entry.
+- Git diff-stat blocks (aggregate completion range and scope review):
+  `GIT_SUMMARY_SECTION_MAX_CHARS` (20,000 characters) via
+  `truncateInlineSectionBody`.
+
+Every bound is a module constant, not configuration. Three sections are
+intentionally unbounded and rely on the provider input budget below as their
+backstop: the inlined plan text, the progress text, and the review-findings
+selected-range diff (`buildReviewFindingsInlinedDiffSection` in
+`src/neal/review-findings/prompts.ts` inlines the full resolved-range diff
+for read-only reviewers because it is the source of truth for what the range
+changed — only the separate draft-prompt preview is capped, at
+`DIFF_PREVIEW_LIMIT`). The `INLINE_SECTION_MAX_CHARS` cap applies to the
+inlined range-diff sections built through `truncateInlineSectionBody`, not to
+every diff that reaches a prompt.
+
+**Providers with a hard limit reject oversized prompts before the SDK call.**
+A capability role that declares `maxInputChars` gets an adapter-boundary
+preflight on the exact text each turn sends; over-limit prompts fail fast
+with a non-retryable `input_too_large` error naming the prompt size, the
+limit, and the three largest `## ` sections. See
+[providers.md](providers.md) for the capability field, the preflight
+mechanics, and the error kind.
+
+**Input-size failures are recoverable without state surgery.** There is no
+sticky gate: the preflight re-measures the actual rebuilt prompt on every
+attempt, so `neal resume` after the prompt shrinks proceeds normally, while
+an unchanged oversized prompt fails fast before any provider call. While the
+latest failure is `input_too_large`, `neal status` renders a conditional Next
+Action: shrink the named largest input first (trim operator guidance files,
+or upgrade neal so current prompt bounds apply on resume), then resume; if
+the prompt can't fit under the limit, start a new run on a provider with a
+larger or no declared limit, because per-run provider rebinding doesn't
+exist.
+
 ## Provider variants
 
 Provider-specific variants are allowed, but they are not the default escape hatch. Each spec declares `providerVariants` for `shared` (status `default`) plus `openai-codex` and `anthropic-claude` (status `reserved_for_justified_divergence`).
@@ -283,6 +361,8 @@ testing or profile experiments. That override wins over the default directory.
 
 When present, the file contents are appended under a fixed `## User Guidance` section inside the built-in prompt. Structured output contracts, completion markers, and the canonical plan contract survive injection.
 
+In the scope reviewer and final-completion reviewer prompts, `## User Guidance` renders after the `neal.review_level` calibration lines (`getReviewLevelCalibrationLines` in [src/neal/prompts/review-doctrine.ts](../src/neal/prompts/review-doctrine.ts)). The level supplies the baseline trust boundaries and the default finding-severity rules; guidance may widen or narrow those boundaries and demote or promote finding categories, and the refined boundaries are what "reachable" means when the reviewer decides whether a finding blocks. Guidance can't remove the floor: the reachability filter, the adversarial stance, and blocking on reachable correctness failures (including correctness regressions) stay on at every level. The calibration text itself states this merge rule, so the precedence is rendered in the prompt rather than implied by section order.
+
 Diagnostics: when a neal writer run initializes or resumes, it logs which roles have guidance applied and the byte count to the run's `stderr.log` and as a `run.user_guidance_applied` / `run.user_guidance_scanned` event. That is enough to confirm a guidance file was picked up without dumping contents.
 
 Non-goals: no repo-local `.neal/guidance/` override, no full-prompt replacement, no per-scope guidance variants, and no substitution of built-in sections.

package/docs/providers.md

@@ -72,6 +72,7 @@ Each provider capability role declares:
 
 - whether the role is supported
 - read, write, and shell tool access
+- an optional hard per-turn input limit in characters (`maxInputChars`)
 - session resume support
 - model override support
 - neal structured control protocol support
@@ -85,6 +86,16 @@ structured-advisor capability and read tool access: every reviewer inspects
 the repository directly. Session resume support is required when a persisted
 session handle is present.
 
+A role that declares `maxInputChars` gets an input-budget preflight
+(`src/neal/providers/input-budget.ts`) in the adapter on the exact text each
+SDK turn sends: the bare prompt for plain turns, the protocol-wrapped prompt
+for structured turns, and each generated repair prompt before its repair
+thread is created. Every call site is covered without per-site wiring. A
+prompt over the limit fails fast with a non-retryable `input_too_large` error
+before any SDK call and without consuming API-retry budget; the error message
+names the prompt size, the limit, and the three largest `## ` sections. Roles
+without a declared limit skip the preflight.
+
 Current built-in capabilities are intentionally conservative:
 
 - OpenAI Codex supports coder and structured-advisor roles. The coder role is
@@ -92,6 +103,8 @@ Current built-in capabilities are intentionally conservative:
   broad local access. The structured-advisor (reviewer) role is read capable
   but never write or shell capable (see
   [The read-only reviewer invariant](#the-read-only-reviewer-invariant)).
+  Both roles declare `maxInputChars: 1,048,576` — the size at which Codex's
+  app-server rejects a turn with its `input_too_large` input-error code.
 - Anthropic Claude supports coder and structured-advisor roles. The coder role
   is read, write, and shell capable. The structured-advisor (reviewer) role is
   read capable but never write or shell capable.
@@ -402,6 +415,12 @@ Normalized error kinds are:
 - `structured_output_invalid`
 - `permission_denied`
 - `session_unavailable`
+- `input_too_large` (the assembled prompt exceeds the role's declared
+  `maxInputChars`; thrown by the adapter's preflight before any SDK call, and
+  a provider-side over-limit rejection — Codex's `input_too_large`
+  input-error code — normalizes to the same kind. Always non-retryable; the
+  message names the prompt size, the limit, and the three largest `## `
+  sections)
 - `provider_failed`
 - `unknown`
 

package/docs/state-machine.md

@@ -79,6 +79,12 @@ Site A below). The consultant is read-only: it never grants authorization, expan
 scope, or waives verification gates. A recoverable verdict acts automatically. A
 non-recoverable verdict yields to the operator, carrying the verdict as advice.
 
+Each recovery turn records its `origin` — `operator` for a `neal resume --message`
+directive, `consultant` for a consultant injection — and the same marker rides the
+turn-cap `pendingDirective`. A later-scope revision is offered only on an
+operator-origin turn, so a consultant directive can direct the current scope but
+never rewrites a later scope on its own.
+
 Public resume eligibility is classified by `src/neal/resume-decision.ts` before
 any recovery mutation. That read-only decision layer combines loaded child-run
 state with lock, queue, and retrospective evidence, then returns the shared

package/neal.yml

@@ -40,7 +40,16 @@
 #
 #   # Maximum number of times final completion review may send execution back
 #   # for more work before neal stops reopening the plan.
-#   final_completion_continue_execution_max: 2
+#   final_completion_continue_execution_max: 3
+#
+#   # How strict the scope and final-completion reviewers are about what
+#   # rises to a blocking finding. Under every level a blocking finding must
+#   # describe a failure reachable under the assumed trust boundaries.
+#   #   strict:   assume adversarial trust boundaries; block on hardening gaps
+#   #   moderate: ordinary trust boundaries; internal run artifacts are not
+#   #             security boundaries; block on correctness and normal-use bugs
+#   #   lenient:  correctness and real, reachable bugs only
+#   review_level: moderate
 #
 #   # Optional local notification command. Leave commented to keep
 #   # notifications disabled.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navels/neal",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "A source-first multi-agent CLI for planning, executing, reviewing, and resuming scoped code changes.",
   "license": "MIT",
   "publishConfig": {
@@ -56,8 +56,8 @@
   },
   "dependencies": {
     "@ai-sdk/openai-compatible": "3.0.34",
-    "@anthropic-ai/claude-agent-sdk": "0.3.239",
-    "@openai/codex-sdk": "0.149.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.246",
+    "@openai/codex-sdk": "0.149.1",
     "ai": "7.0.74",
     "dotenv": "^17.4.2",
     "yaml": "^2.9.0",