@navels/neal 0.1.0 → 0.3.0

package/dist/neal/orchestrator/completion.js

@@ -11,8 +11,8 @@ import { getFinalCompletionReviewArtifactPath, readFinalCompletionUnstructuredOu
 import { EXECUTE_FINALIZATION_PHASE } from '../execute-finalization.js';
 import { getChangedFilesForRange, getCommitRange, getCommitMessage, getCommitSubjects, getHeadCommit, getStagedChangedFiles, getWorktreeStatus, assertNoIgnoredChangedFiles, cleanUntracked, resetHard, squashCommits as createScopeFinalizationCommit, stagePath, } from '../git.js';
 import { notifyBlocked, notifyComplete, notifyScopeAccepted } from './notifications.js';
-import { inspectPlanDocDisposition } from '../plan-doc.js';
-import { appendDerivedSubScopeAndParentCompletion, appendParentCompletionFromAcceptedDerivedScopes, computeNextScopeStateAfterExecuteFinalization, computeNextScopeStateAfterParentAdvance, } from './transitions.js';
+import { inspectPlanDocDisposition, withPlanDocPreserved } from '../plan-doc.js';
+import { appendDerivedSubScopeAndParentCompletion, appendParentCompletionFromAcceptedDerivedScopes, computeNextScopeStateAfterExecuteFinalization, computeNextScopeStateAfterParentAdvance, createNextScopeEntryReset, } from './transitions.js';
 import { writePlanProgressArtifacts } from '../progress.js';
 import { writeCheckpointRetrospective } from '../retrospective.js';
 import { renderReviewMarkdown, writeReviewMarkdown } from '../review.js';
@@ -21,7 +21,7 @@ import { saveState } from '../state.js';
 import { getFinalCompletionReviewerScratchDir, getScopeReviewerScratchDir } from '../storage-paths.js';
 import { requireFinalCompletionView, resolveFinalCompletionReviewAction, } from '../state-views.js';
 import { filterAllowedDirtyPathStatus, filterWrapperOwnedWorktreeStatus, formatDirtyWorktreeDiagnostic, } from '../worktree-status.js';
-import { shouldNotifyFailure } from './failures.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({
@@ -52,6 +52,38 @@ async function persistFailedFinalCompletionReview(args) {
     });
     return failedState;
 }
+// Sibling of persistFailedFinalCompletionReview for the terminal blocked
+// landing of a reviewer content-safety refusal (`content_refused`). Only a
+// ReviewerRoundError can carry that kind; FinalCompletionReviewerVerdictError
+// never does, so persistFailedFinalCompletionReview keeps serving the
+// verdict-invalid path unchanged. Persists a terminal
+// phase:'blocked'/status:'blocked' state so the run ends blocked (exit 2)
+// rather than as a generic terminal failure, still writing the failed
+// final-completion review artifact and execution artifacts.
+async function persistBlockedFinalCompletionReview(args) {
+    const blockedState = await saveState(args.statePath, {
+        ...args.state,
+        phase: 'blocked',
+        reviewerSessionHandle: null,
+        status: 'blocked',
+        blockedFromPhase: null,
+        blockerReason: REVIEWER_CONTENT_REFUSED_BLOCK_REASON,
+    });
+    await args.runtime.writeExecutionArtifacts(blockedState);
+    await writeFailedFinalCompletionReviewArtifact({
+        state: blockedState,
+        source: 'reviewer_verdict',
+        sessionHandle: args.error.sessionHandle,
+    });
+    await args.logger?.event('phase.error', {
+        phase: 'final_completion_review',
+        sessionHandle: args.error.sessionHandle,
+        subtype: args.error.subtype,
+        errorKind: args.error.kind,
+        message: args.error.message,
+    });
+    return blockedState;
+}
 function normalizeFinalCommitMessage(message) {
     const normalizedNewlines = message.replace(/\r\n/g, '\n');
     const convertedEscapes = normalizedNewlines.replace(/\\n(?=- )/g, '\n');
@@ -105,7 +137,12 @@ function getFinalCompletionReviewBlockReason(args) {
     return `final_completion_review: reviewer blocked completion for operator guidance. ${args.rationale} One available next step is to inspect with \`neal status\` and provide guidance with \`neal resume --message "..."\` only if the run is waiting for operator guidance.`;
 }
 async function discardFinalCompletionReviewerWorktreeChanges(args) {
-    const statusOutput = filterWrapperOwnedWorktreeStatus(await getWorktreeStatus(args.state.cwd, { untrackedFiles: 'all' }));
+    // The plan document is a wrapper-owned overlay, not reviewer dirt: it may be
+    // an uncommitted modification of a tracked file (a reset --hard would
+    // silently swap in the committed content — a different plan — mid-run) or an
+    // untracked seed. Exclude it from the trigger and the post-check, and
+    // preserve its bytes across the destructive cleanup.
+    const statusOutput = filterAllowedDirtyPathStatus(args.state.cwd, filterWrapperOwnedWorktreeStatus(await getWorktreeStatus(args.state.cwd, { untrackedFiles: 'all' })), [args.state.planDoc]);
     if (!statusOutput.trim()) {
         return;
     }
@@ -115,9 +152,11 @@ async function discardFinalCompletionReviewerWorktreeChanges(args) {
         statusOutput,
         message: 'Final completion review is read-only; discarding reviewer-created worktree changes before state transition.',
     });
-    await resetHard(args.state.cwd, headCommit);
-    await cleanUntracked(args.state.cwd, ['.neal/', '.forge/', 'CURRENT_PLAN.md']);
-    const remainingStatusOutput = filterWrapperOwnedWorktreeStatus(await getWorktreeStatus(args.state.cwd, { untrackedFiles: 'all' }));
+    await withPlanDocPreserved(args.state.planDoc, async () => {
+        await resetHard(args.state.cwd, headCommit);
+        await cleanUntracked(args.state.cwd, ['.neal/', '.forge/', 'CURRENT_PLAN.md']);
+    });
+    const remainingStatusOutput = filterAllowedDirtyPathStatus(args.state.cwd, filterWrapperOwnedWorktreeStatus(await getWorktreeStatus(args.state.cwd, { untrackedFiles: 'all' })), [args.state.planDoc]);
     if (remainingStatusOutput.trim()) {
         throw new Error(`Final completion review left a dirty worktree Neal could not restore:\n${remainingStatusOutput}`);
     }
@@ -149,7 +188,8 @@ async function runParentAdvanceFinalization(args) {
                 `Neal-created commits: ${formatCommitList(state.createdCommits)}`,
             ].join('\n'));
         }
-        await resetHard(state.cwd, state.baseCommit);
+        const parentBaseCommit = state.baseCommit;
+        await withPlanDocPreserved(state.planDoc, () => resetHard(state.cwd, parentBaseCommit));
     }
     const finalCommit = state.baseCommit;
     const archivedReviewPath = join(state.runDir, `REVIEW-${finalCommit}.md`);
@@ -203,11 +243,10 @@ async function runParentAdvanceFinalization(args) {
     }, parentScope?.commitSubject ?? `Parent scope ${parentScopeLabel} complete via derived plan`, logger);
     return nextState;
 }
-export async function runExecuteFinalizationPhase(state, statePath, logger, runtime) {
-    if (!state.baseCommit) {
-        throw new Error('Cannot finalize without a baseCommit');
-    }
-    await logger?.event('phase.start', { phase: EXECUTE_FINALIZATION_PHASE });
+// Dirty-worktree admission for execute finalization: capture the head commit,
+// filter the worktree status down to disallowed dirt, and refuse to finalize
+// (with the expected-scratch-dir diagnostic) when any remains.
+async function admitFinalizationWorktree(state) {
     const headCommit = await getHeadCommit(state.cwd);
     const statusOutput = filterAllowedDirtyPathStatus(state.cwd, filterWrapperOwnedWorktreeStatus(await getWorktreeStatus(state.cwd)), state.allowedDirtyPaths);
     if (statusOutput) {
@@ -217,6 +256,132 @@ export async function runExecuteFinalizationPhase(state, statePath, logger, runt
         });
         throw new Error([`Cannot finalize with a dirty worktree:\n${statusOutput}`, diagnostic].filter(Boolean).join('\n\n'));
     }
+    return { headCommit, statusOutput };
+}
+// Raw material for final-commit message synthesis: the full message of the
+// latest Neal-created commit, falling back to the last recorded subject (with
+// any leading hash stripped) and then to the fixed default.
+async function readRawFinalCommitMessage(cwd, createdCommits) {
+    const commitSubjects = await getCommitSubjects(cwd, createdCommits);
+    const latestCreatedCommit = createdCommits.at(-1) ?? null;
+    return latestCreatedCommit
+        ? await getCommitMessage(cwd, latestCreatedCommit)
+        : commitSubjects.at(-1)?.replace(/^[a-f0-9]+\s+/, '') || 'Finalize scope work';
+}
+// Final-commit message synthesis: strip the scope prefix, normalize newlines
+// (falling back to the fixed default when stripping leaves nothing), apply the
+// plan-doc-only special case, and derive the subject line.
+function synthesizeFinalCommitMessage(args) {
+    const strippedFinalMessage = stripScopePrefixFromCommitMessage(args.rawFinalMessage);
+    const finalMessage = normalizeFinalCommitMessage(strippedFinalMessage.trim() ? strippedFinalMessage : 'Finalize scope work');
+    const onlyChangedFile = args.finalizationChangedFiles.length === 1 ? args.finalizationChangedFiles[0] : null;
+    const onlyChangedPlanDoc = onlyChangedFile !== null &&
+        args.planDocRepoRelativePath !== null &&
+        onlyChangedFile === args.planDocRepoRelativePath;
+    const finalCommitMessage = onlyChangedPlanDoc ? 'Record Neal plan document\n' : finalMessage;
+    const finalSubject = finalCommitMessage.split(/\r?\n/, 1)[0] || 'Finalize scope work';
+    return { finalCommitMessage, finalSubject };
+}
+// The one shared failure-persistence path for both summary-adjudication catch
+// branches. Ordering is pinned by test/execute-finalization-failure.test.ts:
+// failed state save, execution artifacts, failed final-completion review
+// artifact (coder-round branch only), checkpoint retrospective, phase.error,
+// gated notification (coder-round branch only).
+async function persistExecuteFinalizationFailure(args) {
+    const { state, coderRoundExtras } = args;
+    const failedState = await saveState(args.statePath, {
+        ...state,
+        finalCommit: args.finalCommit,
+        archivedReviewPath: args.archivedReviewPath,
+        completedScopes: args.completedScopes,
+        ...(coderRoundExtras
+            ? {
+                coderSessionHandle: coderRoundExtras.sessionHandleOverride,
+                coderSessionProtocol: coderRoundExtras.sessionHandleOverride
+                    ? state.coderSessionProtocol ?? 'structured_json_v1'
+                    : null,
+            }
+            : {}),
+        status: 'failed',
+    });
+    await args.runtime.writeExecutionArtifacts(failedState);
+    if (coderRoundExtras) {
+        await writeFailedFinalCompletionReviewArtifact({
+            state: failedState,
+            source: 'coder_summary',
+            sessionHandle: coderRoundExtras.sessionHandleOverride,
+        });
+    }
+    await writeCheckpointRetrospective({
+        ...failedState,
+        finalCompletionSummary: args.finalCompletionSummary,
+    }, 'failed');
+    await args.logger?.event('phase.error', {
+        phase: EXECUTE_FINALIZATION_PHASE,
+        sessionHandle: coderRoundExtras ? coderRoundExtras.sessionHandleOverride : state.coderSessionHandle,
+        message: args.errorMessage,
+    });
+    if (coderRoundExtras?.notify) {
+        await notifyBlocked(failedState, args.errorMessage, args.logger);
+    }
+}
+// Summary adjudication for a terminal finalization: archive the review, build
+// the final-completion packet, run the coder final-completion summary round,
+// and route BOTH failure branches through the shared persistence helper
+// before rethrowing.
+async function adjudicateFinalCompletionSummary(args) {
+    const { state, logger } = args;
+    await writeTextAtomic(args.archivedReviewPath, renderReviewMarkdown({ ...args.archivedReviewState, finalCompletionSummary: null, finalCompletionReviewVerdict: null }));
+    const packet = await buildFinalCompletionPacket({
+        state: args.retrospectiveState,
+        terminalScope: {
+            finalCommit: args.finalCommit,
+            commitSubject: args.finalSubject,
+            changedFiles: args.finalizationChangedFiles,
+            archivedReviewPath: args.archivedReviewPath,
+            marker: state.lastScopeMarker,
+        },
+    });
+    try {
+        const { summary: finalCompletion } = await runFinalCompletionSummaryAdjudication({
+            state,
+            packet,
+            logger,
+        });
+        return finalCompletion.summary;
+    }
+    catch (error) {
+        const coderRoundFailure = error instanceof CoderRoundError ? error : null;
+        await persistExecuteFinalizationFailure({
+            state,
+            statePath: args.statePath,
+            runtime: args.runtime,
+            logger,
+            finalCommit: args.finalCommit,
+            archivedReviewPath: args.archivedReviewPath,
+            completedScopes: args.completedScopes,
+            finalCompletionSummary: args.finalCompletionSummary,
+            errorMessage: coderRoundFailure
+                ? coderRoundFailure.message
+                : error instanceof Error
+                    ? error.message
+                    : String(error),
+            coderRoundExtras: coderRoundFailure
+                ? {
+                    sessionHandleOverride: coderRoundFailure.sessionHandle ?? state.coderSessionHandle,
+                    notify: shouldNotifyFailure(coderRoundFailure),
+                }
+                : null,
+        });
+        throw error;
+    }
+}
+export async function runExecuteFinalizationPhase(state, statePath, logger, runtime) {
+    if (!state.baseCommit) {
+        throw new Error('Cannot finalize without a baseCommit');
+    }
+    await logger?.event('phase.start', { phase: EXECUTE_FINALIZATION_PHASE });
+    const { headCommit, statusOutput } = await admitFinalizationWorktree(state);
     if (state.currentScopeMeaningfulProgressVerdict?.action === 'advance_parent') {
         return runParentAdvanceFinalization({
             state,
@@ -227,13 +392,7 @@ export async function runExecuteFinalizationPhase(state, statePath, logger, runt
             statusOutput,
         });
     }
-    const commitSubjects = await getCommitSubjects(state.cwd, state.createdCommits);
-    const latestCreatedCommit = state.createdCommits.at(-1) ?? null;
-    const rawFinalMessage = latestCreatedCommit
-        ? await getCommitMessage(state.cwd, latestCreatedCommit)
-        : commitSubjects.at(-1)?.replace(/^[a-f0-9]+\s+/, '') || 'Finalize scope work';
-    const strippedFinalMessage = stripScopePrefixFromCommitMessage(rawFinalMessage);
-    const finalMessage = normalizeFinalCommitMessage(strippedFinalMessage.trim() ? strippedFinalMessage : 'Finalize scope work');
+    const rawFinalMessage = await readRawFinalCommitMessage(state.cwd, state.createdCommits);
     const planDocInspection = await inspectPlanDocDisposition(state.cwd, state.planDoc);
     if (planDocInspection.eligibleForCommit && planDocInspection.repoRelativePath) {
         await stagePath(state.cwd, planDocInspection.repoRelativePath);
@@ -242,12 +401,11 @@ export async function runExecuteFinalizationPhase(state, statePath, logger, runt
     const stagedChangedFiles = await getStagedChangedFiles(state.cwd);
     const finalizationChangedFiles = unionChangedFiles(changedFilesSinceBase, stagedChangedFiles);
     await assertNoIgnoredChangedFiles(state.cwd, finalizationChangedFiles, 'Execute finalization');
-    const onlyChangedFile = finalizationChangedFiles.length === 1 ? finalizationChangedFiles[0] : null;
-    const onlyChangedPlanDoc = onlyChangedFile !== null &&
-        planDocInspection.repoRelativePath !== null &&
-        onlyChangedFile === planDocInspection.repoRelativePath;
-    const finalCommitMessage = onlyChangedPlanDoc ? 'Record Neal plan document\n' : finalMessage;
-    const finalSubject = finalCommitMessage.split(/\r?\n/, 1)[0] || 'Finalize scope work';
+    const { finalCommitMessage, finalSubject } = synthesizeFinalCommitMessage({
+        rawFinalMessage,
+        finalizationChangedFiles,
+        planDocRepoRelativePath: planDocInspection.repoRelativePath,
+    });
     const finalCommit = finalizationChangedFiles.length > 0
         ? await createScopeFinalizationCommit(state.cwd, state.baseCommit, finalCommitMessage)
         : headCommit;
@@ -278,78 +436,20 @@ export async function runExecuteFinalizationPhase(state, statePath, logger, runt
     const initialFinalCompletion = requireFinalCompletionView(state, 'run execute finalization');
     let finalCompletionSummary = initialFinalCompletion.summary;
     if (!continueScopes && !finalCompletionSummary) {
-        await writeTextAtomic(archivedReviewPath, renderReviewMarkdown({ ...archivedReviewState, finalCompletionSummary: null, finalCompletionReviewVerdict: null }));
-        const packet = await buildFinalCompletionPacket({
-            state: retrospectiveState,
-            terminalScope: {
-                finalCommit,
-                commitSubject: finalSubject,
-                changedFiles: finalizationChangedFiles,
-                archivedReviewPath,
-                marker: state.lastScopeMarker,
-            },
+        finalCompletionSummary = await adjudicateFinalCompletionSummary({
+            state,
+            statePath,
+            logger,
+            runtime,
+            finalCommit,
+            archivedReviewPath,
+            archivedReviewState,
+            retrospectiveState,
+            completedScopes,
+            finalSubject,
+            finalizationChangedFiles,
+            finalCompletionSummary,
         });
-        try {
-            const { summary: finalCompletion } = await runFinalCompletionSummaryAdjudication({
-                state,
-                packet,
-                logger,
-            });
-            finalCompletionSummary = finalCompletion.summary;
-        }
-        catch (error) {
-            if (error instanceof CoderRoundError) {
-                const failedState = await saveState(statePath, {
-                    ...state,
-                    finalCommit,
-                    archivedReviewPath,
-                    completedScopes,
-                    coderSessionHandle: error.sessionHandle ?? state.coderSessionHandle,
-                    coderSessionProtocol: (error.sessionHandle ?? state.coderSessionHandle)
-                        ? state.coderSessionProtocol ?? 'structured_json_v1'
-                        : null,
-                    status: 'failed',
-                });
-                await runtime.writeExecutionArtifacts(failedState);
-                await writeFailedFinalCompletionReviewArtifact({
-                    state: failedState,
-                    source: 'coder_summary',
-                    sessionHandle: error.sessionHandle ?? state.coderSessionHandle,
-                });
-                await writeCheckpointRetrospective({
-                    ...failedState,
-                    finalCompletionSummary,
-                }, 'failed');
-                await logger?.event('phase.error', {
-                    phase: EXECUTE_FINALIZATION_PHASE,
-                    sessionHandle: error.sessionHandle ?? state.coderSessionHandle,
-                    message: error.message,
-                });
-                if (shouldNotifyFailure(error)) {
-                    await notifyBlocked(failedState, error.message, logger);
-                }
-            }
-            else {
-                const failedState = await saveState(statePath, {
-                    ...state,
-                    finalCommit,
-                    archivedReviewPath,
-                    completedScopes,
-                    status: 'failed',
-                });
-                await runtime.writeExecutionArtifacts(failedState);
-                await writeCheckpointRetrospective({
-                    ...failedState,
-                    finalCompletionSummary,
-                }, 'failed');
-                await logger?.event('phase.error', {
-                    phase: EXECUTE_FINALIZATION_PHASE,
-                    sessionHandle: state.coderSessionHandle,
-                    message: error instanceof Error ? error.message : String(error),
-                });
-            }
-            throw error;
-        }
     }
     const nextState = await saveState(statePath, continueScopes
         ? {
@@ -412,6 +512,21 @@ export async function runFinalCompletionReviewPhase(state, statePath, logger, ru
         }));
     }
     catch (error) {
+        // A reviewer content-safety refusal ends the run blocked (exit 2) with a
+        // durable actionable reason, by RETURNING the terminal blocked state rather
+        // than throwing. Only a ReviewerRoundError carries `content_refused`; the
+        // verdict-invalid error never does, so it stays on the failed path below.
+        if (error instanceof ReviewerRoundError && error.kind === 'content_refused') {
+            const blockedState = await persistBlockedFinalCompletionReview({
+                state,
+                statePath,
+                error,
+                logger,
+                runtime,
+            });
+            await notifyBlocked(blockedState, REVIEWER_CONTENT_REFUSED_BLOCK_REASON, logger);
+            return blockedState;
+        }
         if (error instanceof ReviewerRoundError || error instanceof FinalCompletionReviewerVerdictError) {
             const failedState = await persistFailedFinalCompletionReview({
                 state,
@@ -462,32 +577,19 @@ export async function runFinalCompletionReviewPhase(state, statePath, logger, ru
         : actionResolution.effectiveAction === 'continue_execution'
             ? await saveState(statePath, {
                 ...baseState,
-                baseCommit: state.finalCommit,
-                finalCommit: null,
-                archivedReviewPath: null,
-                coderSessionHandle: null,
-                coderSessionProtocol: null,
+                ...createNextScopeEntryReset(state.finalCommit),
                 coderRetryCount: 0,
                 currentScopeNumber: shouldAdvanceTopLevelScopeNumber(state)
                     ? state.currentScopeNumber + 1
                     : state.currentScopeNumber,
-                lastScopeMarker: null,
-                currentScopeProgressJustification: null,
-                currentScopeMeaningfulProgressVerdict: null,
-                finalCompletionSummary: null,
-                rounds: [],
-                recentBlocks: [],
                 // The reopened follow-on scope is a fresh scope boundary: per-scope
                 // budgets reset here exactly as they do at every scope-advance
                 // transition, so an earlier scope's adjudication or split-plan
                 // consumption never exhausts the reopened scope's budget.
-                reviewStuckArbiterCount: 0,
+                // (`consultantAttemptCount` resets via the shared next-scope
+                // reset spread above.)
                 splitPlanCountForCurrentScope: 0,
-                findings: [],
-                createdCommits: [],
                 blockedFromPhase: null,
-                phase: 'coder_scope',
-                status: 'running',
             })
             : unattendedFinalCompletionBlock
                 ? await persistUnattendedBlockUnresolvedFailure({

package/dist/neal/orchestrator/failures.js

@@ -1,4 +1,11 @@
 import { CoderRoundError } from '../agents.js';
+// Shared, durable blocked reason for a reviewer content-safety refusal
+// (`content_refused`). Defined once so the wording cannot drift across the
+// three reviewer-phase catch sites that route it to a terminal blocked landing.
+export const REVIEWER_CONTENT_REFUSED_BLOCK_REASON = 'The reviewer refused this content on content-safety grounds. The change ' +
+    'under review may read as security-adjacent. Switch the reviewer to a ' +
+    'different provider, rephrase the scope, or seek provider authorization, ' +
+    'then re-run.';
 export function isCoderTimeoutError(error) {
     return (error.kind === 'timeout' ||
         error.kind === 'no_progress_timeout' ||

package/dist/neal/orchestrator/notifications.js

@@ -3,40 +3,40 @@ import { notify } from '../../notifier.js';
 import { getCurrentScopeLabel, getExecutionPlanPath, getExecutionPlanScopeCount, getParentScopeLabel, renderScopeProgressSegments, } from '../scopes.js';
 import { saveState } from '../state.js';
 import { getDerivedPlanView } from '../state-views.js';
-// Concise representation of the read-only blocked-adjudicator advice for the
+// Concise representation of the read-only consultant advice for the
 // operator notification surface. Present only on an attended run whose active
-// interactive-blocked-recovery record carries adjudicator advice (knob > 0,
+// 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
 // notifications, where the active record is already finalized to null — is
 // unchanged.
-function adjudicatorAdviceNotificationSuffix(state) {
-    const advice = state.interactiveBlockedRecovery?.adjudicatorAdvice;
+function consultantAdviceNotificationSuffix(state) {
+    const advice = state.interactiveBlockedRecovery?.consultantAdvice;
     if (!advice) {
         return '';
     }
     const directive = advice.resolutionDirective.trim() || 'n/a';
-    return ` | adjudicator advice (read-only): triage ${advice.triageCategory}; suggested directive: ${directive}`;
+    return ` | consultant advice (read-only): triage ${advice.triageCategory}; suggested directive: ${directive}`;
 }
 async function notifyBlocked(state, reason, logger) {
     const planName = basename(state.planDoc);
-    const adviceSuffix = adjudicatorAdviceNotificationSuffix(state);
+    const adviceSuffix = consultantAdviceNotificationSuffix(state);
     await logger?.event('notify.blocked', {
         reason,
         planName,
-        adjudicatorAdvice: state.interactiveBlockedRecovery?.adjudicatorAdvice ?? null,
+        consultantAdvice: state.interactiveBlockedRecovery?.consultantAdvice ?? null,
     });
     await notify('blocked', `[neal] ${planName}: ${reason}${adviceSuffix}`, state.cwd);
 }
 async function notifyInteractiveBlockedRecovery(state, reason, logger) {
     const planName = basename(state.planDoc);
     const scopeLabel = getCurrentScopeLabel(state);
-    const adviceSuffix = adjudicatorAdviceNotificationSuffix(state);
+    const adviceSuffix = consultantAdviceNotificationSuffix(state);
     await logger?.event('notify.interactive_blocked_recovery', {
         reason,
         planName,
         scopeNumber: scopeLabel,
-        adjudicatorAdvice: state.interactiveBlockedRecovery?.adjudicatorAdvice ?? null,
+        consultantAdvice: state.interactiveBlockedRecovery?.consultantAdvice ?? null,
     });
     await notify('retry', `[neal] ${planName}: interactive blocked recovery for scope ${scopeLabel}: ${reason}${adviceSuffix}`, state.cwd);
 }