@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/hitl/approvalHolds.js

@@ -1,6 +1,6 @@
 import { hostLog } from '../host.js';
 import { liveFrameCallKey } from './gateIdentity.js';
-import { decideReceiptReopen } from '../decideReceipt.js';
+import { decideReceiptReopen, readDecideReceipt } from '../decideReceipt.js';
 export const APPROVAL_SETTLED_HOWS = Object.freeze(['answered', 'interrupted', 'closed_by_engine']);
 export const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
@@ -73,7 +73,7 @@ export async function awaitApprovalHolder(hold, signal, asker) {
         }
         if (r.kind !== 'unsettled' || r.cause !== 'interrupted' || hold.trailing === undefined)
             return HOLDER_FREE;
-        const landed = await hold.trailing.then(() => true, () => false);
+        const landed = await hold.trailing.then((raw) => decideReceiptReopen(readDecideReceipt(raw)) === null, () => false);
         return landed ? Object.freeze({ kind: 'settled', how: 'interrupted', outcome: r }) : HOLDER_FREE;
     }
     finally {
@@ -98,7 +98,7 @@ async function awaitHostHolder(hold, signal, asker) {
         unsubscribe();
     }
 }
-function holdHostCard(identity) {
+function holdHostCard(identity, signal) {
     const h = approvalDecisionHolds;
     const key = `hitl-host:${++h.clock}`;
     let resolveReleased = () => { };
@@ -109,41 +109,71 @@ function holdHostCard(identity) {
     const hold = { lane: 'host', identity: frozen, phase: 'card', released };
     h.inFlight.set(key, hold);
     let done = false;
-    return Object.freeze({
+    let stopFollowing = () => { };
+    const release = (settled) => {
+        if (done)
+            return;
+        done = true;
+        stopFollowing();
+        const how = settled === 'answered' || settled === 'interrupted' ? settled : undefined;
+        if (how !== undefined && nonEmpty(frozen.approvalId))
+            noteSettled(frozen.approvalId, how, false, how === 'interrupted' ? interruptedThere('decide') : nothingSentHere('decide'), true);
+        if (h.inFlight.get(key) === hold)
+            h.inFlight.delete(key);
+        resolveReleased(how);
+    };
+    const handle = Object.freeze({
         identity: frozen,
         sending: () => {
-            if (!done)
-                hold.phase = 'respond';
-        },
-        release: (settled) => {
             if (done)
                 return;
-            done = true;
-            const how = settled === 'answered' || settled === 'interrupted' ? settled : undefined;
-            if (how !== undefined && nonEmpty(frozen.approvalId))
-                noteSettled(frozen.approvalId, how, false, how === 'interrupted' ? interruptedThere('decide') : nothingSentHere('decide'), true);
-            if (h.inFlight.get(key) === hold)
-                h.inFlight.delete(key);
-            resolveReleased(how);
+            hold.phase = 'respond';
+            stopFollowing();
         },
+        release,
+    });
+    stopFollowing = followCallerSignal(signal, () => {
+        if (!done && hold.phase === 'card')
+            release();
     });
+    return handle;
+}
+function callerSignalAborted(signal) {
+    if (signal === undefined || signal === null)
+        return false;
+    try {
+        return signal.aborted === true;
+    }
+    catch {
+        return false;
+    }
 }
-const CLAIM_MAX_ROUNDS = 8;
 export async function claimApprovalCardFor(who, signal) {
-    for (let round = 0; round < CLAIM_MAX_ROUNDS; round++) {
-        const entry = settledApprovalOf(who.approvalId);
-        if (settledForDurableLane(entry) && entry !== undefined)
-            return Object.freeze({ kind: 'joined', outcome: { ...entry.outcome, joinedInFlight: true } });
-        const holder = approvalHoldFor(who);
-        if (holder === undefined)
-            return Object.freeze({ kind: 'held', hold: holdHostCard(who) });
-        const wait = await awaitApprovalHolder(holder, signal, 'decide');
-        if (wait.kind === 'settled')
-            return Object.freeze({ kind: 'joined', outcome: { ...wait.outcome, joinedInFlight: true } });
-        if (wait.kind === 'left')
-            return Object.freeze({ kind: 'joined', outcome: { ...nothingSentHere('decide'), joinedInFlight: true } });
+    let leave = () => { };
+    const left = new Promise((resolve) => {
+        leave = () => resolve('aborted');
+    });
+    const unsubscribe = followCallerSignal(signal, leave);
+    try {
+        for (;;) {
+            if (callerSignalAborted(signal))
+                return Object.freeze({ kind: 'aborted' });
+            const entry = settledApprovalOf(who.approvalId);
+            if (settledForDurableLane(entry) && entry !== undefined)
+                return Object.freeze({ kind: 'joined', outcome: { ...entry.outcome, joinedInFlight: true } });
+            const holder = approvalHoldFor(who);
+            if (holder === undefined)
+                return Object.freeze({ kind: 'held', hold: holdHostCard(who, signal) });
+            const wait = await Promise.race([awaitApprovalHolder(holder, undefined, 'decide'), left]);
+            if (wait === 'aborted')
+                return Object.freeze({ kind: 'aborted' });
+            if (wait.kind === 'settled')
+                return Object.freeze({ kind: 'joined', outcome: { ...wait.outcome, joinedInFlight: true } });
+        }
+    }
+    finally {
+        unsubscribe();
     }
-    return Object.freeze({ kind: 'held', hold: holdHostCard(who) });
 }
 export const approvalDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), outcomes: new Map(), clock: 0 };
 export function settledApprovalOf(approvalId) {
@@ -180,6 +210,20 @@ function engineClosedOutcome() {
 export function noteEngineClosedApproval(approvalId, parked) {
     noteSettled(approvalId, 'closed_by_engine', parked, engineClosedOutcome());
 }
+export function settleEngineClosedApproval(frame, parked) {
+    let id;
+    try {
+        const d = typeof frame === 'object' && frame !== null ? Object.getOwnPropertyDescriptor(frame, 'approvalId') : undefined;
+        id = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+    }
+    catch {
+        return false;
+    }
+    if (!nonEmpty(id))
+        return false;
+    noteEngineClosedApproval(id, parked);
+    return supersedeLiveCard(liveFrameCallKey(id), parked);
+}
 export function noteHolderSettledApproval(approvalId, how, outcome) {
     noteSettled(approvalId, how, false, outcome, true);
 }

package/dist/hitl/askClassPair.d.ts

@@ -1,4 +1,4 @@
-import type { CORE_MODE_ARBITRATION } from '../generated/engineFactTables.js';
+import { CORE_MODE_ARBITRATION } from '../generated/engineFactTables.js';
 export declare const DEPLOYMENT_LIST_ASK_CLASSES: readonly (keyof typeof CORE_MODE_ARBITRATION)[];
 export type AskClassPairReading = {
     readonly state: 'pair';

package/dist/hitl/askClassPair.js

@@ -1,3 +1,4 @@
+import { CORE_MODE_ARBITRATION } from '../generated/engineFactTables.js';
 export const DEPLOYMENT_LIST_ASK_CLASSES = Object.freeze(['ask_rule']);
 const ABSENT = Object.freeze({ state: 'absent' });
 const MALFORMED = Object.freeze({ state: 'malformed' });
@@ -35,8 +36,23 @@ export function readAskClassPairState(v) {
         return MALFORMED;
     if (classes[0] !== askClass)
         return MALFORMED;
+    if (!inCanonicalOrder(classes))
+        return MALFORMED;
     return Object.freeze({ state: 'pair', askClass, classes: Object.freeze(classes) });
 }
+function inCanonicalOrder(classes) {
+    const order = Object.keys(CORE_MODE_ARBITRATION);
+    let last = -1;
+    for (const c of classes) {
+        const rank = order.indexOf(c);
+        if (rank < 0)
+            continue;
+        if (rank <= last)
+            return false;
+        last = rank;
+    }
+    return true;
+}
 export function readAskClassPair(v) {
     const r = readAskClassPairState(v);
     return r.state === 'pair' ? { askClass: r.askClass, classes: r.classes } : undefined;

package/dist/hitl/askGateWire.js

@@ -6,6 +6,7 @@ import { abortableSleep } from '../abortableSleep.js';
 import { hostLog } from '../host.js';
 import { decideAcceptedNotResolved, readDecideReceipt } from '../decideReceipt.js';
 import { APPROVAL_EXPIRED } from '../engineErrorCodes.js';
+import { isNotFoundFailure } from '../wireErrorTriage.js';
 import { readDecisionRefusalAsk } from './decisionRefusal.js';
 import { resumeReopenFromError } from './suspendedReopen.js';
 import { refusedParkFromError, resumeRefusalFromError } from '../resumeRefusalCopy.js';
@@ -192,7 +193,7 @@ export function lateDecideOutcomeOf(reply, opts) {
         const r = readDecisionRefusalAsk(e);
         if (r.reading !== 'settled' && !(r.reading === 'not_settled' && r.gateMoved))
             return LATE_UNKNOWN;
-        const probeWorthy = status === 404 || status === 410 || (typeof code === 'string' && code.startsWith('not_found.'));
+        const probeWorthy = status === 404 || status === 410 || isNotFoundFailure(e) !== false;
         return Object.freeze(probeWorthy ? { kind: 'settled-elsewhere', probeWorthy: true } : { kind: 'settled-elsewhere' });
     }
     catch {

package/dist/hitl/askSettlementLine.d.ts

@@ -1,10 +1,11 @@
-export declare function askEndingCauseClause(cause: string | undefined): string | undefined;
+import type { UiLanguage } from '../env/uiLanguage.js';
+export declare function askEndingCauseClause(cause: string | undefined, lang?: UiLanguage): string | undefined;
 export interface AskSettlementInput {
     readonly cause?: string | undefined;
     readonly toolName?: string | undefined;
     readonly parked?: boolean | undefined;
 }
-export declare function askSettlementLine(settled: AskSettlementInput): string | undefined;
+export declare function askSettlementLine(settled: AskSettlementInput, lang?: UiLanguage): string | undefined;
 export type AskAcceptedFollow = 'following' | 'already-following' | 'not-following';
 export interface AskAcceptedInput {
     readonly decision?: string | undefined;
@@ -13,6 +14,15 @@ export interface AskAcceptedInput {
     readonly follow?: AskAcceptedFollow | undefined;
     readonly executed?: string | undefined;
 }
-export declare function askAcceptedLine(accepted: AskAcceptedInput): string;
+export declare function askAcceptedLine(accepted: AskAcceptedInput, lang?: UiLanguage): string;
 export type AskParkedCardForm = 'approval' | 'question' | 'queue_no_deadline';
-export declare function askParkedCardNote(form?: string | undefined, toolName?: string | undefined): string;
+export declare function askParkedCardNote(form?: string | undefined, toolName?: string | undefined, lang?: UiLanguage): string;
+export interface AskHumanSettledInput {
+    readonly kind?: string | undefined;
+    readonly decision?: string | undefined;
+    readonly taskId?: string | undefined;
+    readonly late?: boolean | undefined;
+    readonly follow?: AskAcceptedFollow | undefined;
+    readonly executed?: string | undefined;
+}
+export declare function askHumanSettlementLine(settled: AskHumanSettledInput, lang?: UiLanguage): string | undefined;

package/dist/hitl/askSettlementLine.js

@@ -1,79 +1,99 @@
 import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { guardedRead, readOwnDataValue } from '../ownKey.js';
-const ENDING_CAUSE_CLAUSES = Object.freeze({
-    routing_failure_fail_closed: 'the engine could not route it to anywhere that can answer it, so it closed it',
-    run_cancelled: 'the run that asked for it was cancelled',
-    run_exited: 'the run that asked for it exited before anyone answered',
-    batch_aborted: 'the batch of tool calls it belonged to was aborted',
-    batch_sibling_withdrawn: 'another approval in the same batch was refused or withdrawn, which withdrew this one too',
-    batch_bound_elsewhere: 'the decision for its batch was bound to a different approval',
-    adhoc_leg_no_durable_domain: 'this kind of request cannot be kept waiting for an answer on this deployment',
-    orphan_ttl_exceeded: "it was left without an owner past the engine's time limit",
-    crashed_before_park: 'the engine process stopped before it could keep the request waiting',
-    shutdown_before_park: 'the engine shut down before it could keep the request waiting',
-    ttl_expired: 'nobody answered within the approval window',
-    broadcast_lost: 'it never reached any open connection',
-    stream_disconnected: 'the connection carrying this card dropped',
-    undeliverable: 'it could not be delivered to any approval surface',
+const ENDING_CAUSE_KEYS = Object.freeze({
+    routing_failure_fail_closed: 'approval.settle.cause.routingFailureFailClosed',
+    run_cancelled: 'approval.settle.cause.runCancelled',
+    run_exited: 'approval.settle.cause.runExited',
+    batch_aborted: 'approval.settle.cause.batchAborted',
+    batch_sibling_withdrawn: 'approval.settle.cause.batchSiblingWithdrawn',
+    batch_bound_elsewhere: 'approval.settle.cause.batchBoundElsewhere',
+    adhoc_leg_no_durable_domain: 'approval.settle.cause.adhocLegNoDurableDomain',
+    orphan_ttl_exceeded: 'approval.settle.cause.orphanTtlExceeded',
+    crashed_before_park: 'approval.settle.cause.crashedBeforePark',
+    shutdown_before_park: 'approval.settle.cause.shutdownBeforePark',
+    ttl_expired: 'approval.settle.cause.ttlExpired',
+    broadcast_lost: 'approval.settle.cause.broadcastLost',
+    stream_disconnected: 'approval.settle.cause.streamDisconnected',
+    undeliverable: 'approval.settle.cause.undeliverable',
 });
-export function askEndingCauseClause(cause) {
-    return typeof cause === 'string' && Object.hasOwn(ENDING_CAUSE_CLAUSES, cause) ? ENDING_CAUSE_CLAUSES[cause] : undefined;
+function endingCauseKeyOf(cause) {
+    return typeof cause === 'string' && Object.hasOwn(ENDING_CAUSE_KEYS, cause) ? ENDING_CAUSE_KEYS[cause] : undefined;
+}
+export function askEndingCauseClause(cause, lang) {
+    const key = endingCauseKeyOf(cause);
+    return key !== undefined ? renderMessage(msg(key), lang) : undefined;
 }
 function ownSlot(o, key) {
     if (typeof o !== 'object' || o === null)
         return undefined;
     return guardedRead(() => readOwnDataValue(o, key));
 }
-function subjectOf(toolName, named, fallback) {
+function subjectOf(toolName, named, generic) {
     const quoted = typeof toolName === 'string' ? guardedRead(() => quoteUntrustedForSentence(toolName, 80)) : undefined;
-    return quoted === undefined ? fallback : named(quoted);
+    return quoted === undefined ? msg(generic) : msg(named, { tool: quoted });
 }
-const SETTLEMENT_TAIL = ' Nothing was approved from this card; if the step is still needed, ask for it again.';
-export function askSettlementLine(settled) {
+export function askSettlementLine(settled, lang) {
     if (ownSlot(settled, 'parked') === true)
         return undefined;
     const cause = ownSlot(settled, 'cause');
     if (typeof cause !== 'string' || cause === '')
         return undefined;
-    const subject = subjectOf(ownSlot(settled, 'toolName'), (q) => `the approval request for ${q}`, 'this approval request');
-    const clause = askEndingCauseClause(cause);
-    const why = clause !== undefined ? `: ${clause}` : " (the engine's reason is one this build does not know yet)";
-    return `${subject} ended on the engine without an answer${why}.${SETTLEMENT_TAIL}`;
+    const subject = subjectOf(ownSlot(settled, 'toolName'), 'approval.settle.subject.named', 'approval.settle.subject.generic');
+    const clauseKey = endingCauseKeyOf(cause);
+    return renderMessage(clauseKey !== undefined ? msg('approval.settle.endedKnown', { subject, clause: msg(clauseKey) }) : msg('approval.settle.endedUnknown', { subject }), lang);
 }
 const TASK_ID_MAX = 64;
-const EXECUTED_TAILS = Object.freeze({
-    allowed: ' The engine also reports that the already-decided step was ALLOWED when it ran.',
-    denied: ' The engine also reports that the already-decided step was DENIED at execution time (a deployment review can overturn an approval after the fact).',
+const EXECUTED_TAIL_KEYS = Object.freeze({
+    allowed: 'approval.settle.executed.allowed',
+    denied: 'approval.settle.executed.denied',
 });
-const FOLLOW_CLAUSES = Object.freeze({
-    following: 'sema is following that run here',
-    'already-following': 'this screen is already following that run',
+const FOLLOW_CLAUSE_KEYS = Object.freeze({
+    following: 'approval.settle.follow.following',
+    'already-following': 'approval.settle.follow.alreadyFollowing',
 });
-export function askAcceptedLine(accepted) {
+export function askAcceptedLine(accepted, lang) {
     const decision = ownSlot(accepted, 'decision');
-    const what = decision === 'approve' ? 'approved' : decision === 'deny' ? 'denied' : 'answered';
-    const late = ownSlot(accepted, 'late') === false ? '' : ' late';
+    const what = msg(decision === 'approve' ? 'approval.settle.what.approved' : decision === 'deny' ? 'approval.settle.what.denied' : 'approval.settle.what.answered');
+    const late = ownSlot(accepted, 'late') === false ? '' : msg('approval.settle.late');
     const rawTask = ownSlot(accepted, 'taskId');
     const shownTask = typeof rawTask === 'string' ? guardedRead(() => displayUntrusted(rawTask, { max: TASK_ID_MAX, blanks: true })) : undefined;
-    const where = shownTask === undefined || shownTask === '' ? '' : ` (task ${shownTask})`;
+    const where = shownTask === undefined || shownTask === '' ? '' : msg('approval.settle.where', { task: shownTask });
     const follow = ownSlot(accepted, 'follow');
     const executed = ownSlot(accepted, 'executed');
-    const tail = executed === 'allowed' || executed === 'denied' ? EXECUTED_TAILS[executed] : '';
+    const tail = executed === 'allowed' || executed === 'denied' ? msg(EXECUTED_TAIL_KEYS[executed]) : '';
     if (follow === 'following' || follow === 'already-following') {
-        return `${what}${late} — the engine took this decision${where}; ${FOLLOW_CLAUSES[follow]}, so what it does next shows up below.${tail}`;
+        return renderMessage(msg('approval.settle.acceptedFollowing', { what, late, where, follow: msg(FOLLOW_CLAUSE_KEYS[follow]), tail }), lang);
     }
-    return (`${what}${late} — the engine took this decision${where}. Whether the parked call has resumed yet is not something this reply can say; ` +
-        `this screen is not following that run, so what it does next will not show up here by itself.${tail}`);
+    return renderMessage(msg('approval.settle.acceptedNotFollowing', { what, late, where, tail }), lang);
 }
-const PARKED_CARD_NOTES = Object.freeze({
-    approval: "This step was already parked in the engine's durable queue and waiting for a decision before this card went up. Yes approves it now and lets the step run late; No abandons the step — the model gets a refusal and can take another route.",
-    question: "This step was already parked in the engine's durable queue and waiting for a decision before this card went up. Answering now sends your decision late and lets the parked step continue with it; closing this card without answering abandons the step — the model gets a refusal and can take another route.",
-    queue_no_deadline: "{subject} is in the engine's durable queue (no deadline was reported for it). It waits for your decision — nothing has been decided on your behalf.",
+const PARKED_CARD_NOTE_KEYS = Object.freeze({
+    approval: 'approval.settle.parkedNote.approval',
+    question: 'approval.settle.parkedNote.question',
+    queue_no_deadline: 'approval.settle.parkedNote.queueNoDeadline',
 });
-export function askParkedCardNote(form, toolName) {
+export function askParkedCardNote(form, toolName, lang) {
     const key = form === 'question' || form === 'queue_no_deadline' ? form : 'approval';
-    const template = PARKED_CARD_NOTES[key];
     if (key !== 'queue_no_deadline')
-        return template;
-    return template.split('{subject}').join(subjectOf(toolName, (q) => `the approval for ${q}`, 'this approval'));
+        return renderMessage(msg(PARKED_CARD_NOTE_KEYS[key]), lang);
+    return renderMessage(msg(PARKED_CARD_NOTE_KEYS[key], { subject: subjectOf(toolName, 'approval.settle.parkedSubject.named', 'approval.settle.parkedSubject.generic') }), lang);
+}
+export function askHumanSettlementLine(settled, lang) {
+    const kind = ownSlot(settled, 'kind');
+    if (kind === 'accepted-not-resolved')
+        return askAcceptedLine(settled, lang);
+    if (kind === 'expired-reaped')
+        return renderMessage(msg('approval.settleHuman.expiredReaped'), lang);
+    if (kind === 'settled-elsewhere')
+        return renderMessage(msg('approval.settleHuman.settledElsewhere'), lang);
+    if (kind !== 'resumed')
+        return undefined;
+    const decision = ownSlot(settled, 'decision');
+    const what = msg(decision === 'approve' ? 'approval.settle.what.approved' : decision === 'deny' ? 'approval.settle.what.denied' : 'approval.settle.what.answered');
+    const rawTask = ownSlot(settled, 'taskId');
+    const shownTask = typeof rawTask === 'string' ? guardedRead(() => displayUntrusted(rawTask, { max: TASK_ID_MAX, blanks: true })) : undefined;
+    const where = shownTask === undefined || shownTask === '' ? '' : msg('approval.settle.where', { task: shownTask });
+    const executed = ownSlot(settled, 'executed');
+    const tail = executed === 'allowed' || executed === 'denied' ? msg(EXECUTED_TAIL_KEYS[executed]) : '';
+    return renderMessage(msg(ownSlot(settled, 'late') === false ? 'approval.settleHuman.resumed' : 'approval.settleHuman.resumedLate', { what, where, tail }), lang);
 }

package/dist/hitl/automaticAnswerVerdict.d.ts

@@ -1,5 +1,6 @@
 import { type CoreModeArbitrationRow } from '../generated/engineFactTables.js';
 import { CORE_ASK_FACES } from '../generated/engineAskFaceTables.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
 export type AutomaticAnswerLane = 'mode_posture' | 'standing_rule' | 'permission_request_hook';
 export type AutomaticAnswerAskFace = (typeof CORE_ASK_FACES)[number];
 export interface AutomaticAnswerFacts {
@@ -22,6 +23,6 @@ export type AutomaticAnswerVerdict = {
 export declare const MODE_ARBITRATION: Readonly<Record<"hook" | "write_protection" | "mode" | "target_unresolved" | "content_question" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "org_rule" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
 export declare function foldModeArbitrationRow(classes: Iterable<string>, askFace?: AutomaticAnswerAskFace): CoreModeArbitrationRow;
 export declare function automaticAnswerVerdict(card: object | null | undefined, lane: AutomaticAnswerLane, facts?: AutomaticAnswerFacts | null): AutomaticAnswerVerdict;
-export declare function mandatedApprovalDetailOf(card: object | null | undefined): string;
+export declare function mandatedApprovalDetailOf(card: object | null | undefined, lang?: UiLanguage): string;
 export type PermissionRequestHookScope = 'allow_or_deny' | 'deny_only' | 'skip';
 export declare function permissionRequestHookScope(verdict: AutomaticAnswerVerdict | null | undefined): PermissionRequestHookScope;

package/dist/hitl/automaticAnswerVerdict.js

@@ -1,6 +1,7 @@
 import { CORE_MODE_ARBITRATION, CORE_MODE_RELEASE_REASONS } from '../generated/engineFactTables.js';
 import { CORE_RELEASABLE_ASK_CLASSES_BY_FACE, CORE_SHELL_FACE_TOOL_NAMES } from '../generated/engineAskFaceTables.js';
 import { mandatedApprovalDetail } from '../gateVocabulary.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { readAskOrigin, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPairState } from './askClassPair.js';
 import { readRequiresRealApproval } from './approvalCardReading.js';
@@ -179,26 +180,25 @@ export function automaticAnswerVerdict(card, lane, facts) {
         return UNKNOWN.card_unreadable;
     }
 }
-export function mandatedApprovalDetailOf(card) {
+export function mandatedApprovalDetailOf(card, lang) {
     try {
         if (typeof card !== 'object' || card === null)
-            return mandatedApprovalDetail();
+            return mandatedApprovalDetail(lang);
         const pair = readAskClassPairState(card);
         if (pair.state !== 'pair')
-            return mandatedApprovalDetail();
+            return mandatedApprovalDetail(lang);
         const classes = pair.classes;
         if (classes.some((c) => !Object.hasOwn(TABLE, c)))
-            return mandatedApprovalDetail();
+            return mandatedApprovalDetail(lang);
         const row = foldModeArbitrationRow(classes);
         if (row.classifierEligible || row.sandboxAdmission)
-            return mandatedApprovalDetail();
-        return MANDATED_NO_AUTOMATIC_CHECK_DETAIL;
+            return mandatedApprovalDetail(lang);
+        return renderMessage(msg('approval.mandate.noAutomaticCheck'), lang);
     }
     catch {
-        return mandatedApprovalDetail();
+        return mandatedApprovalDetail(lang);
     }
 }
-const MANDATED_NO_AUTOMATIC_CHECK_DETAIL = 'no saved allow rule and no remembered answer can retire this question, and no automatic check answers it; each call is settled on its own, by you here, and an answer covers only that call';
 export function permissionRequestHookScope(verdict) {
     try {
         const kind = typeof verdict === 'object' && verdict !== null ? verdict.kind : undefined;

package/dist/hitl/crashConvergedNotice.d.ts

@@ -1,6 +1,7 @@
+import type { UiLanguage } from '../env/uiLanguage.js';
 import type { CrashConvergedProjection, CrashConvergedRowReading } from './crashConverged.js';
 export declare const NEEDS_HUMAN_REASON_ORDER: readonly ["approved_then_interrupted", "pending_unsafe", "contradictory", "unstable_row"];
-export declare function crashConvergedNeedsHumanSentence(reason: string | undefined, n: number, total: number): string | undefined;
-export declare function crashConvergedNotice(projection: CrashConvergedProjection | undefined): string | undefined;
-export declare function crashConvergedRowSentence(projection: CrashConvergedProjection | undefined, row: Pick<CrashConvergedRowReading, 'approvalId'>): string | undefined;
-export declare function crashConvergedCauseSentence(cause: string | undefined): string | undefined;
+export declare function crashConvergedNeedsHumanSentence(reason: string | undefined, n: number, total: number, lang?: UiLanguage): string | undefined;
+export declare function crashConvergedNotice(projection: CrashConvergedProjection | undefined, lang?: UiLanguage): string | undefined;
+export declare function crashConvergedRowSentence(projection: CrashConvergedProjection | undefined, row: Pick<CrashConvergedRowReading, 'approvalId'>, lang?: UiLanguage): string | undefined;
+export declare function crashConvergedCauseSentence(cause: string | undefined, lang?: UiLanguage): string | undefined;

package/dist/hitl/crashConvergedNotice.js

@@ -1,3 +1,4 @@
+import { msg, renderMessage } from '../i18n/translate.js';
 import { askEndingCauseClause } from './askSettlementLine.js';
 import { crashConvergedRowInProjection, isCrashConvergedCause, readCrashConvergedNoticeFacts } from './crashConverged.js';
 export const NEEDS_HUMAN_REASON_ORDER = Object.freeze(['approved_then_interrupted', 'pending_unsafe', 'contradictory', 'unstable_row']);
@@ -7,53 +8,40 @@ const _orderHasNoDuplicate = true;
 void _orderCoversReasons;
 void _orderInsideReasons;
 void _orderHasNoDuplicate;
-const RECORDED = 'based on what was recorded';
-const NO_AUTO_RERUN = 'sema has not re-run anything';
 const plural = (n, one, many) => (n === 1 ? one : many);
 const NEEDS_HUMAN_CLAUSES = Object.freeze({
-    approved_then_interrupted: {
-        one: 'had already been approved and may have been running when the previous engine run ended, so a side effect may have partly landed',
-        many: 'had already been approved and may have been running when the previous engine run ended, so a side effect may have partly landed',
-    },
-    pending_unsafe: {
-        one: `had not started, ${RECORDED}, but the engine did not mark it as safe to re-run`,
-        many: `had not started, ${RECORDED}, but the engine did not mark them as safe to re-run`,
-    },
-    contradictory: { one: 'has a contradictory record', many: 'have contradictory records' },
-    unstable_row: {
-        one: 'has a record that read differently each time it was read',
-        many: 'have records that read differently each time they were read',
-    },
+    approved_then_interrupted: { one: 'session.crashConverged.reason.approvedThenInterrupted.one', many: 'session.crashConverged.reason.approvedThenInterrupted.many' },
+    pending_unsafe: { one: 'session.crashConverged.reason.pendingUnsafe.one', many: 'session.crashConverged.reason.pendingUnsafe.many' },
+    contradictory: { one: 'session.crashConverged.reason.contradictory.one', many: 'session.crashConverged.reason.contradictory.many' },
+    unstable_row: { one: 'session.crashConverged.reason.unstableRow.one', many: 'session.crashConverged.reason.unstableRow.many' },
 });
-const FALLBACK_CLAUSE = Object.freeze({
-    one: 'had already been approved, or cannot be accounted for, so a side effect may have partly landed',
-    many: 'had already been approved, or cannot be accounted for, so a side effect may have partly landed',
-});
-const RESUME_SAFE_CLAUSE = `had not started, ${RECORDED}, and can be re-run`;
-const countedClause = (clause, n, total) => `${n} of ${total} ${n === 1 ? clause.one : clause.many}`;
+const FALLBACK_CLAUSE = Object.freeze({ one: 'session.crashConverged.fallback.one', many: 'session.crashConverged.fallback.many' });
+const RESUME_SAFE_CLAUSE = 'session.crashConverged.resumeSafe';
+const countedClause = (clause, n, total, lang) => renderMessage(msg('session.crashConverged.counted', { n, total, clause: msg(n === 1 ? clause.one : clause.many) }), lang);
 const isNeedsHumanReason = (v) => typeof v === 'string' && Object.hasOwn(NEEDS_HUMAN_CLAUSES, v);
-export function crashConvergedNeedsHumanSentence(reason, n, total) {
+export function crashConvergedNeedsHumanSentence(reason, n, total, lang) {
     if (!isNeedsHumanReason(reason))
         return undefined;
     if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 1)
         return undefined;
     if (typeof total !== 'number' || !Number.isSafeInteger(total) || total < n)
         return undefined;
-    return countedClause(NEEDS_HUMAN_CLAUSES[reason], n, total);
+    return countedClause(NEEDS_HUMAN_CLAUSES[reason], n, total, lang);
 }
-function needsHumanClauses(reasons, total) {
+function needsHumanClauses(reasons, total, lang) {
     const clauses = [];
     for (const reason of NEEDS_HUMAN_REASON_ORDER) {
         const n = reasons.filter((r) => r === reason).length;
         if (n > 0)
-            clauses.push(countedClause(NEEDS_HUMAN_CLAUSES[reason], n, total));
+            clauses.push(countedClause(NEEDS_HUMAN_CLAUSES[reason], n, total, lang));
     }
     const fallback = reasons.filter((r) => !isNeedsHumanReason(r)).length;
     if (fallback > 0)
-        clauses.push(countedClause(FALLBACK_CLAUSE, fallback, total));
-    return `${clauses.join('; ')} — check ${plural(reasons.length, 'it', 'them')} by hand before re-running`;
+        clauses.push(countedClause(FALLBACK_CLAUSE, fallback, total, lang));
+    const joined = clauses.join(renderMessage(msg('session.crashConverged.clauseJoin'), lang));
+    return renderMessage(msg(plural(reasons.length, 'session.crashConverged.needsHumanBody.one', 'session.crashConverged.needsHumanBody.many'), { clauses: joined }), lang);
 }
-export function crashConvergedNotice(projection) {
+export function crashConvergedNotice(projection, lang) {
     const facts = readCrashConvergedNoticeFacts(projection);
     if (facts === undefined)
         return undefined;
@@ -61,16 +49,15 @@ export function crashConvergedNotice(projection) {
     if (total === 0 && dropped === 0)
         return undefined;
     if (total === 0) {
-        return `the previous session left ${dropped} crash-converged approval ${plural(dropped, 'record', 'records')} that this version could not read. ${NO_AUTO_RERUN}.`;
+        return renderMessage(msg(plural(dropped, 'session.crashConverged.droppedOnly.one', 'session.crashConverged.droppedOnly.many'), { count: dropped }), lang);
     }
-    const recordedAs = causes !== undefined && causes.length > 0 ? ` (recorded as ${causes.join(', ')})` : '';
-    const head = `the previous engine run ended with ${total} ${plural(total, 'approval', 'approvals')} still waiting${recordedAs}, ` +
-        `and the engine converged ${plural(total, 'it', 'them')} to denied`;
-    const body = needsHumanReasons.length > 0 ? needsHumanClauses(needsHumanReasons, total) : `${RECORDED}, ${plural(total, 'it', 'they')} can be re-run`;
-    const droppedClause = dropped > 0 ? ` (${dropped} further ${plural(dropped, 'record', 'records')} could not be read.)` : '';
-    return `${head}; ${body}. ${NO_AUTO_RERUN}.${droppedClause}`;
+    const recordedAs = causes !== undefined && causes.length > 0 ? msg('session.crashConverged.recordedAs', { causes: causes.join(', ') }) : '';
+    const head = renderMessage(msg(plural(total, 'session.crashConverged.head.one', 'session.crashConverged.head.many'), { total, recorded: recordedAs }), lang);
+    const body = needsHumanReasons.length > 0 ? needsHumanClauses(needsHumanReasons, total, lang) : renderMessage(msg(plural(total, 'session.crashConverged.rerunnable.one', 'session.crashConverged.rerunnable.many')), lang);
+    const droppedClause = dropped > 0 ? msg(plural(dropped, 'session.crashConverged.droppedTail.one', 'session.crashConverged.droppedTail.many'), { count: dropped }) : '';
+    return renderMessage(msg('session.crashConverged.line', { head, body, dropped: droppedClause }), lang);
 }
-export function crashConvergedRowSentence(projection, row) {
+export function crashConvergedRowSentence(projection, row, lang) {
     const hit = crashConvergedRowInProjection(projection, row);
     if (hit === undefined)
         return undefined;
@@ -82,13 +69,13 @@ export function crashConvergedRowSentence(projection, row) {
         return undefined;
     }
     if (hit.bucket === 'resumeSafe')
-        return descriptor === undefined ? RESUME_SAFE_CLAUSE : undefined;
+        return descriptor === undefined ? renderMessage(msg(RESUME_SAFE_CLAUSE), lang) : undefined;
     const reason = descriptor !== undefined && Object.hasOwn(descriptor, 'value') ? descriptor.value : undefined;
-    return (isNeedsHumanReason(reason) ? NEEDS_HUMAN_CLAUSES[reason] : FALLBACK_CLAUSE).one;
+    return renderMessage(msg((isNeedsHumanReason(reason) ? NEEDS_HUMAN_CLAUSES[reason] : FALLBACK_CLAUSE).one), lang);
 }
-export function crashConvergedCauseSentence(cause) {
+export function crashConvergedCauseSentence(cause, lang) {
     if (typeof cause !== 'string' || cause === '')
         return undefined;
-    const clause = isCrashConvergedCause(cause) ? askEndingCauseClause(cause) : undefined;
-    return clause === undefined ? 'the decision converged automatically' : `${clause}, and the decision converged automatically`;
+    const clause = isCrashConvergedCause(cause) ? askEndingCauseClause(cause, lang) : undefined;
+    return renderMessage(clause === undefined ? msg('session.crashConverged.cause.neutral') : msg('session.crashConverged.cause.withClause', { clause }), lang);
 }

package/dist/hitl/frameRouter.js

@@ -8,11 +8,11 @@ import { readRunTerminal, runTerminalCode, runTerminalGateKind, runTerminalGateT
 import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { inheritFrameBinding } from '../frameBinding.js';
 import { surfaceForCurrentSession, surfaceReplayedApprovalListUnreadable } from './hitlHostSurface.js';
-import { liveCardHoldOf, noteEngineClosedApproval, supersedeLiveCard } from './approvalHolds.js';
+import { liveCardHoldOf, noteEngineClosedApproval, settleEngineClosedApproval } from './approvalHolds.js';
 import { approvalCompleteParked } from './approvalCompleteParked.js';
 import { liveFrameCallKey } from './gateIdentity.js';
 import { SEMA_DENIAL_KIND_KEY, hasLedgerPositionKey } from './gateLedger.js';
-import { replayedApprovalDisposition, settledApprovalDisposition } from './replayedApproval.js';
+import { replayedApprovalClosesCardFrame, replayedApprovalDisposition, settledApprovalDisposition } from './replayedApproval.js';
 import { settleWithinDeadline } from '../abortableSleep.js';
 import { ccToolDenialKindForSettledBy } from '../gateVocabulary.js';
 import { REJECT_MESSAGE } from '../adapt/wireShapes.js';
@@ -285,12 +285,9 @@ const TOOL_END_ARMS = [
 async function routeToolApprovalFrame(ev, ctx) {
     const { led, deps } = ctx;
     if (ev.type === 'tool_approval_complete') {
-        const id = ev.approvalId;
-        const parked = approvalCompleteParked(ev);
-        if (typeof id === 'string' && id !== '')
-            noteEngineClosedApproval(id, parked);
-        if (typeof id === 'string' && id !== '' && supersedeLiveCard(liveFrameCallKey(id), parked)) {
-            hostLog('debug', `liveHitlAskWire: tool_approval_complete for ${id} arrived while its card was waiting — card withdrawn (nothing will be sent from it)`);
+        if (settleEngineClosedApproval(ev, approvalCompleteParked(ev))) {
+            const id = ev.approvalId;
+            hostLog('debug', `liveHitlAskWire: tool_approval_complete for ${String(id)} arrived while its card was waiting — card withdrawn (nothing will be sent from it)`);
         }
         return { kind: 'skip' };
     }
@@ -307,6 +304,8 @@ async function routeToolApprovalFrame(ev, ctx) {
                 : `liveHitlAskWire: tool_approval frame ${ev.approvalId} read back from the run event log is ${disposition.kind}` +
                     `${disposition.kind === 'unknown' ? ` (${disposition.why})` : disposition.cause !== undefined ? ` (${disposition.cause})` : ''}` +
                     ' — not raised as a question, no decision sent');
+            if (settledHere === undefined && replayedApprovalClosesCardFrame(disposition))
+                noteEngineClosedApproval(ev.approvalId, false);
             if (disposition.kind === 'unknown' && ctx.signal?.aborted !== true)
                 surfaceReplayedApprovalListUnreadable();
             if (deps.onReplayedApproval !== undefined) {

package/dist/hitl/hitlBridge.d.ts

@@ -3,6 +3,7 @@ import type { PermissionResult } from '@sema-agent/agent-types';
 import type { ApprovalsListEnvelope } from './crashConverged.js';
 import { type SuspendedReopenReading } from './suspendedReopen.js';
 export declare const DEFAULT_DENY_REASON = "The user rejected this tool use";
+export declare const MAX_DENY_REASON_CHARS = 4096;
 export declare function denyReasonForWire(reason: string | undefined, tag: string): string | undefined;
 export interface HitlPermissionDecisionLike {
     behavior: 'allow' | 'ask' | 'deny';