@akagilnc/pi-workflow-roles 0.1.4586 → 0.1.4631

package/dist/public-cli/option-definitions.js

@@ -1050,7 +1050,7 @@ const ROLE_COMMAND_HELP = {
     },
     navigator: {
         command: "navigator",
-        summary: "Direct Navigator (游奕使) route advice: ordered next-role candidates.",
+        summary: "Direct Navigator (游奕使) free-form prose route advice.",
         usage: ["ak-role navigator [options] [instruction]"],
         examples: [
             'ak-role navigator "刚完成 coder apply 收敛，下一步？"',

package/dist/public-cli/post-admission.js

@@ -8,7 +8,7 @@
 import { randomUUID } from "node:crypto";
 import { writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
-import { buildResumeContinuationPrompt, RESUME_TRANSPORT_ENVELOPE, } from "./run-lifecycle.js";
+import { buildAutoResumeContinuationPrompt, buildResumeContinuationPrompt, RESUME_TRANSPORT_ENVELOPE, } from "./run-lifecycle.js";
 import { CliUsageError } from "./cli-errors.js";
 import { bindAdmittedTicketNumber, buildInstructionTransportPrompt, freezeAttachmentsIntoRun, } from "./invocation.js";
 import { readRecordedSubmissionRows } from "../submission-ledger.js";
@@ -37,10 +37,36 @@ import { mintEngineDetourInvocationScope, readInvocationSelectedHost, withEngine
 import { projectHostTransitionPriorNative } from "../host-transition-prior-native.js";
 import { missingCredentialPreDispatchFailure, postRunMissingCredentialFailure, } from "./public-run-credentials.js";
 import { acquireRunWriterLease, clearCurrentCourt, clearTypedProviderHttpObservation, describeErrorIdentity, markRunRunning, readCurrentCourt, recordCurrentCourt, renderResumeCommand, RunWriterLeaseHeldError, } from "./run-lifecycle.js";
+import { processCancelDiagnostic, processCancelSignalName, } from "./process-cancel.js";
 import { homeFromRunDirectory } from "../activation-ledger-topology.js";
 import { attemptProducedFreshSubmission, classifyPostAdmissionFailure, controlledFailureInputFromResolution, exitCodeForTerminalOutcome, explicitInternalKnownFailureClassificationInput, formatCliDiagnostic, formatTerminalResult, inspectJudgeSession, isLawfulTypedTerminalOutcome, presentFailureTerminal, presentStructuralRejection, resolveAuditedRunnerFailureResolution, resolveControlledFailureResumeObservation, settleFailureTerminalResult, settleHostEndedNoReceipt, attachRecordedSubmissions, } from "./settlement.js";
 import {} from "./terminal.js";
 import { ensureRealArtifactsDirectory, persistReturnedRunState, runWithAutoResumeLoop, TurnDispatchedFailure, } from "./auto-resume.js";
+/** #855: process-cancel settlement never re-enters auto-resume. */
+function withProcessCancelSkipAutoResume(result, signal) {
+    if (processCancelSignalName(signal) === undefined) {
+        return result;
+    }
+    return { ...result, skipAutoResume: true };
+}
+/**
+ * #855: turn already started, then a catchable process signal arrived before
+ * lawful seal — settle as named cancel failure and skip auto-resume.
+ */
+async function settleProcessCancelAfterTurn(input) {
+    const failed = await settleAfterTurnStarted(input.admitted, withEngineDetourInvocationScope({
+        timedOut: input.result.timedOut,
+        code: input.result.code,
+        stderr: input.result.stderr,
+        knownDiagnostic: processCancelDiagnostic(input.cancelName),
+    }, input.invocationScopeId), input.adapters, input.env.principalAuthority, input.io, input.persistRunState);
+    return {
+        ...failed,
+        turnDispatched: true,
+        skipAutoResume: true,
+        ...input.deferredPersist,
+    };
+}
 /**
  * Nested station-child role already finished its own call-local loop.
  * Parent records that failure once and must not auto-resume into a re-summon
@@ -258,6 +284,26 @@ export async function dispatchPostAdmissionTurn(input) {
         if (afterDispatchApplied)
             return result;
         afterDispatchApplied = true;
+        // #855: re-read cancel before afterDispatch finalization — never present
+        // lawful success after a catchable process signal. skipRunStateWrite: run-state
+        // may already be terminal from a prior lawful persist; do not reopen as resumable.
+        const cancelBeforeFinish = processCancelSignalName(env.signal);
+        if (cancelBeforeFinish !== undefined &&
+            result.terminal !== undefined &&
+            isLawfulTypedTerminalOutcome(result.terminal.roleOutcome)) {
+            result = {
+                ...(await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
+                    timedOut: false,
+                    code: null,
+                    stderr: "",
+                    knownDiagnostic: processCancelDiagnostic(cancelBeforeFinish),
+                    skipRunStateWrite: true,
+                }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState)),
+                turnDispatched: true,
+                skipAutoResume: true,
+                ...deferredPersist,
+            };
+        }
         try {
             // #858: an unbound seat may assert its ticket on the existing receipt.
             // Read the original accepted payload; do not rewrite it, infer from prose,
@@ -412,13 +458,16 @@ export async function dispatchPostAdmissionTurn(input) {
             result = await env.roleTurnHost.executeTurn(turnRequest);
         }
         catch (error) {
+            const processCancelName = processCancelSignalName(env.signal);
             const settled = await settleAfterTurnStarted(admitted, withEngineDetourInvocationScope({
                 timedOut: false,
                 code: null,
                 stderr: "",
-                thrown: error,
+                thrown: processCancelName === undefined
+                    ? error
+                    : new Error(processCancelDiagnostic(processCancelName), { cause: error }),
             }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
-            return await finishAfterTurn({ ...settled, turnDispatched: true, ...deferredPersist });
+            return await finishAfterTurn(withProcessCancelSkipAutoResume({ ...settled, turnDispatched: true, ...deferredPersist }, env.signal));
         }
         // `result.stderr` stays live in memory for the real classification below
         // regardless of whether this durable mirror write succeeds. A write
@@ -514,10 +563,12 @@ export async function dispatchPostAdmissionTurn(input) {
             // retroactively invalidate an acceptance that already sealed this turn
             // — a resolved 429 observed earlier in the same session is exactly
             // that.
+            const processCancelName = processCancelSignalName(env.signal);
             const directHostFailureSignal = result.timedOut
                 || result.knownFailure !== undefined
                 || runnerKnownFailure !== undefined
-                || credentialFailure !== undefined;
+                || credentialFailure !== undefined
+                || processCancelName !== undefined;
             hostSignalFailed =
                 directHostFailureSignal
                     || (result.code !== null && result.code !== 0)
@@ -553,11 +604,15 @@ export async function dispatchPostAdmissionTurn(input) {
             // where a bare nonzero exit / resolution failure must not be outranked
             // by someone else's earlier success (#836 r12 class 2).
             const staleAcceptanceOutranksRealFailure = !settledIsFreshThisAttempt && hostSignalFailed;
+            // #855: re-read cancel after trySettle/attach awaits — a signal in this
+            // window must not land as lawful accepted.
+            const cancelAfterSettle = processCancelSignalName(env.signal);
             if (settled !== undefined
                 && shouldPresent(settled)
                 && !directHostFailureSignal
                 && !staleAcceptanceOutranksRealFailure
-                && stderrLogWriteFailure === undefined) {
+                && stderrLogWriteFailure === undefined
+                && cancelAfterSettle === undefined) {
                 // This court sealed — drop open-court pointer (bare resume no longer continues it).
                 if (settled.roleOutcome.kind === "accepted" &&
                     request.courtAttemptId !== undefined &&
@@ -597,6 +652,22 @@ export async function dispatchPostAdmissionTurn(input) {
             return await finishAfterTurn({ ...settledFailure, turnDispatched: true, ...deferredPersist });
         }
         if (settledOutcome !== undefined) {
+            // #855: final cancel re-read before lawful seal — settlement window may
+            // have received SIGTERM/SIGINT/SIGHUP after the earlier snapshot.
+            const lateCancel = processCancelSignalName(env.signal);
+            if (lateCancel !== undefined) {
+                return await finishAfterTurn(await settleProcessCancelAfterTurn({
+                    admitted,
+                    cancelName: lateCancel,
+                    result,
+                    adapters,
+                    env,
+                    io,
+                    persistRunState,
+                    deferredPersist,
+                    invocationScopeId: request.invocationScopeId,
+                }));
+            }
             if (persistRunState) {
                 try {
                     await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
@@ -619,16 +690,18 @@ export async function dispatchPostAdmissionTurn(input) {
                         thrown: error,
                         skipRunStateWrite: true,
                     }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
-                    return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
+                    return await finishAfterTurn(withProcessCancelSkipAutoResume({ ...failed, turnDispatched: true, ...deferredPersist }, env.signal));
                 }
             }
             // Lawful persist + present is the caller's stop seam (auto-resume loop /
             // manual resume), not this retried host-turn function.
+            // #855 cancel re-read lives in finishAfterTurn (before afterDispatch).
             return await finishAfterTurn({ ...settledOutcome, ...deferredPersist });
         }
         // Host/runner true failure coexists with already-recorded payloads — never wash as accepted.
         if (hostSignalFailed) {
             const resolutionInput = controlledFailureInputFromResolution(resolution);
+            const processCancelName = processCancelSignalName(env.signal);
             const stderrLogWriteDetails = stderrLogWriteFailure === undefined
                 ? undefined
                 : { stderrLogWriteFailure: describeCaughtError(stderrLogWriteFailure) };
@@ -637,6 +710,9 @@ export async function dispatchPostAdmissionTurn(input) {
                 code: result.code,
                 stderr: result.stderr,
                 ...resolutionInput,
+                ...(processCancelName === undefined
+                    ? {}
+                    : { knownDiagnostic: processCancelDiagnostic(processCancelName) }),
                 // Secondary fact only — never the cause. Rides on whichever channel
                 // classification actually reads (knownFailure.details owns it when
                 // a knownFailure exists; the top-level knownDetails otherwise).
@@ -651,7 +727,7 @@ export async function dispatchPostAdmissionTurn(input) {
                         }
                         : { knownDetails: stderrLogWriteDetails }),
             }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
-            return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
+            return await finishAfterTurn(withProcessCancelSkipAutoResume({ ...failed, turnDispatched: true, ...deferredPersist }, env.signal));
         }
         // Nothing else was wrong, but the durable stderr mirror itself failed to
         // write — that is the real (infrastructure) problem in this case, not a
@@ -666,6 +742,21 @@ export async function dispatchPostAdmissionTurn(input) {
             return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
         }
         const noReceipt = await attachRecordedSubmissions(admitted, await settleHostEndedNoReceipt(admitted, env.principalAuthority, courtScope), courtScope);
+        // #855: cancel during no_receipt settlement window is not lawful success.
+        const noReceiptCancel = processCancelSignalName(env.signal);
+        if (noReceiptCancel !== undefined) {
+            return await finishAfterTurn(await settleProcessCancelAfterTurn({
+                admitted,
+                cancelName: noReceiptCancel,
+                result,
+                adapters,
+                env,
+                io,
+                persistRunState,
+                deferredPersist,
+                invocationScopeId: request.invocationScopeId,
+            }));
+        }
         if (persistRunState) {
             try {
                 await persistReturnedRunState(admitted, env.principalAuthority, { lawful: true });
@@ -683,9 +774,10 @@ export async function dispatchPostAdmissionTurn(input) {
                     thrown: error,
                     skipRunStateWrite: true,
                 }, request.invocationScopeId), adapters, env.principalAuthority, io, persistRunState);
-                return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
+                return await finishAfterTurn(withProcessCancelSkipAutoResume({ ...failed, turnDispatched: true, ...deferredPersist }, env.signal));
             }
         }
+        // #855 cancel re-read lives in finishAfterTurn (before afterDispatch).
         return await finishAfterTurn({
             exitCode: exitCodeForTerminalOutcome(noReceipt.roleOutcome),
             admitted,
@@ -972,6 +1064,7 @@ export async function runPostAdmissionSeatResume(input) {
                 io: input.io,
                 sessionAppender: env.sessionAppender,
                 autoResumeLimit: env.autoResumeLimit,
+                ...(env.signal === undefined ? {} : { signal: env.signal }),
                 buildInitialPayload: () => ({ resumeTurn: false }),
                 buildResumePayload: () => ({ resumeTurn: true }),
                 // Same as public manual resume: prior-court sealed acceptance is not a
@@ -1062,7 +1155,7 @@ export async function runPostAdmissionOneShot(input) {
             ...input.request,
             continuation: {
                 kind: "resume",
-                prompt: buildResumeContinuationPrompt({
+                prompt: buildAutoResumeContinuationPrompt({
                     packageRoot: input.env.packageRoot,
                     ...pickEngineAxis({
                         engine: input.effectiveEngine ?? input.env.engine,
@@ -1095,6 +1188,7 @@ export async function runPostAdmissionResumable(input) {
         io,
         sessionAppender: env.sessionAppender,
         autoResumeLimit: env.autoResumeLimit,
+        ...(env.signal === undefined ? {} : { signal: env.signal }),
         buildInitialPayload: buildScopedInitial,
         buildResumePayload: buildScopedResume,
         dispatch: async (request, lease, _isFirst, attemptIo) => {

package/dist/public-cli/process-cancel.js

@@ -0,0 +1,57 @@
+/**
+ * #855: catchable process signals for ak-role public entry.
+ * SIGTERM / SIGINT / SIGHUP abort the shared controller so hosts can gracefully
+ * terminate children (SIGTERM only, never SIGKILL). Uncatchable death (SIGKILL,
+ * crash, power loss) is reported via run-state + writer lease on analyst.
+ */
+const CATCHABLE_PROCESS_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+/**
+ * Install once per process entry. First catchable signal wins; later signals
+ * are ignored so settlement can finish without re-entry storms.
+ */
+export function installProcessCancelHandlers(processRef = process) {
+    const controller = new AbortController();
+    let received;
+    const listeners = new Map();
+    for (const sig of CATCHABLE_PROCESS_SIGNALS) {
+        const onSignal = () => {
+            if (received !== undefined)
+                return;
+            received = sig;
+            try {
+                controller.abort(sig);
+            }
+            catch {
+                // already aborted
+            }
+        };
+        listeners.set(sig, onSignal);
+        processRef.on(sig, onSignal);
+    }
+    return {
+        signal: controller.signal,
+        receivedSignal: () => received,
+        dispose() {
+            for (const [sig, onSignal] of listeners) {
+                processRef.off(sig, onSignal);
+            }
+            listeners.clear();
+        },
+    };
+}
+/** Signal name when this AbortSignal was aborted by installProcessCancelHandlers. */
+export function processCancelSignalName(signal) {
+    if (signal === undefined || signal.aborted !== true)
+        return undefined;
+    const reason = signal.reason;
+    if (reason === "SIGTERM" ||
+        reason === "SIGINT" ||
+        reason === "SIGHUP") {
+        return reason;
+    }
+    return undefined;
+}
+/** Diagnostic line for a catchable process-signal termination (failure honesty). */
+export function processCancelDiagnostic(signalName) {
+    return `ak-role terminated by ${signalName}`;
+}

package/dist/public-cli/run-lifecycle.js

@@ -26,20 +26,31 @@ export const V1_RESUMABLE_PROVIDERS = ["openai-codex", "xai"];
  * source: runWithAutoResumeLoop receives the effective value once per call.
  */
 export const AUTO_RESUME_LIMIT = 2;
-/** Package-owned turn trigger for resume. Not caller instruction and not semantic task content. */
-export const RESUME_TRANSPORT_ENVELOPE = "[ak-role:resume-continue]";
 /**
- * Unique continuation-prompt selector for manual/auto engine-axis resume
- * (#471 / #600 / #736). Message present → those bytes; absent → engine pointers only.
- * #836: no transport-token prompt, no line-by-line 重新读 rewrite.
+ * Package-owned non-empty Chinese neutral resume transport (#959 / ADR 0073).
+ * Used by:
+ *   - auto-resume (all seats via buildAutoResumeContinuationPrompt) — required so
+ *     hosts that reject empty stdin (codex) still receive a prompt;
+ *   - reviewer seat manual resume (reviewerResumePrompt) — same non-empty need on
+ *     that seat's own manual entry.
+ * Generic bare `ak-role resume` stays empty-capable via selectResumeContinuationPrompt
+ * / buildResumeContinuationPrompt — ADR 0080 keeps auto and generic-manual entries separate.
+ */
+export const RESUME_TRANSPORT_ENVELOPE = "继续。";
+/**
+ * Manual resume continuation selector (#471 / #600 / #736 / ADR 0080).
+ * Message present → those bytes; absent → engine pointers only (may be empty).
+ * Caller message (including blank) still wins verbatim when supplied.
+ * Auto-resume must use buildAutoResumeContinuationPrompt — do not fold the
+ * non-empty Chinese envelope into this shared manual selector (#959).
  */
 export function selectResumeContinuationPrompt(message, engineMaterial) {
     const lines = message !== undefined ? [message] : [];
     return appendEngineSessionMaterial(lines, engineMaterial).join("\n");
 }
 /**
- * Resume continuation with engine material resolved from the seat env (#600).
- * Seat table / invocation engine axis rides the same prompt seam as initial runs.
+ * Manual resume continuation with engine material from the seat env (#600).
+ * Bare manual resume stays empty-prompt-capable; auto-resume is a separate entry.
  */
 export function buildResumeContinuationPrompt(options) {
     return selectResumeContinuationPrompt(options.message, engineSessionMaterialFromOptions({
@@ -47,6 +58,17 @@ export function buildResumeContinuationPrompt(options) {
         ...pickEngineAxis(options),
     }));
 }
+/**
+ * Auto-resume continuation only (#959 / ADR 0080).
+ * Always non-empty: Chinese neutral envelope plus optional engine pointers.
+ * Never call this from manual `ak-role resume`.
+ */
+export function buildAutoResumeContinuationPrompt(options) {
+    return selectResumeContinuationPrompt(RESUME_TRANSPORT_ENVELOPE, engineSessionMaterialFromOptions({
+        packageRoot: options.packageRoot,
+        ...pickEngineAxis(options),
+    }));
+}
 const RUN_STATE_FILE = "run-state.json";
 const WRITER_LOCK_FILE = "writer.lock";
 /** @deprecated #416: 429-only classification removed; kept for compatibility. */

package/dist/public-cli/settlement.js

@@ -157,7 +157,7 @@ async function closedLedgerOutcome(admitted, role, scope) {
 function coordinatesFromAdmitted(authority, admitted) {
     return authority.decode(admitted.principal);
 }
-import { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, recommendationNavigatorFact, } from "./terminal.js";
+import { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, adviceNavigatorFact, } from "./terminal.js";
 export { exitCodeForTerminalOutcome, formatTerminalResult, isLawfulTypedTerminalOutcome, };
 /**
  * Host stderr as recorded — full bytes, no flood filter, no char clip (#836).
@@ -457,7 +457,13 @@ export function explicitInternalKnownFailureClassificationInput(failure) {
         ...(failure.details === undefined ? {} : { knownDetails: failure.details }),
     };
 }
-/** Post-role Navigator delivery grace (Issue #11 / #101 / #106 / #159). */
+/**
+ * Post-role Navigator delivery grace (Issue #11 / #101 / #106 / #159).
+ * After the parent finishes: wait at most this long for navigator output, then
+ * stop waiting. Navigator must already be running from parent start (prepare
+ * host round in parallel); this window is only the tail after parent end — not
+ * the budget to start a cold full host turn (owner 2026-09-17 #959).
+ */
 export const NAVIGATOR_POST_ROLE_GRACE_MS = 10_000;
 function isMissingPathError(error) {
     return (error instanceof Error &&
@@ -1334,11 +1340,6 @@ export async function appendRunAttemptHistory(source, outcome) {
     }
     catch { }
 }
-function navigatorPhaseValue(value) {
-    if (value === "plan" || value === "apply")
-        return value;
-    return null;
-}
 /**
  * Minimal attendance provenance against the bound marker (ADR 0043).
  * Keep only invocationId + post-terminal ordering. Runtime-self-produced
@@ -1357,35 +1358,48 @@ function parseNavigatorAttendanceDetails(details) {
     const advisoryDiagnostic = typeof details.routePlaybookReadFailure === "string"
         ? { advisoryDiagnostic: details.routePlaybookReadFailure }
         : {};
-    if (disposition === "recommendation") {
-        const next = details.next;
-        if (!isRecord(next) || typeof next.role !== "string") {
+    // #959: advice prose is presented as-is. Legacy "recommendation" with next/reason/
+    // command is projected into prose so historical sessions still render — never wash
+    // a real recommendation into no-advice when any advice body is recoverable.
+    if (disposition === "advice" || disposition === "recommendation") {
+        let prose;
+        if (typeof details.prose === "string" && details.prose.trim() !== "") {
+            prose = details.prose;
+        }
+        else {
+            const next = isRecord(details.next) && typeof details.next.role === "string"
+                ? details.next.role
+                : undefined;
+            const reason = typeof details.reason === "string" && details.reason.trim() !== ""
+                ? details.reason
+                : undefined;
+            const command = typeof details.command === "string" && details.command.trim() !== ""
+                ? details.command
+                : undefined;
+            if (reason !== undefined && next !== undefined) {
+                prose = `${reason}（下一步：${next}）`;
+            }
+            else if (reason !== undefined) {
+                prose = reason;
+            }
+            else if (next !== undefined) {
+                // Historical recommendation with only typed next — still real advice.
+                prose = `下一步：${next}`;
+            }
+            else if (command !== undefined) {
+                prose = command;
+            }
+        }
+        if (prose === undefined || prose.trim() === "") {
+            // Attended but empty body is affirmative no-advice, not unavailable (#959).
             return {
-                disposition: "unavailable",
-                source: "unknown",
-                reason: "navigator recommendation missing typed next role",
+                disposition: "no-advice",
+                ...advisoryDiagnostic,
             };
         }
-        const reason = typeof details.reason === "string" ? details.reason : "";
-        const route = Array.isArray(details.route)
-            ? details.route
-                .filter(isRecord)
-                .map((target) => ({
-                role: String(target.role),
-                phase: navigatorPhaseValue(target.phase),
-            }))
-            : undefined;
-        return recommendationNavigatorFact({
+        return adviceNavigatorFact({
+            prose,
             ...advisoryDiagnostic,
-            next: {
-                role: next.role,
-                phase: navigatorPhaseValue(next.phase),
-            },
-            reason,
-            ...(route === undefined ? {} : { route }),
-            ...(typeof details.command === "string"
-                ? { modelCommand: details.command }
-                : {}),
         });
     }
     if (disposition === "unavailable") {

package/dist/public-cli/terminal.js

@@ -1,11 +1,3 @@
-/**
- * Terminal result: typed semantic regions for one admitted Role run (ADR 0052 / #106).
- * Presentation may rearrange labels/order; only regions and typed facts are stable.
- *
- * Free-text cells are JSON-string encoded so legitimate newlines/tabs cannot forge
- * extra rows or shift column boundaries (note / fix.summary / decision question / reason).
- */
-import { isPublicCallableRole, renderPublicAkRoleCommand, } from "./command-renderer.js";
 /** Encode one free-text Terminal cell. JSON string form cannot embed raw tab/newline. */
 export function encodeTerminalField(value) {
     return JSON.stringify(value);
@@ -34,21 +26,13 @@ export function roleResultPayloads(outcome) {
     return [];
 }
 /**
- * Build a recommendation navigator fact. Model command is kept when present;
- * registry render is fallback only. Unknown seats stay recommendations (#836 B4.1).
+ * Build an advice navigator fact (#959). Prose is presented as submitted;
+ * code does not parse route/next or judge usability.
  */
-export function recommendationNavigatorFact(input) {
-    const command = typeof input.modelCommand === "string" && input.modelCommand.trim() !== ""
-        ? input.modelCommand
-        : isPublicCallableRole(input.next.role)
-            ? renderPublicAkRoleCommand(input.next)
-            : undefined;
+export function adviceNavigatorFact(input) {
     return {
-        disposition: "recommendation",
-        next: input.next,
-        reason: input.reason,
-        ...(command === undefined ? {} : { command }),
-        ...(input.route === undefined ? {} : { route: input.route }),
+        disposition: "advice",
+        prose: input.prose,
         ...(input.advisoryDiagnostic === undefined ? {} : { advisoryDiagnostic: input.advisoryDiagnostic }),
     };
 }
@@ -82,12 +66,9 @@ export function formatTerminalResult(result) {
     if (result.navigator.advisoryDiagnostic !== undefined) {
         lines.push(`navigator-advisory\t${encodeTerminalField(result.navigator.advisoryDiagnostic)}`);
     }
-    if (result.navigator.disposition === "recommendation") {
-        lines.push(`next\t${result.navigator.next.role}\t${result.navigator.next.phase ?? "none"}`);
-        lines.push(`reason\t${encodeTerminalField(result.navigator.reason)}`);
-        if (result.navigator.command !== undefined) {
-            lines.push(`command\t${encodeTerminalField(result.navigator.command)}`);
-        }
+    if (result.navigator.disposition === "advice") {
+        // #959: present navigator prose as-is — no next/reason/command parsing.
+        lines.push(`prose\t${encodeTerminalField(result.navigator.prose)}`);
     }
     else if (result.navigator.disposition === "unavailable") {
         lines.push(`unavailable\t${result.navigator.source}\t${encodeTerminalField(result.navigator.reason)}`);

package/dist/public-role-summons.js

@@ -269,14 +269,32 @@ async function summonPublicRole(options) {
     case "navigator":
     case "gatekeeper": {
       const seat2 = options.role;
-      const [{ runPublicInstructionSeat }, invocation] = await Promise.all([
+      const [{ runPublicInstructionSeat, runPublicInstructionSeatResume }, invocation] = await Promise.all([
         import("./public-cli/instruction-seat-run.js"),
         import("./public-cli/invocation.js")
       ]);
       const parse = seat2 === "auditor" ? invocation.parseAuditorArgv : seat2 === "navigator" ? invocation.parseNavigatorArgv : invocation.parseGatekeeperArgv;
-      const stepped = await runPrepared(parse, (env, once) => runPublicInstructionSeat(options.argv, env, io, seat2, once));
-      if ("fail" in stepped) return stepped.fail;
-      result = stepped.ok;
+      const resumeRunId = typeof options.resumeRunId === "string" && options.resumeRunId.trim() !== "" ? options.resumeRunId.trim() : void 0;
+      if (resumeRunId !== void 0) {
+        const instruction = options.argv[0] ?? "";
+        const stepped = await runPrepared(parse, (env) => runPublicInstructionSeatResume(
+          {
+            runId: resumeRunId,
+            summons: {
+              instruction,
+              instructionEmpty: instruction.trim() === ""
+            }
+          },
+          env,
+          io
+        ));
+        if ("fail" in stepped) return stepped.fail;
+        result = stepped.ok;
+      } else {
+        const stepped = await runPrepared(parse, (env, once) => runPublicInstructionSeat(options.argv, env, io, seat2, once));
+        if ("fail" in stepped) return stepped.fail;
+        result = stepped.ok;
+      }
       break;
     }
     case "judge": {