@sema-agent/client-core 0.99.0 → 0.100.0

package/dist/generated/engineFactTables.d.ts

@@ -14,6 +14,7 @@ export declare const CORE_ASK_EVIDENCE_ABSENCE_VALUES: readonly ["not_wired", "n
 export declare const CORE_SYSTEM_INJECTION_PRIORITIES: readonly ["now", "next", "later"];
 export declare const CORE_READ_DENY_BUILTIN_TIERS: readonly ["credentials", "shell-history", "browser", "wallet", "agent-config"];
 export declare const CORE_READ_DENY_DEFAULT_TIERS: readonly ["credentials", "agent-config"];
+export declare const CORE_ASK_CLASSES: readonly ["content_question", "hook", "ancestor", "dangerous_delete", "unverifiable_delete", "unverifiable_shell_text", "transcript_write", "org_rule", "rule_unreadable", "ask_rule", "denial_limit_fallback", "classifier_no_ruling", "requires_user_interaction", "operator_forced", "shell_floor", "target_unresolved", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "policy_rra", "artifact_shared_read", "mode", "unstated", "ordinary"];
 export interface CoreModeArbitrationRow {
     readonly bypassImmune: boolean;
     readonly classifierEligible: boolean;

package/dist/generated/engineFactTables.js

@@ -140,6 +140,33 @@ export const CORE_READ_DENY_DEFAULT_TIERS = Object.freeze([
     "credentials",
     "agent-config",
 ]);
+export const CORE_ASK_CLASSES = Object.freeze([
+    "content_question",
+    "hook",
+    "ancestor",
+    "dangerous_delete",
+    "unverifiable_delete",
+    "unverifiable_shell_text",
+    "transcript_write",
+    "org_rule",
+    "rule_unreadable",
+    "ask_rule",
+    "denial_limit_fallback",
+    "classifier_no_ruling",
+    "requires_user_interaction",
+    "operator_forced",
+    "shell_floor",
+    "target_unresolved",
+    "probe",
+    "write_protection",
+    "tool_marks_mcp",
+    "tool_marks_a2a",
+    "policy_rra",
+    "artifact_shared_read",
+    "mode",
+    "unstated",
+    "ordinary",
+]);
 export const CORE_MODE_ARBITRATION = Object.freeze({
     "content_question": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
     "hook": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),

package/dist/generated/engineNoticeTables.js

@@ -31,6 +31,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "permission.read_deny_unapplied",
     "permission.rule_store_unavailable",
     "permission.rule_row_dropped",
+    "config.session_rules_earlier_grammar",
     "permission.allowed_tool_not_granted",
     "mods.registration_refused",
     "peer.inbound_disposition",
@@ -128,6 +129,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "permission.read_deny_unapplied": "user",
     "permission.rule_store_unavailable": "user",
     "permission.rule_row_dropped": "user",
+    "config.session_rules_earlier_grammar": "user",
     "permission.allowed_tool_not_granted": "user",
     "mods.registration_refused": "user",
     "peer.inbound_disposition": "user",
@@ -231,6 +233,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "permission.read_deny_unapplied": "engine",
     "permission.rule_store_unavailable": "engine",
     "permission.rule_row_dropped": "engine",
+    "config.session_rules_earlier_grammar": "engine",
     "permission.allowed_tool_not_granted": "engine",
     "mods.registration_refused": "engine",
     "peer.inbound_disposition": "engine",

package/dist/generated/settingsSchemaFns.d.ts

@@ -1,4 +1,5 @@
 import type { HooksClassification } from './settingsSchemaTypes.js';
+import type { McpContentOrigin, RequestMcpTransportRead } from './settingsSchemaTypes.js';
 export declare const SETTINGS_AT_MENTION_MODES: readonly ["all", "none", "only"];
 export type SettingsAtMention = {
     readonly mode: Exclude<(typeof SETTINGS_AT_MENTION_MODES)[number], 'only'>;
@@ -12,8 +13,19 @@ export declare const SETTINGS_IS_HIERARCHICAL_URL: (raw: string) => boolean;
 export declare const SETTINGS_NARROW_AT_MENTION: (atMention: SettingsAtMention, available: ReadonlySet<string>) => SettingsAtMention;
 export declare const SETTINGS_HOOK_MATCHER_SELECTS: (matcher: string | undefined, name: string) => boolean | 'invalid';
 export declare const SETTINGS_HOOK_MATCHER_FORM: (matcher: string | undefined) => SettingsHookMatcherForm;
+export declare const SETTINGS_STARTS_WITH_HTTP_SCHEME: (raw: string) => boolean;
 export declare const SETTINGS_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "Notification", "UserPromptSubmit", "UserPromptExpansion", "SessionStart", "SessionEnd", "Stop", "StopFailure", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "PermissionRequest", "PermissionDenied", "Setup", "TeammateIdle", "TaskCreated", "TaskCompleted", "Elicitation", "ElicitationResult", "ConfigChange", "WorktreeCreate", "WorktreeRemove", "InstructionsLoaded", "CwdChanged", "FileChanged", "MessageDisplay", "DirectoryAdded", "PreModelSwitch", "PostModelSwitch"];
 export declare const SETTINGS_HOOKS_CLASSIFICATION_OUTCOMES: readonly ["loaded", "loaded-partial", "rejected"];
 export declare const SETTINGS_HOOKS_DROPPED_PIECE_CODES: readonly ["hooks-not-object", "unknown-event", "event-not-array", "matcher-invalid", "entry-invalid"];
 export declare const SETTINGS_HOOKS_REJECTION_CODES: readonly ["guard-outside-hooks", "hooks-is-matcher", "guard-under-unknown-event", "guard-event-not-array", "guard-matcher-invalid", "guard-entry-invalid"];
 export declare const SETTINGS_CLASSIFY_HOOKS_CONFIG: (settingsDoc: unknown) => HooksClassification;
+export declare const SETTINGS_READ_REQUEST_MCP_TRANSPORT: (t: unknown) => RequestMcpTransportRead;
+export declare const SETTINGS_READ_MCP_IDENTITY_HEADERS: (transport: Record<string, unknown>) => {
+    principalHeader?: string;
+    assertionHeader?: string;
+};
+export declare const SETTINGS_IS_USABLE_WIRE_NAME: (v: unknown) => v is string;
+export declare const SETTINGS_DESCRIBE_BAD_WIRE_NAME: (v: unknown) => string;
+export declare const SETTINGS_IS_CONTENT_ORIGIN_WORD: (v: unknown) => v is McpContentOrigin;
+export declare const SETTINGS_DESCRIBE_BAD_CONTENT_ORIGIN: (v: unknown) => string;
+export declare const SETTINGS_TOOL_WIRE_NAME_MAX_CHARS: 128;

package/dist/generated/settingsSchemaFns.js

@@ -1,4 +1,6 @@
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE } from './settingsSchemaHooksClassifier.js';
+import { SETTINGS_MCP_REQUEST_ENTRY_CLOSURE } from './settingsSchemaMcpRequestEntry.js';
+import { SETTINGS_MCP_CONTENT_ORIGINS } from './settingsSchemaTables.js';
 export const SETTINGS_AT_MENTION_MODES = Object.freeze([
     "all",
     "none",
@@ -74,6 +76,9 @@ export const SETTINGS_HOOK_MATCHER_FORM = function hookMatcherForm(matcher) {
         }
     }
 };
+export const SETTINGS_STARTS_WITH_HTTP_SCHEME = function startsWithHttpScheme(raw) {
+    return /^https?:\/\//i.test(raw);
+};
 export const SETTINGS_HOOK_EVENTS = Object.freeze([
     "PreToolUse",
     "PostToolUse",
@@ -130,3 +135,11 @@ export const SETTINGS_HOOKS_REJECTION_CODES = Object.freeze([
     "guard-entry-invalid",
 ]);
 export const SETTINGS_CLASSIFY_HOOKS_CONFIG = SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE(SETTINGS_HOOK_EVENTS);
+const SETTINGS_MCP_REQUEST_ENTRY = SETTINGS_MCP_REQUEST_ENTRY_CLOSURE(SETTINGS_MCP_CONTENT_ORIGINS, SETTINGS_STARTS_WITH_HTTP_SCHEME);
+export const SETTINGS_READ_REQUEST_MCP_TRANSPORT = SETTINGS_MCP_REQUEST_ENTRY.readRequestMcpTransport;
+export const SETTINGS_READ_MCP_IDENTITY_HEADERS = SETTINGS_MCP_REQUEST_ENTRY.readMcpIdentityHeaders;
+export const SETTINGS_IS_USABLE_WIRE_NAME = SETTINGS_MCP_REQUEST_ENTRY.isUsableWireName;
+export const SETTINGS_DESCRIBE_BAD_WIRE_NAME = SETTINGS_MCP_REQUEST_ENTRY.describeBadWireName;
+export const SETTINGS_IS_CONTENT_ORIGIN_WORD = SETTINGS_MCP_REQUEST_ENTRY.isContentOriginWord;
+export const SETTINGS_DESCRIBE_BAD_CONTENT_ORIGIN = SETTINGS_MCP_REQUEST_ENTRY.describeBadContentOrigin;
+export const SETTINGS_TOOL_WIRE_NAME_MAX_CHARS = SETTINGS_MCP_REQUEST_ENTRY.TOOL_WIRE_NAME_MAX_CHARS;

package/dist/generated/settingsSchemaMcpRequestEntry.d.ts

@@ -0,0 +1 @@
+export declare const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE: (MCP_CONTENT_ORIGINS: readonly ["local", "execution", "external"], startsWithHttpScheme: (raw: string) => boolean) => any;

package/dist/generated/settingsSchemaMcpRequestEntry.js

@@ -0,0 +1,162 @@
+export const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE = (MCP_CONTENT_ORIGINS, startsWithHttpScheme) => {
+    function describeValueShape(v) {
+        if (v === undefined)
+            return "nothing (the key is absent)";
+        if (v === null)
+            return "null";
+        if (Array.isArray(v))
+            return "an array";
+        if (typeof v === "string")
+            return v.length === 0 ? "an empty string" : `a string of ${v.length} characters`;
+        if (typeof v === "object")
+            return "an object";
+        return `a ${typeof v}`;
+    }
+    function describeNotStringArray(v) {
+        return Array.isArray(v) ? "an array with a non-string element" : describeValueShape(v);
+    }
+    function isStringArray(v) {
+        return Array.isArray(v) && v.every((a) => typeof a === "string");
+    }
+    const CONTROL_AND_BIDI_STRIP_RE = /[\u0000-\u001f\u007f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
+    const CALLER_TEXT_ECHO_MAX_CHARS = 64;
+    function echoCallerText(text) {
+        const clean = text.replace(CONTROL_AND_BIDI_STRIP_RE, "");
+        return clean.length > CALLER_TEXT_ECHO_MAX_CHARS ? `${clean.slice(0, CALLER_TEXT_ECHO_MAX_CHARS)}…` : clean;
+    }
+    function quotedCallerText(text) {
+        return `"${echoCallerText(text)}"`;
+    }
+    const TOOL_WIRE_NAME_MAX_CHARS = 128;
+    const hasEdgeWhitespace = (v) => v.trim() !== v;
+    function isUsableWireName(v) {
+        return typeof v === "string" && v.length > 0 && v.length <= TOOL_WIRE_NAME_MAX_CHARS && !hasEdgeWhitespace(v);
+    }
+    function describeBadWireName(v) {
+        if (typeof v !== "string")
+            return v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+        if (v.length === 0)
+            return "empty";
+        const head = quotedCallerText(v);
+        const tooLong = `${v.length} chars > ${TOOL_WIRE_NAME_MAX_CHARS}`;
+        if (!hasEdgeWhitespace(v))
+            return `${head} (${tooLong})`;
+        return `${head} (${v.length > TOOL_WIRE_NAME_MAX_CHARS ? `${tooLong}, ` : ""}leading or trailing whitespace)`;
+    }
+    const CONTENT_ORIGIN_WORDS = new Set(MCP_CONTENT_ORIGINS);
+    function isContentOriginWord(v) {
+        return typeof v === "string" && CONTENT_ORIGIN_WORDS.has(v);
+    }
+    function describeBadContentOrigin(v) {
+        return typeof v === "string" ? quotedCallerText(v) : v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+    }
+    function readMcpIdentityHeaders(transport) {
+        return {
+            ...(typeof transport.principalHeader === "string" ? { principalHeader: transport.principalHeader } : {}),
+            ...(transport.principalHeader === undefined && typeof transport.assertionHeader === "string" ? { assertionHeader: transport.assertionHeader } : {}),
+        };
+    }
+    const transportBad = (path, reason) => ({ ok: false, issue: { path, reason } });
+    function readRequestMcpTransport(t) {
+        if (!t || typeof t !== "object")
+            return transportBad("transport", `must be an object with a "kind" of "stdio" or "http" — got ${describeValueShape(t)}`);
+        const tr = t;
+        const lost = [];
+        if (tr.kind === "stdio") {
+            if (typeof tr.command !== "string" || tr.command.length === 0)
+                return transportBad("transport.command", `must be a non-empty string (the command to run) — got ${describeValueShape(tr.command)}`);
+            if (tr.args !== undefined && !isStringArray(tr.args))
+                lost.push({ path: "transport.args", reason: `must be an array of strings — got ${describeNotStringArray(tr.args)}` });
+            const env = readTransportRecord("transport.env", tr.env, lost);
+            return {
+                ok: true,
+                transport: {
+                    kind: "stdio",
+                    command: tr.command,
+                    ...(isStringArray(tr.args) ? { args: tr.args } : {}),
+                    ...(env !== undefined ? { env } : {}),
+                },
+                lost,
+            };
+        }
+        if (tr.kind === "http") {
+            if (typeof tr.url !== "string" || !startsWithHttpScheme(tr.url))
+                return transportBad("transport.url", "must be an absolute http(s) URL (put credentials in transport.headers, never in the URL)");
+            const ids = readMcpIdentityHeaders(tr);
+            const headers = readTransportRecord("transport.headers", tr.headers, lost);
+            if (tr.principalHeader !== undefined && ids.principalHeader === undefined) {
+                lost.push({ path: "transport.principalHeader", reason: `must be a string (the HTTP header NAME the end-user principal is injected into) — got ${describeValueShape(tr.principalHeader)}` });
+            }
+            return {
+                ok: true,
+                transport: {
+                    kind: "http",
+                    url: tr.url,
+                    ...(headers !== undefined ? { headers } : {}),
+                    ...ids,
+                },
+                lost,
+            };
+        }
+        return transportBad("transport.kind", `must be "stdio" or "http" — got ${describeValueShape(tr.kind)}`);
+    }
+    const RESERVED_MEMBER_NAME = "__proto__";
+    const RESERVED_MEMBER_FAULT = `no member of a declaration may be named "${RESERVED_MEMBER_NAME}"`;
+    function readPlainStringRecord(v) {
+        if (v === null || typeof v !== "object" || Array.isArray(v))
+            return { ok: false, fault: "not_plain_record", detail: v === null ? "got null" : Array.isArray(v) ? "got an array" : `got a ${typeof v}` };
+        let proto;
+        let names;
+        try {
+            proto = Object.getPrototypeOf(v);
+            names = Object.getOwnPropertyNames(v);
+        }
+        catch {
+            return { ok: false, fault: "not_plain_record", detail: "got an object that could not be inspected (a proxy trap threw)" };
+        }
+        if (proto !== Object.prototype && proto !== null) {
+            return { ok: false, fault: "not_plain_record", detail: "got an object that is not plain data (a class instance, a Map, process.env, or a record built on a prototype; copy it into a plain object)" };
+        }
+        const record = {};
+        let reservedMember = false;
+        for (const name of names) {
+            let value;
+            let unreadable = false;
+            try {
+                const d = Object.getOwnPropertyDescriptor(v, name);
+                value = d === undefined ? undefined : Object.hasOwn(d, "value") ? d.value : d.get === undefined ? undefined : Reflect.apply(d.get, v, []);
+            }
+            catch {
+                unreadable = true;
+            }
+            if (unreadable || typeof value !== "string") {
+                const valueFault = unreadable ? "could not be read (its getter threw)" : `must be a string — got ${describeValueShape(value)}`;
+                const reserved = name === RESERVED_MEMBER_NAME;
+                return {
+                    ok: false,
+                    fault: reserved ? "member_name_reserved" : "member_not_string",
+                    member: echoCallerText(name),
+                    detail: `its member "${echoCallerText(name)}" ${reserved ? `is not allowed (${RESERVED_MEMBER_FAULT}) and its value ${valueFault}` : valueFault}`,
+                };
+            }
+            if (name === RESERVED_MEMBER_NAME)
+                reservedMember = true;
+            else
+                record[name] = value;
+        }
+        return { ok: true, record, reservedMember };
+    }
+    function readTransportRecord(path, raw, lost) {
+        if (raw === undefined)
+            return undefined;
+        const read = readPlainStringRecord(raw);
+        if (!read.ok) {
+            lost.push({ path, reason: `must be a plain object of string values — ${read.detail}`, ...(read.member !== undefined ? { member: read.member } : {}), fault: read.fault });
+            return undefined;
+        }
+        if (read.reservedMember)
+            lost.push({ path: `${path}.${RESERVED_MEMBER_NAME}`, reason: RESERVED_MEMBER_FAULT, member: RESERVED_MEMBER_NAME, fault: "member_name_reserved" });
+        return read.record;
+    }
+    return { readRequestMcpTransport, readMcpIdentityHeaders, isUsableWireName, describeBadWireName, isContentOriginWord, describeBadContentOrigin, TOOL_WIRE_NAME_MAX_CHARS };
+};

package/dist/generated/settingsSchemaTables.d.ts

@@ -10,3 +10,4 @@ export declare const SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS: readonly ["maxBudget
 export declare const SETTINGS_MODEL_API_WORDS: readonly ["openai-completions", "anthropic-messages"];
 export declare const SETTINGS_TOOL_NAME_MATCHER_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure"];
 export declare const SETTINGS_UI_LANGUAGE_VALUES: readonly ["en", "zh"];
+export declare const SETTINGS_MCP_CONTENT_ORIGINS: readonly ["local", "execution", "external"];

package/dist/generated/settingsSchemaTables.js

@@ -45,3 +45,8 @@ export const SETTINGS_UI_LANGUAGE_VALUES = Object.freeze([
     "en",
     "zh",
 ]);
+export const SETTINGS_MCP_CONTENT_ORIGINS = Object.freeze([
+    "local",
+    "execution",
+    "external",
+]);

package/dist/generated/settingsSchemaTypes.d.ts

@@ -102,4 +102,32 @@ export type HooksClassification = {
     readonly dropped: readonly [];
     readonly rejections: readonly HooksRejection[];
 };
+export type RequestMcpTransport = {
+    kind: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+} | {
+    kind: "http";
+    url: string;
+    headers?: Record<string, string>;
+    principalHeader?: string;
+    assertionHeader?: string;
+};
+export interface McpEntryKeyIssue {
+    readonly path: string;
+    readonly reason: string;
+    readonly member?: string;
+    readonly fault?: "not_plain_record" | "member_not_string" | "member_name_reserved";
+}
+export type RequestMcpTransportRead = {
+    ok: true;
+    transport: RequestMcpTransport;
+    lost: readonly McpEntryKeyIssue[];
+} | {
+    ok: false;
+    issue: McpEntryKeyIssue;
+};
+declare const MCP_CONTENT_ORIGINS: readonly ["local", "execution", "external"];
+export type McpContentOrigin = (typeof MCP_CONTENT_ORIGINS)[number];
 export {};

package/dist/hitl/allowRuleShadow.js

@@ -1,5 +1,5 @@
 import { CORE_ALLOW_RULE_MEMBERS } from '../generated/engineFactTables.js';
-import { quoteUntrustedForSentence } from '../displayUntrusted.js';
+import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 const KNOWN_MEMBERS = new Set(CORE_ALLOW_RULE_MEMBERS);
 function freezeMember(m) {
@@ -207,7 +207,7 @@ export function allowRuleShadowSentence(card, lang) {
         const single = singlePersistedEntry(shadow);
         if (single !== undefined)
             return renderMessage(msg('approval.card.shadow.single', { entry: single }), lang);
-        return renderMessage(msg('approval.card.shadow.several', { members: shadow.members.map((m) => memberPhrase(m, lang)).join(' · ') }), lang);
+        return renderMessage(msg('approval.card.shadow.several', { members: displayUntrusted(shadow.members.map((m) => memberPhrase(m, lang)).join(' · ')) }), lang);
     }
     catch {
         return renderMessage(msg('approval.card.shadow.unreadable'), lang);

package/dist/hitl/approvalCardReasons.js

@@ -104,8 +104,8 @@ export function approvalCardReasons(card, opts, lang) {
     for (const r of raw) {
         if (r.text === undefined)
             continue;
-        const text = displayUntrusted(r.text);
-        if (text === '' || seen.has(text))
+        const text = r.text;
+        if (text.trim() === '' || seen.has(text))
             continue;
         seen.add(text);
         lines.push(Object.freeze({ source: r.source, text }));

package/dist/hitl/approvalHolds.d.ts

@@ -1,5 +1,6 @@
 import type { ApprovalHolderIdentity } from './toolApprovalWire.js';
 import type { ApprovalResolution, ApprovalResolutionLane } from './approvalResolution.js';
+import { type DecisionLedgerOp } from './decisionLedger.js';
 export declare const APPROVAL_SETTLED_HOWS: readonly ["answered", "interrupted", "closed_by_engine"];
 export type ApprovalSettledHow = (typeof APPROVAL_SETTLED_HOWS)[number];
 export declare const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
@@ -29,6 +30,7 @@ export interface LiveCardHold {
     readonly cardSignal: AbortSignal;
     readonly interrupt: () => void;
     trailing?: Promise<boolean>;
+    ledgerOp?: DecisionLedgerOp;
 }
 export interface HostCardHold {
     readonly lane: 'host';
@@ -61,6 +63,17 @@ export interface HostApprovalCardHold {
     sending(): void;
     release(settled?: 'answered' | 'interrupted'): void;
 }
+export declare function hostHoldIsActive(handle: HostApprovalCardHold): boolean;
+export declare function takeHostHoldLedgerOp(handle: HostApprovalCardHold): DecisionLedgerOp | undefined;
+export type ApprovalHoldAttempt = {
+    readonly kind: 'settled';
+} | {
+    readonly kind: 'busy';
+} | {
+    readonly kind: 'held';
+    readonly hold: HostApprovalCardHold;
+};
+export declare function tryHoldApprovalNow(who: HoldIdentity, signal: AbortSignal | undefined): ApprovalHoldAttempt;
 export type ApprovalCardClaim = {
     readonly kind: 'held';
     readonly hold: HostApprovalCardHold;
@@ -93,4 +106,5 @@ export declare function settledLiveCardOutcome(approvalId: string): ApprovalReso
 export declare function liveCardHoldOf(key: string): LiveCardHold | undefined;
 export declare function holdLiveCard(identity: LiveCardIdentity, callerSignal: AbortSignal | undefined, present: (hold: LiveCardHold) => Promise<ApprovalResolution>): Promise<ApprovalResolution>;
 export declare function joinLiveCard(hold: LiveCardHold, signal: AbortSignal | undefined): Promise<ApprovalResolution>;
+export declare function enterLiveRespondPhase(hold: LiveCardHold): void;
 export declare function supersedeLiveCard(key: string, parked: boolean): boolean;

package/dist/hitl/approvalHolds.js

@@ -1,6 +1,7 @@
 import { hostLog } from '../host.js';
 import { liveFrameCallKey } from './gateIdentity.js';
 import { decideReceiptReopen, readDecideReceipt } from '../decideReceipt.js';
+import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp, settleDecisionOp } from './decisionLedger.js';
 export const APPROVAL_SETTLED_HOWS = Object.freeze(['answered', 'interrupted', 'closed_by_engine']);
 export const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
@@ -110,11 +111,16 @@ function holdHostCard(identity, signal) {
     h.inFlight.set(key, hold);
     let done = false;
     let stopFollowing = () => { };
+    let ledgerOp;
     const release = (settled) => {
         if (done)
             return;
         done = true;
         stopFollowing();
+        if (ledgerOp !== undefined) {
+            settleDecisionOp(ledgerOp, 'host');
+            ledgerOp.ownCallOpen = false;
+        }
         const how = settled === 'answered' || settled === 'interrupted' ? settled : undefined;
         if (how !== undefined && nonEmpty(frozen.approvalId))
             noteSettled(frozen.approvalId, how, false, how === 'interrupted' ? interruptedThere('decide') : nothingSentHere('decide'), true);
@@ -127,6 +133,8 @@ function holdHostCard(identity, signal) {
         sending: () => {
             if (done)
                 return;
+            if (hold.phase !== 'respond')
+                ledgerOp = openDecisionOp('tool_approval', ledgerKeysOfHold(frozen), 'handed', true);
             hold.phase = 'respond';
             stopFollowing();
         },
@@ -136,8 +144,31 @@ function holdHostCard(identity, signal) {
         if (!done && hold.phase === 'card')
             release();
     });
+    hostHoldControls.set(handle, {
+        active: () => !done && h.inFlight.get(key) === hold,
+        takeLedgerOp: () => {
+            const op = ledgerOp;
+            ledgerOp = undefined;
+            return op;
+        },
+    });
     return handle;
 }
+const hostHoldControls = new WeakMap();
+export function hostHoldIsActive(handle) {
+    return hostHoldControls.get(handle)?.active() === true;
+}
+export function takeHostHoldLedgerOp(handle) {
+    return hostHoldControls.get(handle)?.takeLedgerOp();
+}
+export function tryHoldApprovalNow(who, signal) {
+    const entry = settledApprovalOf(who.approvalId);
+    if (entry !== undefined && settledForDurableLane(entry))
+        return Object.freeze({ kind: 'settled' });
+    if (approvalHoldFor(who) !== undefined)
+        return Object.freeze({ kind: 'busy' });
+    return Object.freeze({ kind: 'held', hold: holdHostCard(who, signal) });
+}
 function callerSignalAborted(signal) {
     if (signal === undefined || signal === null)
         return false;
@@ -254,6 +285,8 @@ export function holdLiveCard(identity, callerSignal, present) {
     const hold = { lane: 'live', identity: Object.freeze({ ...identity }), outcome, phase: 'card', cardSignal: cut.signal, interrupt };
     h.inFlight.set(key, hold);
     const release = () => {
+        if (hold.ledgerOp !== undefined)
+            closeDecisionOp(hold.ledgerOp, 'package');
         if (h.inFlight.get(key) === hold)
             h.inFlight.delete(key);
     };
@@ -320,6 +353,14 @@ function followCallerSignal(signal, onAbort) {
         }
     };
 }
+function ledgerKeysOfHold(identity) {
+    return decisionLedgerKeysOf({ taskId: identity.taskId, approvalId: identity.approvalId, callId: identity.toolCallId });
+}
+export function enterLiveRespondPhase(hold) {
+    if (hold.ledgerOp === undefined)
+        hold.ledgerOp = openDecisionOp('tool_approval', ledgerKeysOfHold(hold.identity), 'posting', true);
+    hold.phase = 'respond';
+}
 export function supersedeLiveCard(key, parked) {
     const hold = liveCardHoldOf(key);
     if (hold === undefined || hold.phase !== 'card' || hold.superseded !== undefined)

package/dist/hitl/askClassPair.d.ts

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

package/dist/hitl/askClassPair.js

@@ -1,4 +1,4 @@
-import { CORE_MODE_ARBITRATION } from '../generated/engineFactTables.js';
+import { CORE_ASK_CLASSES } from '../generated/engineFactTables.js';
 export const DEPLOYMENT_LIST_ASK_CLASSES = Object.freeze(['ask_rule']);
 const ABSENT = Object.freeze({ state: 'absent' });
 const MALFORMED = Object.freeze({ state: 'malformed' });
@@ -41,7 +41,7 @@ export function readAskClassPairState(v) {
     return Object.freeze({ state: 'pair', askClass, classes: Object.freeze(classes) });
 }
 function inCanonicalOrder(classes) {
-    const order = Object.keys(CORE_MODE_ARBITRATION);
+    const order = CORE_ASK_CLASSES;
     let last = -1;
     for (const c of classes) {
         const rank = order.indexOf(c);

package/dist/hitl/attributionLadder.d.ts

@@ -0,0 +1,23 @@
+export declare function shouldResendWithoutAttribution(e: {} | null | undefined, sentAttributionKey: boolean, signal?: AbortSignal): boolean;
+export declare function shouldResendUnderSuccessorKey(e: {} | null | undefined, lastSendCarriedRetiredKey: boolean, signal?: AbortSignal): boolean;
+export declare function carriesAttributionKey(body: object): boolean;
+export declare function withoutAttributionKey<T extends {
+    settledBy?: unknown;
+    decidedBy?: unknown;
+}>(body: T): Omit<T, 'settledBy' | 'decidedBy'>;
+export declare function withAttributionKeyRenamed<T extends {
+    settledBy?: unknown;
+    decidedBy?: unknown;
+}>(body: T): Omit<T, 'settledBy' | 'decidedBy'> & {
+    decidedBy?: Exclude<T['settledBy'], undefined>;
+};
+export interface AttributionLadderState {
+    lastCarried: boolean;
+    dropped: boolean;
+    renamed: boolean;
+}
+export type AttributionLadderStep = 'dropped' | 'renamed' | 'renamed_then_dropped';
+export declare function deliverWithAttributionLadder<B extends {
+    settledBy?: unknown;
+    decidedBy?: unknown;
+}, R>(body: B, send: (b: B) => Promise<R>, signal: AbortSignal | undefined, state: AttributionLadderState, onStep?: (step: AttributionLadderStep) => void): Promise<R>;

package/dist/hitl/attributionLadder.js

@@ -0,0 +1,67 @@
+import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
+export function shouldResendWithoutAttribution(e, sentAttributionKey, signal) {
+    if (!sentAttributionKey)
+        return false;
+    if (signal?.aborted === true)
+        return false;
+    return denyAttributionRefusalFromError(e, true)?.kind === 'not_in_proof';
+}
+export function shouldResendUnderSuccessorKey(e, lastSendCarriedRetiredKey, signal) {
+    if (!lastSendCarriedRetiredKey)
+        return false;
+    if (signal?.aborted === true)
+        return false;
+    return denyAttributionRefusalFromError(e, true)?.kind === 'retired_key';
+}
+export function carriesAttributionKey(body) {
+    return Object.hasOwn(body, 'settledBy') || Object.hasOwn(body, 'decidedBy');
+}
+export function withoutAttributionKey(body) {
+    const { settledBy: _droppedSettledBy, decidedBy: _droppedDecidedBy, ...rest } = body;
+    void _droppedSettledBy;
+    void _droppedDecidedBy;
+    return rest;
+}
+export function withAttributionKeyRenamed(body) {
+    const { settledBy, decidedBy: _replaced, ...rest } = body;
+    void _replaced;
+    return settledBy === undefined ? rest : { ...rest, decidedBy: settledBy };
+}
+export async function deliverWithAttributionLadder(body, send, signal, state, onStep) {
+    state.lastCarried = carriesAttributionKey(body);
+    state.dropped = false;
+    state.renamed = false;
+    try {
+        return await send(body);
+    }
+    catch (first) {
+        if (shouldResendWithoutAttribution(first, state.lastCarried, signal)) {
+            const withoutAttribution = withoutAttributionKey(body);
+            state.lastCarried = false;
+            onStep?.('dropped');
+            const r = await send(withoutAttribution);
+            state.dropped = true;
+            return r;
+        }
+        if (shouldResendUnderSuccessorKey(first, Object.hasOwn(body, 'settledBy'), signal)) {
+            const renamed = withAttributionKeyRenamed(body);
+            onStep?.('renamed');
+            try {
+                const r = await send(renamed);
+                state.renamed = true;
+                return r;
+            }
+            catch (second) {
+                if (!shouldResendWithoutAttribution(second, true, signal))
+                    throw second;
+                const renamedWithoutAttribution = withoutAttributionKey(renamed);
+                state.lastCarried = false;
+                onStep?.('renamed_then_dropped');
+                const r = await send(renamedWithoutAttribution);
+                state.dropped = true;
+                return r;
+            }
+        }
+        throw first;
+    }
+}