@navels/neal 0.4.2 → 0.5.0

package/dist/neal/orchestrator/phases/recovery.js

@@ -1,6 +1,5 @@
 import { CoderRoundError, runBlockedRecoveryCoderRound, } from '../../agents.js';
 import { CONSULTANT_ELIGIBLE_SOURCE_PHASES, buildRecentBlockCandidate, isReviewerConsultantPhase, runConsultant, upsertRecentBlock, } from '../../adjudicator/consultant.js';
-import { UNATTENDED_AUTO_RESUME_GUIDANCE } from '../../blocked-guidance.js';
 import { getInteractiveBlockedRecoveryMaxTurns, getConsultantMaxAttempts } from '../../config.js';
 import { EXECUTE_FINALIZATION_PHASE } from '../../execute-finalization.js';
 import { hasPendingOperatorGuidance } from '../../run-status.js';
@@ -11,14 +10,7 @@ import { writeExecutionArtifacts } from '../artifacts.js';
 import { isCoderTimeoutError, shouldNotifyFailure } from '../failures.js';
 import { flushDerivedPlanNotifications, notifyBlocked } from '../notifications.js';
 import { persistSplitPlanRecovery } from '../split-plan.js';
-import { bestEffortCleanupTimedOutCoder, persistBlockedScope, persistCoderFailureState, persistUnattendedBlockUnresolvedFailure, scheduleCoderFreshSessionRetry, shouldRetryCoderWithFreshSession, } from './shared.js';
-// Bounded number of synthesized conservative auto-resumes the execute-mode
-// interactive-recovery chokepoint performs under `unattended` before it fails
-// cleanly and terminally. Kept a module constant (not a config knob) and held
-// at or below `interactive_blocked_recovery_max_turns` (default 3) so an
-// auto-resume turn never pushes past the recovery turn cap. Revisit here if the
-// unattended push proves too short or too long for headless runs.
-export const UNATTENDED_MAX_AUTO_RESUMES = 2;
+import { bestEffortCleanupTimedOutCoder, persistBlockedScope, persistCoderFailureState, scheduleCoderFreshSessionRetry, shouldRetryCoderWithFreshSession, } from './shared.js';
 export class InteractiveBlockedRecoveryPendingTurnError extends Error {
     pendingTurn;
     constructor(pendingTurn) {
@@ -78,12 +70,10 @@ function isConsultantEligibleBlock(reason, sourcePhase) {
 // budget-exhausted cases emit NO `consultant.*` events so they preserve
 // the generic recovery path byte-for-byte: a disabled or exhausted consultant
 // must be indistinguishable from the consultant never having existed.
-// The single uniform budget is shared by both run modes — an invocation consumes
-// one unit whether it auto-applies a recoverable verdict (either mode) or, on a
-// non-recoverable verdict, finalizes terminally (unattended) or produces advice
-// and yields (attended) — and is reset to 0 at every scope boundary (see the
-// scope-advance transitions and the split-plan persist) so one scope's
-// adjudication never exhausts a later scope.
+// An invocation consumes one unit whether it auto-applies a recoverable verdict
+// or produces advice and yields for the operator, and the budget is reset to 0
+// at every scope boundary (see the scope-advance transitions and the split-plan
+// persist) so one scope's adjudication never exhausts a later scope.
 function isConsultantBudgetAvailable(state) {
     const maxAttempts = getConsultantMaxAttempts(state.cwd);
     if (maxAttempts <= 0) {
@@ -91,121 +81,21 @@ function isConsultantBudgetAvailable(state) {
     }
     return state.consultantAttemptCount < maxAttempts;
 }
-// Unattended interception for every eligible block class. Runs the read-only
-// consultant (which may itself short-circuit on an anti-thrash repeat) and, on a
-// recoverable verdict with a concrete in-scope directive, enters interactive
-// recovery with that directive injected as the pending turn — bounded by a
-// SEPARATE counter (`consultantAttemptCount`) that never touches
-// `unattendedAutoResumeCount` or the recovery turn cap. A non-recoverable verdict
-// (including a thrash repeat) is finalized TERMINALLY rather than silently
-// auto-resumed. Every gate that prevents the consultant from running — an
-// ineligible source phase, the disabled/exhausted budget, the turn cap, or an
-// consultant error — returns null so the caller falls through to the existing
-// generic auto-resume / terminal-fail path with `recentBlocks` left unchanged.
-// The consultant itself makes zero commits and zero file edits; this function is
-// the sole writer of `recentBlocks`, and only on the branches where the
-// consultant actually ran.
-async function maybeResolveBlockedUnattended(state, statePath, reason, sourcePhase, nextRecovery, logger) {
-    if (!isConsultantEligibleBlock(reason, sourcePhase)) {
-        return null;
-    }
-    if (!isConsultantBudgetAvailable(state)) {
-        return null;
-    }
-    // Never push past the recovery turn cap; if there is no room for a recovery
-    // turn, fall through to the generic bound check unchanged.
-    if (nextRecovery.turns.length >= nextRecovery.maxTurns) {
-        return null;
-    }
-    await logger?.event('consultant.start', {
-        scopeNumber: state.currentScopeNumber,
-        sourcePhase,
-        blockedReason: reason,
-    });
-    let verdict;
-    try {
-        verdict = await runConsultant(state, reason, sourcePhase, logger);
-    }
-    catch (error) {
-        // An consultant failure must never crash the run or weaken existing recovery;
-        // record the decline and fall through to the generic path with `recentBlocks`
-        // unchanged (the consultant did not complete for this block).
-        await logger?.event('consultant.declined', {
-            scopeNumber: state.currentScopeNumber,
-            sourcePhase,
-            blockedReason: reason,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return null;
-    }
-    // The consultant ran (possibly short-circuiting internally on a thrash repeat),
-    // so this block is recorded in the anti-thrash window regardless of the verdict.
-    // The candidate is built from the PRE-update array and written in this same
-    // transition, so a block can never match itself. It MUST be built from the same
-    // `state` snapshot `runConsultant` checked: the candidate's evidence
-    // fingerprint is derived from `state.createdCommits`, and a divergent snapshot
-    // would record a fingerprint the guard never compared against.
-    const candidate = buildRecentBlockCandidate(state, reason, sourcePhase);
-    const recentBlocks = upsertRecentBlock(state.recentBlocks, candidate);
-    const resolutionDirective = verdict.resolutionDirective.trim();
-    if (!verdict.recoverable || !resolutionDirective) {
-        // Genuine wall (recoverable:false) or a thrash repeat: an unattended run has
-        // no operator to escalate to, so finalize TERMINALLY instead of synthesizing a
-        // generic auto-resume. The consultant actually ran, so this branch consumes
-        // one unit of the shared per-scope budget (`consultantAttemptCount`) exactly
-        // like the recoverable branch, and persists the anti-thrash record via the
-        // threaded `recentBlocks`. Only the fallback paths where `runConsultant`
-        // was never invoked leave the budget untouched.
-        await logger?.event('consultant.declined', {
-            scopeNumber: state.currentScopeNumber,
-            sourcePhase,
-            blockedReason: reason,
-            recoverable: verdict.recoverable,
-            triageCategory: verdict.triageCategory,
-            consultantAttemptCount: state.consultantAttemptCount + 1,
-        });
-        return failUnattendedRecoveryTerminally({ ...state, recentBlocks, consultantAttemptCount: state.consultantAttemptCount + 1 }, statePath, 'terminal_block', state.coderSessionHandle, logger);
-    }
-    await logger?.event('consultant.verdict', {
-        scopeNumber: state.currentScopeNumber,
-        sourcePhase,
-        blockedReason: reason,
-        recoverable: verdict.recoverable,
-        triageCategory: verdict.triageCategory,
-        targetCanonicalIds: verdict.targetCanonicalIds,
-        // Report the post-increment count this verdict is about to consume so the
-        // verdict and the later `resolved` event agree on the budget figure.
-        consultantAttemptCount: state.consultantAttemptCount + 1,
-    });
-    // Recoverable verdict with a concrete directive: auto-apply it (shared with the
-    // attended path) so the coder consumes the directive and the run continues.
-    return applyRecoverableConsultantDirective({
-        state,
-        statePath,
-        reason,
-        sourcePhase,
-        nextRecovery,
-        recentBlocks,
-        resolutionDirective,
-        verdict,
-        logger,
-    });
-}
-// Attended interception for every eligible block class. The consultant NEVER
-// auto-applies its verdict in attended mode; instead it triages read-only and the
-// verdict is returned as advice (plus the updated anti-thrash window) for the
-// caller to persist alongside the operator yield. Gated by the SAME eligibility +
-// disable knob + per-scope budget as the unattended path; when any gate blocks the
-// consultant (ineligible phase, knob 0, exhausted budget, or an consultant
-// error) this returns null and the caller yields exactly as today with no advice,
-// no budget consumption, and `recentBlocks` unchanged.
+// Consultant interception for every eligible block class. The consultant triages
+// read-only and the verdict is returned as advice (plus the updated anti-thrash
+// window) for the caller to either auto-apply (recoverable verdict with a
+// concrete directive) or persist alongside the operator yield. Gated by the
+// eligibility check, the disable knob, and the per-scope budget; when any gate
+// blocks the consultant (ineligible phase, knob 0, exhausted budget, or a
+// consultant error) this returns null and the caller yields for the operator
+// with no advice, no budget consumption, and `recentBlocks` unchanged.
 //
-// The consultant runs BEFORE any `consultant.*` event is emitted, so an
-// consultant error degrades to today's plain attended yield with a byte-for-byte
+// The consultant runs BEFORE any `consultant.*` event is emitted, so a
+// consultant error degrades to a plain operator yield with a byte-for-byte
 // generic observable surface: zero consultant events, no advice, and no
 // counter/`recentBlocks` mutation. The `start`/`verdict` audit pair is emitted only
 // once the consultant has actually produced a verdict for this block.
-async function buildAttendedConsultantAdvice(state, reason, sourcePhase, logger) {
+async function buildConsultantAdvice(state, reason, sourcePhase, logger) {
     if (!isConsultantEligibleBlock(reason, sourcePhase)) {
         return null;
     }
@@ -217,7 +107,7 @@ async function buildAttendedConsultantAdvice(state, reason, sourcePhase, logger)
         verdict = await runConsultant(state, reason, sourcePhase, logger);
     }
     catch {
-        // Degrade to today's plain attended yield: never crash the run, and emit NO
+        // Degrade to a plain operator yield: never crash the run, and emit NO
         // `consultant.*` events so the fallback is indistinguishable from the
         // disabled/exhausted/ineligible generic yield.
         return null;
@@ -236,9 +126,11 @@ async function buildAttendedConsultantAdvice(state, reason, sourcePhase, logger)
         targetCanonicalIds: verdict.targetCanonicalIds,
         consultantAttemptCount: state.consultantAttemptCount + 1,
     });
-    // Same-snapshot rule as the unattended writer: the recorded candidate's
-    // commit-trail evidence fingerprint must come from the `state` the consultant
-    // just checked, never a fresher snapshot.
+    // Same-snapshot rule: the recorded candidate's commit-trail evidence
+    // fingerprint must come from the `state` the consultant just checked, never a
+    // fresher snapshot — the candidate's evidence fingerprint is derived from
+    // `state.createdCommits`, and a divergent snapshot would record a fingerprint
+    // the anti-thrash guard never compared against.
     const candidate = buildRecentBlockCandidate(state, reason, sourcePhase);
     const recentBlocks = upsertRecentBlock(state.recentBlocks, candidate);
     const advice = {
@@ -250,13 +142,13 @@ async function buildAttendedConsultantAdvice(state, reason, sourcePhase, logger)
     };
     return { advice, recentBlocks, verdict };
 }
-// Applies a recoverable consultant verdict — shared by both run modes. Enters
-// interactive recovery and injects the consultant's in-scope directive as the
-// pending turn, exactly like a human-supplied `neal resume --message`, so the
-// coder consumes it and the run continues. Consumes one unit of the per-scope
-// consultant budget (`consultantAttemptCount`, never `unattendedAutoResumeCount`)
-// and persists the anti-thrash `recentBlocks`. The caller has already emitted the
-// `consultant.verdict` audit event for this verdict.
+// Applies a recoverable consultant verdict. Enters interactive recovery and
+// injects the consultant's in-scope directive as the pending turn, exactly like
+// a human-supplied `neal resume --message`, so the coder consumes it and the
+// run continues. Consumes one unit of the per-scope consultant budget
+// (`consultantAttemptCount`) and persists the anti-thrash `recentBlocks`. The
+// caller has already emitted the `consultant.verdict` audit event for this
+// verdict.
 async function applyRecoverableConsultantDirective(args) {
     const { state, statePath, reason, sourcePhase, nextRecovery, recentBlocks, resolutionDirective, verdict, logger } = args;
     const enteredState = await saveState(statePath, {
@@ -305,67 +197,13 @@ export async function enterInteractiveBlockedRecovery(state, statePath, reason,
         pendingDirective: null,
         turns: [],
     };
-    // Unattended runs have no operator to answer, so instead of yielding-and-halting
-    // we either synthesize a conservative auto-resume turn (bounded) or, past the
-    // bound, run the shared terminal-fail action. Gate purely on structural state:
-    // the persisted counter and the recovery turn cap, never on guidance text.
-    if (state.unattended) {
-        // Before the generic auto-resume/terminal-fail decision, give the bounded
-        // read-only consultant a chance to triage the block: autonomously resolve it
-        // with an in-scope directive (recoverable) or finalize terminally (a genuine
-        // wall or thrash repeat). Any ineligible source phase, disabled/exhausted
-        // budget, turn cap, or consultant error falls through to the existing generic
-        // behavior unchanged.
-        const consultantResolved = await maybeResolveBlockedUnattended(state, statePath, reason, sourcePhase, nextRecovery, logger);
-        if (consultantResolved) {
-            return consultantResolved;
-        }
-        const canAutoResume = state.unattendedAutoResumeCount < UNATTENDED_MAX_AUTO_RESUMES &&
-            nextRecovery.turns.length < nextRecovery.maxTurns;
-        if (!canAutoResume) {
-            // Past the bound, finalize any active recovery record into history and land
-            // on a terminal failed shape (status:'failed', phase:'blocked',
-            // interactiveBlockedRecovery:null) so the run is never persisted as an
-            // active/waiting recovery. Reuses the same finalizer as the disposition
-            // terminal-fail paths.
-            return failUnattendedRecoveryTerminally(state, statePath, 'terminal_block', state.coderSessionHandle, logger);
-        }
-        const enteredState = await saveState(statePath, {
-            ...state,
-            phase: 'interactive_blocked_recovery',
-            status: 'running',
-            blockedFromPhase: state.blockedFromPhase ?? state.phase,
-            unattendedAutoResumeCount: state.unattendedAutoResumeCount + 1,
-            interactiveBlockedRecovery: {
-                ...nextRecovery,
-                sourcePhase,
-                blockedReason: reason,
-            },
-        });
-        await writeExecutionArtifacts(enteredState);
-        await logger?.event('interactive_blocked_recovery.entered', {
-            scopeNumber: enteredState.currentScopeNumber,
-            sourcePhase: enteredState.interactiveBlockedRecovery?.sourcePhase,
-            blockedReason: reason,
-        });
-        await logger?.event('interactive_blocked_recovery.unattended_auto_resume', {
-            scopeNumber: enteredState.currentScopeNumber,
-            sourcePhase,
-            autoResumeCount: enteredState.unattendedAutoResumeCount,
-            maxAutoResumes: UNATTENDED_MAX_AUTO_RESUMES,
-        });
-        // Reuse the turn-recording helper so the synthesized guidance turn satisfies
-        // the same invariants a human-supplied `neal resume --message` would; the run
-        // loop then proceeds into runInteractiveBlockedRecoveryPhase to consume it.
-        return recordInteractiveBlockedRecoveryGuidance(statePath, UNATTENDED_AUTO_RESUME_GUIDANCE, logger);
-    }
-    // Attended runs run the same bounded read-only consultant. On a recoverable
-    // verdict with a concrete directive, they auto-apply it exactly as unattended
-    // runs do — the consultant's advice is acted on in both modes. On a genuine wall
+    // Give the bounded read-only consultant a chance to triage the block. On a
+    // recoverable verdict with a concrete directive, auto-apply it so the coder
+    // consumes the directive and the run continues. On a genuine wall
     // (recoverable:false), or when the disable knob / budget / eligibility gate the
-    // consultant off, the attended run yields for the operator, carrying the verdict
-    // as advice when there is one so the operator sees why it stopped.
-    const advisory = await buildAttendedConsultantAdvice(state, reason, sourcePhase, logger);
+    // consultant off, the run yields for the operator, carrying the verdict as
+    // advice when there is one so the operator sees why it stopped.
+    const advisory = await buildConsultantAdvice(state, reason, sourcePhase, logger);
     if (advisory) {
         const resolutionDirective = advisory.advice.resolutionDirective.trim();
         if (advisory.advice.recoverable && resolutionDirective) {
@@ -405,16 +243,14 @@ export async function enterInteractiveBlockedRecovery(state, statePath, reason,
     });
     return nextState;
 }
-// Whether a caller of `enterInteractiveBlockedRecovery` should emit an attended
-// blocked / interactive-recovery notification for the returned state. Notify only
-// when an attended run is actually WAITING for the operator. An attended run whose
-// block the consultant auto-fixed leaves a pending directive to consume (status
-// 'running', a recorded recovery turn) — that is `waitingForOperatorGuidance:
-// false`, so it must not notify. Unattended runs never wait here (they auto-resume
-// or terminally fail), so `!state.unattended` already excludes them. Gate
-// structurally on the derived recovery view, never on text.
+// Whether a caller of `enterInteractiveBlockedRecovery` should emit a blocked /
+// interactive-recovery notification for the returned state. Notify only when the
+// run is actually WAITING for the operator. A run whose block the consultant
+// auto-fixed leaves a pending directive to consume (status 'running', a recorded
+// recovery turn) — that is `waitingForOperatorGuidance: false`, so it must not
+// notify. Gate structurally on the derived recovery view, never on text.
 export function shouldNotifyInteractiveBlockedRecoveryEntry(state) {
-    return !state.unattended && (getInteractiveRecoveryView(state)?.waitingForOperatorGuidance ?? false);
+    return getInteractiveRecoveryView(state)?.waitingForOperatorGuidance ?? false;
 }
 export async function recordInteractiveBlockedRecoveryGuidance(statePath, operatorGuidance, logger) {
     const trimmedGuidance = operatorGuidance.trim();
@@ -586,65 +422,6 @@ function getInteractiveBlockedRecoveryResumePhase(sourcePhase) {
             return sourcePhase;
     }
 }
-// Shared unattended terminal-fail for a recovery disposition. The active
-// recovery record is finalized into history (so `interactiveBlockedRecovery`
-// becomes null and the lifecycle view is no longer "active"/waiting — required
-// because the state invariant ties a non-null record to the recovery phase),
-// the run lands on the recovery's source phase for diagnostics, and the shared
-// classified terminal-fail action runs (status:'failed', no `notifyBlocked`).
-// `state` must carry the disposition already recorded on its latest turn.
-async function failUnattendedRecoveryTerminally(state, statePath, action, sessionHandle, logger) {
-    const recovery = state.interactiveBlockedRecovery;
-    const sourcePhase = recovery?.sourcePhase ?? state.blockedFromPhase ?? state.phase;
-    // The history record's resultPhase must satisfy the disposition-result invariant
-    // (stay_blocked -> recovery, terminal_block/replace -> blocked); the run itself
-    // lands on the terminal `blocked` phase with status:'failed', which keeps the
-    // lifecycle view out of any waiting/active recovery state.
-    const historyResultPhase = action === 'stay_blocked' ? 'interactive_blocked_recovery' : 'blocked';
-    await logger?.event('interactive_blocked_recovery.unattended_terminal_fail', {
-        scopeNumber: state.currentScopeNumber,
-        sourcePhase,
-        autoResumeCount: state.unattendedAutoResumeCount,
-        maxAutoResumes: UNATTENDED_MAX_AUTO_RESUMES,
-    });
-    const finalized = recovery ? finalizeInteractiveBlockedRecovery(state, action, historyResultPhase) : state;
-    return persistUnattendedBlockUnresolvedFailure({
-        ...finalized,
-        phase: 'blocked',
-        blockedFromPhase: sourcePhase,
-        coderSessionHandle: sessionHandle,
-        coderSessionProtocol: sessionHandle ? state.coderSessionProtocol : null,
-        coderRetryCount: 0,
-    }, statePath, 'interactive_blocked_recovery', logger);
-}
-// Under `unattended`, a recovery disposition that would otherwise leave the run
-// waiting for an operator (`stay_blocked`) is resolved structurally: synthesize
-// another conservative auto-resume turn while still under the persisted
-// auto-resume cap and the recovery turn cap, otherwise run the shared
-// terminal-fail action. `state` must already be persisted in
-// `interactive_blocked_recovery` with its recovery record holding the handled
-// turns. Gates only on the persisted counter and turn cap, never on text.
-async function continueOrTerminateUnattendedRecovery(state, statePath, sessionHandle, logger) {
-    const recovery = state.interactiveBlockedRecovery;
-    const canAutoResume = !!recovery &&
-        state.unattendedAutoResumeCount < UNATTENDED_MAX_AUTO_RESUMES &&
-        recovery.turns.length < recovery.maxTurns;
-    if (!canAutoResume) {
-        return failUnattendedRecoveryTerminally(state, statePath, 'stay_blocked', sessionHandle, logger);
-    }
-    const incremented = await saveState(statePath, {
-        ...state,
-        unattendedAutoResumeCount: state.unattendedAutoResumeCount + 1,
-    });
-    await writeExecutionArtifacts(incremented);
-    await logger?.event('interactive_blocked_recovery.unattended_auto_resume', {
-        scopeNumber: incremented.currentScopeNumber,
-        sourcePhase: recovery.sourcePhase,
-        autoResumeCount: incremented.unattendedAutoResumeCount,
-        maxAutoResumes: UNATTENDED_MAX_AUTO_RESUMES,
-    });
-    return recordInteractiveBlockedRecoveryGuidance(statePath, UNATTENDED_AUTO_RESUME_GUIDANCE, logger);
-}
 export async function applyInteractiveBlockedRecoveryDisposition(state, statePath, disposition, sessionHandle, logger) {
     if (state.phase !== 'interactive_blocked_recovery' || !state.interactiveBlockedRecovery) {
         throw new Error(`Run is not in interactive blocked recovery: ${statePath}`);
@@ -688,14 +465,6 @@ export async function applyInteractiveBlockedRecoveryDisposition(state, statePat
             writeExecutionArtifacts,
         });
         const resultPhase = persistedState.phase === 'blocked' ? 'blocked' : 'reviewer_plan';
-        if (state.unattended && resultPhase === 'blocked') {
-            // An unattended replacement that could not produce a runnable plan must not
-            // leave the run resumable-blocked; finalize recovery and fail cleanly.
-            return failUnattendedRecoveryTerminally({
-                ...persistedState,
-                interactiveBlockedRecovery: withRecordedInteractiveBlockedRecoveryDisposition({ ...persistedState, interactiveBlockedRecovery: state.interactiveBlockedRecovery }, disposition, sessionHandle, 'blocked').interactiveBlockedRecovery,
-            }, statePath, 'replace_current_scope', sessionHandle, logger);
-        }
         return persistFinalizedInteractiveBlockedRecovery({
             ...persistedState,
             interactiveBlockedRecovery: state.interactiveBlockedRecovery,
@@ -737,11 +506,6 @@ export async function applyInteractiveBlockedRecoveryDisposition(state, statePat
             coderRetryCount: 0,
         });
         await writeExecutionArtifacts(nextState);
-        if (nextState.unattended) {
-            // No operator will answer a stay_blocked: synthesize another conservative
-            // auto-resume turn under the bounds, or run the shared terminal-fail action.
-            return continueOrTerminateUnattendedRecovery(nextState, statePath, sessionHandle, logger);
-        }
         return nextState;
     }
     const terminalBlockedState = isActivePendingDerivedPlanReview(state)
@@ -751,13 +515,6 @@ export async function applyInteractiveBlockedRecoveryDisposition(state, statePat
             derivedScopeIndex: null,
         }
         : state;
-    if (state.unattended) {
-        // Unattended terminal_block must not take the attended blocked + notifyBlocked
-        // path; record the coder's terminal decision for diagnostics, then run the
-        // shared classified terminal-fail action (status:'failed', no notifyBlocked).
-        const recordedTerminalState = withRecordedInteractiveBlockedRecoveryDisposition(terminalBlockedState, disposition, sessionHandle, 'blocked');
-        return failUnattendedRecoveryTerminally(recordedTerminalState, statePath, 'terminal_block', sessionHandle, logger);
-    }
     const finalizedBlockedState = await persistFinalizedInteractiveBlockedRecovery(terminalBlockedState, statePath, disposition, sessionHandle, 'blocked');
     const blockedState = await saveState(statePath, {
         ...finalizedBlockedState,

package/dist/neal/orchestrator/phases/shared.js

@@ -86,32 +86,6 @@ export async function persistCoderFailureState(state, statePath, phase, error, l
     });
     return failedState;
 }
-// Shared terminal-fail action for the three operator-block sites under
-// `unattended`. Mirrors `persistCoderFailureState`: save `status:'failed'`,
-// re-render the execution artifacts, write a `failed` checkpoint retrospective,
-// and emit a classified log event — deliberately WITHOUT `notifyBlocked` (that
-// is the attended wait notification). Any produced diff/plan is left in the
-// worktree/run dir as an artifact and is not submitted, exactly as today's
-// failed runs leave it. `phase`/`blockedFromPhase` are preserved for
-// diagnostics (defaulting `blockedFromPhase` to the current phase).
-export async function persistUnattendedBlockUnresolvedFailure(state, statePath, site, logger) {
-    const blockedFromPhase = state.blockedFromPhase ?? state.phase;
-    const failedState = await saveState(statePath, {
-        ...state,
-        status: 'failed',
-        blockedFromPhase,
-    });
-    await writeExecutionArtifacts(failedState);
-    await writeCheckpointRetrospective(failedState, 'failed');
-    await logger?.event('unattended.block_unresolved', {
-        reason: 'unattended_block_unresolved',
-        site,
-        blockedFromPhase,
-        phase: failedState.phase,
-        scopeNumber: failedState.currentScopeNumber,
-    });
-    return failedState;
-}
 export async function persistBlockedScope(state, statePath, reason) {
     const scopeLabel = getCurrentScopeLabel(state);
     if (state.completedScopes.some((scope) => scope.number === scopeLabel)) {

package/dist/neal/orchestrator/run-loop.js

@@ -103,11 +103,7 @@ export async function runOnePass(args) {
         archivedReviewPath: currentState.archivedReviewPath,
     });
     if (currentState.phase === 'blocked' || currentState.phase === 'done') {
-        // A terminal-failed run (e.g. unattended site-A terminal-fail lands on
-        // phase:'blocked' with status:'failed') must keep its failed retrospective
-        // rather than be overwritten as a blocked one.
-        const retrospectiveReason = currentState.status === 'failed' ? 'failed' : currentState.phase === 'blocked' ? 'blocked' : 'done';
-        await runtime.writeCheckpointRetrospective(currentState, retrospectiveReason);
+        await runtime.writeCheckpointRetrospective(currentState, currentState.phase === 'blocked' ? 'blocked' : 'done');
     }
     return currentState;
 }

package/dist/neal/orchestrator.js

@@ -74,7 +74,6 @@ export async function initializeOrchestration(planDoc, cwd, agentConfig, topLeve
         topLevelMode,
         allowedDirtyPaths: options?.allowedDirtyPaths ?? [],
         agentConfig,
-        unattended: options?.unattended ?? false,
         autoSquashOnCompletion: options?.autoSquashOnCompletion ?? true,
         progressJsonPath: join(logger.runDir, 'plan-progress.json'),
         progressMarkdownPath: join(logger.runDir, 'PLAN_PROGRESS.md'),

package/dist/neal/plan-queue.js

@@ -148,7 +148,6 @@ export async function runPlanAndExecuteQueue(args) {
         state: queue,
         agentConfig: args.agentConfig,
         squashOnCompletion: args.squashOnCompletion ?? true,
-        unattended: args.unattended ?? false,
         deps: args.deps,
     });
 }
@@ -162,7 +161,7 @@ export async function continuePlanAndExecuteQueue(args) {
             break;
         }
         if (item.status === 'pending') {
-            state = await runQueueChildStage(state, item.index, 'planning', args.agentConfig, args.squashOnCompletion ?? true, args.unattended ?? false, deps);
+            state = await runQueueChildStage(state, item.index, 'planning', args.agentConfig, args.squashOnCompletion ?? true, deps);
             if (state.status !== 'running') {
                 return state;
             }
@@ -172,7 +171,7 @@ export async function continuePlanAndExecuteQueue(args) {
             break;
         }
         if (plannedItem.status === 'planned') {
-            state = await runQueueChildStage(state, plannedItem.index, 'execution', args.agentConfig, args.squashOnCompletion ?? true, args.unattended ?? false, deps);
+            state = await runQueueChildStage(state, plannedItem.index, 'execution', args.agentConfig, args.squashOnCompletion ?? true, deps);
             if (state.status !== 'running') {
                 return state;
             }
@@ -220,15 +219,9 @@ export async function continuePlanAndExecuteQueueFromChildRun(args) {
         state: advancedState,
         agentConfig: args.agentConfig,
         // Carry the squash preference forward across the cross-process
-        // queue-resume handoff the same way unattended is below: the resumed
-        // child's persisted run state wins when the caller supplies nothing.
+        // queue-resume handoff: the resumed child's persisted run state wins when
+        // the caller supplies nothing.
         squashOnCompletion: args.squashOnCompletion ?? args.childResult.finalState.autoSquashOnCompletion,
-        // Carry unattended forward across the cross-process queue-resume handoff.
-        // The resumed child's persisted finalState is the authoritative source (it
-        // was initialized with the value the original `neal run` resolved), so
-        // subsequent queue children do not silently revert to attended mode. An
-        // explicit caller-supplied value still wins.
-        unattended: args.unattended ?? args.childResult.finalState.unattended,
         deps: args.deps,
     });
 }
@@ -352,7 +345,7 @@ function resolveQueueRunnerDeps(deps) {
         runFreshChild: deps?.runFreshChild ?? runFreshPlanAndExecuteChild,
     };
 }
-async function runQueueChildStage(state, itemIndex, stage, agentConfig, squashOnCompletion, unattended, deps) {
+async function runQueueChildStage(state, itemIndex, stage, agentConfig, squashOnCompletion, deps) {
     try {
         await assertQueueWorktreeReady(state, deps);
     }
@@ -374,7 +367,6 @@ async function runQueueChildStage(state, itemIndex, stage, agentConfig, squashOn
             planDoc,
             agentConfig,
             squashOnCompletion,
-            unattended,
         }, async (child) => {
             initialized = true;
             activeState = await recordQueueChildInitialized(activeState, itemIndex, stage, child);
@@ -490,7 +482,6 @@ async function runFreshPlanAndExecuteChild(args, onInitialized) {
         const loaded = await loadOrInitialize(planDoc, cwd, args.agentConfig, undefined, topLevelMode, {
             allowedDirtyPaths: args.stage === 'execution' ? [planDoc] : [],
             runDir: prepared.runDir,
-            unattended: args.unattended,
             // Seed the queue's resolved squash preference onto the child run
             // state (unstaged: planning children persist it too so a resumed
             // planning child carries it back into queue continuation). Once
@@ -513,7 +504,6 @@ async function runFreshPlanAndExecuteChild(args, onInitialized) {
         });
         return executeRun(loaded.state, loaded.statePath, loaded.logger, {
             autoSquashOnCompletion: args.stage === 'execution' && args.squashOnCompletion,
-            unattended: args.unattended,
         });
     });
 }

package/dist/neal/prompts/execute.js

@@ -1,5 +1,5 @@
 import { renderInlinedRangeDiffSection, truncateInlineSectionBody } from '../context/inline-review-context.js';
-import { AUTONOMY_BLOCKED, AUTONOMY_DONE, AUTONOMY_SCOPE_DONE, AUTONOMY_SPLIT_PLAN, buildProgressSection, getCanonicalPlanContractLines, getDerivedPlanSectionContractLines, getExecuteScopeProgressPayloadContractLines, getProtocolMarkerArtifactProhibitionLines, getStandalonePlanPayloadSourceOfTruthLines, getTerminalMarkerArtifactBoundaryLines, getUnattendedAutonomyLines, } from './shared.js';
+import { AUTONOMY_BLOCKED, AUTONOMY_DONE, AUTONOMY_SCOPE_DONE, AUTONOMY_SPLIT_PLAN, buildProgressSection, getCanonicalPlanContractLines, getDerivedPlanSectionContractLines, getExecuteScopeProgressPayloadContractLines, getProtocolMarkerArtifactProhibitionLines, getStandalonePlanPayloadSourceOfTruthLines, getTerminalMarkerArtifactBoundaryLines, } from './shared.js';
 import { assertPromptBuilder } from './assert-builder.js';
 import { getUserGuidanceLines } from './guidance.js';
 import { getAdversarialReviewDoctrineLines, getCodeReviewFalsificationLines, getFindingQualityLines, getPreexistingFailureContractLines, getRegressionPreservationLines, getVerificationSkepticismLines, } from './review-doctrine.js';
@@ -11,7 +11,7 @@ export const CODER_PREEXISTING_FAILURE_LINES = [
     "When it is inside the surface and the fix is bounded, fix it and add a focused regression check when practical. When it is inside the surface but the fix is not bounded, do not silently expand the scope; surface it as a blocking concern through this prompt's blocked escape naming the failure as the blocker, or through this prompt's split-plan escape with a derived plan that sequences the fix, so it becomes an explicit decision.",
     'When it is outside the surface, record what you observed and why it cannot affect the required behavior in your progress justification, then continue without fixing it. Fixing out-of-surface pre-existing issues is scope drift.',
 ];
-export function buildScopePrompt(planDoc, progressText, options) {
+export function buildScopePrompt(planDoc, progressText) {
     const spec = assertPromptBuilder('scope_coder', 'buildScopePrompt', PROMPT_MODULE_PATH);
     const primaryVariant = spec.variants.find((variant) => variant.kind === 'primary');
     if (!primaryVariant) {
@@ -25,7 +25,6 @@ export function buildScopePrompt(planDoc, progressText, options) {
         '2. Read any companion docs or required-context files explicitly referenced by that plan before starting work.',
         '3. Reset your instructions for this turn from the current contents of the plan, the inlined progress state below, and required context.',
         '',
-        ...getUnattendedAutonomyLines(options?.unattended),
         'Then execute exactly one implementation scope.',
         'Do not start a second scope in this turn.',
         'Return only the structured execution envelope requested by the provider schema.',
@@ -198,7 +197,6 @@ export function buildReviewerPrompt(args) {
         'Do not use `block_for_operator` solely to ask Neal to retire an already-complete parent objective inside that derived-plan case; use `advance_parent` only for that narrow empty-derived-scope case.',
         'Keep `block_for_operator` for ambiguous already-satisfied claims, missing evidence, missing operator decisions, or unsafe parent-completion claims.',
         'A non-empty or uncertain current diff is the normal case, not a reason to escalate: handle it by accepting, requesting a bounded revision, or splitting the plan rather than choosing `block_for_operator`.',
-        ...getUnattendedAutonomyLines(args.unattended),
         'Use `meaningfulProgressRationale` to explain the convergence judgment against the parent objective and recent accepted-scope history. Do not use it to restate correctness findings.',
         '',
         'Coder progress justification for this scope:',

package/dist/neal/prompts/planning.js

@@ -1,4 +1,4 @@
-import { AUTONOMY_BLOCKED, AUTONOMY_DONE, getCanonicalPlanContractLines, getDerivedPlanSectionContractLines, getProtocolMarkerArtifactProhibitionLines, getTerminalMarkerArtifactBoundaryLines, getUnattendedAutonomyLines, } from './shared.js';
+import { AUTONOMY_BLOCKED, AUTONOMY_DONE, getCanonicalPlanContractLines, getDerivedPlanSectionContractLines, getProtocolMarkerArtifactProhibitionLines, getTerminalMarkerArtifactBoundaryLines, } from './shared.js';
 import { assertPromptBuilder } from './assert-builder.js';
 import { getUserGuidanceLines } from './guidance.js';
 const PROMPT_MODULE_PATH = 'src/neal/prompts/planning.ts';
@@ -142,7 +142,6 @@ export function buildPlanningPrompt(planDoc, planDocument, options) {
         ...getPlanningPromptBaseLines(planDoc),
         ...getInlineCurrentPlanLines(planDocument),
         ...getAuthoredOneShotPlanningLines(options?.authoredOneShot),
-        ...getUnattendedAutonomyLines(options?.unattended),
         ...getProtocolMarkerArtifactProhibitionLines(),
         ...getCanonicalPlanContractLines(),
         'If critical information is missing, do not invent it. Surface the concrete missing questions in your final response.',
@@ -221,7 +220,6 @@ export function buildPlanReviewerPrompt(args) {
         reviewHistoryLine,
         ...getAuthoredOneShotReviewerLines(args.authoredOneShot),
         ...getReviewerContextLines(args.reviewerContext),
-        ...getUnattendedAutonomyLines(args.unattended),
         ...getUserGuidanceLines('reviewer'),
         '',
         planInspectionLine,

package/dist/neal/prompts/shared.js

@@ -4,13 +4,6 @@ export const AUTONOMY_CHUNK_DONE = 'AUTONOMY_CHUNK_DONE';
 export const AUTONOMY_DONE = 'AUTONOMY_DONE';
 export const AUTONOMY_BLOCKED = 'AUTONOMY_BLOCKED';
 export const AUTONOMY_SPLIT_PLAN = 'AUTONOMY_SPLIT_PLAN';
-// Single autonomy line rendered into agent prompts when the run is unattended.
-// It tells the agent no operator can answer while keeping every verification
-// requirement intact (unattended means "no human to ask", not "skip checks").
-export const UNATTENDED_AUTONOMY_PROMPT_LINE = 'No operator is available to answer. Resolve this autonomously: do not escalate for operator guidance; make your best judgment and keep all verification requirements intact.';
-export function getUnattendedAutonomyLines(unattended) {
-    return unattended ? [UNATTENDED_AUTONOMY_PROMPT_LINE] : [];
-}
 export function getCanonicalPlanContractLines() {
     return [
         'Choose exactly one execution shape: `one_shot`, `multi_scope`, or `multi_scope_unknown`.',