@navels/neal 0.1.0 → 0.3.0

package/dist/neal/adjudicator/planning.js

@@ -1,16 +1,18 @@
 import { resolve } from 'node:path';
 import { runCoderPlanResponseRound, runPlanReviewerRound } from '../agents.js';
-import { createInlineSection, readTextForInlineSection, reviewerNeedsInlineContext, } from '../context/inline-review-context.js';
+import { readTextForInlineSection } from '../context/inline-review-context.js';
 import { buildAndPersistReviewerContextPacket } from '../context/reviewer-context.js';
 import { getProviderDefinition } from '../providers/registry.js';
 import { getDerivedPlanView } from '../state-views.js';
+import { findCanonicalId, getNextCanonicalIndex, getOpenBlockingCanonicalSet, getReopenedCanonical, hasRepeatedUnresolvedBlockingCanonicalsForWindow, isOpenBlockingFinding, isOpenNonBlockingFinding, } from './execute.js';
+import { toPlanReviewDebt } from '../review-debt.js';
 import { getAdjudicationSpec } from './specs.js';
 export function isDerivedPlanReviewState(state) {
     return getDerivedPlanView(state)?.reviewActive ?? false;
 }
 // The planner role runs through the coder adapter, so its session-resume capability comes from
 // the provider's coder capabilities. Providers that declare `supportsSessionResume: false`
-// (openai-compatible, generic-agentic) never persist a planner session handle — a null handle is
+// (openai-compatible) never persist a planner session handle — a null handle is
 // their expected steady state, so top-level plan-refinement responses must start a fresh planner
 // session for them instead of treating the missing handle as corrupted state. Resume-capable
 // planner providers keep the hard invariant: a missing handle there is a genuine violation.
@@ -39,18 +41,263 @@ export function resolvePlanningAdjudicationContext(state) {
         derivedFromScopeNumber: derivedPlanReview && derivedPlan ? derivedPlan.parentScopeNumber : null,
     };
 }
-async function buildPlanReviewerInlineContext(args) {
-    const planContent = await readTextForInlineSection(resolve(args.state.cwd, args.reviewedPlanPath));
-    const sections = [
-        createInlineSection(`Reviewed plan document content (${args.reviewedPlanPath})`, planContent || '(plan document content unavailable)'),
-    ];
-    if (args.context.reviewMode === 'derived-plan' && args.context.parentPlanDoc) {
-        const parentPlanContent = await readTextForInlineSection(resolve(args.state.cwd, args.context.parentPlanDoc));
-        sections.push(createInlineSection(`Parent plan document content (${args.context.parentPlanDoc})`, parentPlanContent || '(parent plan document content unavailable)'));
+// Mirrors resolveExecuteReviewDisposition in adjudicator/execute.ts: one resolver derives every
+// disposition-dependent value runPlanReviewPhase persists (plus the transition signal it asserts)
+// from the same condition set, so the five outcomes can never drift apart.
+// The plan-review acceptance transition, reused by clean acceptance and by the
+// accept-with-recorded-reservations landing so both emit identical transition
+// signals (`accept_plan` for top-level plan review, `accept_derived_plan` for a
+// derived-plan review) — no adjudication-spec change is needed.
+function planReviewAcceptanceDisposition(derivedPlanReview, currentDerivedPlanStatus) {
+    if (derivedPlanReview) {
+        return {
+            planningSignal: 'accept_derived_plan',
+            phase: 'awaiting_derived_plan_execution',
+            status: 'running',
+            derivedPlanStatus: 'accepted',
+            blockedFromPhase: null,
+        };
     }
-    const reviewHistory = await readTextForInlineSection(resolve(args.state.cwd, args.reviewMarkdownPath));
-    sections.push(createInlineSection('Prior review history (REVIEW.md content)', reviewHistory || '(no prior review history)'));
-    return { sections };
+    return {
+        planningSignal: 'accept_plan',
+        phase: 'done',
+        status: 'done',
+        derivedPlanStatus: currentDerivedPlanStatus,
+        blockedFromPhase: null,
+    };
+}
+export function resolvePlanReviewDisposition(args) {
+    if (args.shouldBlockForConvergence) {
+        return {
+            planningSignal: 'block_for_operator',
+            phase: 'blocked',
+            status: 'blocked',
+            derivedPlanStatus: args.currentDerivedPlanStatus,
+            blockedFromPhase: 'reviewer_plan',
+        };
+    }
+    // Round-forcing blocking findings keep their precedence over the
+    // accept-with-debt landing: any open plan-correctness / non-convertible /
+    // repeat blocker still forces a revision round (or blocks at the cap), even
+    // when convertible hardening findings are also present. Because roundForcing
+    // and landAcceptedWithDebt are mutually exclusive, no guard is needed here.
+    if (args.hasRoundForcingBlockingFindings) {
+        return {
+            planningSignal: args.reachedMaxRounds ? 'block_for_operator' : 'request_revision',
+            phase: args.reachedMaxRounds ? 'blocked' : 'coder_plan_response',
+            status: args.reachedMaxRounds ? 'blocked' : 'running',
+            derivedPlanStatus: args.currentDerivedPlanStatus,
+            blockedFromPhase: args.reachedMaxRounds ? 'reviewer_plan' : null,
+        };
+    }
+    if (args.landAcceptedWithDebt) {
+        return planReviewAcceptanceDisposition(args.derivedPlanReview, args.currentDerivedPlanStatus);
+    }
+    if (args.hasOpenNonBlockingFindings) {
+        return {
+            planningSignal: 'optional_revision',
+            phase: 'coder_plan_optional_response',
+            status: 'running',
+            derivedPlanStatus: args.currentDerivedPlanStatus,
+            blockedFromPhase: null,
+        };
+    }
+    return planReviewAcceptanceDisposition(args.derivedPlanReview, args.currentDerivedPlanStatus);
+}
+// Pure, class- and novelty-aware partition of the current round's open blocking
+// findings, shared by the arrival-time conversion and the disposition-time
+// landing. The debt-convertibility predicate depends on whether we are at the
+// round cap:
+//   Pre-cap (atCap === false): verification_hardening (an explicit match — an
+//   absent/undefined class never converts) AND first-occurrence of the canonical
+//   (its minimum round across all merged findings equals the current round) AND
+//   round >= threshold. Everything else is round-forcing: plan_correctness or any
+//   non-hardening/absent class, OR any repeat occurrence of an existing canonical
+//   (which still forces a revision round), OR below threshold.
+//   At the cap (atCap === true): there are no rounds left to force, so the
+//   predicate is class-only — every open verification_hardening finding converts
+//   to debt regardless of first-occurrence or threshold, and only a
+//   plan_correctness / non-hardening / absent-class finding stays round-forcing
+//   (which terminal-blocks the run). A re-litigated-but-not-reopened hardening
+//   point therefore converts at the cap rather than failing the run.
+// The explicit-hardening gate is the system-wide fail-safe: an unclassified
+// finding is always round-forcing (blocking). The 3-round reopen and stall
+// terminal blocks are handled separately by shouldBlockForConvergence, which
+// keeps precedence over this partition, so a re-opened or stalled hardening
+// finding — even at the cap — keeps blocking rather than converting.
+export function classifyPlanReviewConvergence(args) {
+    const minRoundByCanonical = new Map();
+    for (const finding of args.mergedFindings) {
+        const existing = minRoundByCanonical.get(finding.canonicalId);
+        if (existing === undefined || finding.round < existing) {
+            minRoundByCanonical.set(finding.canonicalId, finding.round);
+        }
+    }
+    const debtConvertible = [];
+    const roundForcing = [];
+    for (const finding of args.mergedFindings.filter(isOpenBlockingFinding)) {
+        const isHardening = finding.findingClass === 'verification_hardening';
+        const firstOccurrence = minRoundByCanonical.get(finding.canonicalId) === args.round;
+        const convertible = args.atCap
+            ? isHardening
+            : isHardening && firstOccurrence && args.round >= args.debtRoundThreshold;
+        if (convertible) {
+            debtConvertible.push(finding);
+        }
+        else {
+            roundForcing.push(finding);
+        }
+    }
+    return {
+        debtConvertible,
+        roundForcing,
+        landAcceptedWithDebt: roundForcing.length === 0 && debtConvertible.length > 0,
+    };
+}
+// A derived-plan review is split-plan recovery; frame its block reasons so an
+// operator sees that the recovery (not the top-level plan) failed to converge.
+// `derivedPlanReview` is exactly `isDerivedPlanReviewState(state)` (both read
+// `getDerivedPlanView(state)?.reviewActive`), so callers pass the boolean they
+// already resolved from the planning adjudication context.
+export function getDerivedPlanBlockedReason(derivedPlanReview, reason) {
+    if (!derivedPlanReview) {
+        return reason;
+    }
+    return `split-plan recovery failed to converge: ${reason}`;
+}
+// The single pure gating/disposition policy for a plan-review round, shared by
+// the runtime (synthesizePlanReviewRound, which assigns canonicals from the
+// reviewer's raw inputs) and the replay harness (which supplies findings with
+// trusted, recorded canonical IDs). Given the current round's already-assigned
+// findings plus the prior findings on state.findings, it derives the merged set,
+// open sets, convergence signals, disposition, blockReason, and round record. It
+// performs no file, git, agent, or configuration IO; the shared stall helper is
+// invoked through its window-taking pure variant.
+export function synthesizePlanReviewRoundFromFindings(args) {
+    const { findings } = args;
+    const rawMergedFindings = [...args.state.findings, ...findings];
+    const reachedMaxRounds = args.round >= args.roundLimit;
+    const rawOpenBlockingCanonicalSet = getOpenBlockingCanonicalSet(rawMergedFindings);
+    // The convergence block (reopen / stall) is derived from the pre-conversion
+    // merged set and keeps precedence over the accept-with-debt landing.
+    const stalledBlockingCount = hasRepeatedUnresolvedBlockingCanonicalsForWindow({
+        rounds: args.state.rounds,
+        currentOpenBlockingCanonicals: rawOpenBlockingCanonicalSet,
+        reviewStuckWindow: args.reviewStuckWindow,
+    });
+    const reopenedCanonical = getReopenedCanonical(rawMergedFindings);
+    const shouldBlockForConvergence = Boolean(reopenedCanonical || stalledBlockingCount);
+    // Class- and novelty-aware partition of the open blocking findings. Pre-cap, a
+    // first-occurrence past-threshold hardening finding is debt-convertible; at the
+    // cap (reachedMaxRounds) every open hardening finding is convertible regardless
+    // of first-occurrence, so a re-litigated-but-not-reopened hardening point
+    // converts instead of failing the run. When every open blocking finding is
+    // convertible (and none is round-forcing), the round lands accepted-with-debt
+    // and those findings convert to deferred plan-review debt so they leave the
+    // open set.
+    const convergence = classifyPlanReviewConvergence({
+        mergedFindings: rawMergedFindings,
+        round: args.round,
+        debtRoundThreshold: args.debtRoundThreshold,
+        atCap: reachedMaxRounds,
+    });
+    // Drive the blocking gate off the merged open round-forcing set, not the
+    // current reviewer payload. An empty reviewer round over a prior still-open
+    // blocker must keep forcing a revision (or block at the cap), never accept.
+    const hasRoundForcingBlockingFindings = convergence.roundForcing.length > 0;
+    const disposition = resolvePlanReviewDisposition({
+        shouldBlockForConvergence,
+        hasRoundForcingBlockingFindings,
+        landAcceptedWithDebt: !shouldBlockForConvergence && convergence.landAcceptedWithDebt,
+        reachedMaxRounds,
+        hasOpenNonBlockingFindings: rawMergedFindings.some(isOpenNonBlockingFinding),
+        derivedPlanReview: args.derivedPlanReview,
+        currentDerivedPlanStatus: args.currentDerivedPlanStatus,
+    });
+    // Arrival-time debt conversion (Scope 4): pre-cap, a first-occurrence
+    // past-threshold hardening finding banks as deferred plan-review debt the moment
+    // it arrives, even when a co-occurring plan_correctness / repeat finding forces a
+    // revision this round — so novelty-bounded hardening asks never extend the round
+    // count. At the cap the convertible set is class-based (every open hardening
+    // finding), but it only banks when the round actually lands accepted-with-debt: a
+    // co-occurring plan_correctness finding terminal-blocks instead of converting.
+    // The convergence block (reopen/stall) keeps precedence: when it fires nothing
+    // converts, so a re-opened or stalled hardening finding keeps blocking. The
+    // open-blocking round record then reflects the post-flip set.
+    const shouldConvertDebt = !shouldBlockForConvergence &&
+        (reachedMaxRounds ? convergence.landAcceptedWithDebt : convergence.debtConvertible.length > 0);
+    const convertedIds = new Set(shouldConvertDebt ? convergence.debtConvertible.map((finding) => finding.id) : []);
+    const mergedFindings = convertedIds.size
+        ? rawMergedFindings.map((finding) => convertedIds.has(finding.id) ? { ...finding, status: 'deferred' } : finding)
+        : rawMergedFindings;
+    const openBlockingCanonicalSet = convertedIds.size
+        ? getOpenBlockingCanonicalSet(mergedFindings)
+        : rawOpenBlockingCanonicalSet;
+    const openBlockingCanonicalIds = [...openBlockingCanonicalSet].sort();
+    const openBlockingCanonicalCount = openBlockingCanonicalSet.size;
+    const blockReason = reopenedCanonical
+        ? getDerivedPlanBlockedReason(args.derivedPlanReview, `review_stuck: blocking finding ${reopenedCanonical} reopened across multiple reviewer rounds`)
+        : stalledBlockingCount
+            ? getDerivedPlanBlockedReason(args.derivedPlanReview, `review_stuck: blocking findings did not decrease across ${args.reviewStuckWindow} consecutive reviewer rounds`)
+            : reachedMaxRounds && hasRoundForcingBlockingFindings
+                ? getDerivedPlanBlockedReason(args.derivedPlanReview, `reached max review rounds (${args.roundLimit}) with blocking findings still open`)
+                : null;
+    return {
+        findings,
+        mergedFindings,
+        disposition,
+        blockReason,
+        openBlockingCanonicalCount,
+        planReviewDebt: toPlanReviewDebt(mergedFindings),
+        roundRecord: {
+            round: args.round,
+            reviewerSessionHandle: args.reviewerSessionHandle,
+            reviewedPlanPath: args.reviewedPlanPath,
+            normalizationApplied: args.normalizationApplied,
+            normalizationOperations: args.normalizationOperations,
+            normalizationScopeLabelMappings: args.normalizationScopeLabelMappings,
+            commitRange: args.commitRange,
+            openBlockingCanonicalCount,
+            openBlockingCanonicalIds,
+            findings: findings.map((finding) => finding.id),
+        },
+    };
+}
+// Runtime plan-review round core, mirroring synthesizeExecuteReviewerState in
+// adjudicator/execute.ts: it assigns canonical IDs to the reviewer's raw finding
+// inputs (via findCanonicalId), then routes them through the shared
+// synthesizePlanReviewRoundFromFindings policy above, so runtime and replay can
+// never drift apart. Config is resolved by the caller (reviewStuckWindow) so this
+// stays IO-free.
+export function synthesizePlanReviewRound(args) {
+    let nextCanonicalIndex = getNextCanonicalIndex(args.state.findings);
+    const findings = args.findingInputs.map((finding, index) => {
+        const canonicalId = findCanonicalId(args.state.findings, finding) ?? `C${nextCanonicalIndex++}`;
+        return {
+            ...finding,
+            id: `R${args.round}-F${index + 1}`,
+            canonicalId,
+            status: 'open',
+            coderDisposition: null,
+            coderCommit: null,
+        };
+    });
+    return synthesizePlanReviewRoundFromFindings({
+        state: args.state,
+        round: args.round,
+        roundLimit: args.roundLimit,
+        reviewStuckWindow: args.reviewStuckWindow,
+        debtRoundThreshold: args.debtRoundThreshold,
+        derivedPlanReview: args.derivedPlanReview,
+        currentDerivedPlanStatus: args.currentDerivedPlanStatus,
+        reviewerSessionHandle: args.reviewerSessionHandle,
+        reviewedPlanPath: args.reviewedPlanPath,
+        normalizationApplied: args.normalizationApplied,
+        normalizationOperations: args.normalizationOperations,
+        normalizationScopeLabelMappings: args.normalizationScopeLabelMappings,
+        commitRange: args.commitRange,
+        findings,
+    });
 }
 export async function runPlanningReviewerAdjudication(args) {
     const context = resolvePlanningAdjudicationContext(args.state);
@@ -58,22 +305,16 @@ export async function runPlanningReviewerAdjudication(args) {
         planPath: context.reviewTargetPath,
         normalizedPlanPath: args.normalizedPlanPath,
     });
-    // Plan and review-history contents are inlined only for reviewers without
-    // repository read access; read-capable reviewers inspect them directly.
-    const inlineContext = reviewerNeedsInlineContext(args.state.agentConfig.reviewer)
-        ? await buildPlanReviewerInlineContext({
-            state: args.state,
-            context,
-            reviewedPlanPath: preparedReview.reviewedPlanPath,
-            reviewMarkdownPath: args.reviewMarkdownPath,
-        })
-        : null;
     const reviewedPlanContent = await readTextForInlineSection(resolve(args.state.cwd, preparedReview.reviewedPlanPath));
     const parentPlanContent = context.reviewMode === 'derived-plan' && context.parentPlanDoc
         ? await readTextForInlineSection(resolve(args.state.cwd, context.parentPlanDoc))
         : null;
     const reviewerResult = await (args.runReviewerRound ?? runPlanReviewerRound)({
         reviewer: args.state.agentConfig.reviewer,
+        // Resume the reviewer's own session from the previous refinement round
+        // (null on round 1: fresh runs and split-plan recovery both clear it).
+        // Sessionless providers are filtered at the round layer.
+        resumeHandle: args.state.reviewerSessionHandle,
         cwd: args.state.cwd,
         planDoc: preparedReview.reviewedPlanPath,
         round: args.round,
@@ -84,7 +325,6 @@ export async function runPlanningReviewerAdjudication(args) {
         reviewerContext: await buildAndPersistReviewerContextPacket({ state: args.state }),
         reviewedPlanContent,
         parentPlanContent,
-        inlineContext,
         unattended: args.state.unattended,
         // Reinforce an author-declared `one_shot` only for the top-level authored plan; derived
         // plans declare and own their own shape and are never clamped.

package/dist/neal/agents/prompts.js

@@ -1,7 +1,7 @@
 import { assertNoReadPromptInstructionText, renderInlineReviewerContext, } from '../context/inline-review-context.js';
-import { renderReviewerContextMarkdown } from '../context/reviewer-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 { 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';
 export { buildFinalCompletionReviewerPrompt, buildFinalCompletionSummaryPrompt, } from '../prompts/specialized.js';
@@ -10,16 +10,18 @@ export const AUTONOMY_CHUNK_DONE = SHARED_AUTONOMY_CHUNK_DONE;
 export const AUTONOMY_DONE = SHARED_AUTONOMY_DONE;
 export const AUTONOMY_SCOPE_DONE = SHARED_AUTONOMY_SCOPE_DONE;
 export const AUTONOMY_SPLIT_PLAN = SHARED_AUTONOMY_SPLIT_PLAN;
-// Single no-read-safe prompt variant for the read-only blocked-run adjudicator.
+// Single no-read-safe prompt variant for the read-only blocked-run consultant.
 // It generalizes across every triaged block class (a coder-blocked signal or a
 // reviewer `review_stuck` deadlock): it takes a NON-null InlineReviewerContext
 // (the round runner narrows before calling it) and judges entirely from whatever
 // sections that context supplies, making no assumptions about which sections are
 // present. The static Neal-authored instructions must never reference
 // repository/file/shell access, so they pass through the shared no-read guard.
-export function buildBlockedAdjudicatorPrompt(args) {
+export function buildConsultantPrompt(args) {
+    const spec = assertPromptBuilder('consultant', 'buildConsultantPrompt', 'src/neal/agents/prompts.ts');
+    resolvePrimaryVariant(spec, 'consultant');
     const staticInstructionLines = [
-        'You are a read-only adjudicator for a blocked neal run. The run has stopped because a coder or reviewer turn reported a blocker it could not resolve on its own.',
+        'You are a read-only consultant for a blocked neal run. The run has stopped because a coder or reviewer turn reported a blocker it could not resolve on its own.',
         'Judge entirely from the inlined context sections below. You make no changes, run nothing, and look at nothing outside this prompt.',
         'Decide whether the block is an autonomously recoverable misunderstanding that can be resolved WITHIN the existing scope, or a genuine wall that must escalate to a human.',
         'Return `recoverable:true` with `triageCategory:"misunderstanding"` and a concrete, in-scope `resolutionDirective` ONLY when ALL of these hold:',
@@ -34,7 +36,7 @@ export function buildBlockedAdjudicatorPrompt(args) {
         'If the inlined context lists specific blocking findings, set `targetCanonicalIds` to the canonical ids your verdict addresses; otherwise leave it empty.',
         'Always provide a non-empty `rationale` explaining the triage.',
     ];
-    assertNoReadPromptInstructionText(staticInstructionLines.join('\n'), 'buildBlockedAdjudicatorPrompt');
+    assertNoReadPromptInstructionText(staticInstructionLines.join('\n'), 'buildConsultantPrompt');
     return [
         ...staticInstructionLines,
         '',
@@ -44,16 +46,6 @@ export function buildBlockedAdjudicatorPrompt(args) {
         renderInlineReviewerContext(args.inlineContext),
     ].join('\n');
 }
-function getReviewerContextLines(reviewerContext, mode = 'tool-access') {
-    if (!reviewerContext) {
-        return [];
-    }
-    return [
-        '',
-        'Bounded current-run continuity context:',
-        mode === 'inline' ? renderReviewerContextMarkdown(reviewerContext, { mode: 'inline' }) : reviewerContext.promptMarkdown,
-    ];
-}
 export function buildBlockedRecoveryCoderPrompt(args) {
     const allowReplacement = args.allowReplacement ?? true;
     const actionLines = [

package/dist/neal/agents/rounds.js

@@ -2,12 +2,12 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { getAgentTurnRetryLimit, getAgentTurnStartupTimeoutMs, getApiRetryLimit, getInactivityTimeoutMs, } from '../config.js';
 import { runWithAgentTurnLiveness } from '../providers/liveness.js';
 import { normalizeExecutionShapeDeclaration } from '../plan-validation.js';
-import { getCoderAdapter, getStructuredAdvisorAdapter } from '../providers/registry.js';
+import { getCoderAdapter, getProviderDefinition, getStructuredAdvisorAdapter } from '../providers/registry.js';
 import { createProviderTelemetrySink } from '../providers/telemetry.js';
 import { isNealProviderError, NealProviderError } from '../providers/types.js';
-import { getReviewerDoctrineAccessMode, reviewerNeedsInlineContext, } from '../context/inline-review-context.js';
-import { AUTONOMY_BLOCKED, AUTONOMY_CHUNK_DONE, AUTONOMY_DONE, AUTONOMY_SCOPE_DONE, AUTONOMY_SPLIT_PLAN, buildBlockedRecoveryCoderPrompt, buildCoderResponsePrompt, buildCoderPlanResponsePrompt, buildFinalCompletionReviewerPrompt, buildFinalCompletionSummaryPrompt, buildLegacyScopePrompt, buildLegacyPlanningPrompt, buildPlanReviewerPrompt, buildPlanningPrompt, buildReviewerPrompt, buildBlockedAdjudicatorPrompt, buildScopePrompt, } from './prompts.js';
-import { buildCoderBlockedRecoveryDispositionSchema, buildCoderPlanSchema, buildCoderScopeSchema, buildCoderPlanResponseSchema, buildCoderResponseSchema, buildBlockedAdjudicatorSchema, buildFinalCompletionSummarySchema, buildFinalCompletionReviewerSchema, buildPlanReviewerSchema, buildReviewerSchema, parseExecuteScopeProgressPayload, parseFinalCompletionReviewerPayload, parseFinalCompletionSummaryPayload, stripExecuteScopeProgressPayload, validateCoderBlockedRecoveryDispositionPayload, validateCoderPlanPayload, validateCoderPlanResponsePayload, validateCoderResponsePayload, validateCoderScopePayload, validatePlanReviewerPayload, validateBlockedAdjudicatorVerdictPayload, validateReviewerPayload, } from './schemas.js';
+import { getReviewerDoctrineAccessMode, } from '../context/inline-review-context.js';
+import { AUTONOMY_BLOCKED, AUTONOMY_CHUNK_DONE, AUTONOMY_DONE, AUTONOMY_SCOPE_DONE, AUTONOMY_SPLIT_PLAN, buildBlockedRecoveryCoderPrompt, buildCoderResponsePrompt, buildCoderPlanResponsePrompt, buildFinalCompletionReviewerPrompt, buildFinalCompletionSummaryPrompt, buildLegacyScopePrompt, buildLegacyPlanningPrompt, buildPlanReviewerPrompt, buildPlanningPrompt, buildReviewerPrompt, buildConsultantPrompt, buildScopePrompt, } from './prompts.js';
+import { buildCoderBlockedRecoveryDispositionSchema, buildCoderPlanSchema, buildCoderScopeSchema, buildCoderPlanResponseSchema, buildCoderResponseSchema, buildConsultantSchema, buildFinalCompletionSummarySchema, buildFinalCompletionReviewerSchema, buildPlanReviewerSchema, buildReviewerSchema, parseExecuteScopeProgressPayload, parseFinalCompletionReviewerPayload, parseFinalCompletionSummaryPayload, stripExecuteScopeProgressPayload, validateCoderBlockedRecoveryDispositionPayload, validateCoderPlanPayload, validateCoderPlanResponsePayload, validateCoderResponsePayload, validateCoderScopePayload, validatePlanReviewerPayload, validateConsultantVerdictPayload, validateReviewerPayload, } from './schemas.js';
 import { runCoderStructuredPrompt, translateCoderProviderError } from './structured-coder.js';
 export class ReviewerRoundError extends Error {
     sessionHandle;
@@ -110,37 +110,20 @@ function createStructuredAdvisorProviderEventSink(args) {
         cwd: args.cwd,
     });
 }
-// Fail-fast guard for reviewer rounds whose prompts still contain
-// repository/tool-access instructions. A reviewer provider without read tool
-// access must never receive such a prompt: either the round supplies
-// Neal-inlined reviewer context (inlineContextSupplied), or the round must
-// reject the configuration with a clear error instead of silently sending
-// instructions the provider cannot follow. Every reviewer round label now
-// supports inline context, but a call site that fails to supply it for a
-// no-read reviewer must still fail fast here.
-//
-// The guard throws a ReviewerRoundError backed by a non-retryable
-// NealProviderError with sessionHandle: null so it flows through the same
-// orchestrator reviewer failure path as any other reviewer round failure
-// (persisted failed state, written artifacts, logged phase errors).
-function assertReviewerRoundSupportsNoReadReviewer(args) {
-    if (args.inlineContextSupplied || !reviewerNeedsInlineContext(args.reviewer)) {
-        return;
+// Resolves the session handle a reviewer round may resume: the previous
+// round's handle when the provider's structured-advisor capability declares
+// session resume, null otherwise (sessionless providers like
+// openai-compatible must never receive one — openai-compatible treats a
+// non-null resume handle as corrupted state).
+// Reviewer continuity within a review engagement is the original design:
+// a continuing reviewer converges like a human-shuttled review chat, while
+// a cold-started reviewer re-audits from scratch every round.
+export function resolveReviewerResumeHandle(reviewer, resumeHandle) {
+    if (!resumeHandle) {
+        return null;
     }
-    throw new ReviewerRoundError(new NealProviderError({
-        message: [
-            `Reviewer provider ${JSON.stringify(args.reviewer.provider)} has no repository read access,`,
-            `and the ${args.label} reviewer round did not receive Neal-inlined reviewer context,`,
-            'so its prompt would contain repository-access instructions the provider cannot follow.',
-            'Configure a read-capable reviewer provider (agent.reviewer.provider) for runs that reach',
-            `${args.label} rounds until this round supports inline reviewer context.`,
-        ].join(' '),
-        provider: args.reviewer.provider,
-        role: 'structured-advisor',
-        sessionHandle: null,
-        kind: 'provider_failed',
-        retryable: false,
-    }));
+    const capabilities = getProviderDefinition(reviewer.provider).capabilities['structured-advisor'];
+    return capabilities.supported && capabilities.supportsSessionResume ? resumeHandle : null;
 }
 async function runReviewerStructuredRound(args) {
     try {
@@ -150,8 +133,9 @@ async function runReviewerStructuredRound(args) {
             role: 'structured-advisor',
             label: args.label,
             startupTimeoutMs: Math.min(getAgentTurnStartupTimeoutMs(args.cwd), getInactivityTimeoutMs(args.cwd)),
-            // Structured-advisor turns retry locally: they are non-writing by policy
-            // and do not resume sessions at this call site.
+            // Structured-advisor turns retry locally: they are non-writing by
+            // policy, and a liveness retry re-runs the round from the same resume
+            // handle (the prior round's session), never a partially-written one.
             retryLimit: getAgentTurnRetryLimit(args.cwd),
             logger: args.logger,
             baseSink: createStructuredAdvisorProviderEventSink({
@@ -166,6 +150,7 @@ async function runReviewerStructuredRound(args) {
                 prompt: args.prompt,
                 schema: args.schema,
                 structuredJsonProtocol: args.structuredJsonProtocol,
+                resumeHandle: resolveReviewerResumeHandle(args.reviewer, args.resumeHandle),
                 // Liveness retry sits outside the adapter-owned apiRetryLimit; it
                 // does not replace provider API retry.
                 ...getStructuredAdvisorRuntimeOptions(args.cwd),
@@ -183,14 +168,10 @@ async function runReviewerStructuredRound(args) {
     }
 }
 export async function runReviewerRound(args) {
-    assertReviewerRoundSupportsNoReadReviewer({
-        reviewer: args.reviewer,
-        label: 'review',
-        inlineContextSupplied: Boolean(args.inlineContext),
-    });
     const schema = buildReviewerSchema();
     const { sessionHandle, structured } = await runReviewerStructuredRound({
         reviewer: args.reviewer,
+        resumeHandle: args.resumeHandle,
         label: 'review',
         cwd: args.cwd,
         // The doctrine access mode comes from the reviewer provider's declared
@@ -224,14 +205,10 @@ export async function runReviewerRound(args) {
     };
 }
 export async function runPlanReviewerRound(args) {
-    assertReviewerRoundSupportsNoReadReviewer({
-        reviewer: args.reviewer,
-        label: 'plan-review',
-        inlineContextSupplied: Boolean(args.inlineContext),
-    });
     const schema = buildPlanReviewerSchema();
     const { sessionHandle, structured } = await runReviewerStructuredRound({
         reviewer: args.reviewer,
+        resumeHandle: args.resumeHandle,
         label: 'plan-review',
         cwd: args.cwd,
         // The doctrine access mode comes from the reviewer provider's declared
@@ -253,6 +230,9 @@ export async function runPlanReviewerRound(args) {
             round: args.round,
             source: 'reviewer',
             severity: finding.severity,
+            // validatePlanReviewerPayload normalizes an absent class to plan_correctness,
+            // so a plan-review finding always carries a concrete class by this point.
+            findingClass: finding.findingClass,
             files: finding.files,
             claim: finding.claim,
             requiredAction: finding.requiredAction,
@@ -260,25 +240,19 @@ export async function runPlanReviewerRound(args) {
         })),
     };
 }
-// Read-only, inline-only round for the review_stuck arbiter. It runs through the
+// Read-only, inline-only round for the review_stuck consultant. It runs through the
 // same runReviewerStructuredRound plumbing the support / final-completion
 // reviewers use (read-only tools only, zero commits, zero file edits). Because
-// the arbiter judges entirely from Neal-inlined in-memory artifacts (plan, open
+// the consultant judges entirely from Neal-inlined in-memory artifacts (plan, open
 // blocking findings, reviewer-round snapshots), it has a single no-read-safe
-// prompt variant and therefore requires a non-null inlineContext. The guard
-// fires for a no-read reviewer paired with a null context before any adapter
-// contact; the explicit null check below additionally covers a read-capable
-// reviewer that was handed a null context (the adjudicator always passes a
-// non-null context in production).
-export async function runBlockedAdjudicatorRound(args) {
-    assertReviewerRoundSupportsNoReadReviewer({
-        reviewer: args.reviewer,
-        label: 'review-stuck-arbiter',
-        inlineContextSupplied: Boolean(args.inlineContext),
-    });
+// prompt variant and therefore requires a non-null inlineContext. The explicit
+// null check below rejects a caller that hands the round a null context before
+// any adapter contact (the consultant always passes a non-null context in
+// production).
+export async function runConsultantRound(args) {
     if (!args.inlineContext) {
         throw new ReviewerRoundError(new NealProviderError({
-            message: 'review-stuck-arbiter round requires Neal-inlined reviewer context',
+            message: 'consultant round requires Neal-inlined reviewer context',
             provider: args.reviewer.provider,
             role: 'structured-advisor',
             sessionHandle: null,
@@ -286,26 +260,26 @@ export async function runBlockedAdjudicatorRound(args) {
             retryable: false,
         }));
     }
-    const schema = buildBlockedAdjudicatorSchema();
+    const schema = buildConsultantSchema();
     const { sessionHandle, structured } = await runReviewerStructuredRound({
         reviewer: args.reviewer,
-        label: 'review-stuck-arbiter',
+        label: 'consultant',
         cwd: args.cwd,
-        prompt: buildBlockedAdjudicatorPrompt({
+        prompt: buildConsultantPrompt({
             blockedReason: args.blockedReason,
             inlineContext: args.inlineContext,
         }),
         schema,
         structuredJsonProtocol: buildStructuredJsonProtocolSpec({
-            schemaLabel: 'blocked_adjudicator_payload',
+            schemaLabel: 'consultant_payload',
             schema,
-            validator: validateBlockedAdjudicatorVerdictPayload,
+            validator: validateConsultantVerdictPayload,
         }),
         logger: args.logger,
     });
     return {
         sessionHandle,
-        verdict: validateBlockedAdjudicatorVerdictPayload(structured),
+        verdict: validateConsultantVerdictPayload(structured),
     };
 }
 export async function runCoderFinalCompletionSummaryRound(args) {
@@ -317,8 +291,9 @@ export async function runCoderFinalCompletionSummaryRound(args) {
             role: 'structured-advisor',
             label: 'final-completion',
             startupTimeoutMs: Math.min(getAgentTurnStartupTimeoutMs(args.cwd), getInactivityTimeoutMs(args.cwd)),
-            // Structured-advisor turns retry locally: they are non-writing by policy
-            // and do not resume sessions at this call site.
+            // Structured-advisor turns retry locally: they are non-writing by
+            // policy, and a liveness retry re-runs the round from the same resume
+            // handle (the prior round's session), never a partially-written one.
             retryLimit: getAgentTurnRetryLimit(args.cwd),
             logger: args.logger,
             baseSink: createStructuredAdvisorProviderEventSink({
@@ -352,11 +327,6 @@ export async function runCoderFinalCompletionSummaryRound(args) {
     }
 }
 export async function runReviewerFinalCompletionRound(args) {
-    assertReviewerRoundSupportsNoReadReviewer({
-        reviewer: args.reviewer,
-        label: 'final-completion',
-        inlineContextSupplied: Boolean(args.inlineContext),
-    });
     const schema = buildFinalCompletionReviewerSchema();
     const { sessionHandle, structured } = await runReviewerStructuredRound({
         reviewer: args.reviewer,
@@ -373,6 +343,14 @@ export async function runReviewerFinalCompletionRound(args) {
         }),
         logger: args.logger,
     });
+    // Trust-boundary policy: rounds-level validation calls like this one are
+    // the authoritative trust boundary for agent payloads, not redundant dead
+    // code. The json-block protocol validator never runs on native
+    // structured-output paths, and cross-field rules are enforced only here on
+    // those paths; test/orchestrator.test.ts deliberately drives this wrap
+    // (FinalCompletionReviewerVerdictError, subtype
+    // final_completion_verdict_invalid) with a non-conforming fake adapter.
+    // Do not remove rounds-level validation calls.
     let verdict;
     try {
         verdict = parseFinalCompletionReviewerPayload(structured);