@navels/neal 0.4.3 → 0.5.0

package/README.md

@@ -231,13 +231,11 @@ neal run tmp/A.md tmp/B.md
 neal run --no-squash tmp/A.md tmp/B.md
 ```
 
-Run headless (CI, cron, or a benchmark harness) with no operator available to
-answer an operator block:
-
-```bash
-neal execute PLAN.md --unattended
-neal run --unattended tmp/A.md tmp/B.md
-```
+When a run needs an operator it stops in a
+controlled state and the command exits with code `2`; `neal status` says
+whether it takes resume guidance or needs inspection. A harness with no
+operator available (CI, cron, a benchmark driver) treats that exit as a
+failure. See [docs/automation.md](docs/automation.md).
 
 To run an example through neal after configuring providers:
 
@@ -297,9 +295,9 @@ neal check
 neal compat [--model <slug>] [--role coder|reviewer|planner|all] [--reference openai-codex|anthropic-claude|openai-compatible:<slug>] [--json]
 
 # Plan execution
-neal run [--no-squash] [--unattended] <plan.md> [more-plans...]
-neal plan <plan.md> [--unattended]
-neal execute <plan.md> [--no-squash] [--unattended]
+neal run [--no-squash] <plan.md> [more-plans...]
+neal plan <plan.md>
+neal execute <plan.md> [--no-squash]
 neal resume [--run <run-id>] [--message "..."]
 
 # Plan-free review
@@ -341,9 +339,8 @@ work by default. Pass `--no-squash` to keep the per-scope commits.
 needs guidance or manual work, `neal resume` and `neal status` explain what is
 needed and print the command to continue.
 
-`--unattended` runs `neal plan`, `neal execute`, or `neal run` without waiting
-for an operator. See [docs/state-machine.md](docs/state-machine.md) for unattended
-blocks, manual gates, and resume behavior, and [docs/plan-format.md](docs/plan-format.md)
+See [docs/state-machine.md](docs/state-machine.md) for operator blocks, manual
+gates, and resume behavior, and [docs/plan-format.md](docs/plan-format.md)
 for execution shapes and selected-plan handling.
 
 ### Plan-free review
@@ -383,6 +380,14 @@ use this shell contract:
 - `3`: failed writer run or failed `neal run` queue after neal has run
   state/result evidence.
 
+`2` means the run stopped for operator intervention; `3` means a genuine
+failure. A run that stops for an operator always exits `2`, never `3`. Not
+every exit-2 stop resumes with a message: most accept `neal resume`
+(optionally with `--message`), but some — a blocked final-completion review —
+stay blocked and need `neal status` and artifact inspection instead. Harnesses
+that need a hard verdict with no operator attached treat exit `2` as a failure
+themselves.
+
 Use `neal status --json` for the stable detailed automation interface. `neal
 status` exits `0` when it successfully reports status, even if the reported run
 is blocked, paused, waiting for guidance, waiting for a manual gate, or failed.

package/dist/neal/adjudicator/execute.js

@@ -329,7 +329,6 @@ export async function runExecuteReviewerAdjudication(args) {
         reviewerContext: await buildAndPersistReviewerContextPacket({ state: args.state }),
         inlinedRangeDiff,
         earlierScopeChanges,
-        unattended: args.state.unattended,
         logger: args.logger,
     });
     return {

package/dist/neal/adjudicator/final-completion.js

@@ -65,7 +65,6 @@ export async function runFinalCompletionReviewerAdjudication(args) {
         scratchDir,
         reviewerContext: await buildAndPersistReviewerContextPacket({ state: args.state }),
         inlinedRangeDiff,
-        unattended: args.state.unattended,
         logger: args.logger,
     });
     return {

package/dist/neal/adjudicator/planning.js

@@ -325,7 +325,6 @@ export async function runPlanningReviewerAdjudication(args) {
         reviewerContext: await buildAndPersistReviewerContextPacket({ state: args.state }),
         reviewedPlanContent,
         parentPlanContent,
-        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.
         authoredOneShot: !context.derivedPlanReview && args.state.authoredExecutionShape === 'one_shot',

package/dist/neal/agents/rounds.js

@@ -376,7 +376,7 @@ export async function runCoderScopeRound(args) {
         const { sessionHandle, structured } = await runCoderStructuredPrompt({
             coder: args.coder,
             cwd: args.cwd,
-            prompt: buildScopePrompt(args.planDoc, progressText, { unattended: args.unattended }),
+            prompt: buildScopePrompt(args.planDoc, progressText),
             schema,
             label: 'Coder scope round',
             structuredJsonProtocol: buildStructuredJsonProtocolSpec({
@@ -512,7 +512,6 @@ export async function runCoderPlanRound(args) {
             coder: args.coder,
             cwd: args.cwd,
             prompt: buildPlanningPrompt(args.planDoc, planDocument, {
-                unattended: args.unattended,
                 authoredOneShot: args.authoredOneShot,
             }),
             schema,

package/dist/neal/blocked-guidance.js

@@ -9,14 +9,8 @@ import { getRunStatePath } from './state.js';
 const FALLBACK_REASON = 'Neal is waiting for operator guidance before it can continue.';
 const PLAN_REVIEW_REASON = 'Plan review requires operator guidance before Neal can continue.';
 // Conservative operator-facing message offered for the `unknown` blocked
-// category. Exported so the unattended site-A auto-resume can synthesize
-// guidance in the same conservative spirit without forking the wording here.
+// category.
 export const CONTINUE_WITH_GUIDANCE_MESSAGE = 'Continue using this operator guidance. Keep existing verification requirements intact and do not assume any extra authorization.';
-// Synthesized guidance recorded by the unattended execute-mode interactive
-// recovery auto-resume (site A). Self-contained (no human operator text to echo
-// back) and deliberately conservative: continue autonomously, keep every
-// verification requirement, assume no extra authorization.
-export const UNATTENDED_AUTO_RESUME_GUIDANCE = 'No operator is available. Continue autonomously using your best judgment. Keep all existing verification requirements intact and do not assume any extra authorization.';
 const MISSING_EXTERNAL_PREREQUISITE_KEYWORDS = [
     'credential',
     'credentials',

package/dist/neal/cli.js

@@ -5,9 +5,9 @@ export function buildUsageLines(version) {
         `neal ${version}`,
         '',
         'Usage: neal setup',
-        '   or: neal plan <plan.md> [--unattended]',
-        '   or: neal execute <plan.md> [--no-squash] [--unattended]',
-        '   or: neal run [--no-squash] [--unattended] <plan.md> [more-plans...]',
+        '   or: neal plan <plan.md>',
+        '   or: neal execute <plan.md> [--no-squash]',
+        '   or: neal run [--no-squash] <plan.md> [more-plans...]',
         '   or: neal resume [--run <run-id>] [--message "..."]',
         '   or: neal review [message] (--last <n> | --since <base>)',
         '   or: neal squash [plan.md]',
@@ -26,10 +26,8 @@ export function buildUsageLines(version) {
         '  neal plan tmp/PLAN.md',
         '  neal execute tmp/PLAN.md',
         '  neal execute tmp/PLAN.md --no-squash',
-        '  neal execute tmp/PLAN.md --unattended',
         '  neal run tmp/PLAN.md',
         '  neal run --no-squash tmp/PLAN.md',
-        '  neal run --unattended tmp/PLAN.md',
         '  neal resume',
         '  neal resume --run <run-id>',
         '  neal resume --run <run-id> --message "Use the narrower helper approach."',
@@ -100,7 +98,6 @@ export function parseNewRunArgs(args, defaults) {
     }
     const planDoc = requireSubcommandPlanPath(command, args[1]);
     let squashOnCompletion = command === 'execute';
-    let unattended = false;
     let index = 2;
     while (index < args.length) {
         const extra = args[index];
@@ -109,11 +106,6 @@ export function parseNewRunArgs(args, defaults) {
             index += 1;
             continue;
         }
-        if (extra === '--unattended') {
-            unattended = true;
-            index += 1;
-            continue;
-        }
         if (extra?.startsWith('--')) {
             throw new Error(`neal ${command} accepts exactly one plan file path argument; unsupported flag: ${extra}`);
         }
@@ -124,7 +116,6 @@ export function parseNewRunArgs(args, defaults) {
         planDoc,
         agentConfig,
         squashOnCompletion,
-        unattended,
     };
 }
 export function parsePlanAndExecuteArgs(args, defaults) {
@@ -139,7 +130,6 @@ export function parsePlanAndExecuteArgs(args, defaults) {
     };
     let index = 1;
     let squashOnCompletion = true;
-    let unattended = false;
     while (index < args.length) {
         const value = args[index];
         if (value === '--no-squash') {
@@ -147,11 +137,6 @@ export function parsePlanAndExecuteArgs(args, defaults) {
             index += 1;
             continue;
         }
-        if (value === '--unattended') {
-            unattended = true;
-            index += 1;
-            continue;
-        }
         if (value.startsWith('--')) {
             throw new Error(`neal run accepts only plan file path operands; unsupported flag: ${value}`);
         }
@@ -165,7 +150,6 @@ export function parsePlanAndExecuteArgs(args, defaults) {
         planDocs,
         agentConfig,
         squashOnCompletion,
-        unattended,
     };
 }
 export function parseReviewArgs(args) {

package/dist/neal/commands/compat.js

@@ -16,6 +16,7 @@ import { createAgentReviewFindingsProviderAdapter } from '../review-findings/pro
 import { runNealReviewCli } from '../review-findings/run.js';
 import { enableAgentSettingsIsolation } from '../providers/agent-settings-isolation.js';
 import { isNealProviderError } from '../providers/types.js';
+import { getRunDisplayStatus } from '../run-status.js';
 import { getRunDir } from '../storage-paths.js';
 import { verifyConfiguredProviders } from './check.js';
 import { executeRun } from './runtime.js';
@@ -343,7 +344,7 @@ export async function runWriterFixture(options) {
     const runDir = getRunDir(throwawayCwd, createRunId());
     const planDoc = resolve(throwawayCwd, options.documentRelativePath);
     let finalStatus = null;
-    let unattended = null;
+    let finalState = null;
     let threwDuringRun = false;
     let errorMessage = null;
     let verifyExitCode = null;
@@ -353,10 +354,8 @@ export async function runWriterFixture(options) {
         options.onPrepared?.({ throwawayCwd, runDir, planDoc });
         const loaded = await loadOrInitialize(planDoc, throwawayCwd, options.candidateConfig, undefined, options.mode, {
             runDir,
-            unattended: true,
             allowedDirtyPaths: [planDoc],
         });
-        unattended = loaded.state.unattended;
         // executeRun renders its final run summary to process.stdout (runtime.ts).
         // Capture and discard that here so it never leaks into the compat
         // command's own stdout (the PASS/FAIL table / `--json` matrix). Footer and
@@ -364,9 +363,9 @@ export async function runWriterFixture(options) {
         const realStdoutWrite = process.stdout.write.bind(process.stdout);
         process.stdout.write = (() => true);
         try {
-            const result = await executeRun(loaded.state, loaded.statePath, loaded.logger, { unattended: true });
+            const result = await executeRun(loaded.state, loaded.statePath, loaded.logger);
             finalStatus = result.finalState.status;
-            unattended = result.finalState.unattended;
+            finalState = result.finalState;
         }
         catch (error) {
             threwDuringRun = true;
@@ -389,7 +388,7 @@ export async function runWriterFixture(options) {
         }
         return {
             finalStatus,
-            unattended,
+            finalState,
             runDir,
             throwawayCwd,
             events,
@@ -406,6 +405,19 @@ export async function runWriterFixture(options) {
 // ---------------------------------------------------------------------------
 // Failure-mode classification for writer runs
 // ---------------------------------------------------------------------------
+// An operator stop, derived purely from the run's final persisted state. The
+// signal mirrors the writer exit-code-2 mapping (writer-exit-codes.ts): the run
+// is structurally waiting for the operator (the interactive-recovery wait, or a
+// pending-guidance view) or persisted `status: 'blocked'` (the final-completion
+// and top-level plan-review gates).
+export function isOperatorStopFinalState(state) {
+    const displayStatus = getRunDisplayStatus(state);
+    if (displayStatus.effectiveStatus === 'waiting_for_operator' ||
+        displayStatus.pendingOperatorGuidance) {
+        return true;
+    }
+    return state.status === 'blocked';
+}
 export function classifyWriterFailure(args) {
     const { events } = args;
     // Precedence follows the plan taxonomy (most specific first).
@@ -422,16 +434,13 @@ export function classifyWriterFailure(args) {
         }
         return 'provider_failed';
     }
-    if (hasEvent(events, 'unattended.block_unresolved')) {
-        return 'block_unresolved';
-    }
-    if (args.finalStatus === 'blocked') {
+    if (args.finalState !== null && isOperatorStopFinalState(args.finalState)) {
         return 'block_unresolved';
     }
     if (hasEvent(events, 'phase.error')) {
         return 'structured_output';
     }
-    if (args.threwDuringRun || args.finalStatus === null) {
+    if (args.threwDuringRun || args.finalState === null) {
         return 'finalization_error';
     }
     // status 'failed' with no conclusive structural signal.
@@ -468,7 +477,7 @@ export async function evaluateCoderFixture(args) {
         };
     }
     const failureMode = classifyWriterFailure({
-        finalStatus: run.finalStatus,
+        finalState: run.finalState,
         events: run.events,
         threwDuringRun: run.threwDuringRun,
     });
@@ -494,7 +503,7 @@ export async function evaluatePlannerFixture(args) {
     });
     if (run.finalStatus !== 'done') {
         const failureMode = classifyWriterFailure({
-            finalStatus: run.finalStatus,
+            finalState: run.finalState,
             events: run.events,
             threwDuringRun: run.threwDuringRun,
         });
@@ -761,6 +770,19 @@ export function formatCompatTable(report) {
     lines.push(`Overall: ${report.overallPass ? 'PASS' : 'FAIL'}`);
     return lines.join('\n');
 }
+// ---------------------------------------------------------------------------
+// Top-level orchestration
+// ---------------------------------------------------------------------------
+// Compat child runs must be structurally quiet: a child run that lands in an
+// operator-stop state would otherwise invoke the operator's configured notify
+// helper mid-matrix. `getNotifyBin` (config.ts) treats a defined-but-empty
+// NEAL_NOTIFY_BIN as "notifications disabled", so setting the empty override at
+// compat startup silences neal's own notifier for the whole process — the same
+// process-env pattern as `enableAgentSettingsIsolation`, which only isolates
+// the SDK adapters' settings, not neal's notifier.
+export function suppressCompatRunNotifications() {
+    process.env.NEAL_NOTIFY_BIN = '';
+}
 export async function runCompat(args) {
     const { cwd, parsed } = args;
     // compat is a hermetic capability probe that runs the whole role matrix
@@ -768,6 +790,7 @@ export async function runCompat(args) {
     // interactive config so the probe stays quiet (no per-turn notifier hooks)
     // and repeatable. Normal neal runs never call this, so they honor the config.
     enableAgentSettingsIsolation();
+    suppressCompatRunNotifications();
     const deps = args.deps ?? {};
     const compatDir = deps.compatDir ?? getCompatExamplesDir();
     const manifest = deps.manifest ?? loadCompatManifest(compatDir);

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

@@ -2,7 +2,7 @@ import { stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import process from 'node:process';
 import { parseNewRunArgs } from '../cli.js';
-import { assertWriterProvidersConfigured, getConfiguredUnattended } from '../config.js';
+import { assertWriterProvidersConfigured } from '../config.js';
 import { assertGitRepositoryWithCommit } from '../git.js';
 import { loadOrInitialize } from '../orchestrator.js';
 import { assertAgentConfigSupportsWriterRun } from '../providers/registry.js';
@@ -34,9 +34,6 @@ export async function runNewRunCommand(args) {
     };
     assertAgentConfigSupportsWriterRun(parsed.agentConfig, { context: `new ${parsed.topLevelMode} writer run` });
     const planDoc = resolve(cwd, parsed.planDoc);
-    // Flag overrides config: `--unattended` forces true, otherwise fall back to
-    // the resolved `agent.unattended` config value (default false).
-    const unattended = parsed.unattended || getConfiguredUnattended(cwd);
     await assertGitRepositoryWithCommit(cwd, `neal ${parsed.topLevelMode}`);
     await requireExistingPlanFile(planDoc, parsed.planDoc);
     const result = await withPreparedWriterRun({
@@ -47,7 +44,6 @@ export async function runNewRunCommand(args) {
         const loaded = await loadOrInitialize(planDoc, cwd, parsed.agentConfig, undefined, parsed.topLevelMode, {
             allowedDirtyPaths: parsed.topLevelMode === 'execute' ? [planDoc] : [],
             runDir: prepared.runDir,
-            unattended,
             autoSquashOnCompletion: parsed.squashOnCompletion,
         });
         markInitialized();
@@ -57,7 +53,6 @@ export async function runNewRunCommand(args) {
             // state is the single source of truth so `neal resume` sees the same
             // preference this process does.
             autoSquashOnCompletion: loaded.state.autoSquashOnCompletion,
-            unattended,
         });
     });
     setWriterCommandExitCode(getExecuteRunResultExitCode(result));

package/dist/neal/commands/plan-and-execute.js

@@ -1,6 +1,6 @@
 import process from 'node:process';
 import { parsePlanAndExecuteArgs } from '../cli.js';
-import { assertWriterProvidersConfigured, getConfiguredUnattended } from '../config.js';
+import { assertWriterProvidersConfigured } from '../config.js';
 import { assertGitRepositoryWithCommit } from '../git.js';
 import { runPlanAndExecuteQueue } from '../plan-queue.js';
 import { assertAgentConfigSupportsWriterRun } from '../providers/registry.js';
@@ -29,15 +29,11 @@ export async function runPlanAndExecuteCommand(args, deps) {
     };
     assertAgentConfigSupportsWriterRun(parsed.agentConfig, { context: 'plan-and-execute queue' });
     await assertGitRepositoryWithCommit(cwd, 'neal run');
-    // Flag overrides config: `--unattended` forces true, otherwise fall back to
-    // the resolved `agent.unattended` config value (default false).
-    const unattended = parsed.unattended || getConfiguredUnattended(cwd);
     const queueState = await runPlanAndExecuteQueue({
         cwd,
         planDocs: parsed.planDocs,
         agentConfig: parsed.agentConfig,
         squashOnCompletion: parsed.squashOnCompletion,
-        unattended,
         deps,
     });
     setWriterCommandExitCode(getPlanAndExecuteQueueExitCode(queueState));

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

@@ -215,8 +215,8 @@ async function resumeManualGateRun(selection, lock) {
 function executeResumedRun(state, statePath, logger) {
     return executeRun(state, statePath, logger, {
         // Honor the squash preference persisted at run creation (`--no-squash`)
-        // instead of re-deriving it, exactly as `unattended` is. Legacy states
-        // missing the field hydrate to true, keeping the historical behavior.
+        // instead of re-deriving it. Legacy states missing the field hydrate to
+        // true, keeping the historical behavior.
         autoSquashOnCompletion: state.autoSquashOnCompletion,
     });
 }
@@ -297,11 +297,9 @@ async function applyResumeRunExitCode(outcome, deps) {
             const queueState = await continueQueueFromChildRun({
                 childResult: outcome.result,
                 agentConfig: outcome.result.finalState.agentConfig,
-                // Source unattended from the resumed child's persisted state, exactly as
-                // agentConfig is, so the queue continuation keeps headless runs headless.
-                unattended: outcome.result.finalState.unattended,
-                // Likewise source the squash preference from the resumed child's
-                // persisted state so remaining queue items keep honoring --no-squash.
+                // Source the squash preference from the resumed child's persisted
+                // state, exactly as agentConfig is, so remaining queue items keep
+                // honoring --no-squash.
                 squashOnCompletion: outcome.result.finalState.autoSquashOnCompletion,
             });
             setWriterCommandExitCode(queueState

package/dist/neal/config.js

@@ -36,7 +36,6 @@ const DEFAULT_CONFIG = {
             provider: 'anthropic-claude',
             model: null,
         },
-        unattended: false,
     },
 };
 const cachedConfig = new Map();
@@ -161,9 +160,6 @@ function mergeConfig(base, override) {
                 ...base.agent?.reviewer,
                 ...override.agent?.reviewer,
             },
-            // Scalar agent toggle: merged explicitly because the deep-merge above only
-            // covers the three provider sub-objects. Override wins when present.
-            unattended: override.agent?.unattended ?? base.agent?.unattended,
         },
         providers: {
             openai_compatible: {
@@ -194,7 +190,9 @@ function loadConfigFile(cwd = process.cwd()) {
         return cached;
     }
     const sources = getConfigSourceInfo(cacheKey);
-    const resolved = mergeConfig(mergeConfig({}, readYamlFileIfPresent(sources.user.path)), readYamlFileIfPresent(sources.repo.path));
+    const userConfig = readYamlFileIfPresent(sources.user.path);
+    const repoConfig = readYamlFileIfPresent(sources.repo.path);
+    const resolved = mergeConfig(mergeConfig({}, userConfig), repoConfig);
     cachedConfig.set(cacheKey, resolved);
     return resolved;
 }
@@ -409,12 +407,6 @@ export function getDefaultCoderModel(cwd = process.cwd()) {
         ? null
         : (parseStringValue(config.agent?.coder?.model) ?? DEFAULT_CONFIG.agent.coder.model);
 }
-export function getConfiguredUnattended(cwd = process.cwd()) {
-    const config = loadConfigFile(cwd);
-    return typeof config.agent?.unattended === 'boolean'
-        ? config.agent.unattended
-        : DEFAULT_CONFIG.agent.unattended;
-}
 export function getDefaultPlannerProvider(cwd = process.cwd()) {
     const config = loadConfigFile(cwd);
     return (parseConfigProviderValue(config.agent?.planner?.provider, 'agent.planner.provider') ??

package/dist/neal/orchestrator/completion.js

@@ -22,7 +22,6 @@ import { getFinalCompletionReviewerScratchDir, getScopeReviewerScratchDir } from
 import { requireFinalCompletionView, resolveFinalCompletionReviewAction, } from '../state-views.js';
 import { filterAllowedDirtyPathStatus, filterWrapperOwnedWorktreeStatus, formatDirtyWorktreeDiagnostic, } from '../worktree-status.js';
 import { REVIEWER_CONTENT_REFUSED_BLOCK_REASON, shouldNotifyFailure } from './failures.js';
-import { persistUnattendedBlockUnresolvedFailure } from './phases/shared.js';
 async function writeFailedFinalCompletionReviewArtifact(args) {
     const unstructuredOutput = await readFinalCompletionUnstructuredOutput({
         runDir: args.state.runDir,
@@ -558,15 +557,6 @@ export async function runFinalCompletionReviewPhase(state, statePath, logger, ru
         finalCompletionContinueExecutionCapReached: actionResolution.continueExecutionCapReached,
     };
     assertAdjudicationTransitionSignal(context.spec, actionResolution.effectiveAction, 'orchestrator:final_completion_review');
-    // Site B: the final-completion review gate. Under `unattended` a
-    // `block_for_operator` resolution (model-chosen or the forced
-    // continue-execution cap folded into `effectiveAction`) has no operator to
-    // answer, so run the shared terminal-fail action instead of saving
-    // `status:'blocked'`. The continue-execution cap already bounded the
-    // autonomous push, so there is no auto-resume. The aggregate diff is preserved
-    // unsubmitted by the shared action. Gate structurally on the persisted flag,
-    // never on guidance text.
-    const unattendedFinalCompletionBlock = actionResolution.effectiveAction === 'block_for_operator' && state.unattended;
     const nextState = actionResolution.effectiveAction === 'accept_complete'
         ? await saveState(statePath, {
             ...baseState,
@@ -591,18 +581,12 @@ export async function runFinalCompletionReviewPhase(state, statePath, logger, ru
                 splitPlanCountForCurrentScope: 0,
                 blockedFromPhase: null,
             })
-            : unattendedFinalCompletionBlock
-                ? await persistUnattendedBlockUnresolvedFailure({
-                    ...baseState,
-                    phase: 'blocked',
-                    blockedFromPhase: 'final_completion_review',
-                }, statePath, 'final_completion_review', logger)
-                : await saveState(statePath, {
-                    ...baseState,
-                    phase: 'blocked',
-                    status: 'blocked',
-                    blockedFromPhase: 'final_completion_review',
-                });
+            : await saveState(statePath, {
+                ...baseState,
+                phase: 'blocked',
+                status: 'blocked',
+                blockedFromPhase: 'final_completion_review',
+            });
     await runtime.writeExecutionArtifacts(nextState);
     await logger?.event('phase.complete', {
         phase: 'final_completion_review',
@@ -618,7 +602,7 @@ export async function runFinalCompletionReviewPhase(state, statePath, logger, ru
         const finalSubject = terminalScope?.commitSubject ?? 'Finalize scope work';
         await notifyComplete(nextState, finalSubject, logger);
     }
-    else if (actionResolution.effectiveAction === 'block_for_operator' && !state.unattended) {
+    else if (actionResolution.effectiveAction === 'block_for_operator') {
         const reason = getFinalCompletionReviewBlockReason({
             reviewerAction: reviewerResult.verdict.action === 'accept_complete' ? 'block_for_operator' : reviewerResult.verdict.action,
             effectiveAction: actionResolution.effectiveAction,

package/dist/neal/orchestrator/notifications.js

@@ -4,7 +4,7 @@ import { getCurrentScopeLabel, getExecutionPlanPath, getExecutionPlanScopeCount,
 import { saveState } from '../state.js';
 import { getDerivedPlanView } from '../state-views.js';
 // Concise representation of the read-only consultant advice for the
-// operator notification surface. Present only on an attended run whose active
+// operator notification surface. Present only on a run whose active
 // interactive-blocked-recovery record carries consultant advice (knob > 0,
 // budget available, eligible source phase). Returns '' otherwise so notification
 // behavior for recovery states without advice — and terminal blocked

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

@@ -152,7 +152,6 @@ export async function runCoderScopePhase(state, statePath, logger) {
             progressMarkdownPath: state.progressMarkdownPath,
             sessionHandle: state.coderSessionHandle,
             coderSessionProtocol: state.coderSessionProtocol,
-            unattended: state.unattended,
             onSessionStarted: async (sessionHandle) => {
                 state.coderSessionHandle = sessionHandle;
                 state.coderSessionProtocol = activeCoderSessionProtocol;

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

@@ -18,7 +18,7 @@ import { isCoderTimeoutError, REVIEWER_CONTENT_REFUSED_BLOCK_REASON, shouldNotif
 import { flushDerivedPlanNotifications, notifyBlocked, notifyComplete, } from '../notifications.js';
 import { adoptAcceptedDerivedPlan, shouldNotifyDerivedPlanAcceptance, transitionPlanReviewWithoutOpenFindings, } from '../transitions.js';
 import { enterInteractiveBlockedRecovery, shouldNotifyInteractiveBlockedRecoveryEntry } from './recovery.js';
-import { bestEffortCleanupTimedOutCoder, persistCoderFailureState, persistUnattendedBlockUnresolvedFailure, printReviewResult, scheduleCoderFreshSessionRetry, shouldRetryCoderWithFreshSession, } from './shared.js';
+import { bestEffortCleanupTimedOutCoder, persistCoderFailureState, printReviewResult, scheduleCoderFreshSessionRetry, shouldRetryCoderWithFreshSession, } from './shared.js';
 function getNormalizedPlanArtifactPath(state, planPath) {
     const parsed = parse(planPath);
     const extension = parsed.ext || '.md';
@@ -128,10 +128,7 @@ export async function finalizeBlockedPlanReviewResponse(state, statePath, derive
         if (blockCause === 'coder_authored') {
             // Recoverable landing for a coder-authored *response* block: persist the
             // durable blocker reason and leave `status:'blocked'` (writer exit 2) for
-            // an operator to answer via `neal resume --message`. Attended and
-            // unattended land identically now — both blocked-with-reason — because
-            // neither could previously answer this block (attended left it blocked but
-            // reason-less; unattended terminal-failed).
+            // an operator to answer via `neal resume --message`.
             const blockedState = await saveState(statePath, {
                 ...state,
                 blockerReason: blocker,
@@ -141,16 +138,11 @@ export async function finalizeBlockedPlanReviewResponse(state, statePath, derive
             }
             return flushDerivedPlanNotifications(blockedState, statePath, logger, blocker);
         }
-        // Site C: a `dirty_worktree` safety block or a `reviewer_convergence`
-        // cap/stall block. Attended runs leave `status:'blocked'`; unattended runs
-        // have no operator to answer, so run the shared terminal-fail action. The
-        // dirty-worktree case must not be silently converted to the recoverable
-        // landing (the planner dirtied non-plan files with no operator to clean it),
-        // and the convergence cap already bounded the autonomous push. Any plan
-        // artifact is preserved unsubmitted, exactly as today's failed runs leave it.
-        if (state.unattended) {
-            return persistUnattendedBlockUnresolvedFailure(state, statePath, 'reviewer_plan', logger);
-        }
+        // A `dirty_worktree` safety block or a `reviewer_convergence` cap/stall
+        // block: leave `status:'blocked'` (writer exit 2) without a durable
+        // blockerReason. The dirty-worktree case must not be silently converted to
+        // the blocked-with-reason landing (the planner dirtied non-plan files), and
+        // the convergence cap already bounded the autonomous push.
         if (!derivedPlanReview) {
             await notifyBlocked(state, blocker, logger);
         }
@@ -185,7 +177,6 @@ export async function runCoderPlanPhase(state, statePath, logger) {
             planDoc: state.planDoc,
             sessionHandle: state.plannerSessionHandle,
             coderSessionProtocol: state.plannerSessionProtocol,
-            unattended: state.unattended,
             // Reinforce an author-declared `one_shot` only for the top-level authored plan; the
             // coder_plan phase only runs for top-level `neal plan` refinement (derived-plan
             // revisions run through coder_plan_response).