@akagilnc/pi-workflow-roles 0.1.4586 → 0.1.4631

package/src/public-cli/post-admission.ts

@@ -10,6 +10,7 @@ import { writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
 
 import {
+  buildAutoResumeContinuationPrompt,
   buildResumeContinuationPrompt,
   RESUME_TRANSPORT_ENVELOPE,
   type PublicResumeRequest,
@@ -86,6 +87,11 @@ import {
   type TypedProviderHttpObservation,
   type WriterLeaseDiagnosticKind,
 } from "./run-lifecycle.ts";
+import {
+  processCancelDiagnostic,
+  processCancelSignalName,
+  type CatchableProcessSignal,
+} from "./process-cancel.ts";
 import { homeFromRunDirectory } from "../activation-ledger-topology.ts";
 import {
   attemptProducedFreshSubmission,
@@ -118,6 +124,63 @@ import {
   TurnDispatchedFailure,
 } from "./auto-resume.ts";
 
+/** #855: process-cancel settlement never re-enters auto-resume. */
+function withProcessCancelSkipAutoResume<T extends object>(
+  result: T,
+  signal: AbortSignal | undefined,
+): T & { skipAutoResume?: true } {
+  if (processCancelSignalName(signal) === undefined) {
+    return result as T & { skipAutoResume?: true };
+  }
+  return { ...result, skipAutoResume: true as const };
+}
+
+/**
+ * #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<A extends AdmittedRoleInvocation, T extends TerminalResult>(input: {
+  admitted: A;
+  cancelName: CatchableProcessSignal;
+  result: RoleTurnResult;
+  adapters: PostAdmissionAdapters<A, T>;
+  env: PostAdmissionEnv;
+  io: CliIo;
+  persistRunState: boolean;
+  deferredPersist: { needsPersist?: true } | Record<string, never>;
+  invocationScopeId: string | undefined;
+}): Promise<{
+  exitCode: number;
+  admitted: A;
+  terminal?: T;
+  skipAutoResume?: true;
+  turnDispatched?: true;
+  needsPersist?: true;
+}> {
+  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 as const,
+    skipAutoResume: true as const,
+    ...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
@@ -586,6 +649,38 @@ export async function dispatchPostAdmissionTurn<
   const finishAfterTurn = async (result: DispatchOutcome): Promise<DispatchOutcome> => {
     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 as const,
+        skipAutoResume: true as const,
+        ...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,
@@ -787,20 +882,29 @@ export async function dispatchPostAdmissionTurn<
     try {
       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 as const, ...deferredPersist });
+      return await finishAfterTurn(
+        withProcessCancelSkipAutoResume(
+          { ...settled, turnDispatched: true as const, ...deferredPersist },
+          env.signal,
+        ),
+      );
     }
 
     // `result.stderr` stays live in memory for the real classification below
@@ -916,11 +1020,13 @@ export async function dispatchPostAdmissionTurn<
       // 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)
@@ -958,12 +1064,16 @@ export async function dispatchPostAdmissionTurn<
       // 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
+        && cancelAfterSettle === undefined
       ) {
         // This court sealed — drop open-court pointer (bare resume no longer continues it).
         if (
@@ -1016,6 +1126,24 @@ export async function dispatchPostAdmissionTurn<
       return await finishAfterTurn({ ...settledFailure, turnDispatched: true as const, ...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 });
@@ -1044,17 +1172,24 @@ export async function dispatchPostAdmissionTurn<
             io,
             persistRunState,
           );
-          return await finishAfterTurn({ ...failed, turnDispatched: true as const, ...deferredPersist });
+          return await finishAfterTurn(
+            withProcessCancelSkipAutoResume(
+              { ...failed, turnDispatched: true as const, ...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
@@ -1066,6 +1201,9 @@ export async function dispatchPostAdmissionTurn<
           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).
@@ -1085,7 +1223,12 @@ export async function dispatchPostAdmissionTurn<
         io,
         persistRunState,
       );
-      return await finishAfterTurn({ ...failed, turnDispatched: true as const, ...deferredPersist });
+      return await finishAfterTurn(
+        withProcessCancelSkipAutoResume(
+          { ...failed, turnDispatched: true as const, ...deferredPersist },
+          env.signal,
+        ),
+      );
     }
 
     // Nothing else was wrong, but the durable stderr mirror itself failed to
@@ -1113,6 +1256,23 @@ export async function dispatchPostAdmissionTurn<
       await settleHostEndedNoReceipt(admitted, env.principalAuthority, courtScope) as T,
       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 });
@@ -1136,9 +1296,15 @@ export async function dispatchPostAdmissionTurn<
           io,
           persistRunState,
         );
-        return await finishAfterTurn({ ...failed, turnDispatched: true as const, ...deferredPersist });
+        return await finishAfterTurn(
+          withProcessCancelSkipAutoResume(
+            { ...failed, turnDispatched: true as const, ...deferredPersist },
+            env.signal,
+          ),
+        );
       }
     }
+    // #855 cancel re-read lives in finishAfterTurn (before afterDispatch).
     return await finishAfterTurn({
       exitCode: exitCodeForTerminalOutcome(noReceipt.roleOutcome),
       admitted,
@@ -1511,6 +1677,7 @@ export async function runPostAdmissionSeatResume<
         io: input.io,
         sessionAppender: env.sessionAppender,
         autoResumeLimit: env.autoResumeLimit,
+        ...(env.signal === undefined ? {} : { signal: env.signal }),
         buildInitialPayload: (): StationChildAttempt => ({ resumeTurn: false }),
         buildResumePayload: (): StationChildAttempt => ({ resumeTurn: true }),
         // Same as public manual resume: prior-court sealed acceptance is not a
@@ -1624,7 +1791,7 @@ export async function runPostAdmissionOneShot<
       ...input.request,
       continuation: {
         kind: "resume",
-        prompt: buildResumeContinuationPrompt({
+        prompt: buildAutoResumeContinuationPrompt({
           packageRoot: input.env.packageRoot,
           ...pickEngineAxis({
             engine: input.effectiveEngine ?? input.env.engine,
@@ -1677,6 +1844,7 @@ export async function runPostAdmissionResumable<
     io,
     sessionAppender: env.sessionAppender,
     autoResumeLimit: env.autoResumeLimit,
+    ...(env.signal === undefined ? {} : { signal: env.signal }),
     buildInitialPayload: buildScopedInitial,
     buildResumePayload: buildScopedResume,
     dispatch: async (request, lease, _isFirst, attemptIo) => {

package/src/public-cli/process-cancel.ts

@@ -0,0 +1,75 @@
+/**
+ * #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"] as const;
+
+export type CatchableProcessSignal = (typeof CATCHABLE_PROCESS_SIGNALS)[number];
+
+export type ProcessCancelHandle = {
+  readonly signal: AbortSignal;
+  /** Signal name once a catchable signal has been received; else undefined. */
+  readonly receivedSignal: () => CatchableProcessSignal | undefined;
+  dispose(): void;
+};
+
+/**
+ * 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: NodeJS.Process = process,
+): ProcessCancelHandle {
+  const controller = new AbortController();
+  let received: CatchableProcessSignal | undefined;
+  const listeners = new Map<CatchableProcessSignal, () => void>();
+
+  for (const sig of CATCHABLE_PROCESS_SIGNALS) {
+    const onSignal = (): void => {
+      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(): void {
+      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: AbortSignal | undefined,
+): CatchableProcessSignal | undefined {
+  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: CatchableProcessSignal): string {
+  return `ak-role terminated by ${signalName}`;
+}

package/src/public-cli/run-lifecycle.ts

@@ -127,8 +127,17 @@ export type RoleRunRecord = {
   readonly resumable?: TypedHttp429Observation;
 };
 
-/** Package-owned turn trigger for resume. Not caller instruction and not semantic task content. */
-export const RESUME_TRANSPORT_ENVELOPE = "[ak-role:resume-continue]" as const;
+/**
+ * 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 = "继续。" as const;
 
 /** Public manual resume request after the unique CLI parser owns runId + optional message. */
 export type PublicResumeRequest = {
@@ -169,9 +178,11 @@ export type SameTicketSummonsMaterials = {
 };
 
 /**
- * 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.
+ * 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?: string,
@@ -182,8 +193,8 @@ export function selectResumeContinuationPrompt(
 }
 
 /**
- * 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: {
   packageRoot: string;
@@ -200,6 +211,25 @@ export function buildResumeContinuationPrompt(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: {
+  packageRoot: string;
+  engine?: string;
+  engineModel?: string;
+}): string {
+  return selectResumeContinuationPrompt(
+    RESUME_TRANSPORT_ENVELOPE,
+    engineSessionMaterialFromOptions({
+      packageRoot: options.packageRoot,
+      ...pickEngineAxis(options),
+    }),
+  );
+}
+
 const RUN_STATE_FILE = "run-state.json";
 const WRITER_LOCK_FILE = "writer.lock";
 

package/src/public-cli/settlement.ts

@@ -123,7 +123,6 @@ import {
   parseInvocationMarkerIdentity,
   type InvocationMarkerIdentity,
 } from "../navigator-invocation-identity.ts";
-import type { NavigatorPhase } from "../navigator-attendance.ts";
 import {
   NO_RECEIPT_LIFECYCLE_ENTRY_TYPE,
   RECEIPT_DELIVERY_TURN_LIMIT,
@@ -360,7 +359,7 @@ import {
   exitCodeForTerminalOutcome,
   formatTerminalResult,
   isLawfulTypedTerminalOutcome,
-  recommendationNavigatorFact,
+  adviceNavigatorFact,
   type ControlledFailureCause,
   type TerminalArtifactRef,
   type TerminalGateFact,
@@ -782,7 +781,13 @@ export function explicitInternalKnownFailureClassificationInput(
   };
 }
 
-/** 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;
 
 type SessionMessage = {
@@ -1931,11 +1936,6 @@ export type LawfulJudgeRoleOutcome = Extract<
   TerminalRoleOutcome,
   { kind: "accepted" } | { kind: "audit_escalation" }
 >;
-function navigatorPhaseValue(value: unknown): NavigatorPhase {
-  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
@@ -1960,35 +1960,44 @@ function parseNavigatorAttendanceDetails(
   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: string | undefined;
+    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/src/public-cli/terminal.ts

@@ -5,11 +5,6 @@
  * 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.ts";
-import type { NavigatorPhase } from "../navigator-attendance.ts";
 import type { NoReceiptLifecycleFacts } from "../receipt-delivery-policy.ts";
 import type { ControlledFailureCause } from "../host-contracts.ts";
 
@@ -102,12 +97,9 @@ export function exitCodeForTerminalOutcome(
 
 export type TerminalNavigatorFact =
   | {
-      disposition: "recommendation";
-      next: { role: string; phase: NavigatorPhase };
-      reason: string;
-      /** Present only when role/phase is sufficient for a truthful public command. */
-      command?: string;
-      route?: ReadonlyArray<{ role: string; phase: NavigatorPhase }>;
+      /** #959: navigator speaks prose; code does not parse or rank the advice. */
+      disposition: "advice";
+      prose: string;
       advisoryDiagnostic?: string;
     }
   | {
@@ -227,28 +219,16 @@ export type TerminalResult = {
 );
 
 /**
- * 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: {
-  next: { role: string; phase: NavigatorPhase };
-  reason: string;
-  route?: ReadonlyArray<{ role: string; phase: NavigatorPhase }>;
+export function adviceNavigatorFact(input: {
+  prose: string;
   advisoryDiagnostic?: string;
-  modelCommand?: string;
 }): TerminalNavigatorFact {
-  const command =
-    typeof input.modelCommand === "string" && input.modelCommand.trim() !== ""
-      ? input.modelCommand
-      : isPublicCallableRole(input.next.role)
-        ? renderPublicAkRoleCommand(input.next)
-        : undefined;
   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 }),
   };
 }
@@ -288,14 +268,9 @@ export function formatTerminalResult(result: TerminalResult): string {
   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)}`,