@navels/neal 0.6.3 → 0.6.5

package/dist/neal/agents/rounds.js

@@ -556,6 +556,7 @@ export async function runCoderPlanRound(args) {
             sessionHandle,
             finalResponse,
             marker,
+            blockedReason: normalizedPayload.action === 'blocked' ? normalizedPayload.blockedReason.trim() || null : null,
         };
     }
     const coder = getCoderAdapter(args.coder);
@@ -603,6 +604,7 @@ export async function runCoderPlanRound(args) {
         sessionHandle,
         finalResponse,
         marker,
+        blockedReason: null,
     };
 }
 function renderCoderPlanPayload(payload, marker) {

package/dist/neal/commands/runtime.js

@@ -9,6 +9,7 @@ import { runOnePass } from '../orchestrator.js';
 import { writeExecutionArtifacts } from '../orchestrator/artifacts.js';
 import { countOpenNonBlockingFindings, determinePlanRefinementConvergence, formatPlanRefinementSummary, isPlanRefinementState, } from '../plan-refinement.js';
 import { acquireActiveRunLock, releaseActiveRunLockSync } from '../run-lock.js';
+import { planResumeActions } from '../resume-planner.js';
 import { formatPublicRunStatus, getRunDisplayStatus } from '../run-status.js';
 import { getCurrentScopeLabel } from '../scopes.js';
 import { resolveRunStatePath } from '../run-registry.js';
@@ -200,6 +201,12 @@ function armShutdownWatchdog(finalState, logger) {
         });
     };
 }
+// Keep a crash message readable on the console; `neal status` carries the
+// full text from the `phase.error` event.
+function truncateFailureMessage(message) {
+    const trimmed = message.trim();
+    return trimmed.length > 1000 ? `${trimmed.slice(0, 1000)}…` : trimmed;
+}
 function formatFinalSummaryLine(finalState, publicStatus) {
     if (publicStatus === 'waiting_for_manual_gate') {
         const gate = finalState.manualGate;
@@ -255,6 +262,9 @@ function formatFinalNextAction(finalState, displayStatus, runId, guidance) {
         return `Inspect failure: neal status --run ${runId}; resume when ready: neal resume --run ${runId}`;
     }
     if (finalState.status === 'blocked') {
+        if (planResumeActions(finalState).some((action) => action.kind === 'restore_resumable_blocked_phase')) {
+            return `Address the reason above, then re-run ${formatPublicPhase(finalState.blockedFromPhase ?? finalState.phase)}: neal resume --run ${runId}`;
+        }
         return `Inspect blocked run: neal status --run ${runId}; provide guidance with neal resume --run ${runId} --message "..." only if the run is waiting for operator guidance`;
     }
     if (displayStatus.effectiveStatus === 'paused') {
@@ -265,7 +275,7 @@ function formatFinalNextAction(finalState, displayStatus, runId, guidance) {
     }
     return `Continue this run: neal resume --run ${runId}`;
 }
-export function renderFinalRunOutput(finalState, statePath, displayStatus, autoSquashResult = null) {
+export function renderFinalRunOutput(finalState, statePath, displayStatus, autoSquashResult = null, failureMessage = null) {
     const runId = basename(finalState.runDir);
     const publicStatus = formatPublicRunStatus(displayStatus);
     const findings = countFinalFindings(finalState);
@@ -312,6 +322,18 @@ export function renderFinalRunOutput(finalState, statePath, displayStatus, autoS
     if (guidance) {
         lines.push('', ...renderBlockedGuidanceSections(guidance));
     }
+    else if (finalState.blockerReason) {
+        // A block that is not waiting for `--message` guidance has no guidance
+        // section, so print the stored reason under the same heading.
+        lines.push('', '## Why Neal Stopped', finalState.blockerReason);
+    }
+    else if (finalState.status === 'failed' && failureMessage) {
+        // A crashed round is caught above and rendered as a failed result instead
+        // of being rethrown, so the error text has to be printed here or the
+        // console never shows it. `neal status` reads the same message from the
+        // `phase.error` event.
+        lines.push('', '## Why Neal Stopped', truncateFailureMessage(failureMessage));
+    }
     lines.push('', '## Next Action', `- ${formatFinalNextAction(finalState, displayStatus, runId, guidance)}`);
     return lines.join('\n');
 }
@@ -411,6 +433,7 @@ export async function executeRun(state, statePath, logger, options = {}) {
             writeDiagnostic(renderInteractiveKeyHint(allowStopRequest));
         }
         let finalState;
+        let runFailureMessage = null;
         try {
             try {
                 finalState = await runOnePass(state, statePath, logger, {
@@ -435,6 +458,7 @@ export async function executeRun(state, statePath, logger, options = {}) {
                 if (!finalState) {
                     throw error;
                 }
+                runFailureMessage = error instanceof Error ? error.message : String(error);
             }
         }
         finally {
@@ -477,7 +501,7 @@ export async function executeRun(state, statePath, logger, options = {}) {
             status: finalState.status,
             runDir: finalState.runDir,
         });
-        const finalOutput = renderFinalRunOutput(finalState, statePath, displayStatus, autoSquashResult);
+        const finalOutput = renderFinalRunOutput(finalState, statePath, displayStatus, autoSquashResult, runFailureMessage);
         process.stdout.write(finalOutput.trimEnd() + '\n');
         await logger.event('shutdown.final_output_written', {
             phase: finalState.phase,

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

@@ -211,17 +211,23 @@ export async function runCoderPlanPhase(state, statePath, logger) {
     }
     const completionProblem = getPlanningCompletionProblem(codex.marker);
     const dirtyWorktreeBlocker = await getPlanPhaseDirtyWorktreeBlocker(workingState, 'coder_plan');
+    const blocked = codex.marker === 'AUTONOMY_BLOCKED' || Boolean(completionProblem) || Boolean(dirtyWorktreeBlocker);
+    // Persist why the planner stopped so `neal status` and the run result can show
+    // it. A `coder_plan` block is never answerable via `neal resume --message`
+    // (that eligibility keys on `blockedFromPhase`), so a non-null reason here
+    // only informs the operator; it does not change resume behavior.
+    const reason = blocked
+        ? dirtyWorktreeBlocker ?? completionProblem ?? codex.blockedReason ?? 'The planner reported a blocker during plan refinement'
+        : null;
     const nextState = await saveState(statePath, {
         ...workingState,
         plannerSessionHandle: codex.sessionHandle,
         plannerSessionProtocol: codex.sessionHandle ? activePlannerSessionProtocol : null,
         lastScopeMarker: codex.marker,
-        phase: codex.marker === 'AUTONOMY_BLOCKED' || completionProblem || dirtyWorktreeBlocker ? 'blocked' : 'reviewer_plan',
-        status: codex.marker === 'AUTONOMY_BLOCKED' || completionProblem || dirtyWorktreeBlocker ? 'blocked' : 'running',
-        blockedFromPhase: codex.marker === 'AUTONOMY_BLOCKED' || completionProblem || dirtyWorktreeBlocker ? 'coder_plan' : null,
-        // The initial coder_plan authoring block never carries the recoverable
-        // coder-response blocker reason; keep it cleared whether we advance or block.
-        blockerReason: null,
+        phase: blocked ? 'blocked' : 'reviewer_plan',
+        status: blocked ? 'blocked' : 'running',
+        blockedFromPhase: blocked ? 'coder_plan' : null,
+        blockerReason: reason,
     });
     await writeExecutionArtifacts(nextState);
     await logger?.event('phase.complete', {
@@ -230,8 +236,7 @@ export async function runCoderPlanPhase(state, statePath, logger) {
         sessionHandle: codex.sessionHandle,
         nextPhase: nextState.phase,
     });
-    if (nextState.status === 'blocked') {
-        const reason = dirtyWorktreeBlocker ?? completionProblem ?? 'The coder reported a blocker during plan revision';
+    if (nextState.status === 'blocked' && reason !== null) {
         if (nextState.topLevelMode !== 'execute') {
             await notifyBlocked(nextState, reason, logger);
             return nextState;

package/dist/neal/terminal-narrator.js

@@ -325,14 +325,16 @@ function renderLifecycleEvents(state, scopeDescriptor, options) {
     }
     if (state.status === 'blocked') {
         const blockedPhase = state.blockedFromPhase ?? state.phase;
+        const blockLine = formatScopeRelatedPhase(blockedPhase)
+            ? options.scopeIntroEstablished
+                ? `Run is blocked during ${formatPublicPhase(blockedPhase)}.`
+                : `Run is blocked during ${formatPublicPhase(blockedPhase)} for ${scopeReference}.`
+            : `Run is blocked during ${formatPublicPhase(blockedPhase)}.`;
+        const reason = (state.blockerReason ?? state.interactiveBlockedRecovery?.blockedReason ?? '').replace(/\s+/g, ' ').trim();
         return [
             {
                 signature: `lifecycle:${runId}:blocked:${blockedPhase}`,
-                line: formatScopeRelatedPhase(blockedPhase)
-                    ? options.scopeIntroEstablished
-                        ? `Run is blocked during ${formatPublicPhase(blockedPhase)}.`
-                        : `Run is blocked during ${formatPublicPhase(blockedPhase)} for ${scopeReference}.`
-                    : `Run is blocked during ${formatPublicPhase(blockedPhase)}.`,
+                line: reason ? `${blockLine} ${reason}` : blockLine,
             },
         ];
     }

package/docs/maintenance.md

@@ -52,7 +52,9 @@ is gated on it as a whole.
    opens and merges the release-preparation PR (version bump + changelog), and
    runs the Publish workflow through the npm 2FA approval. See
    [docs/release.md](release.md). Urgent bumps (a fix neal needs immediately)
-   may skip the Renovate soak with a manual PR. Qualify them the same way.
+   may skip the Renovate soak with a manual PR: `scripts/bump-native-sdks.sh`
+   opens one at the current latest releases. Qualify it the same way. Leave
+   Renovate's own SDK PR open; it closes itself once the manual bump merges.
 
 ## TypeScript 6 and 7 side by side
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navels/neal",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "A source-first multi-agent CLI for planning, executing, reviewing, and resuming scoped code changes.",
   "license": "MIT",
   "publishConfig": {
@@ -56,8 +56,8 @@
   },
   "dependencies": {
     "@ai-sdk/openai-compatible": "3.0.39",
-    "@anthropic-ai/claude-agent-sdk": "0.3.252",
-    "@openai/codex-sdk": "0.151.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.260",
+    "@openai/codex-sdk": "0.153.2",
     "ai": "7.0.83",
     "dotenv": "^17.4.2",
     "yaml": "^2.9.0",