@sema-agent/client-core 0.91.0 → 0.92.0

package/dist/engineErrorCodes.d.ts

@@ -14,6 +14,8 @@ export declare const CONFIG_DELEGATION_ENTRY_CAPS = "config.delegation_entry_cap
 export declare const CONFIG_MEMORY_PROJECT_KEY_SPELLING = "config.memory_project_key_spelling";
 export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_scope_mismatch";
 export declare const CONFIG_LEGACY_TOOL_NAME = "config.legacy_tool_name";
+export declare const CONFIG_IMAGE_INVALID = "config.image_invalid";
+export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;
 export declare const CONFIG_REFUSAL_CODES: ReadonlySet<string>;
 export declare const RULES_LEGACY_TOOL_NAME = "rules.legacy_tool_name";
 export declare function isRulesRefusalCode(code: string | undefined): boolean;
@@ -69,6 +71,18 @@ export declare const DECIDE_GATE_MOVED = "decide.gate_moved";
 export declare const DECIDE_CLAIM_LOST = "decide.claim_lost";
 export declare const DECIDE_PARK_MOVED_CODES: readonly string[];
 export declare function isDecideParkMovedCode(code: string | null | undefined): boolean;
+export declare const ASK_GONE = "gone.ask";
+export declare const ASK_GONE_DENIED_WORD = "routing_failure_fail_closed";
+export declare const RUN_STALLED = "run.stalled";
+export declare const RUN_ORPHANED = "run.orphaned";
+export declare const APPROVAL_EXPIRED = "approval.expired";
+export declare const RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
+export type RunDeathVerdictCode = (typeof RUN_DEATH_VERDICT_CODES)[number];
+export declare function runDeathVerdictNoteOf(code: string | undefined): string | undefined;
+export declare const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = "capability.operator_principals_required";
+export declare function isUnavailableFaceCode(code: string | undefined): boolean;
+export type OperatorGateRefusal = 'operator_only' | 'operators_unconfigured';
+export declare function operatorGateRefusalContent(cause: OperatorGateRefusal): string | undefined;
 export declare const WORKFLOW_PARK_REFUSAL_CODES: readonly string[];
 export declare function isWorkflowParkRefusalCode(code: unknown): boolean;
 export declare const DRAINING_ERROR_CODE = "draining";

package/dist/engineErrorCodes.js

@@ -19,6 +19,12 @@ export const CONFIG_DELEGATION_ENTRY_CAPS = 'config.delegation_entry_caps';
 export const CONFIG_MEMORY_PROJECT_KEY_SPELLING = 'config.memory_project_key_spelling';
 export const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = 'config.memory_write_scope_mismatch';
 export const CONFIG_LEGACY_TOOL_NAME = 'config.legacy_tool_name';
+export const CONFIG_IMAGE_INVALID = 'config.image_invalid';
+const IMAGE_INVALID_FAILURE_NOTE = 'This run did not start: an image sent with the message was refused before the model was called — the engine’s own error text says which image and what is wrong with it. ' +
+    'Nothing was sent to the model; remove or replace that image, then send the message again.';
+export function imageInvalidFailureNoteOf(code) {
+    return code === CONFIG_IMAGE_INVALID ? IMAGE_INVALID_FAILURE_NOTE : undefined;
+}
 export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_LIMIT_INVALID,
     CONFIG_STRATEGY_FIND_LIMIT_INVALID,
@@ -28,6 +34,7 @@ export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_MEMORY_PROJECT_KEY_SPELLING,
     CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
     CONFIG_LEGACY_TOOL_NAME,
+    CONFIG_IMAGE_INVALID,
     ...CORE_TOOL_DECLARATION_CODES,
 ]);
 export const RULES_LEGACY_TOOL_NAME = 'rules.legacy_tool_name';
@@ -149,6 +156,36 @@ export const DECIDE_PARK_MOVED_CODES = Object.freeze([
 export function isDecideParkMovedCode(code) {
     return typeof code === 'string' && DECIDE_PARK_MOVED_CODES.includes(code);
 }
+export const ASK_GONE = 'gone.ask';
+export const ASK_GONE_DENIED_WORD = 'routing_failure_fail_closed';
+export const RUN_STALLED = 'run.stalled';
+export const RUN_ORPHANED = 'run.orphaned';
+export const APPROVAL_EXPIRED = 'approval.expired';
+export const RUN_DEATH_VERDICT_CODES = Object.freeze([RUN_STALLED, RUN_ORPHANED, APPROVAL_EXPIRED]);
+const RUN_HOLDER_LOST_NOTE = 'This run ended because the engine process that was running it went away (it was restarted, or stopped answering) before the run finished. ' +
+    'The request itself was not at fault, but this run cannot be picked up again; submit the work again as a new task.';
+const RUN_APPROVAL_EXPIRED_NOTE = 'This run ended because it was waiting on an approval for too long and the engine retired it. ' +
+    'The request itself was not at fault, but this run cannot be picked up again; submit the work again as a new task, and it will ask for the approval again.';
+export function runDeathVerdictNoteOf(code) {
+    if (code === RUN_STALLED || code === RUN_ORPHANED)
+        return RUN_HOLDER_LOST_NOTE;
+    if (code === APPROVAL_EXPIRED)
+        return RUN_APPROVAL_EXPIRED_NOTE;
+    return undefined;
+}
+export const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = 'capability.operator_principals_required';
+export function isUnavailableFaceCode(code) {
+    return typeof code === 'string' && (code.startsWith('capability.') || code.startsWith('feature.'));
+}
+export function operatorGateRefusalContent(cause) {
+    if (cause === 'operator_only') {
+        return 'Nothing was done: this is an operator-only action and the caller is not one of this deployment’s operators.';
+    }
+    if (cause === 'operators_unconfigured') {
+        return 'Nothing was done: this is an operator-only action and this deployment has no operators configured, so no caller can perform it here — whoever runs the deployment has to name its operators first.';
+    }
+    return undefined;
+}
 const WORKFLOW_PARK_TRUTH_UNREADABLE = 'workflow.park_truth_unreadable';
 const WORKFLOW_PARK_NOT_PENDING = 'workflow.park_not_pending';
 const WORKFLOW_PARK_BINDING_BROKEN = 'workflow.park_binding_broken';

package/dist/engineNoticeCodes.d.ts

@@ -169,6 +169,19 @@ export interface UserInputUndrainedFactsView {
 }
 export declare function readUserInputUndrained(notice: unknown): UserInputUndrainedFactsView | undefined;
 export declare function userInputUndrainedNotice(facts: Pick<UserInputUndrainedFactsView, 'kind' | 'count' | 'cause' | 'childSessionId'>): string | undefined;
+export interface TurnInterruptedFactsView {
+    lane: 'input_now' | 'user_halt' | 'unrecognized';
+    inputId?: string;
+    cause?: string;
+    sessionId?: string;
+    runId?: string;
+    taskId?: string;
+    actorId?: string;
+}
+export declare function readTurnInterrupted(notice: unknown): TurnInterruptedFactsView | undefined;
+export declare function turnInterruptedNotice(facts: Pick<TurnInterruptedFactsView, 'lane'>): string | undefined;
+export type SteerCutVerdict = 'this_input' | 'other_input' | 'user_halt' | 'unattributed' | 'not_a_cut';
+export declare function steerCutVerdict(notice: unknown, messageId: string | undefined): SteerCutVerdict;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -189,6 +202,7 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'task.tool_turn_incomplete': typeof readToolTurnIncomplete;
     readonly 'task.user_steer_undrained': typeof readUserInputUndrained;
     readonly 'task.user_followup_undrained': typeof readUserInputUndrained;
+    readonly 'task.turn_interrupted': typeof readTurnInterrupted;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;

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

@@ -21,4 +21,19 @@ export interface CoreModeArbitrationRow {
     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" | "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_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

@@ -151,6 +151,7 @@ export const CORE_MODE_ARBITRATION = Object.freeze({
     "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 }),
@@ -164,3 +165,83 @@ export const CORE_MODE_ARBITRATION = Object.freeze({
     "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;