@sema-agent/client-core 0.101.0 → 0.103.0

package/dist/generated/settingsSchemaTypes.d.ts

@@ -118,7 +118,7 @@ export interface McpEntryKeyIssue {
     readonly path: string;
     readonly reason: string;
     readonly member?: string;
-    readonly fault?: "not_plain_record" | "member_not_string" | "member_name_reserved";
+    readonly fault?: PlainStringRecordFault;
 }
 export type RequestMcpTransportRead = {
     ok: true;
@@ -128,6 +128,8 @@ export type RequestMcpTransportRead = {
     ok: false;
     issue: McpEntryKeyIssue;
 };
+declare const PLAIN_STRING_RECORD_FAULTS: readonly ["not_plain_record", "member_not_string", "member_name_reserved"];
+export type PlainStringRecordFault = (typeof PLAIN_STRING_RECORD_FAULTS)[number];
 declare const MCP_CONTENT_ORIGINS: readonly ["local", "execution", "external"];
 export type McpContentOrigin = (typeof MCP_CONTENT_ORIGINS)[number];
 export {};

package/dist/hitl/automaticAnswerVerdict.d.ts

@@ -20,7 +20,7 @@ export type AutomaticAnswerVerdict = {
     readonly kind: 'unknown';
     readonly why: AutomaticAnswerUnknownWhy;
 };
-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" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
+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" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "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, lang?: UiLanguage): string;

package/dist/hitl/decisionConflict.js

@@ -1,9 +1,10 @@
 import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_UNSUPPORTED_VERSION, RESUME_OUTCOME_INVALID } from '../engineErrorCodes.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { ownDataField } from '../ownKey.js';
-import { isSlotCarrier, PROTOCOL_ERROR_NAME, protocolErrorNameOf, readRefusalField } from '../wireFailureShape.js';
+import { isSlotCarrier, PROTOCOL_ERROR_NAME, protocolErrorNameReading, readRefusalSlots, readThrownExtraSnapshot } from '../wireFailureShape.js';
 const BINDING_SEAT_FIELDS = new Set(['boundCallId', 'boundInputHash']);
 const ANSWER_FIELD = 'answer';
+const REFUSAL_WORD_KEYS = Object.freeze(['field', 'reason']);
 const GRANT_DIGEST_FIELD = 'boundGrantDigest';
 function namedProtocolOf(r) {
     return r.state === 'named' ? r.name : undefined;
@@ -11,6 +12,7 @@ function namedProtocolOf(r) {
 export function decisionConflictOf(err, captured, protocolNameRead) {
     if (!isSlotCarrier(err))
         return undefined;
+    const extra = readThrownExtraSnapshot(err);
     let code;
     if (captured !== undefined) {
         if (captured.state !== 'read')
@@ -25,23 +27,21 @@ export function decisionConflictOf(err, captured, protocolNameRead) {
             return undefined;
         }
     }
-    const protocolName = protocolNameRead !== undefined ? namedProtocolOf(protocolNameRead) : protocolErrorNameOf(err);
+    const protocolName = namedProtocolOf(protocolNameRead ?? protocolErrorNameReading(err, extra));
     if (code === CHECKPOINT_UNSUPPORTED_VERSION)
         return 'format_version';
     const bindingFamily = code === APPROVAL_BINDING_MISMATCH || (code === undefined && protocolName === PROTOCOL_ERROR_NAME.ApprovalBindingMismatchError);
     if (!bindingFamily && code !== RESUME_OUTCOME_INVALID)
         return undefined;
-    let field;
-    try {
-        field = readRefusalField(err);
-    }
-    catch {
-        field = undefined;
-    }
+    const slots = readRefusalSlots(err, REFUSAL_WORD_KEYS, extra.bag);
+    const field = slots.field.word;
     if (code === RESUME_OUTCOME_INVALID)
         return field === ANSWER_FIELD ? 'answer_invalid' : field === GRANT_DIGEST_FIELD ? 'grant_changed' : undefined;
-    if (field === undefined)
-        return 'row_integrity';
+    if (field === undefined) {
+        if (slots.field.present)
+            return undefined;
+        return slots.reason.word !== undefined ? 'row_integrity' : undefined;
+    }
     return BINDING_SEAT_FIELDS.has(field) ? 'binding_mismatch' : undefined;
 }
 export const DECISION_ANSWER_INVALID_CONTENT = 'The engine rejected the answer itself because it does not fit the question that was asked · Nothing was decided and the question is still waiting · Correct the answer and send it again';

package/dist/hitl/decisionRefusal.d.ts

@@ -54,6 +54,7 @@ export interface DecisionRefusalReading {
     readonly transient?: true;
     readonly conflict?: DecisionRefusalConflict;
     readonly unrecoverable?: true;
+    readonly acceptableForm?: {} | null;
 }
 export declare function mintDecisionRefusalReading(err: {} | null | undefined, context?: RefusalRouteContext, attributionCarried?: boolean, delivered?: DeliveredReading, carried?: RefusalCarrier): DecisionRefusalReading;
 export declare function readDecisionRefusalReading(err: {} | null | undefined, context?: RefusalRouteContext): DecisionRefusalReading;

package/dist/hitl/decisionRefusal.js

@@ -1,4 +1,4 @@
-import { ASK_GONE, ASK_GONE_PARKED, RESUME_PREFLIGHT_REJECTED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, isDecideRowUnrevivableCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { ASK_GONE, ASK_GONE_PARKED, RESUME_CONSTRAINT_REJECTED, RESUME_PREFLIGHT_REJECTED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, isDecideRowUnrevivableCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
 import { isUiLanguage } from '../env/uiLanguage.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { notPendingCauseReading, refusalCauseWordOf } from './approvalEndingCause.js';
@@ -7,7 +7,7 @@ import { isAlreadyResolvedGateReason, isCodeClassifiedGateFailure } from './park
 import { decisionConflictOf } from './decisionConflict.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { guardedRead, ownDataField, readOwnDataValue } from '../ownKey.js';
-import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, isDisplayableWireCode, isSlotCarrier, ownFoldedCodeBitsOf, protocolErrorNameReading, readErrorRecord, readRefusalField, readThrownSlot } from '../wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, isDisplayableWireCode, isSlotCarrier, ownFoldedCodeBitsOf, protocolErrorNameReading, readErrorPresent, readErrorRecord, readRefusalField, readThrownSlot } from '../wireFailureShape.js';
 import { attributionRefusalOf, carrierReadOf } from './attributionLadder.js';
 import { CODE_UNREADABLE, ownReadingSlot } from '../engineWireFor.js';
 export const ASK_DECIDED_CODE = 'conflict.ask_decided';
@@ -223,6 +223,7 @@ export function mintDecisionRefusalReading(err, context, attributionCarried, del
     const inRange = standing !== undefined && status !== undefined;
     const conflict = inRange && status === 409 && obj !== undefined ? isolated(() => decisionConflictOf(obj, captured, pn)) : undefined;
     const unrecoverable = inRange && status !== undefined && Number.isInteger(status) && status >= 400 && status <= 599 && isDecideRowUnrevivableCode(errorCode);
+    const acceptableForm = errorCode === RESUME_CONSTRAINT_REJECTED && obj !== undefined ? isolated(() => readErrorPresent(obj, 'acceptableForm')) : undefined;
     const transient = inRange &&
         conflict !== 'grant_changed' &&
         !unrecoverable &&
@@ -244,6 +245,7 @@ export function mintDecisionRefusalReading(err, context, attributionCarried, del
         ...(transient ? { transient: true } : {}),
         ...(conflict !== undefined ? { conflict } : {}),
         ...(unrecoverable ? { unrecoverable: true } : {}),
+        ...(acceptableForm !== undefined ? { acceptableForm } : {}),
     });
 }
 export function readDecisionRefusalReading(err, context) {

package/dist/hitl/editedRuleTextPrecheck.d.ts

@@ -12,6 +12,7 @@ export type EditedRuleTextPrecheck = {
     message: string;
 };
 export type EditedRuleTextPrechecker = (text: string, command: string) => EditedRuleTextPrecheck;
+export declare function trimEditedRuleText(text: string): string;
 export declare function installEditedRuleTextPrechecker(fn: EditedRuleTextPrechecker | null): () => void;
 export declare function hasEditedRuleTextPrechecker(): boolean;
 export declare function precheckEditedRuleText(text: string, command: string): EditedRuleTextPrecheck | undefined;

package/dist/hitl/editedRuleTextPrecheck.js

@@ -1,4 +1,29 @@
 let installed = null;
+function escapedAt(s, i) {
+    let n = 0;
+    for (let j = i - 1; j >= 0 && s[j] === '\\'; j -= 1)
+        n += 1;
+    return n % 2 === 1;
+}
+export function trimEditedRuleText(text) {
+    if (typeof text !== 'string')
+        return text;
+    const outer = text.trim();
+    let open = -1;
+    for (let i = 0; i < outer.length; i += 1) {
+        if (outer[i] === '(' && !escapedAt(outer, i)) {
+            open = i;
+            break;
+        }
+    }
+    if (open <= 0)
+        return outer;
+    const head = outer.slice(0, open);
+    const name = head.trimEnd();
+    if (name === head || name.length === 0 || name.endsWith('\\'))
+        return outer;
+    return name + outer.slice(open);
+}
 export function installEditedRuleTextPrechecker(fn) {
     const prev = installed;
     installed = fn;
@@ -13,7 +38,7 @@ export function precheckEditedRuleText(text, command) {
     const fn = installed;
     if (fn === null)
         return undefined;
-    return fn(text, command);
+    return fn(trimEditedRuleText(text), command);
 }
 export function _resetEditedRuleTextPrecheckerForTest() {
     installed = null;

package/dist/hitl/persistedRulesWire.js

@@ -208,6 +208,7 @@ const PERSISTED_RULE_MATCH_KEYS = Object.freeze({
     host: 'rules.match.host',
     subdomain: 'rules.match.subdomain',
     pattern: 'rules.match.pattern',
+    tool: 'rules.match.tool',
 });
 export function persistedRuleMatchLabel(ruleOrMatch, lang) {
     const word = typeof ruleOrMatch === 'string' ? ruleOrMatch : ownSlot(ruleOrMatch, 'match');

package/dist/hitl/planReviewWire.d.ts

@@ -1,4 +1,5 @@
 import { type QuestionAnswer } from '../liveQuestionStore.js';
+import type { EngineWireInjection } from '../engineWireSdk.js';
 import { type PlanReviewModeAfter } from './hitlBridge.js';
 import type { AgentClient } from '@sema-agent/sdk';
 import type { ReopenCardVerdict } from '../adapter/activeRunSelfHeal.js';
@@ -66,7 +67,7 @@ export type PlanReviewWireClient = {
     assistant: Pick<AgentClient['assistant'], 'planReview'>;
     runs: Pick<AgentClient['runs'], 'get'>;
 };
-export interface PlanReviewWire {
+export interface PlanReviewWire extends EngineWireInjection<PlanReviewWireClient> {
     client: PlanReviewWireClient;
 }
 export interface PlanReviewDecisionOutcome extends PlanReviewOutcomeMeta {

package/dist/hitl/planReviewWire.js

@@ -2,6 +2,7 @@ import { publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionRes
 import { hostLog } from '../host.js';
 import { abortableSleep, settleWithinDeadline } from '../abortableSleep.js';
 import { clientHasVerbs, engineWireFor, noAnswerKindOf, sendOnce } from '../engineWireFor.js';
+import { engineCapTrue } from '../engineCapsCache.js';
 import { engineWireTarget } from '../engineWireTarget.js';
 import { enqueuePlanReviewOutcome } from '../notifications.js';
 import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
@@ -370,7 +371,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
         }
         const wire = opts?.wire;
         if (wire !== undefined) {
-            if (!usablePlanReviewWireClient(wire.client)) {
+            if (engineWireFor(wire, DEFAULT_SESSION_KEY, usablePlanReviewWireClient).kind !== 'injected') {
                 hostLog('error', 'planReviewWire: plan_review card NOT armed — the engine client supplied by the host is not usable (needs assistant.planReview and runs.get)');
                 return false;
             }
@@ -454,15 +455,6 @@ export function planReviewOutcomeTail(taskId, decision, effect, cause) {
             return `Do not state the result as fact: tell the user the ${decision} was submitted but its effect could not be confirmed; TaskOutput("${taskId}") shows where the task stands.`;
     }
 }
-function clientOnlyView(wire) {
-    if (wire === undefined || wire === null || typeof wire !== 'object')
-        return wire;
-    return {
-        get client() {
-            return wire.client;
-        },
-    };
-}
 function planReviewDecisionTimedOutOutcome(decision) {
     return (`The plan_review ${decision} was sent, but no answer came back from the engine within the time limit this host allows for it — ` +
         `it may have taken effect (${decision === 'approve' ? 'an approval keeps the engine busy until the resumed work finishes' : 'the engine may still be applying it'}).`);
@@ -654,7 +646,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
     let stillParkedCause;
     let statusSeen;
     const wire = opts?.wire;
-    const resolved = engineWireFor(clientOnlyView(wire), DEFAULT_SESSION_KEY, usablePlanReviewWireClient);
+    const resolved = engineWireFor(wire, DEFAULT_SESSION_KEY, usablePlanReviewWireClient);
     const badMode = permissionModeAfter !== undefined && !isPlanReviewModeAfter(permissionModeAfter);
     if (badMode) {
         hostLog('error', `planReviewWire: ${decision} NOT sent — permissionModeAfter must be "default" or "acceptEdits"`);
@@ -683,11 +675,15 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
             try {
                 const mode = isPlanReviewModeAfter(permissionModeAfter) ? permissionModeAfter : undefined;
                 const reason = denyReasonForWire(opts?.reason, `plan-review ${taskId}`);
+                const capsBase = resolved.kind === 'target' ? resolved.target.baseUrl : resolved.capsBaseUrl;
+                const checkpointId = gateBefore !== undefined && engineCapTrue(capsBase, 'planReviewCheckpointId') ? gateBefore : undefined;
                 const reqBody = { decision };
                 if (reason !== undefined)
                     reqBody.reason = reason;
                 if (mode !== undefined)
                     reqBody.permissionModeAfter = mode;
+                if (checkpointId !== undefined)
+                    reqBody.checkpointId = checkpointId;
                 let body;
                 try {
                     body = await sendOnce(undefined, () => client.assistant.planReview(taskId, reqBody));
@@ -697,7 +693,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                     const defaultConflict = mode === 'default' && conflict?.status === 400 && conflict?.errorCode === REQUEST_FIELD_CONFLICT;
                     if (defaultConflict && !directFailureVerdictOf(e1, directSafetyStopOf(e1)).yields) {
                         hostLog('debug', 'planReviewWire: permissionModeAfter "default" refused as not applicable — re-sending the approval without the key (same meaning)');
-                        body = await sendOnce(undefined, () => client.assistant.planReview(taskId, reason !== undefined ? { decision, reason } : { decision }));
+                        body = await sendOnce(undefined, () => client.assistant.planReview(taskId, { decision, ...(reason !== undefined ? { reason } : {}), ...(checkpointId !== undefined ? { checkpointId } : {}) }));
                     }
                     else {
                         throw e1;

package/dist/hitl/sessionPolicyDeliverable.d.ts

@@ -22,4 +22,3 @@ export interface SessionPolicyDeliverableOptions {
 }
 export declare function sessionPolicyDeliverable(behavior: 'deny' | 'ask', rules: readonly string[], opts?: SessionPolicyDeliverableOptions): SessionPolicyDeliverability;
 export declare function sessionPolicyWithheldNotice(why: SessionPolicyWithheldWhy, lang?: UiLanguage): string;
-export declare function legacyToolNameFailureNoteOf(code: string | undefined): string | undefined;

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,11 +1,9 @@
-import { CONFIG_LEGACY_TOOL_NAME } from '../engineErrorCodes.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { readOwnDataValue } from '../ownKey.js';
 import { denyEntryReading, ruleCompileVerdict } from '../ruleCompileVerdict.js';
 import { ruleToolNameVerdictOf } from '../protocolSegment.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 = {
@@ -204,6 +202,3 @@ export function sessionPolicyWithheldNotice(why, lang) {
     }
     return 'Not written to this session’s rule record.';
 }
-export function legacyToolNameFailureNoteOf(code) {
-    return code === CONFIG_LEGACY_TOOL_NAME ? prepareRefusalNoteOf(code) : undefined;
-}

package/dist/hitl/sessionPolicyWire.js

@@ -21,7 +21,7 @@ const RULE_FIELD_PRESENCE = {
     toolDeny: true,
     allowDirs: true,
 };
-const RECORD_META_KEYS = Object.freeze(['rev', 'gen', 'grammar']);
+const RECORD_META_KEYS = Object.freeze(['rev', 'gen', 'grammar', 'operatorRules']);
 const _metaKeysPin = true;
 void _metaKeysPin;
 export const SESSION_POLICY_RULE_FIELDS = Object.freeze(Object.keys(RULE_FIELD_PRESENCE));

package/dist/hitl/toolApprovalWire.d.ts

@@ -1,6 +1,7 @@
 import { type HitlClientLike, type DecideOperationObserver } from './hitlBridge.js';
 import { readApprovalCardWord, type ApprovalCardWord } from './approvalCardReading.js';
 import { type ApprovalAllowRuleShadow } from './allowRuleShadow.js';
+import { CORE_PERSISTED_RULE_MATCHES } from '../generated/engineFactTables.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
 import type { SessionRuleInertReason } from './sessionPolicyWire.js';
 import { type ApprovalCardClaim } from './approvalHolds.js';
@@ -30,22 +31,33 @@ export type { RuleOfferBatchMember };
 export type { RuleOfferUncoveredDetail };
 export type { RuleOfferUncoveredReason };
 export { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS };
+type RuleOfferMatchWord = (typeof CORE_PERSISTED_RULE_MATCHES)[number];
+type RuleOfferBatchMemberReading = Exclude<RuleOfferBatchMember, {
+    kind: 'command';
+}> | (Omit<Extract<RuleOfferBatchMember, {
+    kind: 'command';
+}>, 'match'> & {
+    match: RuleOfferMatchWord;
+});
 export type { AskOrigin };
 export type { RuleOffersAbsence };
 export type { DenialLimitKind };
 export type { DenialLimitFallback };
 export { RULE_OFFERS_ABSENCE_REASONS };
 export declare const ASK_ORIGIN_WORDS: readonly string[];
-export type RuleOfferReading = (Extract<SdkRuleOffer, {
+export type RuleOfferReading = (Omit<Extract<SdkRuleOffer, {
     kind: 'single';
-}> & {
+}>, 'match'> & {
+    match: RuleOfferMatchWord;
     offerIndex: number;
 }) | (Omit<Extract<SdkRuleOffer, {
     kind: 'batch';
-}>, 'uncoveredDetail'> & {
+}>, 'uncoveredDetail' | 'rules'> & RuleOfferBatchReadingSeats);
+interface RuleOfferBatchReadingSeats {
+    rules: RuleOfferBatchMemberReading[];
     offerIndex: number;
     uncoveredDetail?: readonly RuleOfferUncoveredDetail[];
-});
+}
 export interface ApprovalCardAllowDecision {
     kind: 'allow';
     allowSession: boolean;
@@ -263,8 +275,8 @@ export declare function approvalSupersedesDetail(card: Pick<ApprovalCardRequest,
 export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback | undefined;
 export declare function readRuleOffers(v: unknown): RuleOfferReading[] | undefined;
 export declare function readRuleOfferSupply(offers: unknown): RuleOfferReading[] | undefined;
-export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'grantBinding' | 'unreadableEvidence' | 'message'>;
-export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'approvalCard' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable'>;
+export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'grantBinding' | 'unreadableEvidence' | 'message' | 'approvalCard'>;
+export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable'>;
 export interface ApprovalCardFrameFactsOptions {
     readonly streamArgs?: object;
     readonly argsUnavailable?: true;

package/dist/hitl/toolApprovalWire.js

@@ -3,6 +3,7 @@ import { askParkRowArm } from './askParkRowRouting.js';
 import { parkGateArmOf } from './frameRouter.js';
 import { seatSessionRowOf } from './standingRows.js';
 import { hostLog } from '../host.js';
+import { trimEditedRuleText } from './editedRuleTextPrecheck.js';
 import { appendOwnElement, guardedRead, readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
 import { ownReadingSlot } from '../engineWireFor.js';
 import { DEPLOYMENT_LIST_ASK_CLASSES, readAskClassPair } from './askClassPair.js';
@@ -12,7 +13,7 @@ import { readAllowRuleShadowFromWire, retiredAllowRuleShadowKeyPresent, RETIRED_
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
-import { CORE_ALLOW_ENTRY_INERT_REASONS } from '../generated/engineFactTables.js';
+import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_PERSISTED_RULE_MATCHES } from '../generated/engineFactTables.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
@@ -67,6 +68,8 @@ export function structurallyEqual(a, b) {
     return ka.every(k => structurallyEqual(a[k], b[k]));
 }
 export { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS };
+const _sdkRuleOfferMatchWithinEngine = true;
+void _sdkRuleOfferMatchWithinEngine;
 export { RULE_OFFERS_ABSENCE_REASONS };
 export const ASK_ORIGIN_WORDS = ASK_ORIGINS;
 export const APPROVAL_DENY_SETTLED_BY_WORDS = Object.freeze(['human', 'policy']);
@@ -1336,7 +1339,7 @@ export function readDenialLimitFallback(v) {
     };
 }
 function isRuleOfferMatch(v) {
-    return typeof v === 'string' && RULE_OFFER_MATCHES.includes(v);
+    return typeof v === 'string' && CORE_PERSISTED_RULE_MATCHES.includes(v);
 }
 function readRuleTriple(v) {
     if (v === null || typeof v !== 'object')
@@ -1346,7 +1349,7 @@ function readRuleTriple(v) {
         return undefined;
     if (!isRuleOfferMatch(o.match))
         return undefined;
-    if (typeof o.command !== 'string' || o.command === '')
+    if (typeof o.command !== 'string')
         return undefined;
     return { rule: o.rule, match: o.match, command: o.command };
 }
@@ -1624,6 +1627,8 @@ function cardFactsOf(carrier, leg, opts) {
             if (o !== undefined)
                 out.origin = o;
         });
+    }
+    if (leg !== 'generic') {
         v1Bit(() => {
             const w = readApprovalCardWord(carrier);
             if (w !== undefined)
@@ -1899,7 +1904,7 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
             const edited = card.persistRuleEdited === true;
             if (edited) {
                 if (lane?.respondFreeFormRulesCapable === true) {
-                    persistRule = card.persistRule;
+                    persistRule = trimEditedRuleText(card.persistRule);
                     persistRuleEdited = true;
                 }
                 else {

package/dist/i18n/messages.en.d.ts

@@ -184,6 +184,7 @@ declare const EN: {
     'config.mcp.nameEdgeWhitespace': string;
     'config.mcp.nameCollides': string;
     'config.mcp.nameTooLong': string;
+    'config.mcp.nameReserved': string;
     'config.mcp.identityHeadersBothSet': string;
     'config.mcp.transportUnreadable': string;
     'config.mcp.transportInvalid': string;
@@ -584,6 +585,8 @@ declare const EN: {
     'notice.wayOut.switchModel': string;
     'notice.wayOut.wait': string;
     'notice.wayOut.fixRequest': string;
+    'notice.askUnresolvable.remedy.approver': string;
+    'notice.askUnresolvable.remedy.permissionMode': string;
     'rules.refusal.sentence.one': string;
     'rules.refusal.sentence.other': string;
     'rules.refusal.item': string;
@@ -780,6 +783,7 @@ declare const EN: {
     'rules.match.host': string;
     'rules.match.subdomain': string;
     'rules.match.pattern': string;
+    'rules.match.tool': string;
     'rules.match.unreported': string;
     'rules.match.unknown': string;
     'model.tier.blurb.ultra': string;
@@ -1010,6 +1014,45 @@ declare const EN: {
     'config.hooks.plan.reason.compactionLocalFallback': string;
     'session.hooks.compactTransition.disclosure.engineOutcomeUnknown': string;
     'session.hooks.compactTransition.disclosure.neitherRan': string;
+    'session.background.handedOff': string;
+    'session.background.refusal.noRun': string;
+    'session.background.refusal.streamEnded': string;
+    'session.background.refusal.notStarted': string;
+    'session.background.refusal.alreadyHandedOff': string;
+    'session.background.refusal.finished': string;
+    'session.background.refusal.stopping': string;
+    'session.background.refusal.engineReplaced': string;
+    'session.background.refusal.declined': string;
+    'session.background.refusal.envOff': string;
+    'session.background.refusal.notReattachable': string;
+    'session.background.refusal.unconfirmed': string;
+    'session.background.refusal.durableOff': string;
+    'session.background.refusal.awaitingUser': string;
+    'session.background.unknown': string;
+    'session.background.hostNotNotified': string;
+    'session.background.settled.completed': string;
+    'session.background.settled.failed': string;
+    'session.background.settled.cancelled': string;
+    'session.background.settled.parked': string;
+    'session.background.settled.observationStopped': string;
+    'session.background.busy': string;
+    'session.thinking.state.on': string;
+    'session.thinking.state.off': string;
+    'session.thinking.state.unset': string;
+    'session.thinking.offWithUltracodeOnBody': string;
+    'session.thinking.modelCannotThink': string;
+    'session.thinking.storeUnreadable': string;
+    'session.thinking.notSaved': string;
+    'config.mods.card.mounted': string;
+    'config.mods.card.refused': string;
+    'config.mods.card.none': string;
+    'config.mods.card.counts': string;
+    'config.mods.card.countsWithRefused': string;
+    'config.mods.loader.failed': string;
+    'config.mods.loader.failedNoReason': string;
+    'config.mods.refusal.by': string;
+    'config.mods.rewrite.resultInPlace': string;
+    'config.mods.rewrite.inputBy': string;
 };
 export declare const EN_MESSAGES: Readonly<typeof EN>;
 export type MessageKey = keyof typeof EN;

package/dist/i18n/messages.en.js

@@ -184,6 +184,7 @@ const EN = {
     'config.mcp.nameEdgeWhitespace': 'MCP server name {name}{where} cannot be used as written, so the server was not started: it would not match the same name in other settings (for example a list of disabled servers). Remove the extra whitespace from the name.',
     'config.mcp.nameCollides': 'MCP server name {name}{where} cannot be used as written, so the server was not started: without its leading or trailing whitespace it would be the same name as another MCP server entry. Remove the extra whitespace from the name, or delete the duplicate entry.',
     'config.mcp.nameTooLong': 'MCP server name {name}{where} cannot be used, so the server was not started: server names are limited to 128 characters. Shorten the name.',
+    'config.mcp.nameReserved': 'MCP server name {name}{where} cannot be used, so the server was not started: names starting with "remote-" are kept for the MCP servers a connected device offers. Rename the server.',
     'config.mcp.identityHeadersBothSet': 'MCP server {name}{where} was not started: it sets both principalHeader and assertionHeader, which name the same identity header — keep only one of the two. The other MCP servers are unaffected.',
     'config.mcp.transportUnreadable': 'could not be read (a getter or proxy trap on the declaration threw)',
     'config.mcp.transportInvalid': 'MCP server {name}{where} was not started: its transport setting cannot be used — {path} {problem}. Fix that setting for this server (or remove the server); the other MCP servers are unaffected.',
@@ -302,7 +303,7 @@ const EN = {
     'session.inheritEnv.withheld.scrub': "Not sent with this request: the engine's version is not known yet, so the default-environment setting was left out; that has the same effect, because leaving it out also gives this run the default environment (credential-like variables removed).",
     'session.inheritEnv.withheld.unknown': 'Not sent with this request: the shell-environment setting was held back for a reason this version does not recognize.',
     'session.inheritEnv.refusal': "The engine refused this request as invalid, under a refusal code that many different request fields share · This request asked for the shell to inherit this machine's whole environment, which the engine accepts only when tools run directly on its own machine and the request belongs to a session; if that is what it refused, send it again without that setting (or with the default)",
-    'session.inheritEnv.refusalNamed': "The engine refused the setting that lets the shell inherit this machine's whole environment, which it accepts only when tools run directly on its own machine and the request belongs to a session · Send the request again without that setting (or with the default)",
+    'session.inheritEnv.refusalNamed': "The engine refused this request's shell-environment setting: it accepts only the default or this machine's whole environment, and the whole environment only when tools run directly on its own machine and the request belongs to a session · Send the request again without that setting (or with the default)",
     'session.projectMemory.withheld.absent': 'Not sent with this request: this engine does not declare support for the setting that stops project instruction files from being read, and an engine that does not know it refuses the whole request, so it was held back; those files are still sent to the model.',
     'session.projectMemory.withheld.declined': 'Not sent with this request: this engine declares that it does not support the setting that stops project instruction files from being read, so it was held back; those files are still sent to the model.',
     'session.projectMemory.withheld.unreadable': "Not sent with this request: the engine's capabilities could not be read, so it is not known whether it supports the setting that stops project instruction files from being read, and an engine that does not know it refuses the whole request, so it was held back; those files are still sent to the model.",
@@ -584,6 +585,8 @@ const EN = {
     'notice.wayOut.switchModel': 'The model service cannot serve this request right now — try another model',
     'notice.wayOut.wait': 'The model service is still working on this request — wait a moment, then try again',
     'notice.wayOut.fixRequest': 'The model service refused this request — change the request before sending it again; sending it as it is will not help',
+    'notice.askUnresolvable.remedy.approver': 'Way out: connect an approver who can answer requests like this one, or make the connected approver reachable, then try again',
+    'notice.askUnresolvable.remedy.permissionMode': 'Another way out, if this deployment allows it: the {mode} permission mode lets requests like this one through without anyone answering them, and each request let through this way is marked on the tool call it applied to',
     'rules.refusal.sentence.one': 'permissions: 1 rule will not be enforced — {list}',
     'rules.refusal.sentence.other': 'permissions: {count} rules will not be enforced — {list}',
     'rules.refusal.item': '{rule} ({reason})',
@@ -780,6 +783,7 @@ const EN = {
     'rules.match.host': 'web domain match (one host)',
     'rules.match.subdomain': 'web domain match (every host under the domain)',
     'rules.match.pattern': 'command pattern match (a star placed anywhere in the command)',
+    'rules.match.tool': 'whole-tool match (every call to the tool)',
     'rules.match.unreported': 'an unreported match form',
     'rules.match.unknown': 'a match form this build does not know',
     'model.tier.blurb.ultra': 'reserved above max — binds when a stronger model lands',
@@ -1010,5 +1014,44 @@ const EN = {
     'config.hooks.plan.reason.compactionLocalFallback': 'this compaction is summarized on this client because the engine session is unavailable, so the engine will not run it and this client runs it itself',
     'session.hooks.compactTransition.disclosure.engineOutcomeUnknown': 'The compaction request had already been sent to the engine when the summary fell back to this client, so whether the engine ran the compaction hooks cannot be told here, and this client did not run them again.',
     'session.hooks.compactTransition.disclosure.neitherRan': 'The compaction hooks did not run this time: the engine did not compact here and this client could not start its own summary. If the engine still compacts later it will run them then.',
+    'session.background.handedOff': "Moved to the background. You'll be told when it finishes.",
+    'session.background.refusal.noRun': "There's no answer running from this screen that can be moved to the background.",
+    'session.background.refusal.streamEnded': "This answer is no longer on its original live connection, so it can't be moved to the background from here.",
+    'session.background.refusal.notStarted': "The engine hasn't started streaming this answer yet. Try again in a moment.",
+    'session.background.refusal.alreadyHandedOff': 'This answer is already in the background.',
+    'session.background.refusal.finished': 'This answer has already finished.',
+    'session.background.refusal.stopping': "This answer is being stopped, so it can't move to the background.",
+    'session.background.refusal.engineReplaced': "The engine running this answer has stopped or been replaced; it can't be moved.",
+    'session.background.refusal.declined': "This answer can't move to the background: this engine doesn't keep answers running after you leave. It will finish here.",
+    'session.background.refusal.envOff': 'Background hand-off is turned off (SEMA_HEADLESS_DETACH). This answer will finish here.',
+    'session.background.refusal.notReattachable': "This answer can't move to the background: this window can't reconnect to an answer running elsewhere.",
+    'session.background.refusal.unconfirmed': "This answer can't move to the background: the engine hasn't confirmed it can keep answers running on its own.",
+    'session.background.refusal.durableOff': "This answer can't move to the background: the engine said it can't keep this answer running after you leave.",
+    'session.background.refusal.awaitingUser': "Answer the open question first — an answer that is waiting for you can't move to the background.",
+    'session.background.unknown': "Couldn't confirm this answer can safely move to the background, so it stays here.",
+    'session.background.hostNotNotified': "Moved to the background, but this screen didn't update cleanly.",
+    'session.background.settled.completed': 'The background answer finished.',
+    'session.background.settled.failed': 'The background answer stopped with an error ({code}).',
+    'session.background.settled.cancelled': 'The background answer was cancelled.',
+    'session.background.settled.parked': 'The background answer is waiting for approval; open it to continue.',
+    'session.background.settled.observationStopped': 'Lost track of the background answer. It may still be running — check the task list.',
+    'session.background.busy': "This conversation's answer is still running in the background. Wait for it to finish, or start a new conversation.",
+    'session.thinking.state.on': 'Thinking on',
+    'session.thinking.state.off': 'Thinking off',
+    'session.thinking.state.unset': 'Thinking not set: the effort setting decides, or the engine default when there is none',
+    'session.thinking.offWithUltracodeOnBody': 'This message carries both Ultracode and thinking off; the engine decides which one applies.',
+    'session.thinking.modelCannotThink': 'Thinking is on, but the model {model} does not use extended thinking, so this setting has no effect on it.',
+    'session.thinking.storeUnreadable': 'The thinking setting could not be read, so it is treated as not set: no thinking override is applied and the effort setting decides.',
+    'session.thinking.notSaved': 'The thinking setting was not saved, so it may not have changed.',
+    'config.mods.card.mounted': '{name} is loaded',
+    'config.mods.card.refused': '{name} was not loaded: {refusedBy} refused it — {reason}',
+    'config.mods.card.none': 'No mods registered on this leg',
+    'config.mods.card.counts': '{n} mounted',
+    'config.mods.card.countsWithRefused': '{n} mounted, {m} refused',
+    'config.mods.loader.failed': '{name} could not be loaded: {reason}',
+    'config.mods.loader.failedNoReason': '{name} could not be loaded',
+    'config.mods.refusal.by': 'Refused by {by}',
+    'config.mods.rewrite.resultInPlace': 'Answered by {by} in place of the tool',
+    'config.mods.rewrite.inputBy': 'Arguments changed by {by} before the call was let through',
 };
 export const EN_MESSAGES = Object.freeze(EN);