@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/resumeRefusalCopy.d.ts

@@ -1,3 +1,5 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+import type { ResumeStartupCause } from '@sema-agent/sdk';
 import { RESUME_CONTEXT_UNAVAILABLE, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED } from './engineErrorCodes.js';
 export declare const RESUME_REFUSAL_CODES: readonly string[];
 export interface ResumeRefusalDetail {
@@ -6,7 +8,7 @@ export interface ResumeRefusalDetail {
     waitable: boolean;
 }
 export declare function resumeRefusalFromError(err: unknown): ResumeRefusalDetail | null;
-export declare function resumeRefusalContent(detail: ResumeRefusalDetail): string;
+export declare function resumeRefusalContent(detail: ResumeRefusalDetail, lang?: UiLanguage): string;
 export interface ResumePolicyBlockDetail {
     blockedBy: {
         kind: 'named';
@@ -18,7 +20,7 @@ export interface ResumePolicyBlockDetail {
     };
 }
 export declare function resumePolicyBlockFromError(err: unknown): ResumePolicyBlockDetail | null;
-export declare function resumePolicyBlockContent(detail: ResumePolicyBlockDetail): string;
+export declare function resumePolicyBlockContent(detail: ResumePolicyBlockDetail, lang?: UiLanguage): string;
 export { resumeReopenFromError, resumeReopenContent } from './hitl/suspendedReopen.js';
 export type { ResumeReopenDetail } from './hitl/suspendedReopen.js';
 export type RequireExistingSessionRefusalForm = 'session_not_found' | 'session_id_missing';
@@ -27,26 +29,28 @@ export interface RequireExistingSessionRefusalDetail {
     readonly form: RequireExistingSessionRefusalForm;
 }
 export declare function requireExistingSessionRefusalFromError(err: unknown): RequireExistingSessionRefusalDetail | null;
-export declare function requireExistingSessionRefusalContent(detail: Pick<RequireExistingSessionRefusalDetail, 'form'>): string;
+export declare function requireExistingSessionRefusalContent(detail: Pick<RequireExistingSessionRefusalDetail, 'form'>, lang?: UiLanguage): string;
 export interface ResumeContextUnavailableDetail {
     code: typeof RESUME_CONTEXT_UNAVAILABLE;
     staleAfterSec?: number;
     runId?: string;
 }
 export declare function resumeContextUnavailableFromError(err: unknown): ResumeContextUnavailableDetail | null;
-export declare function resumeContextUnavailableContent(d: ResumeContextUnavailableDetail): string;
+export declare function resumeContextUnavailableContent(d: ResumeContextUnavailableDetail, lang?: UiLanguage): string;
 export type ParkedResumeStartupDecision = 'approve' | 'deny';
 export type ParkedResumeStartupCause = 'resume_rejected' | 'undetermined';
 export interface ParkedResumeStartupDetail {
     code: string;
     cause: ParkedResumeStartupCause;
     taskId?: string;
-    startupCause?: string;
+    startupCause?: ResumeStartupCause | ResumeCauseCoreAhead;
     resendable: false;
     denyStaysOpen: true;
 }
+declare const RESUME_CAUSE_CORE_AHEAD: readonly ["transcript_corrupt"];
+type ResumeCauseCoreAhead = (typeof RESUME_CAUSE_CORE_AHEAD)[number];
 export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
-export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail): string;
+export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail, lang?: UiLanguage): string;
 export interface CheckpointUnsupportedVersionDetail {
     code: 'checkpoint.unsupported_version';
     retriable: true;
@@ -59,7 +63,7 @@ export interface CheckpointUnsupportedVersionContext {
     readonly parkKind?: CheckpointUnsupportedParkKind;
     readonly runId?: string;
 }
-export declare function checkpointUnsupportedVersionContent(detail: CheckpointUnsupportedVersionDetail, ctx?: CheckpointUnsupportedVersionContext): string;
+export declare function checkpointUnsupportedVersionContent(detail: CheckpointUnsupportedVersionDetail, ctx?: CheckpointUnsupportedVersionContext, lang?: UiLanguage): string;
 export type RefusedParkCode = typeof CHECKPOINT_UNSUPPORTED_VERSION | typeof CHECKPOINT_WALLTIME_AXIS_RETIRED | typeof CHECKPOINT_CONFIG_REFUSED;
 export interface RefusedParkFacts {
     readonly code: RefusedParkCode;
@@ -73,5 +77,5 @@ export interface RefusedParkContentInput {
     readonly lane: 'interactive' | 'print';
     readonly runId?: string;
 }
-export declare function refusedParkContent(input: RefusedParkContentInput): string;
-export declare function refusedParkBlockedContent(taskId: string, lane?: 'interactive' | 'print'): string;
+export declare function refusedParkContent(input: RefusedParkContentInput, lang?: UiLanguage): string;
+export declare function refusedParkBlockedContent(taskId: string, lane?: 'interactive' | 'print', lang?: UiLanguage): string;

package/dist/resumeRefusalCopy.js

@@ -1,5 +1,7 @@
-import { readBlockedBy, readErrorNumber, readErrorString } from './wireFailureShape.js';
-import { guardedRead, ownDataField, readOwnDataNonEmptyString } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { readBlockedBy, readErrorNumber, readErrorString, readThrownSlot } from './wireFailureShape.js';
+import { guardedRead, ownDataField, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { CORE_RESUME_STARTUP_CAUSES } from './generated/engineFactTables.js';
 import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, REQUEST_FIELD_CONFLICT, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED, isRefusedParkCode, refusalSaysStillPending, refusalRetriableReading, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineVersionTier } from './supportFloor.js';
@@ -26,51 +28,30 @@ export function resumeRefusalFromError(err) {
         ...(timed.retryAfterSec !== undefined ? { retryAfterSec: timed.retryAfterSec } : {}),
     };
 }
-export function resumeRefusalContent(detail) {
-    const parts = [];
-    if (detail.code === RESUME_PLACEMENT_MISMATCH) {
-        parts.push('This resume named a different placement root than the one recorded when the work was parked');
-        parts.push('The engine refused it before consuming anything — the parked work is untouched');
-        parts.push('Retry with the recorded root, or omit the placement root to inherit it');
-        return parts.join(' · ');
-    }
-    parts.push("The deployment's resume preflight refused this attempt");
-    parts.push('The refusal happened before the commit — your decision was not consumed');
-    parts.push(detail.waitable
-        ? 'The engine supplied a wait, so this token stays redeemable once the obstacle clears'
-        :
-            'The engine supplied no wait, so this refusal does not say whether the token stays redeemable');
-    return parts.join(' · ');
+export function resumeRefusalContent(detail, lang) {
+    if (detail.code === RESUME_PLACEMENT_MISMATCH)
+        return renderMessage(msg('resume.refusal.placementMismatch'), lang);
+    return renderMessage(msg(detail.waitable ? 'resume.refusal.preflightWaitable' : 'resume.refusal.preflightNoWait'), lang);
 }
 export function resumePolicyBlockFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
     const o = err;
-    let outer;
-    try {
-        outer = o['errorCode'];
-    }
-    catch {
-        return null;
-    }
+    const outer = guardedRead(() => ownDataField(err, 'errorCode'));
     if (outer !== RESUME_POLICY_FOLD_CODE)
         return null;
     return { blockedBy: readBlockedBy(o) };
 }
-export function resumePolicyBlockContent(detail) {
+export function resumePolicyBlockContent(detail, lang) {
     const b = detail.blockedBy;
     const reason = b.kind === 'named'
         ? isStatusDerivedCoarseCode(b.code)
-            ? `The refusal did not name a more specific check (it carried only the generic code for its HTTP status: ${b.code})`
-            : `The check that refused it: ${capForDisplay(b.code, 80)}`
+            ? msg('resume.refusal.policyBlockReason.coarse', { code: b.code })
+            : msg('resume.refusal.policyBlockReason.named', { code: capForDisplay(b.code, 80) })
         : b.kind === 'absent'
-            ? 'The refusal did not name a more specific check'
-            : 'The refusal carried a more specific reason that could not be read';
-    return [
-        'The engine refused to resume this parked work at its admission check (the engine reports that its admission policy changed since the work was first accepted)',
-        reason,
-        "This refusal does not say whether anything was consumed before it or whether a retry would pass — check the task's current state before deciding again, and ask whoever operates this deployment if it keeps happening",
-    ].join(' · ');
+            ? msg('resume.refusal.policyBlockReason.absent')
+            : msg('resume.refusal.policyBlockReason.unreadable');
+    return renderMessage(msg('resume.refusal.policyBlock', { reason }), lang);
 }
 export { resumeReopenFromError, resumeReopenContent } from './hitl/suspendedReopen.js';
 const REQUIRE_EXISTING_BY_STATUS = new Map([
@@ -81,27 +62,29 @@ export function requireExistingSessionRefusalFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
     try {
-        const o = err;
-        const status = o['status'];
+        const status = readThrownSlot(err, 'status', 'data');
         const byStatus = typeof status === 'number' ? REQUIRE_EXISTING_BY_STATUS.get(status) : undefined;
         if (byStatus === undefined)
             return null;
-        return o['errorCode'] === byStatus.code ? Object.freeze({ code: RESUME_SESSION_NOT_FOUND, form: byStatus.form }) : null;
+        return readThrownSlot(err, 'errorCode', 'data') === byStatus.code ? Object.freeze({ code: RESUME_SESSION_NOT_FOUND, form: byStatus.form }) : null;
     }
     catch {
         return null;
     }
 }
-const REQUIRE_EXISTING_SESSION_SENTENCES = Object.freeze({
-    session_not_found: 'The engine did not continue this conversation: the conversation it was asked to continue does not exist there (it may have expired, been removed, or never been created on that engine; this client cannot tell which), and this request asked to continue only an existing one, so no new conversation was started · Start a new conversation, or pick another one to continue',
-    session_id_missing: 'The engine did not continue this conversation: this request asked to continue only an existing conversation but named none, so there was nothing to continue and no new conversation was started · Name the conversation to continue, or start a new one',
+const REQUIRE_EXISTING_SESSION_KEYS = Object.freeze({
+    session_not_found: 'resume.refusal.requireExisting.sessionNotFound',
+    session_id_missing: 'resume.refusal.requireExisting.sessionIdMissing',
 });
-const REQUIRE_EXISTING_SESSION_GENERIC = 'The engine did not continue this conversation: this request asked to continue only an existing conversation and there was none it could continue, so no new conversation was started · Start a new conversation, or pick another one to continue';
-export function requireExistingSessionRefusalContent(detail) {
+const REQUIRE_EXISTING_SESSION_GENERIC = 'resume.refusal.requireExisting.generic';
+export function requireExistingSessionRefusalContent(detail, lang) {
+    return renderMessage(msg(requireExistingSessionKey(detail)), lang);
+}
+function requireExistingSessionKey(detail) {
     try {
         const form = detail?.form;
-        return typeof form === 'string' && Object.hasOwn(REQUIRE_EXISTING_SESSION_SENTENCES, form)
-            ? REQUIRE_EXISTING_SESSION_SENTENCES[form]
+        return typeof form === 'string' && Object.hasOwn(REQUIRE_EXISTING_SESSION_KEYS, form)
+            ? REQUIRE_EXISTING_SESSION_KEYS[form]
             : REQUIRE_EXISTING_SESSION_GENERIC;
     }
     catch {
@@ -111,8 +94,7 @@ export function requireExistingSessionRefusalContent(detail) {
 export function resumeContextUnavailableFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
-    const e = err;
-    if (e.errorCode !== RESUME_CONTEXT_UNAVAILABLE)
+    if (readThrownSlot(err, 'errorCode', 'data') !== RESUME_CONTEXT_UNAVAILABLE)
         return null;
     const sec = readErrorNumber(err, 'staleAfterSec');
     const staleSec = sec !== undefined && Number.isInteger(sec) && sec >= 1 ? sec : undefined;
@@ -124,17 +106,11 @@ export function resumeContextUnavailableFromError(err) {
         ...(runId !== undefined ? { runId } : {}),
     };
 }
-export function resumeContextUnavailableContent(d) {
+export function resumeContextUnavailableContent(d, lang) {
     const sec = d.staleAfterSec;
-    const retention = typeof sec === 'number' && Number.isSafeInteger(sec) && sec >= 1 ? ` (this deployment keeps conversations for ${sec} seconds)` : '';
-    const third = (d.runId !== undefined
-        ? "The error carries this run's id: use it to recover the run yourself, then decide again; raising the conversation retention time only prevents this from happening again and cannot rescue this one"
-        : 'The error carries no run id: go back to the run list, find this run and recover it yourself, then decide again; raising the conversation retention time only prevents this from happening again and cannot rescue this one') + retention;
-    return [
-        'This approval has nowhere to be delivered: the conversation that started this run has no usable context to continue it right now',
-        'Nothing was decided and your decision was not consumed; this card is still waiting',
-        third,
-    ].join(' · ');
+    const retention = typeof sec === 'number' && Number.isSafeInteger(sec) && sec >= 1 ? msg('resume.refusal.contextRetention', { sec }) : '';
+    const third = msg(d.runId !== undefined ? 'resume.refusal.contextThird.withRun' : 'resume.refusal.contextThird.noRun', { retention });
+    return renderMessage(msg('resume.refusal.contextUnavailable', { third }), lang);
 }
 function parkedResumeStartupCauseWord(err) {
     let named;
@@ -144,8 +120,14 @@ function parkedResumeStartupCauseWord(err) {
     catch {
         named = undefined;
     }
-    return named;
+    return isResumeStartupCause(named) ? named : undefined;
+}
+function isResumeStartupCause(v) {
+    return typeof v === 'string' && CORE_RESUME_STARTUP_CAUSES.includes(v);
 }
+const RESUME_CAUSE_CORE_AHEAD = Object.freeze(['transcript_corrupt']);
+const _startupCausePin = true;
+void _startupCausePin;
 export function parkedResumeStartupFromError(err, decision) {
     if (typeof err !== 'object' || err === null)
         return null;
@@ -170,32 +152,28 @@ export function parkedResumeStartupFromError(err, decision) {
         denyStaysOpen: true,
     };
 }
-const PARKED_RESUME_STARTUP_STATE = 'This refusal does not say whether the card is still waiting — re-fetch the pending approvals';
-const PARKED_RESUME_STARTUP_SENTENCES = Object.freeze({
-    resume_rejected: [
-        'The engine could not start the parked work to apply this decision (its session may be gone, or the engine rejected the decision itself; this client cannot tell which)',
-        PARKED_RESUME_STARTUP_STATE,
-        'If the card is still there, decide it again from the fresh list',
-    ].join(' · '),
-    undetermined: [
-        'The engine could not start the parked work to apply this decision',
-        PARKED_RESUME_STARTUP_STATE,
-        'If the card is still there: when the engine rejected the decision itself (for example an answer given to the wrong question), correct it and decide again; when the approved tool is one the agent inherits from the task that started it, approving it again will not work on this server — deny the card, or wait for a server upgrade',
-    ].join(' · '),
+const PARKED_RESUME_STARTUP_KEYS = Object.freeze({
+    resume_rejected: 'resume.refusal.startup.resumeRejected',
+    undetermined: 'resume.refusal.startup.undetermined',
 });
-export function parkedResumeStartupContent(detail) {
-    return detail.cause === 'resume_rejected' ? PARKED_RESUME_STARTUP_SENTENCES.resume_rejected : PARKED_RESUME_STARTUP_SENTENCES.undetermined;
+const PARKED_RESUME_STARTUP_CAUSE_KEYS = Object.freeze({
+    environment: 'resume.refusal.startup.cause.environment',
+    session_gone: 'resume.refusal.startup.cause.sessionGone',
+    tool_unavailable: 'resume.refusal.startup.cause.toolUnavailable',
+    configuration: 'resume.refusal.startup.cause.configuration',
+    decision_rejected: 'resume.refusal.startup.cause.decisionRejected',
+    transcript_corrupt: 'resume.refusal.startup.cause.transcriptCorrupt',
+});
+export function parkedResumeStartupContent(detail, lang) {
+    const word = guardedRead(() => readOwnDataValue(detail, 'startupCause'));
+    if (isResumeStartupCause(word))
+        return renderMessage(msg(PARKED_RESUME_STARTUP_CAUSE_KEYS[word]), lang);
+    return renderMessage(msg(detail.cause === 'resume_rejected' ? PARKED_RESUME_STARTUP_KEYS.resume_rejected : PARKED_RESUME_STARTUP_KEYS.undetermined), lang);
 }
 export function checkpointUnsupportedVersionFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
-    let code;
-    try {
-        code = err.errorCode;
-    }
-    catch {
-        return null;
-    }
+    const code = guardedRead(() => ownDataField(err, 'errorCode'));
     if (code !== CHECKPOINT_UNSUPPORTED_VERSION || !refusalSaysStillPending(err))
         return null;
     const writerVersion = readErrorString(err, 'writerVersion');
@@ -221,10 +199,7 @@ function checkpointUnsupportedHasRun(kind) {
             return undefined;
     }
 }
-const CHECKPOINT_UNSUPPORTED_WHAT = 'This server cannot continue this parked work in the form it was stored in';
-const CHECKPOINT_UNSUPPORTED_STILL_WAITING = 'Nothing was decided or resumed and the parked work is still waiting, but sending the same request again will not by itself continue it';
-const CHECKPOINT_UNSUPPORTED_DRAIN = " — whoever operates this deployment can find such parked work before an upgrade with the server's pre-upgrade drain check";
-export function checkpointUnsupportedVersionContent(detail, ctx) {
+export function checkpointUnsupportedVersionContent(detail, ctx, lang) {
     let writer;
     let reader;
     try {
@@ -236,11 +211,7 @@ export function checkpointUnsupportedVersionContent(detail, ctx) {
         reader = undefined;
     }
     if (writerEngineIsNewer(writer, reader)) {
-        return [
-            `This parked work was stored by a newer engine version (${String(writer)}) than this engine (${String(reader)})`,
-            CHECKPOINT_UNSUPPORTED_STILL_WAITING,
-            `Continue it on an engine at version ${String(writer)} or newer`,
-        ].join(' · ');
+        return renderMessage(msg('resume.refusal.checkpoint.newerEngine', { writer: String(writer), reader: String(reader) }), lang);
     }
     let kind;
     let runId;
@@ -255,17 +226,16 @@ export function checkpointUnsupportedVersionContent(detail, ctx) {
     const hasRun = checkpointUnsupportedHasRun(kind);
     let outlet;
     if (hasRun === true) {
-        const named = typeof runId === 'string' && runId.length > 0 ? ` (${capForDisplay(runId, 80)})` : '';
-        outlet = `If it was parked before this server was upgraded, cancel its run${named} first, then submit the work again as a new task`;
+        const named = typeof runId === 'string' && runId.length > 0 ? msg('resume.refusal.checkpoint.runNamed', { runId: capForDisplay(runId, 80) }) : '';
+        outlet = msg('resume.refusal.checkpoint.outletWithRun', { named });
     }
     else if (hasRun === false) {
-        outlet = 'If it was parked before this server was upgraded, there is no run to cancel: start a new task in that conversation';
+        outlet = msg('resume.refusal.checkpoint.outletNoRun');
     }
     else {
-        outlet =
-            'If it was parked before this server was upgraded, submit the work again as a new task (this client cannot tell which kind of parked work this is, so both ways out are given): when it still has a run waiting on it (a tool approval, a plan review or a paused resource), cancel that run first; when it was waiting to be woken up, or was a workflow step continuing its host conversation, there is no run to cancel, so start a new task in that conversation';
+        outlet = msg('resume.refusal.checkpoint.outletUnknownKind');
     }
-    return [CHECKPOINT_UNSUPPORTED_WHAT, CHECKPOINT_UNSUPPORTED_STILL_WAITING, outlet + CHECKPOINT_UNSUPPORTED_DRAIN].join(' · ');
+    return renderMessage(msg('resume.refusal.checkpoint.content', { outlet }), lang);
 }
 const REFUSED_PARK_FIELD_TOKEN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
 export function refusedParkFromError(failure) {
@@ -300,16 +270,14 @@ function refusedParkShownRunId(runId) {
 function refusedParkWhy(code, field) {
     switch (code) {
         case CHECKPOINT_WALLTIME_AXIS_RETIRED:
-            return 'its run carries a wall-clock time allowance, which this engine version no longer enforces';
+            return msg('resume.refusal.park.whyWalltime');
         case CHECKPOINT_CONFIG_REFUSED:
-            return field === 'inheritedGate'
-                ? 'the permission-mode setting it was parked with can no longer be read'
-                : 'the engine refuses the task configuration it was parked with';
+            return msg(field === 'inheritedGate' ? 'resume.refusal.park.whyInheritedGate' : 'resume.refusal.park.whyConfigRefused');
         default:
-            return 'it was parked under conditions this engine version does not support (for example, by an earlier engine version)';
+            return msg('resume.refusal.park.whyUnsupported');
     }
 }
-export function refusedParkContent(input) {
+export function refusedParkContent(input, lang) {
     let what;
     let lane;
     let runId;
@@ -334,30 +302,25 @@ export function refusedParkContent(input) {
         rawCode = field = stillPending = undefined;
     }
     const code = rawCode === CHECKPOINT_WALLTIME_AXIS_RETIRED || rawCode === CHECKPOINT_CONFIG_REFUSED ? rawCode : CHECKPOINT_UNSUPPORTED_VERSION;
-    const shownWhat = typeof what === 'string' && what !== '' ? capForDisplay(what, 40) : 'parked step';
+    const shownWhat = typeof what === 'string' && what !== '' ? capForDisplay(what, 40) : msg('resume.refusal.park.whatDefault');
     const why = refusedParkWhy(code, typeof field === 'string' ? field : undefined);
     const shownRun = refusedParkShownRunId(runId);
-    const head = `This ${shownWhat} cannot be resumed by this engine version: ${why}. The same refusal comes back every time, so ` +
-        `answering it again will not help (nothing was decided and nothing was resumed).`;
-    const configMayReturn = code === CHECKPOINT_CONFIG_REFUSED && field !== 'inheritedGate' ? ' If that configuration is restored, the same answer can go through again.' : '';
+    const head = msg('resume.refusal.park.head', { what: shownWhat, why });
+    const configMayReturn = code === CHECKPOINT_CONFIG_REFUSED && field !== 'inheritedGate' ? msg('resume.refusal.park.configMayReturn') : '';
     if (lane === 'print') {
-        if (stillPending === false) {
-            return `${head} The engine ended that run (${code}); submit the work again as a new task.`;
-        }
+        if (stillPending === false)
+            return renderMessage(msg('resume.refusal.park.printEnded', { head, code }), lang);
         const cancel = `POST /v1/runs/${shownRun ?? '<run id>'}/cancel`;
-        return `${head}${configMayReturn} The parked run still holds this session (${code}): cancel it (${cancel}), then submit the work again as a new task.`;
-    }
-    if (stillPending === false) {
-        return `${head} The engine ended that parked run, so this conversation is free: send the work again as a new message.`;
+        return renderMessage(msg('resume.refusal.park.printHolds', { head, configMayReturn, code, cancel }), lang);
     }
-    return `${head}${configMayReturn} The parked run keeps this conversation busy until it is cancelled.`;
+    if (stillPending === false)
+        return renderMessage(msg('resume.refusal.park.interactiveEnded', { head }), lang);
+    return renderMessage(msg('resume.refusal.park.interactiveBusy', { head, configMayReturn }), lang);
 }
-export function refusedParkBlockedContent(taskId, lane = 'interactive') {
+export function refusedParkBlockedContent(taskId, lane = 'interactive', lang) {
     const runId = refusedParkShownRunId(taskId);
-    const head = `sema will not put the card for run ${runId ?? '<unknown>'} back on screen by itself: this engine version refuses to resume it.`;
-    if (lane === 'print') {
-        return `${head} Cancel the run (POST /v1/runs/${runId ?? '<run id>'}/cancel) and submit the work again as a new task.`;
-    }
-    return (`${head} To free this conversation, send a message to bring the card back and answer it — sema then offers to cancel ` +
-        `that run, after which you can send the work again as a new message.`);
+    const run = runId ?? '<unknown>';
+    if (lane === 'print')
+        return renderMessage(msg('resume.refusal.park.blockedPrint', { run, cancel: `POST /v1/runs/${runId ?? '<run id>'}/cancel` }), lang);
+    return renderMessage(msg('resume.refusal.park.blockedInteractive', { run }), lang);
 }

package/dist/retryStatus.d.ts

@@ -71,4 +71,49 @@ export interface BrainStatusPayload {
 }
 export declare const BRAIN_STATUS_PAYLOAD_KEYS: readonly ["phase", "detail", "retryInSec", "retryInMs", "attempt", "maxRetries", "errClass", "retryAtMs", "errorStatus", "elapsedMs", "timeoutMs", "providerCondition", "providerConditionSource"];
 export declare function mapBrainStatusToRetry(p: BrainStatusPayload, nowMs: number): RetryStatus | null;
+export interface RetryStatusArmLike {
+    readonly phase?: string;
+    readonly detail?: string;
+    readonly retryInSec?: number;
+    readonly retryInMs?: number;
+    readonly attempt?: number;
+    readonly maxRetries?: number;
+    readonly errClass?: string;
+    readonly retryAtMs?: number;
+    readonly errorStatus?: number;
+    readonly elapsedMs?: number;
+    readonly timeoutMs?: number;
+    readonly providerCondition?: string;
+    readonly providerConditionSource?: string;
+    readonly parentToolCallId?: string;
+}
+export declare function retryStatusFromArm(arm: RetryStatusArmLike | null | undefined, nowMs: number): RetryStatus | null | undefined;
+export interface RetryStatusNotice {
+    readonly line: string;
+    readonly recourse?: 'switch_model' | 'wait' | 'fix_request';
+    readonly phase: 'retrying' | 'reconnecting' | 'waiting_first_token' | 'gave_up' | 'cleared';
+}
+export declare function retryStatusNotice(status: RetryStatus | null, ctx?: {
+    readonly modelName?: string;
+}): RetryStatusNotice;
+export interface ApiErrorRowLike {
+    readonly _sema_api_error_status?: number;
+    readonly _sema_provider_condition?: string;
+    readonly _sema_api_error_code?: string;
+}
+export interface ApiErrorRowFacts {
+    readonly status?: number;
+    readonly providerCondition?: string;
+    readonly errorCode?: string;
+}
+export interface ApiErrorNotice {
+    readonly line: string;
+    readonly recourse?: NonNullable<RetryStatusNotice['recourse']> | 'check_credentials';
+}
+export interface ApiErrorNoticeCtx {
+    readonly modelName?: string;
+    readonly providerText?: string;
+}
+export declare function apiErrorFactsOfRow(row: ApiErrorRowLike | null | undefined): ApiErrorRowFacts;
+export declare function apiErrorNotice(facts: ApiErrorRowFacts | null | undefined, ctx?: ApiErrorNoticeCtx): ApiErrorNotice | undefined;
 export {};