@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/adapter/activeRunSelfHeal.js

@@ -1,10 +1,13 @@
 import { abortableSleep } from '../abortableSleep.js';
+import { EN_MESSAGES } from '../i18n/messages.en.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
+import { readThrownStatusSlot } from '../wireFailureShape.js';
 import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 import { readSteerReceipt } from '../steerReceipt.js';
 import { resumeAttachReplayDisclosure, runningAttachOffered } from '../hitl/resumeRunningCard.js';
-import { isSdkRunTerminal, SDK_PARKED_RUN_STATUSES } from '../terminalStatuses.js';
+import { isSdkRunParked, isSdkRunTerminal, SDK_RUN_LIVE_STATUSES } from '../terminalStatuses.js';
 import { SDK_APPROVAL_DECIDE_GATE_KINDS, SDK_PLAN_REVIEW_GATE_KINDS } from '../generated/sdkFactTables.js';
 export const PLAN_REVIEW_GATE_KIND = 'plan_review';
 const APPROVAL_LEG_GATE_KINDS = SDK_APPROVAL_DECIDE_GATE_KINDS;
@@ -40,7 +43,7 @@ export function askParkForeignGateKind(row) {
 export const PLAN_REVIEW_STATES = Object.freeze(['needs_review']);
 export const ASK_PARK_STATES = Object.freeze(['suspended']);
 export const RUNNING_STATES = Object.freeze(['running']);
-export const CLAIM_HELD_STATES = Object.freeze(['running', ...SDK_PARKED_RUN_STATUSES]);
+export const CLAIM_HELD_STATES = SDK_RUN_LIVE_STATUSES;
 export function selfHealSubmissionDisposition(outcome) {
     switch (outcome.kind) {
         case 'decision-pending':
@@ -76,16 +79,6 @@ function sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
 }
-function errorSlot(e, key) {
-    if (e === null || e === undefined)
-        return undefined;
-    try {
-        return e[key];
-    }
-    catch {
-        return undefined;
-    }
-}
 function describeFailure(e) {
     const where = corruptStoredRowWhere(e);
     const rowNote = where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`;
@@ -452,6 +445,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     if (gateLeg === 'approval')
         return askParkArm(taskId, signal, runs, deps);
     let status = signal.activeTaskStatus;
+    const statusFresh = status === null;
     if (status === null) {
         if (typeof runs?.get !== 'function') {
             return { kind: 'state-unknown', taskId, detail: 'this client exposes no durable run verbs' };
@@ -468,8 +462,11 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     if (status === null) {
         return { kind: 'state-unknown', taskId, detail: 'the engine reported no status for that run' };
     }
+    if (isSdkRunTerminal(status))
+        return { kind: 'running-settled', taskId, status };
+    const triageGate = signal.pendingGate && !statusFresh ? { pendingGateKind: signal.pendingGate.kind ?? null } : {};
     if (gateKind !== null)
-        return { kind: 'not-parked', taskId, status };
+        return { kind: 'not-parked', taskId, status, ...triageGate };
     if (PLAN_REVIEW_STATES.includes(status))
         return planReviewArm(taskId, signal, deps);
     if (ASK_PARK_STATES.includes(status))
@@ -477,7 +474,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     if (RUNNING_STATES.includes(status)) {
         return runningChoiceArm(taskId, status, signal, signal.activeTaskStatus !== null, runs, deps);
     }
-    return { kind: 'not-parked', taskId, status };
+    return { kind: 'not-parked', taskId, status, ...triageGate };
 }
 async function planVerdict(taskId, deps) {
     try {
@@ -576,7 +573,7 @@ async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
         answered = true;
     }
     catch (e) {
-        if (errorSlot(e, 'status') === 404)
+        if (typeof e === 'object' && e !== null && readThrownStatusSlot(e) === 404)
             ghost = true;
         else
             errorCode = failureWireCode(e);
@@ -619,6 +616,8 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return runningChoiceArm(taskId, fresh, busy, false, runs, deps);
     if (PLAN_REVIEW_STATES.includes(fresh))
         return planReviewArm(taskId, busy, deps);
+    if (isSdkRunTerminal(fresh))
+        return { kind: 'ask-run-settled', taskId, status: fresh };
     if (!ASK_PARK_STATES.includes(fresh))
         return reopenFailed;
     const offer = deps?.offerStaleParkChoice;
@@ -656,6 +655,10 @@ async function staleParkArm(taskId, busy, runs, deps) {
     if (afterCard.status === null)
         return withFailureCode(reopenFailedAfterCard, afterCard.errorCode);
     if (!ASK_PARK_STATES.includes(afterCard.status)) {
+        if (isSdkRunTerminal(afterCard.status))
+            return { kind: 'ask-run-settled', taskId, status: afterCard.status };
+        if (RUNNING_STATES.includes(afterCard.status))
+            return { kind: 'not-parked', taskId, status: afterCard.status };
         return !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
     }
     const recheck = await readOwnedPendingCount(recheckOwnedPending, deps);
@@ -737,14 +740,10 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
             return { kind: 'running-not-found', taskId };
         if (probeCallerAborted())
             return notParked;
-        if (fresh !== null && !RUNNING_STATES.includes(fresh)) {
-            if (PLAN_REVIEW_STATES.includes(fresh))
-                return planReviewArm(taskId, busy, deps);
-            if (ASK_PARK_STATES.includes(fresh))
-                return askParkArm(taskId, busy, runs, deps);
-            if (isSdkRunTerminal(fresh))
-                return { kind: 'running-settled', taskId, status: fresh };
-            return { kind: 'not-parked', taskId, status: fresh };
+        if (fresh !== null) {
+            const routed = await routeFreshNonRunning(fresh, taskId, busy, runs, deps);
+            if (routed !== undefined)
+                return routed;
         }
     }
     const declineKey = runningChoiceDeclineKey(deps?.sessionId, taskId);
@@ -795,6 +794,16 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         }
     }
     if (choice === 'cancel' && canCancel && runs?.cancel !== undefined && runs.get !== undefined) {
+        if (probeCallerAborted())
+            return notParked;
+        const preFire = await probeRunStatusOnce(taskId, runs, runs.get, deps);
+        if (preFire.ghost)
+            return { kind: 'running-not-found', taskId };
+        if (probeCallerAborted() || preFire.status === null)
+            return notParked;
+        const rerouted = await routeFreshNonRunning(preFire.status, taskId, busy, runs, deps);
+        if (rerouted !== undefined)
+            return rerouted;
         const verdict = await cancelAndConfirmRelease(taskId, runs, runs.get, deps);
         if (verdict.outcome === 'released') {
             return { kind: 'running-cancelled', taskId, ...(verdict.engineStatedRelease ? { releaseConfirmedByEngine: true } : {}) };
@@ -814,38 +823,45 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         return { kind: 'running-attach', taskId };
     return notParked;
 }
-export const INTERACTIVE_WAY_OUT = 'run /clear to keep working in a fresh session';
-const DEFAULT_WAY_OUT = INTERACTIVE_WAY_OUT;
-const DEFAULT_FRESH_SESSION = 'start a new session (drop --resume/--continue)';
-function gateKindPhrase(kind) {
-    return kind ? `a ${kind} decision` : 'a decision';
+async function routeFreshNonRunning(fresh, taskId, busy, runs, deps) {
+    if (RUNNING_STATES.includes(fresh))
+        return undefined;
+    if (PLAN_REVIEW_STATES.includes(fresh))
+        return planReviewArm(taskId, busy, deps);
+    if (ASK_PARK_STATES.includes(fresh))
+        return askParkArm(taskId, busy, runs, deps);
+    if (isSdkRunTerminal(fresh))
+        return { kind: 'running-settled', taskId, status: fresh };
+    return { kind: 'not-parked', taskId, status: fresh };
+}
+export const INTERACTIVE_WAY_OUT = EN_MESSAGES['session.selfHeal.wayOut.interactive'];
+const say = (lang, key, params) => renderMessage(msg(key, params), lang);
+function gateKindPhrase(kind, lang) {
+    return kind ? say(lang, 'session.selfHeal.gate.kind', { kind }) : say(lang, 'session.selfHeal.gate.generic');
 }
-function decidePathClause(signal) {
+function decidePathClause(signal, lang) {
     const decidePath = signal?.pendingGate?.decidePath;
     if (!decidePath)
         return '';
-    return (` The engine says that run is waiting on ${gateKindPhrase(signal?.pendingGate?.kind)} and that it is` +
-        ` decided at POST ${decidePath} — deciding it releases the session.`);
+    return say(lang, 'session.selfHeal.decidePathClause', { gate: gateKindPhrase(signal?.pendingGate?.kind, lang), decidePath });
 }
-function governanceOriginClause(signal) {
-    return signal?.pendingGate?.governanceForced === true
-        ? ' That gate is enforced by this deployment\'s governance policy, not by a permission rule you set.'
-        : '';
+function governanceOriginClause(signal, lang) {
+    return signal?.pendingGate?.governanceForced === true ? say(lang, 'session.selfHeal.governanceOrigin') : '';
 }
-function lastActivityClause(signal) {
+function lastActivityClause(signal, lang) {
     const ms = signal?.msSinceLastActivity;
     if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0)
         return '';
     const human = ms < 120_000 ? `${String(Math.max(1, Math.round(ms / 1000)))}s` : `${String(Math.round(ms / 60_000))}m`;
-    return ` The engine last recorded activity on that run ${human} ago.`;
+    return say(lang, 'session.selfHeal.lastActivity', { ago: human });
 }
-export function activeRunSelfHealRow(outcome, signal, copy, origin, follow) {
+export function activeRunSelfHealRow(outcome, signal, copy, origin, follow, lang) {
     const override = copy?.rowFor?.(outcome, signal);
     if (typeof override === 'string')
         return override;
     const following = follow?.following === true && steerFollowIntent(outcome)?.kind === 'tail';
     if (origin === 'injected')
-        return injectedSubmissionRow(outcome, following);
+        return injectedSubmissionRow(outcome, following, lang);
     const engineDecide = copy?.engineDecidePath !== false;
     const keep = (outcome.kind === 'plan-review-reopen-failed' || outcome.kind === 'ask-reopen-failed') &&
         outcome.decisionInFlight !== true &&
@@ -853,101 +869,77 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow) {
         (outcome.kind !== 'plan-review-reopen-failed' || outcome.dismissedByUser !== true)
         ? keepSessionWayOutOf(copy)
         : null;
-    const base = activeRunSelfHealBaseRow(outcome, signal, copy?.wayOut ?? DEFAULT_WAY_OUT, following, keep, engineDecide);
-    const viaEngine = engineDecide ? decidePathClause(signal) : '';
+    const base = activeRunSelfHealBaseRow(outcome, copy?.wayOut ?? say(lang, 'session.selfHeal.wayOut.interactive'), following, keep, engineDecide, lang);
+    const viaEngine = engineDecide ? decidePathClause(signal, lang) : '';
     switch (outcome.kind) {
         case 'not-parked':
-            return base + lastActivityClause(signal) + viaEngine + governanceOriginClause(signal);
+            return base + lastActivityClause(signal, lang) + (outcome.pendingGateKind !== undefined ? viaEngine + governanceOriginClause(signal, lang) : '');
         case 'state-unknown':
-            return base + viaEngine + governanceOriginClause(signal);
+            return base + viaEngine + governanceOriginClause(signal, lang);
         default:
-            return base + governanceOriginClause(signal);
+            return base + governanceOriginClause(signal, lang);
     }
 }
-const INJECTED_LEAD = 'A follow-up message sema sent on its own (not one you typed)';
-const USER_CLOSED_CARD_NOT_PUT_BACK = 'sema does not put a card you closed back on screen by itself';
-const NO_CARD_VIEW_ATTACHED = 'this session has no view attached that can show decision cards';
-function injectedSubmissionRow(outcome, following = false) {
-    const lead = INJECTED_LEAD;
-    const id = 'taskId' in outcome && outcome.taskId ? ` (id ${outcome.taskId})` : '';
-    if (outcome.kind === 'running-attach') {
-        return `${lead} was not delivered: you chose to watch the reply already in progress${id} instead, and sema is replaying that reply here, so the part already shown above will appear again below. sema did not retry, so the model has not seen it.`;
-    }
+function injectedSubmissionRow(outcome, following = false, lang) {
+    const lead = msg('session.selfHeal.injected.lead');
+    const id = 'taskId' in outcome && outcome.taskId ? msg('session.selfHeal.injected.id', { id: outcome.taskId }) : '';
+    if (outcome.kind === 'running-attach')
+        return say(lang, 'session.selfHeal.injected.attach', { lead, id });
     if (outcome.kind === 'running-steer-failed') {
         return outcome.delivery === 'unknown'
-            ? `${lead} was passed to the reply already in progress${id}, but its delivery could not be confirmed ` +
-                `(${outcome.detail}) — that reply may or may not have received it. sema did not retry, because sending it twice ` +
-                `is not safe; watch that reply for what it does next.`
-            : `${lead} was not delivered: passing it to the reply already in progress${id} was refused (${outcome.detail}). ` +
-                `sema did not retry, so the model has not seen it.`;
+            ? say(lang, 'session.selfHeal.injected.steerUnknown', { lead, id, detail: outcome.detail })
+            : say(lang, 'session.selfHeal.injected.steerRejected', { lead, id, detail: outcome.detail });
     }
     if ((outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.decisionInFlight === true) {
-        return (`${lead} was not delivered: this session is still busy with an earlier reply${id}, and your answer to the decision ` +
-            `it is waiting on is still on its way. sema did not retry, so the model has not seen it.`);
+        return say(lang, 'session.selfHeal.injected.decisionInFlight', { lead, id });
     }
     if (outcome.kind === 'plan-review-reopen-failed' && outcome.dismissedByUser === true) {
-        return (`${lead} was not delivered: this session is held by an earlier reply${id} whose plan is waiting for your review, and ` +
-            `you closed that approval card — ${USER_CLOSED_CARD_NOT_PUT_BACK}. Send a message when you want the card back; ` +
-            `sema did not retry, so the model has not seen it.`);
+        return say(lang, 'session.selfHeal.injected.dismissedPlan', { lead, id, closed: msg('session.selfHeal.userClosedCardNotPutBack') });
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'queued') {
-        const queuedOn = `${lead} is queued on an earlier reply${id} that is paused waiting for a decision`;
+        const queuedOn = msg('session.selfHeal.injected.queuedOn', { lead, id });
         const reopened = reopenedOfOutcome(outcome);
-        if (reopened !== null && reopenDelivered(reopened)) {
-            return `${queuedOn}; sema has shown that decision card, and the message is picked up once you answer it.`;
-        }
-        if (reopenRefusedForDecisionInFlight(reopened)) {
-            return `${queuedOn}; your answer to it is still on its way, and the message is picked up once that answer is applied.`;
-        }
-        if (reopenRefusedForUserDismissal(reopened)) {
-            return (`${queuedOn}; you closed that card yourself, so sema did not put it back on screen — send a message to bring it ` +
-                `back, and the message is picked up once that decision is made.`);
-        }
-        const noView = reopenRefusedForNoPresentationSurface(reopened) ? ` (${NO_CARD_VIEW_ATTACHED})` : '';
-        return `${queuedOn} sema could not show here${noView}; the message is picked up only once that decision is made.`;
+        if (reopened !== null && reopenDelivered(reopened))
+            return say(lang, 'session.selfHeal.injected.queuedShown', { queuedOn });
+        if (reopenRefusedForDecisionInFlight(reopened))
+            return say(lang, 'session.selfHeal.injected.queuedInFlight', { queuedOn });
+        if (reopenRefusedForUserDismissal(reopened))
+            return say(lang, 'session.selfHeal.injected.queuedDismissed', { queuedOn });
+        const noView = reopenRefusedForNoPresentationSurface(reopened) ? msg('session.selfHeal.noCardView.inParens') : '';
+        return say(lang, 'session.selfHeal.injected.queuedCannotShow', { queuedOn, noView });
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'parked_for_wake') {
-        return (`${lead} has not reached the model: the earlier reply${id} had already finished, so the message was set aside on it ` +
-            `instead of starting a new reply, and sema did not retry it.`);
+        return say(lang, 'session.selfHeal.injected.parkedForWake', { lead, id });
     }
     if (outcome.kind === 'running-steered' && outcome.delivery !== 'applied') {
-        const unknown = `${lead} was accepted for the reply already in progress${id}, but how it will be delivered was not reported, ` +
-            `so sema cannot tell whether that reply will pick it up`;
+        const unknown = msg('session.selfHeal.injected.unknownDelivery', { lead, id });
         return following
-            ? `${unknown}. sema is following that reply and will show whatever it asks for next; check what it does ` +
-                `before deciding whether anything needs to be sent again.`
-            : `${unknown} — watch that reply before deciding whether anything needs to be sent again.`;
+            ? say(lang, 'session.selfHeal.injected.unknownDeliveryFollowing', { unknown })
+            : say(lang, 'session.selfHeal.injected.unknownDeliveryWatch', { unknown });
     }
     switch (selfHealSubmissionDisposition(outcome)) {
         case 'held-for-decision':
-            return (`${lead} is on hold: this session is busy with an earlier reply${id} that is waiting on a decision. ` +
-                `sema kept the message queued and will send it after you answer the open card.`);
+            return say(lang, 'session.selfHeal.injected.heldForDecision', { lead, id });
         case 'resending':
             return 'releaseConfirmedByEngine' in outcome && outcome.releaseConfirmedByEngine === true
-                ? `${lead} was held back because this session was busy with an earlier reply${id}; the session is free again, ` +
-                    `so sema is sending the message now — nothing for you to do.`
-                : `${lead} was held back because this session was busy with an earlier reply${id}; that reply is now reported ` +
-                    `as finished, so sema is sending the message now — nothing for you to do (if the session has not quite ` +
-                    `freed up yet, it may be held back once more).`;
+                ? say(lang, 'session.selfHeal.injected.resendingConfirmed', { lead, id })
+                : say(lang, 'session.selfHeal.injected.resendingInferred', { lead, id });
         case 'handed-off':
             return following
-                ? `${lead} was passed to the reply already in progress${id} instead of starting a new one. ` +
-                    `sema is following that reply and will show whatever it asks for next; nothing for you to do now.`
-                : `${lead} was passed to the reply already in progress${id} instead of starting a new one — ` +
-                    `watch that reply for what it does with it.`;
+                ? say(lang, 'session.selfHeal.injected.handedOffFollowing', { lead, id })
+                : say(lang, 'session.selfHeal.injected.handedOffWatch', { lead, id });
         case 'not-delivered': {
             const noView = (outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.noPresentationSurface === true
-                ? ` (${NO_CARD_VIEW_ATTACHED})`
+                ? msg('session.selfHeal.noCardView.inParens')
                 : '';
-            return (`${lead} was not delivered: this session was still busy with an earlier reply${id}, and there was no open card ` +
-                `you could answer to free it${noView}. sema did not retry, so the model has not seen it.`);
+            return say(lang, 'session.selfHeal.injected.notDelivered', { lead, id, noView });
         }
     }
 }
-function decisionInFlightRow(parkedOn) {
-    return (`The previous turn is parked ${parkedOn} and your answer to that card is still on its way to the engine, so ` +
-        `sema did not show the card again — answering it a second time would send a second decision. It did NOT ` +
-        `cancel the run. Your message was NOT sent; send it again in a moment, once the engine has applied that decision.`);
+function decisionInFlightRow(parkedOn, taskId, lang) {
+    return say(lang, 'session.selfHeal.decisionInFlight', {
+        parkedOn: msg(parkedOn === 'ask' ? 'session.selfHeal.parkedOn.ask' : 'session.selfHeal.parkedOn.plan', { taskId }),
+    });
 }
 function keepSessionWayOutOf(copy) {
     if (typeof copy?.keepSessionWayOut !== 'function')
@@ -961,282 +953,182 @@ function keepSessionWayOutOf(copy) {
         return null;
     }
 }
-function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, keepSessionWayOut = null, engineDecide = true) {
+function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessionWayOut = null, engineDecide = true, lang) {
     switch (outcome.kind) {
         case 'decision-pending':
-            return (`This session is held by an earlier turn${outcome.taskId ? ` (run ${outcome.taskId})` : ''} that ` +
-                `is waiting on a decision you have not made yet, and there is a decision card open for it. ` +
-                `sema did NOT cancel it — answering that card is what releases the session, and cancelling ` +
-                `would decide it for you. Your message was NOT sent; answer the open card and send it again.`);
+            return say(lang, 'session.selfHeal.row.decisionPending', { handle: outcome.taskId ? msg('session.selfHeal.handle.run', { taskId: outcome.taskId }) : '' });
         case 'ask-reopened':
-            if (outcome.firstSight) {
-                return (`The previous turn advanced to a decision it needs from you (run ${outcome.taskId}), which is ` +
-                    `why nothing new could start — sema has surfaced that decision card. Answer it and send your ` +
-                    `message again. (sema did NOT cancel the run: cancelling would have decided it for you.)`);
-            }
-            return (`The previous turn is parked waiting for your decision (run ${outcome.taskId}), which is why ` +
-                `nothing new could start — that card was closed without being answered, so sema reopened it. ` +
-                `Answer it and send your message again. (sema did NOT cancel the run: cancelling would have ` +
-                `decided it for you.)`);
+            if (outcome.firstSight)
+                return say(lang, 'session.selfHeal.row.askReopened.firstSight', { taskId: outcome.taskId });
+            return say(lang, 'session.selfHeal.row.askReopened.reseen', { taskId: outcome.taskId });
         case 'plan-review-reopened':
-            if (outcome.firstSight) {
-                return (`The previous turn produced a plan that is waiting for your review (run ${outcome.taskId}), ` +
-                    `which is why nothing new could start — sema has surfaced the review card. Answer it and send ` +
-                    `your message again. (sema did NOT cancel the run: cancelling would have thrown the plan away ` +
-                    `on your behalf.)`);
-            }
-            return (`The previous turn is parked waiting for you to review its plan (run ${outcome.taskId}), which is ` +
-                `why nothing new could start — that approval card was closed without being answered, so sema ` +
-                `reopened it. Answer it and send your message again. (sema did NOT cancel the run: cancelling ` +
-                `would have thrown the plan away on your behalf.)`);
+            if (outcome.firstSight)
+                return say(lang, 'session.selfHeal.row.planReviewReopened.firstSight', { taskId: outcome.taskId });
+            return say(lang, 'session.selfHeal.row.planReviewReopened.reseen', { taskId: outcome.taskId });
         case 'ask-decided-without-card':
-            if (outcome.releaseConfirmedByEngine === true) {
-                return (`The previous turn was parked on an approval that your permission rules decided on their own (no card was ` +
-                    `needed); run ${outcome.taskId} resumed and the engine confirmed it is no longer holding this session — ` +
-                    `sema is re-sending your message.`);
-            }
-            return (`The previous turn was parked on an approval that your permission rules decided on their own (no card was ` +
-                `needed); run ${outcome.taskId} resumed and has since finished — sema is re-sending your message; if that ` +
-                `run has not fully let go of the session yet, you may have to send it once more.`);
+            if (outcome.releaseConfirmedByEngine === true)
+                return say(lang, 'session.selfHeal.row.askDecided.confirmed', { taskId: outcome.taskId });
+            return say(lang, 'session.selfHeal.row.askDecided.inferred', { taskId: outcome.taskId });
         case 'ask-decided-release-unknown':
-            return (`The previous turn was parked on an approval that your permission rules decided on their own (no card was ` +
-                `needed), so run ${outcome.taskId} should be resuming` +
-                (outcome.lastStatus ? ` (last engine status: ${outcome.lastStatus})` : '') +
-                `. sema could not yet confirm it finished, so your message was not sent — wait a moment and send it again.`);
+            return say(lang, 'session.selfHeal.row.askDecided.releaseUnknown', {
+                taskId: outcome.taskId,
+                status: outcome.lastStatus ? msg('session.selfHeal.lastEngineStatus', { status: outcome.lastStatus }) : '',
+            });
         case 'ask-reopen-failed': {
             if (outcome.decisionInFlight === true)
-                return decisionInFlightRow(`waiting for your decision (run ${outcome.taskId})`);
-            const viaEngine = engineDecide && outcome.decidePath
-                ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
-                : '';
-            const noView = outcome.noPresentationSurface === true ? `: ${NO_CARD_VIEW_ATTACHED}` : '';
-            return (`The previous turn is parked waiting for your decision (run ${outcome.taskId}) and sema could ` +
-                `not reopen that card here${noView}. It did NOT cancel the run — that would have decided it for you. ` +
-                (keepSessionWayOut !== null
-                    ? `Your message was NOT sent. To keep this conversation, ${keepSessionWayOut}: the card comes back when the session resumes, if it is still waiting. Or ${wayOut} if you no longer want it.${viaEngine}`
-                    : `Your message was NOT sent; ${wayOut} if you no longer want it.${viaEngine}`));
+                return decisionInFlightRow('ask', outcome.taskId, lang);
+            const viaEngine = engineDecide && outcome.decidePath ? msg('session.selfHeal.viaEngine', { decidePath: outcome.decidePath }) : '';
+            const noView = outcome.noPresentationSurface === true ? msg('session.selfHeal.noCardView.afterColon') : '';
+            return keepSessionWayOut !== null
+                ? say(lang, 'session.selfHeal.row.askReopenFailed.withKeep', { taskId: outcome.taskId, noView, keep: keepSessionWayOut, wayOut, viaEngine })
+                : say(lang, 'session.selfHeal.row.askReopenFailed.noKeep', { taskId: outcome.taskId, noView, wayOut, viaEngine });
         }
         case 'plan-review-reopen-failed': {
             if (outcome.decisionInFlight === true)
-                return decisionInFlightRow(`on a plan review (run ${outcome.taskId})`);
+                return decisionInFlightRow('plan', outcome.taskId, lang);
             if (outcome.dismissedByUser === true) {
-                return (`The previous turn is parked waiting for a plan review (run ${outcome.taskId}), and you closed its approval card — ` +
-                    `${USER_CLOSED_CARD_NOT_PUT_BACK}. It did NOT cancel the run — that would have discarded the plan for you. ` +
-                    `Your message was NOT sent; send it again to bring the card back.`);
+                return say(lang, 'session.selfHeal.row.planReopenFailed.dismissed', { taskId: outcome.taskId, closed: msg('session.selfHeal.userClosedCardNotPutBack') });
             }
-            const viaEngine = engineDecide && outcome.decidePath
-                ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
-                : '';
-            const noView = outcome.noPresentationSurface === true ? `: ${NO_CARD_VIEW_ATTACHED}` : '';
-            return (`The previous turn is parked waiting for a plan review (run ${outcome.taskId}) and sema could not ` +
-                `reopen that approval card${noView}. It did NOT cancel the run — that would have discarded the plan for ` +
-                (keepSessionWayOut !== null
-                    ? `you. Your message was NOT sent. To keep this conversation, ${keepSessionWayOut}: the card comes back when the session resumes, if it is still waiting. Or ${wayOut} if you no longer want that plan.${viaEngine}`
-                    : `you. Your message was NOT sent; ${wayOut} if you no longer want that plan.${viaEngine}`));
+            const viaEngine = engineDecide && outcome.decidePath ? msg('session.selfHeal.viaEngine', { decidePath: outcome.decidePath }) : '';
+            const noView = outcome.noPresentationSurface === true ? msg('session.selfHeal.noCardView.afterColon') : '';
+            return keepSessionWayOut !== null
+                ? say(lang, 'session.selfHeal.row.planReopenFailed.withKeep', { taskId: outcome.taskId, noView, keep: keepSessionWayOut, wayOut, viaEngine })
+                : say(lang, 'session.selfHeal.row.planReopenFailed.noKeep', { taskId: outcome.taskId, noView, wayOut, viaEngine });
         }
         case 'running-steered': {
-            const handle = `run ${outcome.taskId}`;
-            const textOnly = `Only the TEXT of your message was handed over — a steer carries no attachments, so any images in that submission were NOT sent.`;
+            const taskId = outcome.taskId;
+            const textOnly = msg('session.selfHeal.row.steered.textOnly');
             if (outcome.delivery === 'applied') {
-                return (`sema handed your message to the run that is already working (${handle}) — the engine applied it to ` +
-                    `that run, so it is picked up at that run's next step. ${textOnly} Nothing was cancelled, and your ` +
-                    `message did NOT start a new turn — ` +
-                    (following
-                        ? `sema is following that run and will surface whatever it asks for next.`
-                        : `watch that run for what it does with it.`));
+                return say(lang, 'session.selfHeal.row.steered.applied', {
+                    taskId,
+                    textOnly,
+                    tail: msg(following ? 'session.selfHeal.row.steered.tail.following' : 'session.selfHeal.row.steered.tail.watch'),
+                });
             }
             if (outcome.delivery === 'queued') {
-                const parked = outcome.status ? `parked (status ${outcome.status})` : 'parked';
+                const parked = outcome.status ? msg('session.selfHeal.row.steered.parked.withStatus', { status: outcome.status }) : msg('session.selfHeal.row.steered.parked.plain');
                 const reopened = reopenedOfOutcome(outcome);
                 const next = reopened !== null && reopenDelivered(reopened)
-                    ? `sema has surfaced that decision card — answering it is what lets that run resume and pick your message up.`
+                    ? msg('session.selfHeal.row.steered.next.shown')
                     : reopenRefusedForDecisionInFlight(reopened)
-                        ? `Your answer to that decision is still on its way to the engine, so sema did not show the card again; ` +
-                            `that run moves on once the engine applies it.`
+                        ? msg('session.selfHeal.row.steered.next.inFlight')
                         : reopenRefusedForUserDismissal(reopened)
-                            ? `You closed that decision card yourself, so sema did not put it back on screen; nothing will resume that ` +
-                                `run until that decision is made — send a message to bring the card back.`
-                            : `sema could not surface that decision card here` +
-                                (reopenRefusedForNoPresentationSurface(reopened) ? ` (${NO_CARD_VIEW_ATTACHED})` : '') +
-                                `, so nothing will resume that run until that decision is made; ` +
-                                `${wayOut} if you no longer want it.`;
-                return (`${handle} is not actually working right now: the engine reports it ${parked} on a decision it needs ` +
-                    `from you, so it queued your message on that park instead of running it. ${next} ${textOnly} ` +
-                    `Nothing was cancelled, and your message did NOT start a new turn.`);
+                            ? msg('session.selfHeal.row.steered.next.dismissed')
+                            : msg('session.selfHeal.row.steered.next.cannotShow', {
+                                noView: reopenRefusedForNoPresentationSurface(reopened) ? msg('session.selfHeal.noCardView.inParens') : '',
+                                wayOut,
+                            });
+                return say(lang, 'session.selfHeal.row.steered.queued', { taskId, parked, next, textOnly });
             }
             if (outcome.delivery === 'parked_for_wake') {
-                return (`${handle} had already finished, so the engine parked your message on that finished run instead of ` +
-                    `running it — a parked message is delivered only if this session is woken on the engine ` +
-                    `(POST /v1/sessions/:id/wake), which sema does not do here. That run is no longer holding this ` +
-                    `session: send your message again to run it as a new turn — but note that the parked copy is NOT ` +
-                    `discarded, so if anything ever wakes this session on the engine that instruction would run a ` +
-                    `second time. ${textOnly} Nothing was cancelled.`);
+                return say(lang, 'session.selfHeal.row.steered.parkedForWake', { taskId, textOnly });
             }
-            return (`sema handed your message to ${handle}, but the engine did not say how it will be delivered` +
-                `${outcome.status ? ` (it reported that run as ${outcome.status})` : ''}. ${textOnly} Nothing was ` +
-                `cancelled, and your message did NOT start a new turn — ` +
-                (following
-                    ? `sema is following that run and will surface whatever it asks for next before you send it again.`
-                    : `watch that run before sending it again.`));
+            return say(lang, 'session.selfHeal.row.steered.unknown', {
+                taskId,
+                reported: outcome.status ? msg('session.selfHeal.row.steered.reported', { status: outcome.status }) : '',
+                textOnly,
+                tail: msg(following ? 'session.selfHeal.row.steered.unknownTail.following' : 'session.selfHeal.row.steered.unknownTail.watch'),
+            });
         }
         case 'running-steer-failed':
-            if (outcome.delivery === 'rejected') {
-                return (`Handing your message to the running run (run ${outcome.taskId}) was refused: ${outcome.detail}. ` +
-                    `sema did NOT retry it (a steer is not safe to send twice) and it did NOT cancel that run. ` +
-                    `Your message was NOT sent; send it again if you still want it.`);
-            }
-            return (`sema sent your message to the running run (run ${outcome.taskId}) but could not confirm what happened ` +
-                `to it (${outcome.detail}). A steer is not safe to send twice, so sema did NOT retry it, and it did NOT ` +
-                `cancel that run. That run may or may not have received your message — watch what it does next ` +
-                `before sending it again.`);
+            return outcome.delivery === 'rejected'
+                ? say(lang, 'session.selfHeal.row.steerFailed.rejected', { taskId: outcome.taskId, detail: outcome.detail })
+                : say(lang, 'session.selfHeal.row.steerFailed.unknown', { taskId: outcome.taskId, detail: outcome.detail });
         case 'running-attach':
-            return (`${resumeAttachReplayDisclosure(outcome.taskId)} Your message was NOT sent; send it again once that run has finished.`);
+            return say(lang, 'session.selfHeal.row.attach', { disclosure: resumeAttachReplayDisclosure(outcome.taskId) });
         case 'running-cancelled':
             return outcome.releaseConfirmedByEngine === true
-                ? `You chose to cancel run ${outcome.taskId}. The engine confirmed it is no longer holding this session, ` +
-                    `so sema is sending your message now.`
-                : `You chose to cancel run ${outcome.taskId}. The engine now reports that run as finished, so sema is ` +
-                    `sending your message now; if that run has not fully let go of the session yet, you may have to send ` +
-                    `it once more.`;
+                ? say(lang, 'session.selfHeal.row.cancelled.confirmed', { taskId: outcome.taskId })
+                : say(lang, 'session.selfHeal.row.cancelled.reported', { taskId: outcome.taskId });
         case 'running-cancel-timeout': {
             const waited = `${String(Math.max(1, Math.round(outcome.waitedMs / 1000)))}s`;
-            if (outcome.aborted) {
-                return (`sema asked the engine to cancel run ${outcome.taskId} and you interrupted while it was still ` +
-                    `confirming (${waited} in). Cancelling is asynchronous, so that run may still be winding down and ` +
-                    `may still hold this session. Your message was NOT sent; send it again in a moment, or ${wayOut}.`);
-            }
+            if (outcome.aborted)
+                return say(lang, 'session.selfHeal.row.cancelTimeout.aborted', { taskId: outcome.taskId, waited, wayOut });
             if (!outcome.confirmedHeld) {
-                return (`sema asked the engine to cancel run ${outcome.taskId} but could not read that run's state back ` +
-                    `within ${waited}, so it cannot confirm whether the session was released. Your message was NOT sent; ` +
-                    `send it again in a moment (if that run really is gone it will just run), or ${wayOut}.`);
+                return say(lang, 'session.selfHeal.row.cancelTimeout.unread', { taskId: outcome.taskId, waited, wayOut });
             }
-            return (`sema asked the engine to cancel run ${outcome.taskId}, but that run still held this session ` +
-                `${waited} later — cancelling is asynchronous and it may still be winding down. Your message was NOT ` +
-                `sent; send it again in a moment, or ${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.cancelTimeout.held', { taskId: outcome.taskId, waited, wayOut });
         }
         case 'running-cancel-failed':
             if (outcome.delivery === 'unknown') {
-                return (`sema sent the cancel for run ${outcome.taskId} but could not confirm what happened to it ` +
-                    `(${outcome.detail}), and it could not read that run back as released either. That run may or may ` +
-                    `not still be holding this session. Your message was NOT sent; send it again in a moment, or ${wayOut}.`);
+                return say(lang, 'session.selfHeal.row.cancelFailed.unknown', { taskId: outcome.taskId, detail: outcome.detail, wayOut });
             }
-            return (`sema could not cancel run ${outcome.taskId} — the engine rejected that request (${outcome.detail}), so ` +
-                `nothing was cancelled and sema cannot tell whether that run is still holding this session. Your message ` +
-                `was NOT sent; send it again to find out, or ${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.cancelFailed.rejected', { taskId: outcome.taskId, detail: outcome.detail, wayOut });
         case 'ask-run-not-found':
-            return (`The previous turn is recorded as parked on a decision (run ${outcome.taskId}), but the approval it ` +
-                `was waiting on is no longer on the engine, and asking the engine about that run directly comes back ` +
-                `not-found — a lookup that cannot separate a run that is really gone from one this session is simply ` +
-                `not allowed to read. Either way sema has nothing it can act on here, so it did NOT cancel anything. ` +
-                `Your message was NOT sent; send it again (if the session really is free it will just run), or ${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.askRunNotFound', { taskId: outcome.taskId, wayOut });
+        case 'ask-run-settled':
+            return say(lang, 'session.selfHeal.row.askRunSettled', { taskId: outcome.taskId, status: outcome.status, wayOut });
         case 'stale-park-cancelled':
-            if (outcome.releaseConfirmedByEngine === true) {
-                return (`Run ${outcome.taskId} was parked on an approval that no longer exists on the engine, so there was ` +
-                    `nothing left for you to answer. You chose to cancel that run, and the engine confirmed it is no longer ` +
-                    `holding this session, so sema is sending your message again now.`);
-            }
-            return (`Run ${outcome.taskId} was parked on an approval that no longer exists on the engine, so there was ` +
-                `nothing left for you to answer. You chose to cancel that run: the engine now reports it as finished, ` +
-                `so it will not resume — whatever that turn had left to do is not coming back. sema is sending your ` +
-                `message again now; if that run has not fully let go of the session yet, you may have to send it once ` +
-                `more.`);
+            return outcome.releaseConfirmedByEngine === true
+                ? say(lang, 'session.selfHeal.row.stale.cancelled.confirmed', { taskId: outcome.taskId })
+                : say(lang, 'session.selfHeal.row.stale.cancelled.reported', { taskId: outcome.taskId });
         case 'stale-park-cancel-timeout': {
             const waited = `${String(Math.max(1, Math.round(outcome.waitedMs / 1000)))}s`;
-            if (outcome.aborted) {
-                return (`sema asked the engine to cancel run ${outcome.taskId} (it was parked on an approval that no longer ` +
-                    `exists there) and you interrupted while it was still confirming (${waited} in). Cancelling is ` +
-                    `asynchronous, so that run may still be winding down and may still hold this session. Your message ` +
-                    `was NOT sent; send it again in a moment, or ${wayOut}.`);
-            }
+            if (outcome.aborted)
+                return say(lang, 'session.selfHeal.row.stale.cancelTimeout.aborted', { taskId: outcome.taskId, waited, wayOut });
             if (!outcome.confirmedHeld) {
-                return (`sema asked the engine to cancel run ${outcome.taskId} (parked on an approval that no longer exists ` +
-                    `there) but could not read that run's state back within ${waited}, so it cannot confirm whether the ` +
-                    `session was released. Your message was NOT sent; send it again in a moment (if that run really is ` +
-                    `gone it will just run), or ${wayOut}.`);
+                return say(lang, 'session.selfHeal.row.stale.cancelTimeout.unread', { taskId: outcome.taskId, waited, wayOut });
             }
-            return (`sema asked the engine to cancel run ${outcome.taskId} (parked on an approval that no longer exists ` +
-                `there), but that run still held this session ${waited} later — cancelling is asynchronous and it may ` +
-                `still be winding down. Your message was NOT sent; send it again in a moment, or ${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.stale.cancelTimeout.held', { taskId: outcome.taskId, waited, wayOut });
         }
         case 'stale-park-cancel-failed':
             if (outcome.delivery === 'unknown') {
-                return (`sema sent the cancel for run ${outcome.taskId} (parked on an approval that no longer exists on the ` +
-                    `engine) but could not confirm what happened to it (${outcome.detail}), and it could not read that ` +
-                    `run back as released either. That run may or may not still be holding this session. Your message ` +
-                    `was NOT sent; send it again in a moment, or ${wayOut}.`);
+                return say(lang, 'session.selfHeal.row.stale.cancelFailed.unknown', { taskId: outcome.taskId, detail: outcome.detail, wayOut });
             }
-            return (`sema could not cancel run ${outcome.taskId} — the engine rejected that request (${outcome.detail}), ` +
-                `so nothing was cancelled and sema cannot tell whether that run is still holding this session. Your ` +
-                `message was NOT sent; send it again to find out, or ${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.cancelFailed.rejected', { taskId: outcome.taskId, detail: outcome.detail, wayOut });
         case 'stale-park-wait':
-            if (outcome.alreadyOffered === true) {
-                return (`Run ${outcome.taskId} is still parked (status ${outcome.status}) on an approval that no longer ` +
-                    `exists on the engine. sema already asked what to do with it and you chose to leave it alone, so it ` +
-                    `is not asking again. Your message was NOT sent; cancel that run on the engine ` +
-                    `(POST /v1/runs/${outcome.taskId}/cancel — that ends it for good), or ${wayOut}.`);
-            }
-            return (`Run ${outcome.taskId} is still parked (status ${outcome.status}) on an approval that no longer exists ` +
-                `on the engine, so there is no card left to answer and that run will not settle on its own. sema did ` +
-                `NOT cancel it — you chose to leave it alone. Your message was NOT sent; cancel that run on the engine ` +
-                `(POST /v1/runs/${outcome.taskId}/cancel — that ends it for good), or ${wayOut}.`);
+            return outcome.alreadyOffered === true
+                ? say(lang, 'session.selfHeal.row.stale.wait.offered', { taskId: outcome.taskId, status: outcome.status, wayOut })
+                : say(lang, 'session.selfHeal.row.stale.wait.first', { taskId: outcome.taskId, status: outcome.status, wayOut });
         case 'running-not-found':
-            return (`The engine reported this session as held by run ${outcome.taskId} (status running), but it no ` +
-                `longer recognizes that run when asked directly — that claim looks stale (the run most likely no ` +
-                `longer exists). sema did not offer to steer or cancel it: there is nothing left to act on. ` +
-                `Your message was NOT sent; send it again (if the session really is free it will just run), or ${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.runNotFound', { taskId: outcome.taskId, wayOut });
         case 'running-settled':
-            return (`Run ${outcome.taskId} has already finished (status ${outcome.status}), but the engine still ` +
-                `reported it as holding this session — that claim looks stale or mid-release. sema did not offer ` +
-                `to steer or cancel it: the run is over. Your message was NOT sent; send it again (once the claim ` +
-                `clears it will just run), or ${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.runSettled', { taskId: outcome.taskId, status: outcome.status, wayOut });
         case 'not-parked':
             if (outcome.alreadyOffered === true) {
-                return (`Run ${outcome.taskId} is still holding this session (status ${outcome.status}). sema already ` +
-                    `asked what to do with it and you chose to leave it alone, so it is not asking again. ` +
-                    `Your message was NOT sent; wait for that run, cancel it on the engine ` +
-                    `(POST /v1/runs/${outcome.taskId}/cancel), or ${wayOut}.`);
+                return say(lang, 'session.selfHeal.row.notParked.offered', { taskId: outcome.taskId, status: outcome.status, wayOut });
             }
-            if (signal?.pendingGate) {
-                return (`This session is held by an earlier run (run ${outcome.taskId}, status ${outcome.status}) that is ` +
-                    `waiting on ${gateKindPhrase(signal.pendingGate.kind)} — it will not finish on its own. sema did ` +
-                    `NOT cancel it, because cancelling would decide that item for you. Your message was NOT sent; ` +
-                    `${wayOut} if you no longer want it.`);
+            const parkedOn = outcome.pendingGateKind !== undefined
+                ? gateKindPhrase(outcome.pendingGateKind, lang)
+                : isSdkRunParked(outcome.status)
+                    ? gateKindPhrase(null, lang)
+                    : undefined;
+            if (parkedOn !== undefined) {
+                return say(lang, 'session.selfHeal.row.notParked.parkedOn', { taskId: outcome.taskId, status: outcome.status, parkedOn, wayOut });
             }
-            return (`This session already has a run in flight (run ${outcome.taskId}, status ${outcome.status}) — ` +
-                `most likely a turn you sent to the background. sema did NOT cancel it, because that would ` +
-                `throw away work you asked for. Wait for it to finish, or ${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.notParked.inFlight', { taskId: outcome.taskId, status: outcome.status, wayOut });
         case 'state-unknown':
-            return (`This session is locked by an earlier run${outcome.taskId ? ` (run ${outcome.taskId})` : ''} and ` +
-                `sema could not read that run's state, so it did not touch it (${outcome.detail}). ` +
-                `Your message was NOT sent. This session cannot start a new turn until that run settles — ` +
-                `${wayOut}.`);
+            return say(lang, 'session.selfHeal.row.stateUnknown', {
+                handle: outcome.taskId ? msg('session.selfHeal.handle.run', { taskId: outcome.taskId }) : '',
+                detail: outcome.detail,
+                wayOut,
+            });
     }
 }
-export function activeRunBusyHeadlessRow(signal, copy) {
+export function activeRunBusyHeadlessRow(signal, copy, lang) {
     const override = copy?.headlessRowFor?.(signal);
     if (typeof override === 'string')
         return override;
     const activeTaskId = signal.activeTaskId;
-    const handle = activeTaskId ? ` (run ${activeTaskId})` : '';
+    const handle = activeTaskId ? msg('session.selfHeal.handle.run', { taskId: activeTaskId }) : '';
     const cancelPath = `POST /v1/runs/${activeTaskId ?? '<id>'}/cancel`;
     const status = signal.activeTaskStatus;
     const decidePath = signal.pendingGate?.decidePath ?? null;
-    const freshSession = copy?.freshSession ?? DEFAULT_FRESH_SESSION;
+    const hostFresh = copy?.freshSession ?? undefined;
+    const freshSession = hostFresh ?? say(lang, 'session.selfHeal.freshSession.default');
     if (decidePath) {
-        return (`This session is held by an earlier run${handle}${status ? ` (status ${status})` : ''} that is parked ` +
-            `waiting on ${gateKindPhrase(signal.pendingGate?.kind)}, so this message was NOT sent. Decide it and ` +
-            `the session unlocks: POST ${decidePath}. Cancelling instead (${cancelPath}) also unlocks it, but it ` +
-            `decides that item against you. Or ${freshSession}.` +
-            governanceOriginClause(signal));
-    }
-    if (status) {
-        return (`This session is held by an earlier run${handle} with status ${status}, so this message was NOT sent. ` +
-            `The engine reported no decision pending on that run: if it is still working, wait for it to finish; ` +
-            `if it will never settle, release it with ${cancelPath} (that discards whatever it was doing). ` +
-            `Or ${freshSession}.`);
-    }
-    const startOver = `${freshSession.charAt(0).toUpperCase()}${freshSession.slice(1)}`;
-    return (`This session is locked by an earlier run${handle} that was never released, so this message was ` +
-        `NOT sent. Nothing here clears on its own. ${startOver}, or ` +
-        `release the run on the engine: ${cancelPath}`);
+        return say(lang, 'session.selfHeal.headless.decide', {
+            handle,
+            status: status ? msg('session.selfHeal.headless.status', { status }) : '',
+            gate: gateKindPhrase(signal.pendingGate?.kind, lang),
+            decidePath,
+            cancelPath,
+            freshSession,
+            governance: governanceOriginClause(signal, lang),
+        });
+    }
+    if (status)
+        return say(lang, 'session.selfHeal.headless.statusOnly', { handle, status, cancelPath, freshSession });
+    const startOver = hostFresh !== undefined ? `${hostFresh.charAt(0).toUpperCase()}${hostFresh.slice(1)}` : say(lang, 'session.selfHeal.freshSession.defaultCapitalized');
+    return say(lang, 'session.selfHeal.headless.neverReleased', { handle, startOver, cancelPath });
 }