@sema-agent/client-core 0.90.0 → 0.92.0

package/dist/engineNoticeCodes.js

@@ -643,6 +643,76 @@ export function userInputUndrainedNotice(facts) {
     }
     return unrecognizedUndrainedSentence(n, kind);
 }
+export function readTurnInterrupted(notice) {
+    return guardedRead(notice, readTurnInterruptedOf);
+}
+function readTurnInterruptedOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (ownSeat(n, 'code') !== 'task.turn_interrupted')
+        return undefined;
+    const d = ownSeat(n, 'detail');
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const causeRaw = ownSeat(o, 'cause');
+    const cause = nonEmpty(causeRaw);
+    const inputId = nonEmpty(ownSeat(o, 'inputId'));
+    const lane = causeRaw === undefined && inputId !== undefined ? 'input_now' : cause === 'user_halt' ? 'user_halt' : 'unrecognized';
+    const sessionId = nonEmpty(optionalOwnSeat(o, 'sessionId'));
+    const runId = nonEmpty(optionalOwnSeat(o, 'runId'));
+    const taskId = nonEmpty(optionalOwnSeat(o, 'taskId'));
+    const actorId = nonEmpty(optionalOwnSeat(o, 'actorId'));
+    return {
+        lane,
+        ...(lane === 'input_now' && inputId !== undefined ? { inputId } : {}),
+        ...(cause !== undefined ? { cause } : {}),
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(runId !== undefined ? { runId } : {}),
+        ...(taskId !== undefined ? { taskId } : {}),
+        ...(actorId !== undefined ? { actorId } : {}),
+    };
+}
+const TURN_INTERRUPTED_SENTENCE = Object.freeze({
+    input_now: 'Your message interrupted the running turn — tool calls that had already finished keep their results, and the run continues with your message first.',
+    user_halt: 'You stopped the run — the running turn was cut, and tool calls that had already finished keep their results.',
+    unrecognized: 'A running turn was cut for a reason this version does not recognise — tool calls that had already finished keep their results.',
+});
+export function turnInterruptedNotice(facts) {
+    try {
+        if (facts === null || typeof facts !== 'object' || Array.isArray(facts) || !Object.hasOwn(facts, 'lane'))
+            return undefined;
+        const lane = facts.lane;
+        return typeof lane === 'string' && Object.hasOwn(TURN_INTERRUPTED_SENTENCE, lane)
+            ? TURN_INTERRUPTED_SENTENCE[lane]
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function steerCutVerdict(notice, messageId) {
+    let code;
+    try {
+        if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+            return 'not_a_cut';
+        code = ownSeat(notice, 'code');
+    }
+    catch {
+        return 'not_a_cut';
+    }
+    if (code !== 'task.turn_interrupted')
+        return 'not_a_cut';
+    const facts = readTurnInterrupted(notice);
+    if (facts === undefined || facts.lane === 'unrecognized')
+        return 'unattributed';
+    if (facts.lane === 'user_halt')
+        return 'user_halt';
+    if (typeof messageId !== 'string' || messageId.length === 0 || facts.inputId === undefined)
+        return 'unattributed';
+    return facts.inputId === messageId ? 'this_input' : 'other_input';
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -663,6 +733,7 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'task.tool_turn_incomplete': readToolTurnIncomplete,
     'task.user_steer_undrained': readUserInputUndrained,
     'task.user_followup_undrained': readUserInputUndrained,
+    'task.turn_interrupted': readTurnInterrupted,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;

package/dist/executionLaneCapability.js

@@ -64,6 +64,8 @@ export function observedExecutionLane(baseUrl = engineWireTarget()?.baseUrl) {
 export function toolsRunHereFromExecutionLane(reading, legacyInference) {
     if (reading.kind === 'present')
         return reading.view.toolsOnThisHost;
+    if (reading.kind === 'not_reported')
+        return false;
     return legacyInference;
 }
 export function noOsSandboxOnThisHost(reading) {

package/dist/gateOutcome.js

@@ -1,6 +1,6 @@
 import { ccToolDenialKindForSettledBy, isCcToolDenialKind, isGateDeniedByWord } from './gateVocabulary.js';
 import { GATE_PARKED_ERROR_CODE } from './engineErrorCodes.js';
-import { CORE_MODE_RELEASE_REASONS } from './generated/engineFactTables.js';
+import { CORE_MODE_RELEASE_REASONS, CORE_SETTLEMENT_KINDS } from './generated/engineFactTables.js';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
@@ -8,22 +8,7 @@ export const GATE_MODE_RELEASE_REASON_WORDS = CORE_MODE_RELEASE_REASONS;
 export function isGateModeReleaseReasonWord(v) {
     return typeof v === 'string' && CORE_MODE_RELEASE_REASONS.includes(v);
 }
-export const SETTLEMENT_KIND_WORDS = Object.freeze([
-    'human_allowed',
-    'human_refused',
-    'approval_window_expired',
-    'denial_limit_window_expired',
-    'park_sla_expired',
-    'no_approver',
-    'approver_unavailable',
-    'approver_error',
-    'approver_contract',
-    'presentation_failed',
-    'blanket_allow_refused',
-    'policy_allowed',
-    'policy_refused',
-    'task_aborted',
-]);
+export const SETTLEMENT_KIND_WORDS = CORE_SETTLEMENT_KINDS;
 function readWho(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))
         return undefined;

package/dist/gateVocabulary.d.ts

@@ -5,12 +5,11 @@ export type CcToolDenialKind = (typeof CC_TOOL_DENIAL_KINDS)[number];
 export declare function isCcToolDenialKind(v: unknown): v is CcToolDenialKind;
 export declare function isCcToolDenialKindADenial(v: unknown): boolean;
 export declare function ccToolDenialKindForSettledBy(settledBy: unknown): CcToolDenialKind | undefined;
-declare const RETIRED_DENIED_BY_WORDS: readonly ["plan_mode"];
-export type GateDeniedByWord = (typeof CORE_DENIED_BY_VALUES)[number] | (typeof RETIRED_DENIED_BY_WORDS)[number];
+export type GateDeniedByWord = (typeof CORE_DENIED_BY_VALUES)[number];
 export declare const GATE_DENIED_BY_WORDS: readonly GateDeniedByWord[];
 export declare function isGateDeniedByWord(v: unknown): v is GateDeniedByWord;
 export declare function gateDeniedByDetail(deniedBy: unknown): string;
-export declare function askOriginDetail(origin: unknown, message?: unknown): string;
+export declare function askOriginDetail(origin: unknown, _message?: unknown): string;
 export declare const RULE_STORE_UNREADABLE_KINDS: readonly ["store", "call"];
 export type RuleStoreUnreadableKind = (typeof RULE_STORE_UNREADABLE_KINDS)[number];
 export declare function isRuleStoreUnreadableKind(v: unknown): v is RuleStoreUnreadableKind;
@@ -19,4 +18,3 @@ export declare function mandatedApprovalDetail(): string;
 export type ApprovalMandateWord = (typeof APPROVAL_MANDATE_WORDS)[number];
 export declare function isApprovalMandateWord(v: unknown): v is ApprovalMandateWord;
 export declare function approvalMandateDetail(word: ApprovalMandateWord): string;
-export {};

package/dist/gateVocabulary.js

@@ -21,8 +21,7 @@ export function ccToolDenialKindForSettledBy(settledBy) {
         return 'permission-rule';
     return undefined;
 }
-const RETIRED_DENIED_BY_WORDS = Object.freeze(['plan_mode']);
-export const GATE_DENIED_BY_WORDS = Object.freeze([...CORE_DENIED_BY_VALUES, ...RETIRED_DENIED_BY_WORDS]);
+export const GATE_DENIED_BY_WORDS = Object.freeze([...CORE_DENIED_BY_VALUES]);
 const _deniedByWordsPin = true;
 void _deniedByWordsPin;
 const DENIED_BY_SENTENCES = Object.freeze({
@@ -31,7 +30,6 @@ const DENIED_BY_SENTENCES = Object.freeze({
     org: 'denied by an organization rule',
     persisted_rule: 'denied by a persisted rule',
     classifier: 'denied by the auto-mode classifier',
-    plan_mode: 'denied because plan mode only allows reads',
     compliance: 'denied by a compliance lock',
     write_protection: 'denied because the write landed on a write-protected path',
     ask_resolution: 'denied when the approval was resolved',
@@ -46,7 +44,7 @@ export function gateDeniedByDetail(deniedBy) {
         return DENIED_BY_SENTENCES[deniedBy];
     }
     const word = typeof deniedBy === 'string' && deniedBy.length > 0 ? deniedBy : '(none)';
-    return `denied by a layer this build does not know (${word}) — this build does not know this layer name: a newer engine may have added it, or the record may be damaged; this client cannot tell which`;
+    return `denied by a layer this build does not know (${word}) — this build does not know this layer name, so it cannot say which layer refused this call or why`;
 }
 const ASK_ORIGIN_SENTENCES = Object.freeze({
     content_question: 'the tool itself asked you a question',
@@ -61,16 +59,10 @@ const ASK_ORIGIN_SENTENCES = Object.freeze({
     safety_tighten: 'the gate tightened on this call’s own facts (network egress, irreversibility, or a protected write)',
     policy: 'this deployment’s permission policy asks about this call',
 });
-const ORIGIN_PREFERS_ENGINE_MESSAGE = new Set(['rule_store_unavailable']);
-export function askOriginDetail(origin, message) {
+export function askOriginDetail(origin, _message) {
     const known = typeof origin === 'string' && Object.hasOwn(ASK_ORIGIN_SENTENCES, origin)
         ? ASK_ORIGIN_SENTENCES[origin]
         : undefined;
-    if (typeof origin === 'string' && ORIGIN_PREFERS_ENGINE_MESSAGE.has(origin)) {
-        const spoken = typeof message === 'string' ? message.trim() : '';
-        if (spoken.length > 0)
-            return spoken;
-    }
     if (known !== undefined)
         return known;
     const word = typeof origin === 'string' && origin.length > 0 ? origin : '(none)';

package/dist/generated/engineFactTables.d.ts

@@ -10,3 +10,30 @@ export declare const CORE_ENGINE_CARD_TYPES: readonly string[];
 export declare const CORE_TOOL_DECLARATION_CODES: readonly string[];
 export declare const CORE_MODE_RELEASE_REASONS: readonly ["rule_unreadable"];
 export declare const CORE_HOOK_TOOL_ALIASES: Readonly<Record<string, string>>;
+export declare const CORE_ASK_EVIDENCE_ABSENCE_VALUES: readonly ["not_wired", "not_adjudicated", "unavailable", "no_match", "not_reported"];
+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 interface CoreModeArbitrationRow {
+    readonly bypassImmune: boolean;
+    readonly classifierEligible: boolean;
+    readonly sandboxAdmission: boolean;
+    readonly ruleMayClear: boolean;
+    readonly hookAskFloor: boolean;
+}
+export declare const CORE_MODE_ARBITRATION: Readonly<Record<"content_question" | "hook" | "ancestor" | "unverifiable_delete" | "transcript_write" | "org_rule" | "governance_unavailable" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "write_protection_unresolved" | "probe" | "write_protection" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "mode" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
+export declare const CORE_SKILL_GRANT_ORIGINS: readonly ["model", "user", "inherited"];
+export declare const CORE_ALLOW_ENTRY_INERT_REASONS: readonly ["wildcard_all", "namespace_wildcard", "path_pattern", "domain", "content_unsupported", "grammar"];
+export declare const CORE_ALLOW_RULE_MEMBERS: readonly ["hook", "deployment", "persisted", "skill", "request"];
+export declare const CORE_RULE_TOOL_NAME_VERDICTS: readonly ["current", "retired", "unprefixed_namespace"];
+export declare const CORE_SETTLEMENT_KINDS: readonly ["human_allowed", "human_refused", "approval_window_expired", "denial_limit_window_expired", "park_sla_expired", "no_approver", "approver_unavailable", "approver_error", "approver_contract", "presentation_failed", "blanket_allow_refused", "policy_allowed", "policy_refused", "task_aborted"];
+export declare const CORE_CLASSIFIER_DENY_CAUSES: readonly ["unavailable", "parse_error"];
+export declare const CORE_AUTO_MODE_UNAVAILABLE_CAUSES: readonly ["error", "timeout"];
+export declare const CORE_DEFAULT_TIER_ORDER: readonly ["ultra", "max", "pro", "flash", "lite"];
+export declare const CORE_CC_MODEL_TIER_ALIASES: Readonly<Record<"fable" | "mythos" | "opus" | "sonnet" | "haiku", (typeof CORE_DEFAULT_TIER_ORDER)[number]>>;
+export declare const CORE_DURABLE_AGENT_HANDLE_RE: RegExp;
+export declare const CORE_PERMISSION_MODE_CLASSES: readonly ["bypass", "prompting"];
+export declare const CORE_MCP_LIVENESS_STATES: readonly ["reachable", "unreachable", "unknown"];
+export declare const CORE_RULE_BEHAVIORS: readonly ["deny", "ask", "allow"];
+export declare const CORE_MCP_IMAGE_MAX_BASE64: number;
+export declare const CORE_MAX_PENDING_STEER_CHARS: number;

package/dist/generated/engineFactTables.js

@@ -117,3 +117,131 @@ export const CORE_MODE_RELEASE_REASONS = Object.freeze([
 export const CORE_HOOK_TOOL_ALIASES = Object.freeze(Object.assign(Object.create(null), Object.fromEntries([
     ["ListPeers", "ListAgents"],
 ])));
+export const CORE_ASK_EVIDENCE_ABSENCE_VALUES = Object.freeze([
+    "not_wired",
+    "not_adjudicated",
+    "unavailable",
+    "no_match",
+    "not_reported",
+]);
+export const CORE_SYSTEM_INJECTION_PRIORITIES = Object.freeze([
+    "now",
+    "next",
+    "later",
+]);
+export const CORE_READ_DENY_BUILTIN_TIERS = Object.freeze([
+    "credentials",
+    "shell-history",
+    "browser",
+    "wallet",
+    "agent-config",
+]);
+export const CORE_READ_DENY_DEFAULT_TIERS = Object.freeze([
+    "credentials",
+    "agent-config",
+]);
+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 }),
+    "ancestor": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "unverifiable_delete": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "transcript_write": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "org_rule": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "governance_unavailable": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "rule_unreadable": Object.freeze({ bypassImmune: false, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "ask_rule": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "denial_limit_fallback": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "requires_user_interaction": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "operator_forced": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: false }),
+    "shell_floor": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: false }),
+    "write_protection_unresolved": Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: true }),
+    "probe": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "write_protection": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: true }),
+    "tool_marks_mcp": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: false }),
+    "tool_marks_a2a": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: false, hookAskFloor: false }),
+    "policy_rra": Object.freeze({ bypassImmune: true, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "artifact_shared_read": Object.freeze({ bypassImmune: false, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true }),
+    "mode": Object.freeze({ bypassImmune: false, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false }),
+    "unstated": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: true, hookAskFloor: false }),
+    "ordinary": Object.freeze({ bypassImmune: false, classifierEligible: true, sandboxAdmission: true, ruleMayClear: true, hookAskFloor: false }),
+});
+export const CORE_SKILL_GRANT_ORIGINS = Object.freeze([
+    "model",
+    "user",
+    "inherited",
+]);
+export const CORE_ALLOW_ENTRY_INERT_REASONS = Object.freeze([
+    "wildcard_all",
+    "namespace_wildcard",
+    "path_pattern",
+    "domain",
+    "content_unsupported",
+    "grammar",
+]);
+export const CORE_ALLOW_RULE_MEMBERS = Object.freeze([
+    "hook",
+    "deployment",
+    "persisted",
+    "skill",
+    "request",
+]);
+export const CORE_RULE_TOOL_NAME_VERDICTS = Object.freeze([
+    "current",
+    "retired",
+    "unprefixed_namespace",
+]);
+export const CORE_SETTLEMENT_KINDS = Object.freeze([
+    "human_allowed",
+    "human_refused",
+    "approval_window_expired",
+    "denial_limit_window_expired",
+    "park_sla_expired",
+    "no_approver",
+    "approver_unavailable",
+    "approver_error",
+    "approver_contract",
+    "presentation_failed",
+    "blanket_allow_refused",
+    "policy_allowed",
+    "policy_refused",
+    "task_aborted",
+]);
+export const CORE_CLASSIFIER_DENY_CAUSES = Object.freeze([
+    "unavailable",
+    "parse_error",
+]);
+export const CORE_AUTO_MODE_UNAVAILABLE_CAUSES = Object.freeze([
+    "error",
+    "timeout",
+]);
+export const CORE_DEFAULT_TIER_ORDER = Object.freeze([
+    "ultra",
+    "max",
+    "pro",
+    "flash",
+    "lite",
+]);
+export const CORE_CC_MODEL_TIER_ALIASES = Object.freeze({
+    "fable": "max",
+    "mythos": "max",
+    "opus": "pro",
+    "sonnet": "flash",
+    "haiku": "lite",
+});
+export const CORE_DURABLE_AGENT_HANDLE_RE = Object.freeze(/^a[0-9a-f]{6,32}$/);
+export const CORE_PERMISSION_MODE_CLASSES = Object.freeze([
+    "bypass",
+    "prompting",
+]);
+export const CORE_MCP_LIVENESS_STATES = Object.freeze([
+    "reachable",
+    "unreachable",
+    "unknown",
+]);
+export const CORE_RULE_BEHAVIORS = Object.freeze([
+    "deny",
+    "ask",
+    "allow",
+]);
+export const CORE_MCP_IMAGE_MAX_BASE64 = 5242880;
+export const CORE_MAX_PENDING_STEER_CHARS = 16000;

package/dist/generated/engineNoticeTables.js

@@ -28,6 +28,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "permission.ask_released_by_mode",
     "permission.read_deny_unapplied",
     "permission.rule_store_unavailable",
+    "permission.allowed_tool_not_granted",
     "peer.inbound_disposition",
     "peer.held_settled",
     "peer.idle_subscription",
@@ -115,6 +116,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "permission.ask_released_by_mode": "user",
     "permission.read_deny_unapplied": "user",
     "permission.rule_store_unavailable": "user",
+    "permission.allowed_tool_not_granted": "user",
     "peer.inbound_disposition": "user",
     "peer.held_settled": "user",
     "peer.idle_subscription": "user",
@@ -208,6 +210,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "permission.ask_released_by_mode": "engine",
     "permission.read_deny_unapplied": "engine",
     "permission.rule_store_unavailable": "engine",
+    "permission.allowed_tool_not_granted": "engine",
     "peer.inbound_disposition": "engine",
     "peer.held_settled": "engine",
     "peer.idle_subscription": "engine",

package/dist/generated/settingsSchemaTables.d.ts

@@ -0,0 +1,8 @@
+export declare const SETTINGS_ENGINE_OWNED_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PreCompact", "PostCompact", "Stop", "StopFailure", "UserPromptSubmit"];
+export declare const SETTINGS_SECRET_LITERAL_RE: RegExp;
+export declare const SETTINGS_TIER_GROUP_NAME_RE: RegExp;
+export declare const SETTINGS_BUDGET_NUMBER_KEYS: readonly ["maxBudgetUsd", "tpmLimit", "rpmLimit", "maxParallelRequests", "maxRunCostUsd", "maxIterations"];
+export declare const SETTINGS_BUDGET_STRING_KEYS: readonly ["mode", "budgetDuration", "enforcement"];
+export declare const SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS: readonly ["maxBudgetUsd", "tpmLimit", "rpmLimit"];
+export declare const SETTINGS_MODEL_API_WORDS: readonly ["openai-completions", "anthropic-messages"];
+export declare const SETTINGS_TOOL_NAME_MATCHER_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure"];

package/dist/generated/settingsSchemaTables.js

@@ -0,0 +1,40 @@
+export const SETTINGS_ENGINE_OWNED_HOOK_EVENTS = Object.freeze([
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "PreCompact",
+    "PostCompact",
+    "Stop",
+    "StopFailure",
+    "UserPromptSubmit",
+]);
+export const SETTINGS_SECRET_LITERAL_RE = Object.freeze(/^(sk-|gh[opus]_|github_pat_|xox[baprse]-|xapp-|bearer\s|basic\s|eyJ[A-Za-z0-9_-]{10,}\.|AKIA[0-9A-Z]{12,}|AIza[0-9A-Za-z_-]{20,}|-----BEGIN[A-Z0-9 ]*PRIVATE KEY)/i);
+export const SETTINGS_TIER_GROUP_NAME_RE = Object.freeze(/^[a-z0-9][a-z0-9._-]*$/i);
+export const SETTINGS_BUDGET_NUMBER_KEYS = Object.freeze([
+    "maxBudgetUsd",
+    "tpmLimit",
+    "rpmLimit",
+    "maxParallelRequests",
+    "maxRunCostUsd",
+    "maxIterations",
+]);
+export const SETTINGS_BUDGET_STRING_KEYS = Object.freeze([
+    "mode",
+    "budgetDuration",
+    "enforcement",
+]);
+export const SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS = Object.freeze([
+    "maxBudgetUsd",
+    "tpmLimit",
+    "rpmLimit",
+]);
+export const SETTINGS_MODEL_API_WORDS = Object.freeze([
+    "openai-completions",
+    "anthropic-messages",
+]);
+export const SETTINGS_TOOL_NAME_MATCHER_EVENTS = Object.freeze([
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+]);

package/dist/hitl/allowRuleShadow.d.ts

@@ -0,0 +1,21 @@
+export interface ApprovalAllowRuleShadowMember {
+    readonly member?: string;
+    readonly known: boolean;
+    readonly entries?: readonly string[];
+    readonly omitted?: number;
+    readonly malformed?: true;
+}
+export interface AllowRuleShadowedWireMember {
+    readonly member: string;
+    readonly entries: readonly string[];
+    readonly omitted?: number;
+}
+export interface ApprovalAllowRuleShadow {
+    readonly source: 'allow_rule_shadowed' | 'legacy_shadowed_rule';
+    readonly members: readonly ApprovalAllowRuleShadowMember[];
+    readonly unreadable?: true;
+}
+export declare function readAllowRuleShadowFromWire(carrier: object | null | undefined, leg: 'frame' | 'row'): ApprovalAllowRuleShadow | undefined;
+export declare function readApprovalAllowRuleShadow(card: object | null | undefined): ApprovalAllowRuleShadow | undefined;
+export declare function approvalAllowRuleShadowed(card: object | null | undefined): boolean;
+export declare function legacyShadowedRuleTextOf(r: ApprovalAllowRuleShadow | undefined): string | undefined;

package/dist/hitl/allowRuleShadow.js

@@ -0,0 +1,167 @@
+import { CORE_ALLOW_RULE_MEMBERS } from '../generated/engineFactTables.js';
+const KNOWN_MEMBERS = new Set(CORE_ALLOW_RULE_MEMBERS);
+function freezeMember(m) {
+    return Object.freeze({ ...m });
+}
+function unreadable() {
+    return Object.freeze({ source: 'allow_rule_shadowed', members: Object.freeze([]), unreadable: true });
+}
+function readMemberRecord(r) {
+    if (typeof r !== 'object' || r === null || Array.isArray(r))
+        return freezeMember({ known: false, malformed: true });
+    let malformed = false;
+    const rawMember = Object.hasOwn(r, 'member') ? r.member : undefined;
+    const member = typeof rawMember === 'string' && rawMember !== '' ? rawMember : undefined;
+    if (member === undefined)
+        malformed = true;
+    let entries;
+    const rawEntries = Object.hasOwn(r, 'entries') ? r.entries : undefined;
+    if (Array.isArray(rawEntries)) {
+        const length = rawEntries.length;
+        if (typeof length === 'number' && Number.isSafeInteger(length) && length >= 0) {
+            const out = [];
+            let ok = true;
+            for (let i = 0; i < length; i++) {
+                const d = Object.getOwnPropertyDescriptor(rawEntries, i);
+                if (d === undefined || !('value' in d)) {
+                    ok = false;
+                    break;
+                }
+                const e = d.value;
+                if (typeof e !== 'string') {
+                    ok = false;
+                    break;
+                }
+                out.push(e);
+            }
+            if (ok && rawEntries.length === length)
+                entries = Object.freeze(out);
+            else
+                malformed = true;
+        }
+        else
+            malformed = true;
+    }
+    else
+        malformed = true;
+    let omitted;
+    if (Object.hasOwn(r, 'omitted')) {
+        const o = r.omitted;
+        if (typeof o === 'number' && Number.isSafeInteger(o) && o > 0)
+            omitted = o;
+        else if (o !== undefined)
+            malformed = true;
+    }
+    return freezeMember({
+        ...(member !== undefined ? { member } : {}),
+        known: member !== undefined && KNOWN_MEMBERS.has(member),
+        ...(entries !== undefined ? { entries } : {}),
+        ...(omitted !== undefined ? { omitted } : {}),
+        ...(malformed ? { malformed: true } : {}),
+    });
+}
+function readNewKeyValue(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw))
+        return unreadable();
+    const length = raw.length;
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length <= 0)
+        return unreadable();
+    const members = [];
+    for (let i = 0; i < length; i++)
+        members.push(readMemberAt(raw, i));
+    if (raw.length !== length)
+        return unreadable();
+    return Object.freeze({ source: 'allow_rule_shadowed', members: Object.freeze(members) });
+}
+function readLegacyValue(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return undefined;
+    return Object.freeze({
+        source: 'legacy_shadowed_rule',
+        members: Object.freeze([freezeMember({ member: 'persisted', known: true, entries: Object.freeze([raw]) })]),
+    });
+}
+function ownValue(v, key) {
+    return Object.hasOwn(v, key) ? v[key] : undefined;
+}
+function keyValue(v, key) {
+    return v[key];
+}
+function readMemberAt(arr, i) {
+    const d = Object.getOwnPropertyDescriptor(arr, i);
+    return d !== undefined && 'value' in d ? readMemberRecord(d.value) : freezeMember({ known: false, malformed: true });
+}
+export function readAllowRuleShadowFromWire(carrier, leg) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null)
+            return undefined;
+        let host = carrier;
+        if (leg === 'row') {
+            const rd = keyValue(carrier, 'riskDescriptor');
+            host = typeof rd === 'object' && rd !== null ? rd : undefined;
+        }
+        if (host === undefined)
+            return undefined;
+        const fresh = readNewKeyValue(keyValue(host, 'allowRuleShadowed'));
+        if (fresh !== undefined)
+            return fresh;
+        return readLegacyValue(keyValue(host, leg === 'row' ? 'shadowedRule' : 'persistedRuleShadowed'));
+    }
+    catch {
+        return unreadable();
+    }
+}
+function readStampedValue(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return unreadable();
+    const source = ownValue(raw, 'source');
+    const members = ownValue(raw, 'members');
+    if ((source !== 'allow_rule_shadowed' && source !== 'legacy_shadowed_rule') || !Array.isArray(members))
+        return unreadable();
+    const length = members.length;
+    if (typeof length !== 'number' || !Number.isSafeInteger(length))
+        return unreadable();
+    const out = [];
+    for (let i = 0; i < length; i++) {
+        const r = readMemberAt(members, i);
+        const d = Object.getOwnPropertyDescriptor(members, i);
+        const was = d !== undefined && 'value' in d && typeof d.value === 'object' && d.value !== null && d.value.malformed === true;
+        out.push(was && r.malformed !== true ? freezeMember({ ...r, malformed: true }) : r);
+    }
+    if (members.length !== length)
+        return unreadable();
+    return Object.freeze({
+        source,
+        members: Object.freeze(out),
+        ...(ownValue(raw, 'unreadable') === true || out.length === 0 ? { unreadable: true } : {}),
+    });
+}
+export function readApprovalAllowRuleShadow(card) {
+    try {
+        if (typeof card !== 'object' || card === null)
+            return undefined;
+        const stamped = keyValue(card, 'allowRuleShadow');
+        if (stamped !== undefined)
+            return readStampedValue(stamped);
+        return readAllowRuleShadowFromWire(card, 'frame');
+    }
+    catch {
+        return unreadable();
+    }
+}
+export function approvalAllowRuleShadowed(card) {
+    return readApprovalAllowRuleShadow(card) !== undefined;
+}
+export function legacyShadowedRuleTextOf(r) {
+    if (r === undefined)
+        return undefined;
+    for (const m of r.members) {
+        if (m.member !== 'persisted' || m.entries === undefined)
+            continue;
+        const first = m.entries[0];
+        return typeof first === 'string' && first.trim() !== '' ? first : undefined;
+    }
+    return undefined;
+}

package/dist/hitl/askClassPair.d.ts

@@ -0,0 +1,14 @@
+export type AskClassPairReading = {
+    readonly state: 'pair';
+    readonly askClass: string;
+    readonly classes: readonly string[];
+} | {
+    readonly state: 'absent';
+} | {
+    readonly state: 'malformed';
+};
+export declare function readAskClassPairState(v: object | null | undefined): AskClassPairReading;
+export declare function readAskClassPair(v: object | null | undefined): {
+    askClass: string;
+    classes: readonly string[];
+} | undefined;