@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/hitl/hitlBridge.js

@@ -8,7 +8,7 @@ import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameReading,
 import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_INVALID_OUTCOME, RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
 import { suspendedReopenOf } from './suspendedReopen.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
-const MAX_DENY_REASON_CHARS = 4096;
+export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
     if (typeof reason !== 'string')
         return undefined;
@@ -146,13 +146,13 @@ function isTransientDecideTransportFailure(e, depth = 0) {
         return false;
     if (thrownIsInstanceOf(e, HitlSafetyError))
         return false;
-    const status = readThrownSlot(e, 'status');
+    const status = readThrownSlot(e, 'status', 'data');
     if (status === THROWN_SLOT_UNREADABLE || typeof status === 'number')
         return false;
     const name = readThrownSlot(e, 'name');
     if (name === 'TimeoutError' || name === 'AbortError')
         return true;
-    const code = readThrownSlot(e, 'code');
+    const code = readThrownSlot(e, 'code', 'data');
     if (typeof code === 'string' && TRANSIENT_NETWORK_CODES.has(code))
         return true;
     const message = readThrownSlot(e, 'message');

package/dist/hitl/persistedRulesWire.d.ts

@@ -1,4 +1,5 @@
 import type { CcImportLayer, CcImportPrepareResult, CcImportRedeemResult, PersistedRule, RuleBehavior, RuleListParams, RuleListResult, RuleRevokeRequest, RemovalLiveness, RuleRevokeResult, RuleWriteRequest, RuleWriteResult } from '@sema-agent/sdk';
+import type { UiLanguage } from '../env/uiLanguage.js';
 export interface RulesFacade {
     list(params?: RuleListParams, opts?: {
         signal?: AbortSignal;
@@ -93,9 +94,9 @@ export interface PersistedRuleOriginsRow {
         readonly origin?: string | undefined;
     }[] | undefined;
 }
-export declare function persistedRuleAddOriginLabel(origin: string | undefined): string;
-export declare function persistedRuleOriginsLabel(rule: PersistedRuleOriginsRow): string;
-export declare function persistedRuleScopeLabel(scope: string | undefined): string;
+export declare function persistedRuleAddOriginLabel(origin: string | undefined, lang?: UiLanguage): string;
+export declare function persistedRuleOriginsLabel(rule: PersistedRuleOriginsRow, lang?: UiLanguage): string;
+export declare function persistedRuleScopeLabel(scope: string | undefined, lang?: UiLanguage): string;
 export type PersistedRuleRevokeOutcomeWord = 'removed' | 'nothing-written' | 'unknown-status';
 export interface PersistedRuleRevokeResultBody {
     readonly status?: string | undefined;
@@ -107,11 +108,11 @@ export interface PersistedRuleRevokeOutcome {
     readonly notice: string;
     readonly change: string;
 }
-export declare function persistedRuleRevokeOutcome(ruleText: string | undefined, result: PersistedRuleRevokeResultBody | undefined): PersistedRuleRevokeOutcome;
+export declare function persistedRuleRevokeOutcome(ruleText: string | undefined, result: PersistedRuleRevokeResultBody | undefined, lang?: UiLanguage): PersistedRuleRevokeOutcome;
 export interface PersistedRuleMatchRow {
     readonly match?: string | undefined;
 }
-export declare function persistedRuleMatchLabel(ruleOrMatch: string | PersistedRuleMatchRow | undefined): string;
+export declare function persistedRuleMatchLabel(ruleOrMatch: string | PersistedRuleMatchRow | undefined, lang?: UiLanguage): string;
 export declare function revokeTargetFromPersistedRule(rule: unknown, opts?: {
     principal?: string;
 }): RuleRevokeRequest | undefined;

package/dist/hitl/persistedRulesWire.js

@@ -4,6 +4,7 @@ import { CORE_RULE_BEHAVIORS } from '../generated/engineFactTables.js';
 import { wireFailureShapeOf } from '../wireFailureShape.js';
 import { CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED } from '../engineErrorCodes.js';
 import { hostLog } from '../host.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { guardedRead, readOwnDataValue } from '../ownKey.js';
 import { observedPermissionRulesWrite, permissionRulesWriteAvailable } from '../permissionRulesWriteCapability.js';
 import { isToolApprovalRespondReplayed, readToolApprovalRespondAck } from './toolApprovalWire.js';
@@ -114,123 +115,104 @@ export const PERSISTED_RULE_BEHAVIOR_UNKNOWN = '(unknown)';
 export function persistedRuleBehaviorLabel(rule) {
     return rowStr(rule, 'behavior') ?? PERSISTED_RULE_BEHAVIOR_UNKNOWN;
 }
-const PERSISTED_RULE_ORIGIN_PHRASES = Object.freeze({
-    user: 'added by you',
-    'imported-cc': 'imported',
-    starter: 'preset',
+const PERSISTED_RULE_ORIGIN_KEYS = Object.freeze({
+    user: 'rules.origin.user',
+    'imported-cc': 'rules.origin.importedCc',
+    starter: 'rules.origin.starter',
 });
-const UNKNOWN_ORIGIN_PHRASE = 'an origin this build does not know';
-const NO_ORIGIN_PHRASE = 'unknown origin';
+const UNKNOWN_ORIGIN_KEY = 'rules.origin.unknownWord';
+const NO_ORIGIN_KEY = 'rules.origin.none';
+function originKeyOf(origin) {
+    return typeof origin === 'string' && Object.hasOwn(PERSISTED_RULE_ORIGIN_KEYS, origin) ? PERSISTED_RULE_ORIGIN_KEYS[origin] : UNKNOWN_ORIGIN_KEY;
+}
 function ownSlot(o, key) {
     if (typeof o !== 'object' || o === null)
         return undefined;
     return guardedRead(() => readOwnDataValue(o, key));
 }
 const ORIGINS_READ_MAX = 256;
-export function persistedRuleAddOriginLabel(origin) {
-    return typeof origin === 'string' && Object.hasOwn(PERSISTED_RULE_ORIGIN_PHRASES, origin)
-        ? PERSISTED_RULE_ORIGIN_PHRASES[origin]
-        : UNKNOWN_ORIGIN_PHRASE;
+export function persistedRuleAddOriginLabel(origin, lang) {
+    return renderMessage(msg(originKeyOf(origin)), lang);
 }
-export function persistedRuleOriginsLabel(rule) {
+export function persistedRuleOriginsLabel(rule, lang) {
     const adds = ownSlot(rule, 'adds');
     const isArr = guardedRead(() => (Array.isArray(adds) ? true : undefined));
     if (isArr !== true)
-        return NO_ORIGIN_PHRASE;
+        return renderMessage(msg(NO_ORIGIN_KEY), lang);
     const lenRaw = ownSlot(adds, 'length');
     const len = typeof lenRaw === 'number' && Number.isSafeInteger(lenRaw) && lenRaw > 0 ? Math.min(lenRaw, ORIGINS_READ_MAX) : 0;
     const seen = [];
     for (let i = 0; i < len; i++) {
         const origin = ownSlot(ownSlot(adds, String(i)), 'origin');
-        const phrase = persistedRuleAddOriginLabel(typeof origin === 'string' ? origin : undefined);
-        if (!seen.includes(phrase))
-            seen.push(phrase);
+        const key = originKeyOf(typeof origin === 'string' ? origin : undefined);
+        if (!seen.includes(key))
+            seen.push(key);
     }
-    return seen.length === 0 ? NO_ORIGIN_PHRASE : seen.join(' + ');
+    return seen.length === 0 ? renderMessage(msg(NO_ORIGIN_KEY), lang) : seen.map((k) => renderMessage(msg(k), lang)).join(renderMessage(msg('rules.origin.join'), lang));
 }
-const UNKNOWN_SCOPE_PHRASE = 'a scope this build does not know';
-export function persistedRuleScopeLabel(scope) {
+const UNKNOWN_SCOPE_KEY = 'rules.scope.unknown';
+export function persistedRuleScopeLabel(scope, lang) {
     if (scope === 'global')
-        return 'all projects';
+        return renderMessage(msg('rules.scope.all'), lang);
     if (typeof scope === 'string' && scope.startsWith('project:') && scope.length > 'project:'.length) {
         const shown = displayUntrusted(scope.slice('project:'.length), { max: 400, blanks: true });
-        return shown === '' ? UNKNOWN_SCOPE_PHRASE : shown;
+        return shown === '' ? renderMessage(msg(UNKNOWN_SCOPE_KEY), lang) : shown;
     }
-    return UNKNOWN_SCOPE_PHRASE;
+    return renderMessage(msg(UNKNOWN_SCOPE_KEY), lang);
 }
-const PERSISTED_RULE_REVOKE_LINES = Object.freeze({
+const PERSISTED_RULE_REVOKE_KEYS = Object.freeze({
     removed: {
-        yes: {
-            notice: '{rule}: a tombstone was written, but the rule is still live — it was approved again during the call.',
-            change: 'Revoked saved rule {rule} (still live — approved again meanwhile)',
-        },
-        unknown: {
-            notice: '{rule}: a tombstone was written, but whether the rule is still live could not be confirmed — treat it as still in effect and check the list.',
-            change: 'Revoked saved rule {rule} (liveness could not be confirmed — treated as still in effect)',
-        },
-        no: { notice: 'Removed {rule}.', change: 'Revoked saved rule {rule}' },
+        yes: { notice: 'rules.revoke.removed.yes.notice', change: 'rules.revoke.removed.yes.change' },
+        unknown: { notice: 'rules.revoke.removed.unknown.notice', change: 'rules.revoke.removed.unknown.change' },
+        no: { notice: 'rules.revoke.removed.no.notice', change: 'rules.revoke.removed.no.change' },
     },
     'nothing-written': {
-        yes: {
-            notice: '{rule}: nothing was written, and the rule is still live — it was not removed; check the list.',
-            change: 'Removing saved rule {rule} wrote nothing — the rule is still live',
-        },
-        unknown: {
-            notice: '{rule}: nothing was written, and whether the rule is still live could not be confirmed — treat it as still in effect and check the list.',
-            change: 'Removing saved rule {rule} wrote nothing — liveness could not be confirmed',
-        },
-        no: { notice: '{rule}: nothing to remove.', change: 'Removing saved rule {rule} wrote nothing (nothing to remove)' },
+        yes: { notice: 'rules.revoke.nothingWritten.yes.notice', change: 'rules.revoke.nothingWritten.yes.change' },
+        unknown: { notice: 'rules.revoke.nothingWritten.unknown.notice', change: 'rules.revoke.nothingWritten.unknown.change' },
+        no: { notice: 'rules.revoke.nothingWritten.no.notice', change: 'rules.revoke.nothingWritten.no.change' },
     },
 });
-const REVOKE_UNKNOWN_STATUS = Object.freeze({
-    absent: {
-        notice: '{rule}: the engine did not say what this removal did, so whether anything was removed is unclear — check the list.',
-        change: 'Removing saved rule {rule} came back without saying what it did',
-    },
-    unrecognised: {
-        notice: '{rule}: the engine answered with a status this build does not know, so whether anything was removed is unclear — check the list.',
-        change: 'Removing saved rule {rule} returned a status this build does not know',
-    },
-    liveness: { yes: ' It also reports the rule is still live.', unknown: ' Whether the rule is still live could not be confirmed either.', no: '' },
+const REVOKE_UNKNOWN_STATUS_KEYS = Object.freeze({
+    absent: { notice: 'rules.revoke.absent.notice', change: 'rules.revoke.absent.change' },
+    unrecognised: { notice: 'rules.revoke.unrecognised.notice', change: 'rules.revoke.unrecognised.change' },
+    liveness: { yes: 'rules.revoke.liveness.yes', unknown: 'rules.revoke.liveness.unknown', no: undefined },
 });
-const fillRule = (template, rule) => template.split('{rule}').join(rule);
-export function persistedRuleRevokeOutcome(ruleText, result) {
+export function persistedRuleRevokeOutcome(ruleText, result, lang) {
     const quoted = typeof ruleText === 'string' ? quoteUntrustedForSentence(ruleText, 120) : undefined;
-    const rule = quoted ?? 'this rule';
+    const rule = quoted ?? msg('rules.revoke.thisRule');
     const status = ownSlot(result, 'status');
     const rawLive = ownSlot(result, 'stillLive');
     const liveness = rawLive === 'yes' || rawLive === 'no' || rawLive === 'unknown' ? rawLive : 'unknown';
     if (status === 'removed' || status === 'no-op') {
         const outcome = status === 'removed' ? 'removed' : 'nothing-written';
-        const line = PERSISTED_RULE_REVOKE_LINES[outcome][liveness];
-        return Object.freeze({ outcome, liveness, notice: fillRule(line.notice, rule), change: fillRule(line.change, rule) });
+        const line = PERSISTED_RULE_REVOKE_KEYS[outcome][liveness];
+        return Object.freeze({ outcome, liveness, notice: renderMessage(msg(line.notice, { rule }), lang), change: renderMessage(msg(line.change, { rule }), lang) });
     }
-    const head = typeof status === 'string' && status !== '' ? REVOKE_UNKNOWN_STATUS.unrecognised : REVOKE_UNKNOWN_STATUS.absent;
+    const head = typeof status === 'string' && status !== '' ? REVOKE_UNKNOWN_STATUS_KEYS.unrecognised : REVOKE_UNKNOWN_STATUS_KEYS.absent;
+    const tailKey = REVOKE_UNKNOWN_STATUS_KEYS.liveness[liveness];
     return Object.freeze({
         outcome: 'unknown-status',
         liveness,
-        notice: `${fillRule(head.notice, rule)}${REVOKE_UNKNOWN_STATUS.liveness[liveness]}`,
-        change: fillRule(head.change, rule),
+        notice: `${renderMessage(msg(head.notice, { rule }), lang)}${tailKey === undefined ? '' : renderMessage(msg(tailKey), lang)}`,
+        change: renderMessage(msg(head.change, { rule }), lang),
     });
 }
-const PERSISTED_RULE_MATCH_LABELS = Object.freeze({
-    exact: 'exact match',
-    prefix: 'prefix match',
-    wildcard: 'wildcard match',
-    subpath: 'subpath match',
-    path: 'path match',
-    name: 'skill name match',
-    name_prefix: 'skill name prefix match',
-    host: 'web domain match (one host)',
-    subdomain: 'web domain match (every host under the domain)',
+const PERSISTED_RULE_MATCH_KEYS = Object.freeze({
+    exact: 'rules.match.exact',
+    prefix: 'rules.match.prefix',
+    wildcard: 'rules.match.wildcard',
+    subpath: 'rules.match.subpath',
+    path: 'rules.match.path',
+    name: 'rules.match.name',
+    name_prefix: 'rules.match.namePrefix',
+    host: 'rules.match.host',
+    subdomain: 'rules.match.subdomain',
 });
-export function persistedRuleMatchLabel(ruleOrMatch) {
+export function persistedRuleMatchLabel(ruleOrMatch, lang) {
     const word = typeof ruleOrMatch === 'string' ? ruleOrMatch : ownSlot(ruleOrMatch, 'match');
     if (typeof word !== 'string' || word === '')
-        return 'an unreported match form';
-    return Object.hasOwn(PERSISTED_RULE_MATCH_LABELS, word)
-        ? PERSISTED_RULE_MATCH_LABELS[word]
-        : 'a match form this build does not know';
+        return renderMessage(msg('rules.match.unreported'), lang);
+    return renderMessage(msg(Object.hasOwn(PERSISTED_RULE_MATCH_KEYS, word) ? PERSISTED_RULE_MATCH_KEYS[word] : 'rules.match.unknown'), lang);
 }
 export function revokeTargetFromPersistedRule(rule, opts) {
     const behavior = persistedRuleBehaviorOf(rule);

package/dist/hitl/planReviewWire.d.ts

@@ -37,6 +37,11 @@ export interface PlanReviewCardLike {
         }>;
     }>;
 }
+export interface PlanReviewQuestionIdReading {
+    readonly taskId: string;
+    readonly reopened: boolean;
+}
+export declare function planReviewTaskIdFromQuestionId(questionId: {} | null | undefined): PlanReviewQuestionIdReading | undefined;
 export declare function planReviewOfferedModeOf(card: string | PlanReviewCardLike): PlanReviewOfferedMode;
 export interface ArmPlanReviewOptions {
     submittedInPlanMode?: boolean;

package/dist/hitl/planReviewWire.js

@@ -300,6 +300,14 @@ function offeredModeFromLabels(card) {
         return 'two_choice';
     return undefined;
 }
+export function planReviewTaskIdFromQuestionId(questionId) {
+    if (typeof questionId !== 'string')
+        return undefined;
+    const taskId = taskIdFromPlanReviewQuestionId(questionId);
+    if (taskId === undefined)
+        return undefined;
+    return Object.freeze({ taskId, reopened: questionId.includes(REOPEN_ID_TAIL) });
+}
 function offeredModeFromQuestionId(questionId) {
     if (taskIdFromPlanReviewQuestionId(questionId) === undefined)
         return 'unknown';

package/dist/hitl/sessionPolicyDeliverable.d.ts

@@ -1,11 +1,13 @@
 import type { SessionPermissionRules } from '@sema-agent/sdk';
 import type { ToolRosterView } from '../toolRoster.js';
+import type { SessionRuleInertReason } from './sessionPolicyWire.js';
 export type SessionPolicyWithheldWhy = 'ask_no_bucket' | 'qualified_deny' | 'peer_wide' | 'wildcard' | 'not_a_tool_name' | 'legacy_tool_name' | 'not_in_roster';
 export declare const SESSION_POLICY_WITHHELD_WHY: readonly SessionPolicyWithheldWhy[];
 export interface SessionPolicyWithheldRule {
     readonly rule: string;
     readonly why: SessionPolicyWithheldWhy;
     readonly currentName?: string;
+    readonly inertReason?: SessionRuleInertReason;
 }
 export interface SessionPolicyDeliverability {
     readonly deliverable: SessionPermissionRules;

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,6 +1,8 @@
 import { CONFIG_LEGACY_TOOL_NAME } from '../engineErrorCodes.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
 import { ruleCompileVerdict } from '../ruleCompileVerdict.js';
+import { readRuleEntry } from '../coreValuePorts.js';
+import { readOwnDataValue } from '../ownKey.js';
 import { ruleToolNameVerdictOf } from '../protocolSegment.js';
 import { PREFIXES_IN_PROSE, REFUSED_NAME_CLASSES, REFUSED_NAME_FIX } from './refusedToolNameProse.js';
 import { CORE_PROTOCOL_PREFIXES } from '../generated/toolNameTables.js';
@@ -90,8 +92,9 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
             continue;
         }
         let why = withheldWhyOf(r);
+        const engineAsked = why === undefined;
         let currentName;
-        if (why === undefined) {
+        if (engineAsked) {
             const verdict = ruleToolNameVerdictOf(r);
             if (verdict.kind === 'unknown')
                 return unreadable();
@@ -103,6 +106,17 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
             else if (verdict.kind === 'unmintable_segment')
                 why = 'not_a_tool_name';
         }
+        let inertReason;
+        if (engineAsked) {
+            const reading = entryReadingOf(r);
+            if (reading === 'unknown')
+                return unreadable();
+            if (reading !== 'row') {
+                inertReason = reading.reason;
+                if (why === undefined)
+                    why = reading.why;
+            }
+        }
         if (why === undefined) {
             const grammar = ruleCompileVerdict(r, 'deny').kind;
             if (grammar === 'unknown')
@@ -115,13 +129,42 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
         if (why === undefined)
             exact.push(r);
         else {
-            withheld.push(why === 'legacy_tool_name' && currentName !== undefined ? { rule: r, why, currentName } : { rule: r, why });
+            withheld.push({
+                rule: r,
+                why,
+                ...(why === 'legacy_tool_name' && currentName !== undefined ? { currentName } : {}),
+                ...(inertReason !== undefined ? { inertReason } : {}),
+            });
         }
     }
-    if (withheld.length > 0 || exact.length === 0)
+    const blocking = withheld.some((w) => w.inertReason === undefined);
+    if (blocking || exact.length === 0)
         return { deliverable: {}, withheld };
     return { deliverable: { toolDeny: exact }, withheld };
 }
+function entryReadingOf(rule) {
+    try {
+        const reading = readRuleEntry(rule, 'deny');
+        if (typeof reading !== 'object' || reading === null)
+            return 'unknown';
+        const kind = readOwnDataValue(reading, 'kind');
+        if (kind === 'row') {
+            const compiled = readOwnDataValue(reading, 'compiled');
+            return typeof compiled === 'object' && compiled !== null ? 'row' : 'unknown';
+        }
+        if (kind !== 'inert')
+            return 'unknown';
+        const reason = readOwnDataValue(reading, 'reason');
+        if (reason === 'grammar' || reason === 'content_unsupported')
+            return { why: 'not_a_tool_name', reason };
+        if (reason === 'wildcard_all' || reason === 'namespace_wildcard')
+            return { why: 'wildcard', reason };
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 export function sessionPolicyWithheldNotice(why) {
     return typeof why === 'string' && Object.hasOwn(WITHHELD_NOTICE, why)
         ? WITHHELD_NOTICE[why]

package/dist/hitl/sessionPolicyWire.d.ts

@@ -1,4 +1,5 @@
 import type { SessionPermissionRules, StoredSessionRules } from '@sema-agent/sdk';
+import type { UiLanguage } from '../env/uiLanguage.js';
 import type { SessionPolicyReading } from '../sessionPolicyCapability.js';
 import type { ToolRosterView } from '../toolRoster.js';
 import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_RULE_TOOL_NAME_VERDICTS } from '../generated/engineFactTables.js';
@@ -127,7 +128,7 @@ export interface SessionPolicyInertEntryRefusal {
 export declare function tightenSessionPolicy(facade: SessionPolicyFacade, req: SessionPolicyTightenRequest, opts?: {
     signal?: AbortSignal;
 }): Promise<SessionPolicyTightenOutcome>;
-export declare function sessionPolicyTightenNotice(outcome: SessionPolicyTightenOutcome): string;
+export declare function sessionPolicyTightenNotice(outcome: SessionPolicyTightenOutcome, lang?: UiLanguage): string;
 export declare function sessionPolicyReadNotice(outcome: Exclude<SessionPolicyReadOutcome, {
     kind: 'present';
 }> | {

package/dist/hitl/sessionPolicyWire.js

@@ -1,5 +1,6 @@
 import { wireFailureShapeOf } from '../wireFailureShape.js';
 import { hostLog } from '../host.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { ruleToolNameVerdictOf } from '../protocolSegment.js';
 import { RULES_INERT_ENTRY, RULES_INVALID_SHAPE, isRulesRefusalCode } from '../engineErrorCodes.js';
 import { deniedEntryToolName } from '../engineToolDirectory.js';
@@ -411,50 +412,48 @@ export async function tightenSessionPolicy(facade, req, opts) {
         return second.done;
     return { kind: 'conflict', rev: second.retryAtRev };
 }
-const SESSION_POLICY_INERT_ENTRY_WRITE_NOTE = 'The engine refused to write these session rules, and the stored record was not changed at all: one entry in them reads as matching nothing — written in, it would neither block nor allow any call (the engine’s own error text names the entry and why). Correct that entry or take it out, then write the rules again. If that entry was already in this session’s rule record, it has to be removed from the record before the record can be written again.';
-const SESSION_POLICY_EARLIER_GRAMMAR_NOTE = 'Nothing was written: this session’s rules were saved before the current rule grammar, when an allow entry written in a tool’s own rule form (such as Bash(git:*)) was read as a plain tool name and so allowed nothing. Writing the record back now would read those entries in the current grammar, where they do allow calls — a widening nobody asked for — so the record was left as it is. Rewrite this session’s allow entries in the current form, or take those entries out, before changing its rules here.';
-export function sessionPolicyTightenNotice(outcome) {
+const earlierGrammarNote = (lang) => renderMessage(msg('rules.sessionPolicy.tighten.earlierGrammar'), lang);
+export function sessionPolicyTightenNotice(outcome, lang) {
+    const say = (key, params) => renderMessage(msg(key, params), lang);
     switch (outcome.kind) {
         case 'written':
-            return `Session rules saved (version ${outcome.rev}) — the record now holds everything it already had plus the entries sent here, and it applies from this session’s next tool gate onward; the step already running is not interrupted.`;
+            return say('rules.sessionPolicy.tighten.written', { rev: outcome.rev });
         case 'conflict':
-            return 'Session rules were changed by someone else while this tightening was being written, twice in a row — nothing was written. Re-read the current rules and try again, or let the other writer finish first.';
+            return say('rules.sessionPolicy.tighten.conflict');
         case 'loosen_forbidden':
-            return 'The engine refused this write because it would relax the session rules: at least one entry sent here widens what is allowed rather than narrowing it. Only entries that add restrictions are accepted on this path.';
+            return say('rules.sessionPolicy.tighten.loosenForbidden');
         case 'capability_absent':
-            return outcome.why === 'absent'
-                ? 'This deployment does not keep per-session tool rules, so there is nothing to tighten here.'
-                : 'This engine does not say whether it keeps per-session tool rules — it predates that answer — so the tightening entry stays hidden rather than being written blind.';
+            return outcome.why === 'absent' ? say('rules.sessionPolicy.tighten.capabilityAbsent') : say('rules.sessionPolicy.tighten.capabilityNotReported');
         case 'refused':
-            return SESSION_POLICY_EARLIER_GRAMMAR_NOTE;
+            return earlierGrammarNote(lang);
         case 'inert_entry':
-            return SESSION_POLICY_INERT_ENTRY_WRITE_NOTE;
+            return say('rules.sessionPolicy.tighten.inertEntry');
         case 'unknown':
             switch (outcome.why) {
                 case 'face_unavailable':
-                    return 'This deployment does not keep per-session tool rules, so nothing was written.';
+                    return say('rules.sessionPolicy.tighten.unknown.faceUnavailable');
                 case 'session_not_found':
-                    return 'This session is not readable from here — it may not exist, or it may belong to someone else (the engine answers both the same way, so this client cannot tell which); nothing was written.';
+                    return say('rules.sessionPolicy.tighten.unknown.sessionNotFound');
                 case 'session_ownerless':
-                    return 'This session has no owner, so a rule written for it could never be read back; nothing was written. Attach an identity to the session and try again.';
+                    return say('rules.sessionPolicy.tighten.unknown.sessionOwnerless');
                 case 'unauthorized':
-                    return 'This call could not present a verifiable identity, so nothing was written.';
+                    return say('rules.sessionPolicy.tighten.unknown.unauthorized');
                 case 'request_rejected':
-                    return 'The engine rejected the shape of this rule record, so nothing was written. Fix the entries before sending them again.';
+                    return say('rules.sessionPolicy.tighten.unknown.requestRejected');
                 case 'store_corrupt':
-                    return 'The engine could not establish which version this session’s rules are at and refused to stamp a new one, so nothing was written. The entries sent here are not the problem — this needs an operator to look at the rule store.';
+                    return say('rules.sessionPolicy.tighten.unknown.storeCorrupt');
                 case 'read_unreadable':
-                    return 'The session’s current rules could not be read, so nothing was written — writing over a record that cannot be read would replace real restrictions with an empty one.';
+                    return say('rules.sessionPolicy.tighten.unknown.readUnreadable');
                 case 'read_failed':
-                    return 'The session’s current rules could not be fetched, so nothing was written.';
+                    return say('rules.sessionPolicy.tighten.unknown.readFailed');
                 case 'write_refused':
-                    return 'The engine refused this write, so nothing was written. Re-read the current rules before trying again.';
+                    return say('rules.sessionPolicy.tighten.unknown.writeRefused');
                 case 'write_indeterminate':
-                    return 'The write never came back with an answer from the engine — it may or may not have taken effect. Re-read the current rules before writing anything else.';
+                    return say('rules.sessionPolicy.tighten.unknown.writeIndeterminate');
                 case 'write_receipt_unreadable':
-                    return 'The tightening was sent but the engine’s answer could not be read — it may already be in effect. Re-read the current rules before writing anything else.';
+                    return say('rules.sessionPolicy.tighten.unknown.writeReceiptUnreadable');
                 case 'write_receipt_mismatch':
-                    return 'The tightening was sent but the engine’s answer does not account for it (the version did not advance, the entries sent here are not in the returned record, or the record came back without the rule-grammar mark it was sent with, so its entries may now read differently) — it may already be in effect. Re-read the current rules before writing anything else.';
+                    return say('rules.sessionPolicy.tighten.unknown.writeReceiptMismatch');
             }
     }
 }
@@ -718,7 +717,7 @@ export function sessionPolicyRemovalNotice(outcome) {
         case 'write_unconfirmed':
             return 'The removal was sent but no clear answer came back from the engine — it may already be in effect. Run the removal again: it re-reads the record, and reports nothing left to remove if it did take effect.';
         case 'refused':
-            return SESSION_POLICY_EARLIER_GRAMMAR_NOTE;
+            return earlierGrammarNote();
         case 'inert_entry':
             return 'Nothing was changed: the engine refused to write this session’s rule record back, because an entry this removal keeps reads as matching nothing (the engine’s own error text names the entry and why). This removal only takes out names the engine refuses to start a run with, so it leaves that entry for a person to correct or remove; while the record holds it, it cannot be written, so the entries this removal meant to take out stay in it as well.';
         default:

package/dist/hitl/suspendedReopen.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from '../env/uiLanguage.js';
 export type SuspendedReopenReading = {
     readonly kind: 'reopened';
     readonly code: string;
@@ -13,4 +14,4 @@ export interface ResumeReopenDetail {
     retriable: true;
 }
 export declare function resumeReopenFromError(err: unknown): ResumeReopenDetail | null;
-export declare function resumeReopenContent(detail: ResumeReopenDetail): string;
+export declare function resumeReopenContent(detail: ResumeReopenDetail, lang?: UiLanguage): string;

package/dist/hitl/suspendedReopen.js

@@ -1,4 +1,5 @@
 import { RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { guardedRead, ownDataField } from '../ownKey.js';
 const UNSTATED = Object.freeze({ kind: 'unstated' });
 const NOT_REOPENED = Object.freeze({ kind: 'not_reopened' });
@@ -31,15 +32,11 @@ export function resumeReopenFromError(err) {
     const reason = code.slice('resume.'.length);
     return { code, reason, retriable: true };
 }
-export function resumeReopenContent(detail) {
-    const first = detail.code === RESUME_ENV_FAILED
-        ? 'The execution environment for this parked work could not be brought back'
+export function resumeReopenContent(detail, lang) {
+    const first = msg(detail.code === RESUME_ENV_FAILED
+        ? 'resume.reopen.first.envFailed'
         : detail.code === RESUME_TOOL_UNAVAILABLE
-            ? 'The tool this approval was granted for is not available on this engine'
-            : 'The tool this approval was granted for has changed since the approval was recorded';
-    return [
-        first,
-        'The engine re-parked the work before consuming anything — the approval is still pending and your decision was not consumed',
-        'Re-fetch the pending approvals and decide again on an engine where the same tool is available',
-    ].join(' · ');
+            ? 'resume.reopen.first.toolUnavailable'
+            : 'resume.reopen.first.toolContractMismatch');
+    return renderMessage(msg('resume.reopen.content', { first }), lang);
 }

package/dist/hitl/toolApprovalWire.d.ts

@@ -1,5 +1,7 @@
 import { type HitlClientLike, type DecideOperationObserver } from './hitlBridge.js';
 import { type ApprovalAllowRuleShadow } from './allowRuleShadow.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+import type { SessionRuleInertReason } from './sessionPolicyWire.js';
 import { type ApprovalCardClaim } from './approvalHolds.js';
 import { type ApprovalResolution } from './approvalResolution.js';
 import { type ApprovalMandateWord } from '../gateVocabulary.js';
@@ -243,14 +245,21 @@ export declare function decisionAttributionKeyOf(reading: ApprovalDecidedByReadi
     settledBy: 'policy';
 } | Record<never, never>;
 export declare function isToolApprovalFrame(ev: unknown): ev is ToolApprovalFrame;
-export declare function askProbeReasonDetail(card: Pick<ApprovalCardRequest, 'probeReason' | 'probeCause'> | null | undefined): string | undefined;
+export declare function askProbeReasonDetail(card: Pick<ApprovalCardRequest, 'probeReason' | 'probeCause'> | null | undefined, lang?: UiLanguage): string | undefined;
 export declare function readApprovalRememberRefused(v: unknown): boolean;
 export declare function readApprovalBoundGrants(v: unknown): BoundSkillGrantsWire | undefined;
+export type BoundGrantEntryReading = {
+    readonly kind: 'rule';
+} | {
+    readonly kind: 'reads_as_nothing';
+    readonly reason?: SessionRuleInertReason;
+};
+export declare function readBoundGrantEntry(entry: string): BoundGrantEntryReading | undefined;
 export type ApprovalGrantBinding = 'bound' | 'none' | 'unreadable';
 export declare function readApprovalClassifierNoRuling(v: unknown): string | undefined;
-export declare function classifierNoRulingDetail(word: string | undefined): string;
-export declare function approvalBoundGrantsDetail(grants: BoundSkillGrantsWire | null | undefined): string | undefined;
-export declare function approvalPriorCardsDetail(card: Pick<ApprovalCardRequest, 'priorCardsForCall' | 'origin'> | null | undefined): string | undefined;
+export declare function classifierNoRulingDetail(word: string | undefined, lang?: UiLanguage): string;
+export declare function approvalBoundGrantsDetail(grants: BoundSkillGrantsWire | null | undefined, lang?: UiLanguage): string | undefined;
+export declare function approvalPriorCardsDetail(card: Pick<ApprovalCardRequest, 'priorCardsForCall' | 'origin'> | null | undefined, lang?: UiLanguage): string | undefined;
 export declare function approvalSupersedesDetail(card: Pick<ApprovalCardRequest, 'supersedes'> | null | undefined): string | undefined;
 export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback | undefined;
 export declare function readRuleOffers(v: unknown): RuleOfferReading[] | undefined;
@@ -289,5 +298,8 @@ export type ApprovalHolderJoin = {
     readonly kind: 'free';
 };
 export declare function joinApprovalHolder(identity: ApprovalHolderIdentity, signal?: AbortSignal): Promise<ApprovalHolderJoin>;
-export declare function claimApprovalCard(identity: ApprovalHolderIdentity, signal?: AbortSignal): Promise<ApprovalCardClaim>;
+export interface ApprovalCardClaimOptions {
+    readonly signal?: AbortSignal;
+}
+export declare function claimApprovalCard(identity: ApprovalHolderIdentity, options?: ApprovalCardClaimOptions): Promise<ApprovalCardClaim>;
 export type { ApprovalCardClaim, HostApprovalCardHold } from './approvalHolds.js';