@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,8 +1,11 @@
 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 { PREFIXES_IN_PROSE, REFUSED_NAME_FIX } from './refusedToolNameProse.js';
+import { prepareRefusalNoteOf } from '../prepareRefusal.js';
 import { CORE_PROTOCOL_PREFIXES } from '../generated/toolNameTables.js';
 const COVERING_NAMESPACE_PREFIXES = CORE_PROTOCOL_PREFIXES;
 const WITHHELD_NOTICE = {
@@ -90,8 +93,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 +107,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,22 +130,47 @@ 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]
         : 'Not written to this session’s rule record.';
 }
-const LEGACY_TOOL_NAME_FAILURE_NOTE = `This run did not start: a tool rule applied to it names a tool the engine refuses — ${REFUSED_NAME_CLASSES} (the engine's own error text names the entry). ` +
-    'Every later run fails the same way until that entry is removed from wherever it is set: this session’s rule record, the settings sent with the run, a parent session’s rule record, or the deployment’s own tool rules.';
 export function legacyToolNameFailureNoteOf(code) {
-    if (code === CONFIG_LEGACY_TOOL_NAME)
-        return LEGACY_TOOL_NAME_FAILURE_NOTE;
-    return undefined;
+    return code === CONFIG_LEGACY_TOOL_NAME ? prepareRefusalNoteOf(code) : undefined;
 }

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';