@navels/neal 0.5.1 → 0.6.1

package/README.md

@@ -453,6 +453,54 @@ agent:
     effort: xhigh
 ```
 
+### Review level
+
+`neal.review_level` sets how strict the scope reviewer and the final-completion
+reviewer are about what rises to a blocking finding. It takes one of three
+values and defaults to `moderate`:
+
+- `strict`: assume adversarial trust boundaries. Block on any failure reachable
+  under the worst case, including hardening gaps and missing defenses against
+  local or adversarial actors.
+- `moderate`: ordinary trust boundaries. Internal run artifacts aren't security
+  boundaries. Block on correctness bugs and failures reachable under normal use;
+  don't require defenses against an actor who could already subvert the system.
+- `lenient`: correctness and real, reachable bugs only. Minimal robustness,
+  style, or hardening demands.
+
+```yaml
+neal:
+  review_level: moderate
+```
+
+Set it in the repo's `neal.yml` or in `~/.neal/config.yml`; the repo value wins.
+A blank or null value means unset and falls back to `moderate`. Any other
+nonblank value (a typo, say) is rejected before any agent work: `neal check`
+fails, every fresh writer command fails at config load, and a `neal resume`
+that has selected a run and is about to resume writer work (plain, manual
+gate, or `--message`) fails before it takes the writer lock, rewrites run
+state, or starts an agent turn. Resume outcomes that never execute writer work
+(already done, already running, waiting for operator guidance) are decided
+first and don't validate the level.
+
+Under every level a blocking finding has to describe a failure that's actually
+reachable under the assumed trust boundaries, and the reviewer still treats the
+change as hostile input and tries to falsify it before crediting it. A level
+narrows what counts as blocking; it never means trust the coder or skip
+inspection. The plan reviewer, the consultant, and `neal review` don't use the
+level.
+
+`~/.neal/guidance/reviewer.md` refines the level rather than replacing it. It
+can widen or narrow the assumed trust boundaries ("we do defend the run
+directory against local processes" makes a local-process attack on the run
+directory blockable even at `moderate`) and it can demote or promote finding
+categories ("ignore performance, correctness only" makes a performance
+regression non-blocking at any level). It can't turn off the reachability
+filter, the adversarial stance, or blocking on reachable correctness failures,
+including correctness regressions. Guidance that conflicts with that floor is
+ignored on that point. See [Custom guidance](#custom-guidance) for where the
+file lives.
+
 ### Custom guidance
 
 neal supports additive guidance files for local preferences alongside the built-in protocol prompts:
@@ -463,6 +511,11 @@ neal supports additive guidance files for local preferences alongside the built-
 
 Set `NEAL_GUIDANCE_DIR=/path/to/guidance` to load those same `coder.md`, `reviewer.md`, and `planner.md` files from another directory. neal records applied guidance roles, selected paths, and byte counts in run artifacts. Guidance contents stay out of terminal output.
 
+For the two code reviewers, `reviewer.md` layers on top of `neal.review_level`
+(see [Review level](#review-level)): it can adjust trust boundaries and finding
+categories, but it can't switch off the reachability filter or blocking on
+reachable correctness failures.
+
 ## Artifacts and storage
 
 Writer run artifacts live under `.neal/runs/<run-id>/`, including the original-plan backup at `.neal/runs/<run-id>/PLAN_ORIGINAL.md` and reviewer scratch space under `.neal/runs/<run-id>/scratch/`. Queue artifacts live under `.neal/queues/<queue-id>/`. Review findings artifacts live under `.neal/reviews/<review-id>/`.

package/dist/neal/adjudicator/execute.js

@@ -1,6 +1,6 @@
 import { mkdir } from 'node:fs/promises';
 import { runCoderResponseRound, runReviewerRound } from '../agents.js';
-import { readOnlyReviewerNeedsInlinedDiff } from '../context/inline-review-context.js';
+import { OPEN_FINDINGS_PROMPT_ITEM_LIMIT, readOnlyReviewerNeedsInlinedDiff, } from '../context/inline-review-context.js';
 import { buildAndPersistReviewerContextPacket } from '../context/reviewer-context.js';
 import { getReviewStuckWindow } from '../config.js';
 import { getDiffForRangePaths } from '../git.js';
@@ -229,9 +229,19 @@ export function buildVerificationHint(state) {
         '- Rerun full test suites only if your new changes materially invalidate that reviewed baseline or the plan explicitly requires new end-of-scope full-suite verification.',
     ].join('\n');
 }
+// The bounded finding set for one coder response round. Both the response
+// prompt and validateExecuteResponseCoverage consume this same selection, so
+// the coder is asked to disposition exactly the findings it can see. At most
+// OPEN_FINDINGS_PROMPT_ITEM_LIMIT findings are presented per round; findings
+// beyond the limit stay open and synthesizeExecuteResponseState keeps the
+// response phase active, presenting the next batch immediately, until every
+// open finding of the round's kind has been dispositioned.
 export function getExecuteResponseOpenFindings(state, mode = 'blocking') {
     const selector = mode === 'optional' ? isOpenNonBlockingFinding : isOpenBlockingFinding;
-    return state.findings.filter(selector).map((finding) => ({
+    return state.findings
+        .filter(selector)
+        .slice(0, OPEN_FINDINGS_PROMPT_ITEM_LIMIT)
+        .map((finding) => ({
         id: finding.id,
         source: finding.source,
         claim: finding.claim,
@@ -266,7 +276,7 @@ function validateExecuteResponseCoverage(args) {
         throw new Error(`Coder ${args.mode} response returned duplicate finding dispositions: ${[...duplicateIds].join(', ')}`);
     }
     if (unknownIds.size > 0) {
-        throw new Error(`Coder ${args.mode} response returned dispositions for non-open findings: ${[...unknownIds].join(', ')}`);
+        throw new Error(`Coder ${args.mode} response returned dispositions for findings outside the presented open set: ${[...unknownIds].join(', ')}`);
     }
     if (args.response.payload.outcome !== 'responded') {
         return;
@@ -526,7 +536,12 @@ export function synthesizeExecuteReviewerState(args) {
         ];
         mergedFindings = [...args.state.findings, ...findings];
     }
-    const hasBlockingFindings = findings.some((finding) => finding.severity === 'blocking');
+    // Deliberately derived from the merged set as well as the current reviewer
+    // payload: a prior round's still-open blocker (for example one beyond the
+    // batched response round's presentation limit) must keep forcing a revision
+    // even when the current reviewer round is empty, so an empty round can never
+    // accept over an open blocking finding.
+    const hasBlockingFindings = findings.some((finding) => finding.severity === 'blocking') || mergedFindings.some(isOpenBlockingFinding);
     const hasOpenNonBlockingFindings = mergedFindings.some(isOpenNonBlockingFinding);
     const openBlockingCanonicalSet = getOpenBlockingCanonicalSet(mergedFindings);
     const openBlockingCanonicalIds = [...openBlockingCanonicalSet].sort();
@@ -633,11 +648,22 @@ export function synthesizeExecuteResponseState(args) {
         };
     });
     const outcome = args.response.payload.outcome;
+    // Response rounds batch: when open findings of this round's kind remain
+    // after the dispositions are applied (they were beyond the per-round
+    // presentation limit), stay in the same response phase so the next batch is
+    // presented immediately instead of spending a reviewer round per batch.
+    // Coverage validation guarantees the presented batch was fully
+    // dispositioned, so the backlog strictly shrinks and the loop terminates.
+    const hasNextResponseBatch = findings.some(mode === 'optional' ? isOpenNonBlockingFinding : isOpenBlockingFinding);
     const nextPhase = outcome === 'blocked' || outcome === 'split_plan'
         ? 'blocked'
         : mode === 'optional'
-            ? EXECUTE_FINALIZATION_PHASE
-            : 'reviewer_scope';
+            ? hasNextResponseBatch
+                ? 'coder_optional_response'
+                : EXECUTE_FINALIZATION_PHASE
+            : hasNextResponseBatch
+                ? 'coder_response'
+                : 'reviewer_scope';
     return {
         findings,
         nextPhase,

package/dist/neal/agents/prompts.js

@@ -1,6 +1,6 @@
-import { assertNoReadPromptInstructionText, renderInlineReviewerContext, } from '../context/inline-review-context.js';
+import { assertNoReadPromptInstructionText, boundFreeTextValues, renderInlineReviewerContext, truncateInlineSectionBody, } from '../context/inline-review-context.js';
 import { AUTONOMY_BLOCKED as SHARED_AUTONOMY_BLOCKED, AUTONOMY_CHUNK_DONE as SHARED_AUTONOMY_CHUNK_DONE, AUTONOMY_DONE as SHARED_AUTONOMY_DONE, AUTONOMY_SCOPE_DONE as SHARED_AUTONOMY_SCOPE_DONE, AUTONOMY_SPLIT_PLAN as SHARED_AUTONOMY_SPLIT_PLAN, buildProgressSection, getCanonicalPlanContractLines, getProtocolMarkerArtifactProhibitionLines, getStandalonePlanPayloadSourceOfTruthLines, } from '../prompts/shared.js';
-import { getUserGuidanceLines } from '../prompts/guidance.js';
+import { getUserGuidanceLines, USER_GUIDANCE_MAX_CHARS } from '../prompts/guidance.js';
 import { assertPromptBuilder, resolvePrimaryVariant } from '../prompts/assert-builder.js';
 export { buildCoderResponsePrompt, buildLegacyScopePrompt, buildReviewerPrompt, buildScopePrompt } from '../prompts/execute.js';
 export { buildCoderPlanResponsePrompt, buildLegacyPlanningPrompt, buildPlanReviewerPrompt, buildPlanningPrompt, } from '../prompts/planning.js';
@@ -41,13 +41,16 @@ export function buildConsultantPrompt(args) {
         ...staticInstructionLines,
         '',
         'Blocked reason:',
-        args.blockedReason,
+        // Agent-authored free text shares the fixed agent free-text cap at render
+        // time; the persisted blocked reason keeps its full text.
+        boundFreeTextValues([args.blockedReason])[0],
         '',
         renderInlineReviewerContext(args.inlineContext),
     ].join('\n');
 }
 export function buildBlockedRecoveryCoderPrompt(args) {
     const allowReplacement = args.allowReplacement ?? true;
+    const laterScopeRevision = args.terminalOnly ? null : args.laterScopeRevision ?? null;
     const actionLines = [
         '- `resume_current_scope`',
         ...(allowReplacement ? ['- `replace_current_scope`'] : []),
@@ -85,6 +88,14 @@ export function buildBlockedRecoveryCoderPrompt(args) {
         allowReplacement
             ? 'Always include a `replacementPlan` string. Use an empty string unless action=`replace_current_scope`.'
             : 'Always include an empty `replacementPlan` string.',
+        ...(laterScopeRevision
+            ? [
+                'Always include an integer `laterScopeNumber` and a `laterScopeBody` string. Use `0` and an empty string unless the operator guidance directs a change to a later top-level scope.',
+                `The operator guidance may direct a change to one later scope of the top-level plan at ${laterScopeRevision.topLevelPlanDoc}. The current top-level scope is ${laterScopeRevision.currentScopeNumber}; eligible target scopes are ${laterScopeRevision.currentScopeNumber + 1} through ${laterScopeRevision.scopeCount}.`,
+                'To revise a later scope, set `laterScopeNumber` to the target scope number and `laterScopeBody` to the complete replacement text of that one `### Scope N:` entry. The body must start with the line `### Scope N:` for the same N (the title after the colon may change), must contain no other `### ` or `## ` heading, and must keep the `- Goal:`, `- Verification:`, and `- Success Condition:` bullets.',
+                'A later-scope revision may accompany action=`resume_current_scope` or action=`stay_blocked` only. Set both fields or neither. Do not revise the current scope, an earlier scope, or a derived plan this way, and do not edit the plan file yourself: Neal validates the revised plan and writes it. Put the reasoning for the revision in `rationale`.',
+            ]
+            : ['Always include `laterScopeNumber` as `0` and `laterScopeBody` as an empty string.']),
         ...(allowReplacement
             ? [
                 'When action=`replace_current_scope`, `replacementPlan` must use the same Neal-executable contract as a top-level plan.',
@@ -102,9 +113,12 @@ export function buildBlockedRecoveryCoderPrompt(args) {
         'Do not treat operator guidance as authorization to skip verification, waive policy, or reinterpret the target beyond the current scope.',
         '',
         'Blocked recovery context:',
-        `- Blocked reason: ${args.blockedReason}`,
+        // The blocked reason is agent-authored free text and the guidance is
+        // operator-authored; each gets its class's render-time cap while the
+        // persisted values keep their full text.
+        `- Blocked reason: ${boundFreeTextValues([args.blockedReason])[0]}`,
         `- Recovery turns used: ${args.turnsTaken} of ${args.maxTurns}`,
-        `- Latest operator guidance: ${args.operatorGuidance}`,
+        `- Latest operator guidance: ${truncateInlineSectionBody(args.operatorGuidance, USER_GUIDANCE_MAX_CHARS)}`,
         '',
         'Current progress state:',
         buildProgressSection(args.progressText),

package/dist/neal/agents/rounds.js

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { getAgentTurnRetryLimit, getAgentTurnStartupTimeoutMs, getApiRetryLimit, getInactivityTimeoutMs, } from '../config.js';
+import { getReviewLevel } from '../config.js';
 import { runWithAgentTurnLiveness } from '../providers/liveness.js';
 import { normalizeExecutionShapeDeclaration } from '../plan-validation.js';
 import { getCoderAdapter, getProviderDefinition, getStructuredAdvisorAdapter } from '../providers/registry.js';
@@ -176,7 +177,13 @@ export async function runReviewerRound(args) {
         cwd: args.cwd,
         // The doctrine access mode comes from the reviewer provider's declared
         // structured-advisor tool access, not from inline-context presence alone.
-        prompt: buildReviewerPrompt({ ...args, accessMode: getReviewerDoctrineAccessMode(args.reviewer) }),
+        // The review level comes from current config (`neal.review_level`), not
+        // persisted run state; the builder itself never reads config.
+        prompt: buildReviewerPrompt({
+            ...args,
+            accessMode: getReviewerDoctrineAccessMode(args.reviewer),
+            reviewLevel: getReviewLevel(args.cwd),
+        }),
         schema,
         structuredJsonProtocol: buildStructuredJsonProtocolSpec({
             schemaLabel: 'reviewer_payload',
@@ -334,7 +341,13 @@ export async function runReviewerFinalCompletionRound(args) {
         cwd: args.cwd,
         // The doctrine access mode comes from the reviewer provider's declared
         // structured-advisor tool access, not from inline-context presence alone.
-        prompt: buildFinalCompletionReviewerPrompt({ ...args, accessMode: getReviewerDoctrineAccessMode(args.reviewer) }),
+        // The review level comes from current config (`neal.review_level`), not
+        // persisted run state; the builder itself never reads config.
+        prompt: buildFinalCompletionReviewerPrompt({
+            ...args,
+            accessMode: getReviewerDoctrineAccessMode(args.reviewer),
+            reviewLevel: getReviewLevel(args.cwd),
+        }),
         schema,
         structuredJsonProtocol: buildStructuredJsonProtocolSpec({
             schemaLabel: 'final_completion_reviewer_payload',
@@ -629,6 +642,15 @@ export async function runCoderResponseRound(args) {
 export async function runBlockedRecoveryCoderRound(args) {
     const progressText = await safeReadText(args.progressMarkdownPath);
     const schema = buildCoderBlockedRecoveryDispositionSchema();
+    const laterScopeRevision = args.terminalOnly ? null : args.laterScopeRevision ?? null;
+    const laterScopeContext = laterScopeRevision
+        ? {
+            allowLaterScopeRevision: true,
+            currentScopeNumber: laterScopeRevision.currentScopeNumber,
+            planDocument: laterScopeRevision.planDocument,
+        }
+        : null;
+    const validator = (rawPayload) => validateCoderBlockedRecoveryDispositionPayload(rawPayload, laterScopeContext);
     const { sessionHandle, structured } = await runCoderStructuredPrompt({
         coder: args.coder,
         cwd: args.cwd,
@@ -642,20 +664,27 @@ export async function runBlockedRecoveryCoderRound(args) {
             turnsTaken: args.turnsTaken,
             terminalOnly: args.terminalOnly,
             allowReplacement: args.allowReplacement,
+            laterScopeRevision: laterScopeRevision
+                ? {
+                    topLevelPlanDoc: laterScopeRevision.topLevelPlanDoc,
+                    currentScopeNumber: laterScopeRevision.currentScopeNumber,
+                    scopeCount: laterScopeRevision.scopeCount,
+                }
+                : null,
         }),
         schema,
         label: 'Coder blocked-recovery round',
         structuredJsonProtocol: buildStructuredJsonProtocolSpec({
             schemaLabel: 'coder_blocked_recovery_disposition_payload',
             schema,
-            validator: validateCoderBlockedRecoveryDispositionPayload,
+            validator,
         }),
         resumeHandle: args.sessionHandle,
         logger: args.logger,
     });
     return {
         sessionHandle,
-        payload: validateCoderBlockedRecoveryDispositionPayload(structured),
+        payload: validator(structured),
     };
 }
 export async function runCoderPlanResponseRound(args) {

package/dist/neal/agents/schemas.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { reviseLaterScope } from '../plan-scope-revision.js';
 import { normalizeExecutionShapeDeclaration, validatePlanDocument } from '../plan-validation.js';
 import { repairReviewerSquashMessageDraft, validateReviewerSquashMessageDraft } from '../squash-message.js';
 export const EXECUTE_SCOPE_PROGRESS_PAYLOAD_START = 'NEAL_PROGRESS_JUSTIFICATION_JSON_START';
@@ -101,6 +102,8 @@ const coderBlockedRecoveryDispositionPayloadSchema = z.object({
     rationale: z.string(),
     blocker: z.string(),
     replacementPlan: z.string(),
+    laterScopeNumber: z.number(),
+    laterScopeBody: z.string(),
 });
 const coderPlanResponsePayloadSchema = z.object({
     outcome: z.enum(CODER_PLAN_RESPONSE_OUTCOMES),
@@ -823,7 +826,33 @@ function validateManualGateResumeChecks(value) {
         };
     });
 }
-export function validateCoderBlockedRecoveryDispositionPayload(rawPayload) {
+export function getCoderBlockedRecoveryLaterScopeErrors(payload, context) {
+    const hasNumber = payload.laterScopeNumber !== 0;
+    const hasBody = payload.laterScopeBody.trim().length > 0;
+    if (!hasNumber && !hasBody) {
+        return [];
+    }
+    if (!Number.isInteger(payload.laterScopeNumber) || payload.laterScopeNumber < 0) {
+        return [`laterScopeNumber must be a non-negative integer, received ${String(payload.laterScopeNumber)}.`];
+    }
+    if (hasNumber !== hasBody) {
+        return ['laterScopeNumber and laterScopeBody must be set together: both for a later-scope revision, or 0 and an empty string.'];
+    }
+    if (context === null || !context.allowLaterScopeRevision) {
+        return ['A later-scope revision is not available for this round; return laterScopeNumber=0 and an empty laterScopeBody.'];
+    }
+    if (payload.action !== 'resume_current_scope' && payload.action !== 'stay_blocked') {
+        return [`A later-scope revision may accompany only action=resume_current_scope or action=stay_blocked, not action=${payload.action}.`];
+    }
+    const result = reviseLaterScope({
+        planDocument: context.planDocument,
+        currentScopeNumber: context.currentScopeNumber,
+        targetScopeNumber: payload.laterScopeNumber,
+        replacementBody: payload.laterScopeBody,
+    });
+    return result.ok ? [] : result.errors;
+}
+export function validateCoderBlockedRecoveryDispositionPayload(rawPayload, laterScopeContext = null) {
     const payload = parsePayload(coderBlockedRecoveryDispositionPayloadSchema, rawPayload, 'Coder blocked-recovery payload');
     const blocker = payload.blocker.trim();
     const replacementPlan = payload.replacementPlan.trim();
@@ -836,6 +865,10 @@ export function validateCoderBlockedRecoveryDispositionPayload(rawPayload) {
     if ((payload.action === 'stay_blocked' || payload.action === 'terminal_block') && !blocker) {
         throw new Error(`Coder blocked-recovery round returned action=${payload.action} without a blocker payload.`);
     }
+    const laterScopeErrors = getCoderBlockedRecoveryLaterScopeErrors(payload, laterScopeContext);
+    if (laterScopeErrors.length > 0) {
+        throw new Error(`Coder blocked-recovery round returned an invalid later-scope revision: ${laterScopeErrors.join(' ')}`);
+    }
     return payload;
 }
 export function parseFinalCompletionSummaryPayload(rawPayload) {

package/dist/neal/commands/check.js

@@ -2,8 +2,9 @@ import { createInterface } from 'node:readline/promises';
 import process from 'node:process';
 import { verifyNotification } from '../../notifier.js';
 import { parseCheckArgs } from '../cli.js';
-import { assertWriterProvidersConfigured, getAgentTurnRetryLimit, getAgentTurnStartupTimeoutMs, getApiRetryLimit, getFinalCompletionContinueExecutionMax, getInactivityTimeoutMs, getInteractiveBlockedRecoveryMaxTurns, getMaxReviewRounds, getNotifyBin, getPhaseHeartbeatMs, getReviewStuckWindow, } from '../config.js';
+import { assertWriterProvidersConfigured, getAgentTurnRetryLimit, getAgentTurnStartupTimeoutMs, getApiRetryLimit, getFinalCompletionContinueExecutionMax, getInactivityTimeoutMs, getInteractiveBlockedRecoveryMaxTurns, getMaxReviewRounds, getNotifyBin, getPhaseHeartbeatMs, getReviewLevel, getReviewStuckWindow, } from '../config.js';
 import { getNealDirGitIgnoreStatus } from '../git.js';
+import { collectGuidanceDiagnostics, USER_GUIDANCE_MAX_CHARS } from '../prompts/guidance.js';
 import { runWithAgentTurnLiveness } from '../providers/liveness.js';
 import { getCoderAdapter, getProviderDefinition, getStructuredAdvisorAdapter, } from '../providers/registry.js';
 import { sanitizeSensitiveText } from '../sensitive-text.js';
@@ -64,6 +65,7 @@ function validateConfig(cwd) {
     getInteractiveBlockedRecoveryMaxTurns(cwd);
     getFinalCompletionContinueExecutionMax(cwd);
     getNotifyBin(cwd);
+    getReviewLevel(cwd);
     return agentConfig;
 }
 async function promptForProviderVerification(stdin, stdout) {
@@ -343,6 +345,11 @@ export async function runNealCheckCli(options = {}) {
     writeLine(stdout, `  ${describeRole('coder', agentConfig.coder)}`);
     writeLine(stdout, `  ${describeRole('reviewer', agentConfig.reviewer)}`);
     writeLine(stdout, `  ${describeNotificationScript(notifyBin)}`);
+    for (const entry of collectGuidanceDiagnostics()) {
+        if (entry.chars > USER_GUIDANCE_MAX_CHARS) {
+            writeLine(stdout, `  warning: ${entry.role} guidance at ${entry.path} is ${entry.chars} characters; prompts inline the first ${USER_GUIDANCE_MAX_CHARS} and truncate the rest. Trim the file.`);
+        }
+    }
     writeLine(stdout, '');
     // Native adapters drive their providers directly; any other writer provider is
     // an openai-compatible model that should be qualified end-to-end with `neal compat`.

package/dist/neal/commands/resume-run.js

@@ -2,7 +2,7 @@ import process from 'node:process';
 import { readdir, stat } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { parseResumeArgs } from '../cli.js';
-import { assertWriterProvidersConfigured } from '../config.js';
+import { assertWriterProvidersConfigured, getReviewLevel } from '../config.js';
 import { writeDiagnostic } from '../diagnostic.js';
 import { assertGitRepositoryWithCommit } from '../git.js';
 import { loadOrInitialize } from '../orchestrator.js';
@@ -261,6 +261,12 @@ function emitAlreadyRunningOutcome(selection) {
     return { kind: 'already_running' };
 }
 async function withResumeWriterLock(selection, evidence, action) {
+    // Every path that resumes writer work (plain, manual gate, --message) goes
+    // through this seam. The review level is read from current config, not
+    // persisted run state, so it is validated here before the lock is taken or
+    // any run state is rewritten. No-op and rejection outcomes (done, already
+    // running, waiting for guidance) are decided earlier and never reach it.
+    getReviewLevel(selection.state.cwd);
     let lock;
     try {
         lock = await acquireResumeWriterLock(selection, evidence);

package/dist/neal/config.js

@@ -3,6 +3,7 @@ import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import YAML from 'yaml';
 import { assertAgentConfigSupportsWriterRun, parseProviderId, } from './providers/registry.js';
+const REVIEW_LEVELS = ['strict', 'moderate', 'lenient'];
 const OPENAI_COMPATIBLE_DEFAULT_API_KEY_ENV = 'OPENAI_COMPATIBLE_API_KEY';
 const WRITER_PROVIDER_CONFIG_KEYS = {
     coder: 'agent.coder.provider',
@@ -19,9 +20,10 @@ const DEFAULT_CONFIG = {
         agent_turn_startup_timeout_ms: 300_000,
         agent_turn_retry_limit: 1,
         interactive_blocked_recovery_max_turns: 3,
-        final_completion_continue_execution_max: 2,
+        final_completion_continue_execution_max: 3,
         consultant_max_attempts: 1,
         notify_bin: null,
+        review_level: 'moderate',
     },
     agent: {
         planner: {
@@ -101,6 +103,22 @@ function parseNumberValue(value) {
 function parseStringValue(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
+function isReviewLevel(value) {
+    return REVIEW_LEVELS.includes(value);
+}
+function parseReviewLevelValue(value, fieldPath) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === 'string' && !value.trim()) {
+        return undefined;
+    }
+    const level = typeof value === 'string' ? value.trim() : value;
+    if (typeof level !== 'string' || !isReviewLevel(level)) {
+        throw new Error(`Invalid review level for ${fieldPath}: ${JSON.stringify(level)}. Valid values: ${REVIEW_LEVELS.join(', ')}`);
+    }
+    return level;
+}
 function parseConfigProviderValue(value, fieldPath) {
     if (value === undefined || value === null) {
         return undefined;
@@ -255,8 +273,13 @@ export function assertWriterProvidersConfigured(cwd = process.cwd(), options = {
         throw new WriterProvidersNotConfiguredError(options.guidance ?? 'writer-run', missingProviderKeys);
     }
     assertAgentConfigSupportsWriterRun(agentConfig, { context: options.context });
+    getReviewLevel(cwd);
     return agentConfig;
 }
+export function getReviewLevel(cwd = process.cwd()) {
+    const config = loadConfigFile(cwd);
+    return parseReviewLevelValue(config.neal?.review_level, 'neal.review_level') ?? DEFAULT_CONFIG.neal.review_level;
+}
 export function getInactivityTimeoutMs(cwd = process.cwd()) {
     const config = loadConfigFile(cwd);
     return (parseNumberValue(config.neal?.inactivity_timeout_ms) ??

package/dist/neal/context/inline-review-context.js

@@ -4,6 +4,122 @@ import { getProviderDefinition, isRegisteredProviderId } from '../providers/regi
 // truncation posture of truncateForPrompt in src/neal/agents/structured-json.ts:
 // truncate with an explicit marker instead of silently dropping content.
 export const INLINE_SECTION_MAX_CHARS = 200_000;
+// Fixed aggregate character budget for the free-text values of one
+// agent-authored payload embedded in another agent's prompt (review-finding
+// text, progress justifications, completion summaries). The budget covers the
+// total rendered free text including truncation markers, so the free-text
+// contribution of a section never exceeds this constant. Control data (ids,
+// severities, statuses, file paths) never rides this budget: callers render it
+// separately and exactly via boundOpenFindingsForPrompt-style wrappers.
+export const AGENT_FREE_TEXT_SECTION_MAX_CHARS = 20_000;
+// Upper bound on one rendered truncation marker:
+// '\n[truncated N character(s)]' with N at most 16 digits.
+const TRUNCATION_MARKER_MAX_CHARS = 42;
+// Maximum open findings presented to the coder per response round. Response
+// selection (getExecuteResponseOpenFindings and the plan-review response
+// phase) and prompt rendering share this bound, so the coder always sees
+// exactly the finding set it must disposition; findings beyond the limit stay
+// open and are presented in later response rounds until every one is handled.
+// The limit also keeps boundFreeTextValues' cardinality precondition
+// satisfied: 3 free-text values per finding times this limit stays far under
+// AGENT_FREE_TEXT_SECTION_MAX_CHARS / TRUNCATION_MARKER_MAX_CHARS.
+export const OPEN_FINDINGS_PROMPT_ITEM_LIMIT = 50;
+function renderBoundedFreeTextValue(text, cap) {
+    if (text.length <= cap) {
+        return text;
+    }
+    if (cap <= 0) {
+        return `[truncated ${text.length} character(s)]`;
+    }
+    return `${text.slice(0, cap)}\n[truncated ${text.length - cap} character(s)]`;
+}
+// Largest equal per-value kept-character cap such that the values fit the
+// kept-character budget (water-filling): short values keep their full text and
+// long values share the remaining budget equally. Returns MAX_SAFE_INTEGER
+// when everything already fits.
+function computeFairValueCap(lengths, budget) {
+    const sorted = [...lengths].sort((left, right) => left - right);
+    let remaining = budget;
+    for (let index = 0; index < sorted.length; index += 1) {
+        const share = Math.floor(remaining / (sorted.length - index));
+        if (sorted[index] > share) {
+            return Math.max(share, 0);
+        }
+        remaining -= sorted[index];
+    }
+    return Number.MAX_SAFE_INTEGER;
+}
+// Bounds a fixed list of agent-authored free-text values to a fixed aggregate
+// budget, truncation markers included: marker allowance is reserved up front,
+// the kept characters are water-filled over the rest, so the total rendered
+// length is always <= budget. Positions are preserved one-to-one with the
+// input. Callers keep control data (ids, files, severities) out of this list
+// and enforce the finite cardinality this validates. Never mutates the input.
+export function boundFreeTextValues(texts, budget = AGENT_FREE_TEXT_SECTION_MAX_CHARS) {
+    if (texts.length * TRUNCATION_MARKER_MAX_CHARS > budget) {
+        throw new Error(`boundFreeTextValues received ${texts.length} free-text values; the aggregate budget of ${budget} characters supports at most ${Math.floor(budget / TRUNCATION_MARKER_MAX_CHARS)}. Bound the payload's item cardinality before rendering free text.`);
+    }
+    const keptBudget = budget - texts.length * TRUNCATION_MARKER_MAX_CHARS;
+    const cap = computeFairValueCap(texts.map((text) => text.length), keptBudget);
+    return texts.map((text) => renderBoundedFreeTextValue(text, cap));
+}
+// Render-only view of an open-findings list for prompt embedding. Every
+// finding renders: id, source, and severity are copied exactly, each files
+// path renders whole with the list length bounded via boundChangedFileList,
+// and only the claim, requiredAction, and roundSummary free text shares the
+// fixed aggregate budget. Callers must present at most
+// OPEN_FINDINGS_PROMPT_ITEM_LIMIT findings — the same bounded set their
+// response processing validates against — so this never drops a finding the
+// coder is required to disposition; it throws on a larger list instead of
+// silently diverging from the response contract. Never mutates the input.
+export function boundOpenFindingsForPrompt(findings) {
+    if (findings.length > OPEN_FINDINGS_PROMPT_ITEM_LIMIT) {
+        throw new Error(`boundOpenFindingsForPrompt received ${findings.length} findings; response rounds present at most ${OPEN_FINDINGS_PROMPT_ITEM_LIMIT}. Bound the selection where the response set is chosen.`);
+    }
+    const boundedTexts = boundFreeTextValues(findings.flatMap((finding) => [finding.claim, finding.requiredAction, finding.roundSummary]));
+    return findings.map((finding, index) => ({
+        ...finding,
+        claim: boundedTexts[index * 3],
+        requiredAction: boundedTexts[index * 3 + 1],
+        roundSummary: boundedTexts[index * 3 + 2],
+        files: boundChangedFileList(finding.files),
+    }));
+}
+// Maximum commit subjects rendered per commit-subject list that reaches a
+// prompt (the aggregate completion range and the scope review's commits-in-scope
+// list). Matches CHANGED_FILE_LIST_LIMIT so both run-scaling list bounds read
+// the same way.
+export const COMMIT_SUBJECT_LIST_LIMIT = 20;
+// Character cap for one rendered git summary block that grows with run length
+// (diff-stat output, one line per file). Applied via truncateInlineSectionBody,
+// so an over-cap block carries an explicit truncation marker.
+export const GIT_SUMMARY_SECTION_MAX_CHARS = 20_000;
+// Bounds a commit-subject list for prompt rendering: the first
+// COMMIT_SUBJECT_LIST_LIMIT subjects render with their text sharing the fixed
+// aggregate free-text budget (subjects are largely agent-authored), and the
+// rest collapse to an explicit "(+N more)" entry. The underlying arrays keep
+// every subject for non-prompt consumers. Never mutates the input.
+export function boundCommitSubjectList(subjects) {
+    const kept = boundFreeTextValues(subjects.slice(0, COMMIT_SUBJECT_LIST_LIMIT));
+    if (subjects.length <= COMMIT_SUBJECT_LIST_LIMIT) {
+        return kept;
+    }
+    return [...kept, `(+${subjects.length - COMMIT_SUBJECT_LIST_LIMIT} more)`];
+}
+// Maximum file paths rendered per changed-file list that reaches a prompt.
+// Matches the reviewer continuity packet's per-scope bound
+// (COMPLETED_SCOPE_CHANGED_FILE_LIMIT in src/neal/context/reviewer-context.ts).
+export const CHANGED_FILE_LIST_LIMIT = 20;
+// Bounds a changed-file list for prompt rendering: the first
+// CHANGED_FILE_LIST_LIMIT entries render and the rest collapse to an explicit
+// "(+N more)" marker entry. Callers join or JSON-embed the result; the
+// underlying arrays in state and packets keep every path.
+export function boundChangedFileList(files, limit = CHANGED_FILE_LIST_LIMIT) {
+    if (files.length <= limit) {
+        return [...files];
+    }
+    return [...files.slice(0, limit), `(+${files.length - limit} more)`];
+}
 // Canonical forbidden-phrase list for no-read prompts (today: the blocked-run
 // consultant, which always judges from Neal-inlined in-memory context). A
 // no-read prompt must contain no instruction that requires repository, file,

package/dist/neal/final-completion.js

@@ -1,11 +1,12 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getFinalCompletionContinueExecutionMax } from './config.js';
+import { boundChangedFileList } from './context/inline-review-context.js';
 import { getChangedFilesForRange, getCommitRange, getCommitSubjects, getDiffStatForRange, } from './git.js';
 import { toResidualReviewDebt } from './review-debt.js';
 import { buildScopeAccountingSummary, getCurrentScopeLabel } from './scopes.js';
 import { getDerivedPlanView, getFinalCompletionView } from './state-views.js';
-import { extractVerificationCommandResults, latestCommandResultPerCommand, summarizeVerificationCommandResults, } from './verification-events.js';
+import { buildVerificationTally, extractVerificationCommandResults, } from './verification-events.js';
 function getEventsPath(runDir) {
     return join(runDir, 'events.ndjson');
 }
@@ -27,7 +28,7 @@ function renderCompletedScopeSummary(scopes) {
     return scopes
         .map((scope) => {
         const changedFiles = scope.changedFiles.length > 0
-            ? `${scope.changedFiles.length} file(s): ${scope.changedFiles.join(', ')}`
+            ? `${scope.changedFiles.length} file(s): ${boundChangedFileList(scope.changedFiles).join(', ')}`
             : 'no changed files';
         const commit = scope.finalCommit ?? 'pending';
         const parent = scope.derivedFromParentScope ? ` | parent ${scope.derivedFromParentScope}` : '';
@@ -191,8 +192,6 @@ export async function buildFinalCompletionPacket(args) {
     const finalCommit = terminalScope?.finalCommit ?? args.state.finalCommit;
     const effectiveScopes = mergeCompletedScopesWithTerminalScope(args.state, terminalScope);
     const allVerificationCommandResults = await loadVerificationCommandResults(args.state.runDir);
-    const verificationCommandResults = latestCommandResultPerCommand(allVerificationCommandResults);
-    const verificationCommands = verificationCommandResults.map((result) => result.command);
     const scopeAccounting = buildScopeAccountingSummary(effectiveScopes);
     const terminalChangedFiles = [...(terminalScope?.changedFiles ?? [])];
     const planChangedFiles = uniqueFiles(effectiveScopes
@@ -219,9 +218,7 @@ export async function buildFinalCompletionPacket(args) {
         planChangedFilesSummary: summarizeChangedFiles(planChangedFiles),
         residualReviewDebt,
         residualReviewDebtSummary: summarizeResidualReviewDebt(effectiveScopes),
-        verificationCommands,
-        verificationCommandResults,
-        verificationSummary: summarizeVerificationCommandResults(verificationCommandResults),
+        verificationTally: buildVerificationTally(allVerificationCommandResults),
         lastNonEmptyImplementationScope: findLastNonEmptyImplementationScope(effectiveScopes, terminalScope, args.state),
         continueExecutionCount: finalCompletion?.continueExecutionCount ?? 0,
         continueExecutionMax: Math.max(0, getFinalCompletionContinueExecutionMax(args.state.cwd)),