@sema-agent/client-core 0.91.0 → 0.93.0

package/dist/engineNoticeCodes.d.ts

@@ -1,4 +1,4 @@
-import { CORE_TOOL_TURN_INCOMPLETE_CAUSES, CORE_USER_STEER_UNDRAINED_CAUSES } from './generated/engineNoticeTables.js';
+import { CORE_TOOL_TURN_INCOMPLETE_CAUSES, CORE_USER_INPUT_UNDRAINED_CAUSES } from './generated/engineNoticeTables.js';
 export type NoticeAudience = 'user' | 'operator';
 export declare const ENGINE_NOTICE_CODES: readonly string[];
 export declare function engineNoticeInCatalog(code: unknown): boolean;
@@ -157,7 +157,7 @@ export interface ToolTurnIncompleteFactsView {
     runId: string;
 }
 export declare function readToolTurnIncomplete(notice: unknown): ToolTurnIncompleteFactsView | undefined;
-export type UserSteerUndrainedCause = (typeof CORE_USER_STEER_UNDRAINED_CAUSES)[number];
+export type UserSteerUndrainedCause = (typeof CORE_USER_INPUT_UNDRAINED_CAUSES)[number];
 export interface UserInputUndrainedFactsView {
     kind: 'steer' | 'followUp';
     count: number;
@@ -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/engineWireFor.d.ts

@@ -41,4 +41,26 @@ export declare function noAnswerKindOf(e: object | null | undefined): EngineWire
 export declare function noAnswerDetailFrom(e: object | null | undefined): string | null;
 export declare function sendOnce<T>(signal: AbortSignal | null | undefined, run: () => Promise<T>): Promise<T>;
 export declare function provablyNotSent(e: object | null | undefined): boolean;
+export interface TransportFailureSocket {
+    readonly localPort?: number;
+    readonly remotePort?: number;
+    readonly bytesWritten?: number;
+    readonly bytesRead?: number;
+}
+export interface TransportFailureLayer {
+    readonly name?: string;
+    readonly code?: string;
+    readonly errno?: number;
+    readonly syscall?: string;
+    readonly socket?: TransportFailureSocket;
+}
+export type TransportFailureChainEnd = 'complete' | 'depth_cap' | 'cycle' | 'unreadable';
+export interface TransportFailureScene {
+    readonly layers: ReadonlyArray<TransportFailureLayer>;
+    readonly end: TransportFailureChainEnd;
+    readonly status?: number;
+    readonly provablyNotSent: boolean;
+    readonly noAnswer: EngineWireNoAnswerKind | null;
+}
+export declare function transportFailureScene(error: unknown): TransportFailureScene;
 export declare function settleInjected<T>(ms: number, signal: AbortSignal | null | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/engineWireFor.js

@@ -206,19 +206,33 @@ function allAttemptsFailedBeforeSend(errors) {
         return false;
     return errors.every((x) => x !== null && typeof x === 'object' && isPreSendCode(x.code, x.syscall));
 }
-function failedBeforeSend(e) {
+const CAUSE_CHAIN_MAX_LAYERS = 4;
+function walkCauseChain(e, visit) {
     let cur = e;
-    for (let depth = 0; depth < 4 && cur !== null && typeof cur === 'object'; depth++) {
-        const o = cur;
-        if (isPreSendCode(o.code, o.syscall))
-            return true;
-        if (allAttemptsFailedBeforeSend(o.errors))
-            return true;
+    for (let depth = 0; depth < CAUSE_CHAIN_MAX_LAYERS && cur !== null && typeof cur === 'object'; depth++) {
+        if (visit(cur, depth) === 'stop')
+            return { stopped: true };
         cur = cur.cause;
     }
-    return false;
+    return { stopped: false, end: cur !== null && typeof cur === 'object' ? 'depth_cap' : 'complete' };
+}
+function readLayerEvidence(layer) {
+    const o = layer;
+    const code = o.code;
+    const syscall = o.syscall;
+    if (isPreSendCode(code, syscall))
+        return { proof: 'code', code, syscall };
+    if (allAttemptsFailedBeforeSend(o.errors))
+        return { proof: 'attempts', code, syscall };
+    return { proof: null, code, syscall };
+}
+function failedBeforeSend(e) {
+    return walkCauseChain(e, (layer) => (readLayerEvidence(layer).proof !== null ? 'stop' : undefined)).stopped;
 }
 export function noAnswerKindOf(e) {
+    return noAnswerKindWith(e, () => failedBeforeSend(e));
+}
+function noAnswerKindWith(e, chainProof) {
     try {
         if (e === null || typeof e !== 'object')
             return null;
@@ -231,7 +245,7 @@ export function noAnswerKindOf(e) {
         const name = e.name;
         if (name === 'TimeoutError')
             return 'time-limit';
-        if ((e instanceof TypeError || name === 'TypeError') && !failedBeforeSend(e))
+        if ((e instanceof TypeError || name === 'TypeError') && !chainProof())
             return 'connection-lost';
         return null;
     }
@@ -339,6 +353,137 @@ export function provablyNotSent(e) {
         return false;
     }
 }
+const TRANSPORT_BIT_STRING = /^[A-Za-z0-9_.:-]{1,64}$/;
+function bitString(v) {
+    return typeof v === 'string' && TRANSPORT_BIT_STRING.test(v) ? v : undefined;
+}
+function bitNumber(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+}
+function layerBitsOf(layer, onUnreadable, known) {
+    const read = (target, key) => {
+        try {
+            return target[key];
+        }
+        catch {
+            onUnreadable();
+            return undefined;
+        }
+    };
+    const name = bitString(read(layer, 'name'));
+    const code = bitString(known !== undefined ? known.code : read(layer, 'code'));
+    const errno = bitNumber(read(layer, 'errno'));
+    const syscall = bitString(known !== undefined ? known.syscall : read(layer, 'syscall'));
+    const sock = read(layer, 'socket');
+    let socket;
+    if (sock !== null && typeof sock === 'object') {
+        const localPort = bitNumber(read(sock, 'localPort'));
+        const remotePort = bitNumber(read(sock, 'remotePort'));
+        const bytesWritten = bitNumber(read(sock, 'bytesWritten'));
+        const bytesRead = bitNumber(read(sock, 'bytesRead'));
+        const counters = {
+            ...(localPort !== undefined ? { localPort } : {}),
+            ...(remotePort !== undefined ? { remotePort } : {}),
+            ...(bytesWritten !== undefined ? { bytesWritten } : {}),
+            ...(bytesRead !== undefined ? { bytesRead } : {}),
+        };
+        if (Object.keys(counters).length > 0)
+            socket = Object.freeze(counters);
+    }
+    return Object.freeze({
+        ...(name !== undefined ? { name } : {}),
+        ...(code !== undefined ? { code } : {}),
+        ...(errno !== undefined ? { errno } : {}),
+        ...(syscall !== undefined ? { syscall } : {}),
+        ...(socket !== undefined ? { socket } : {}),
+    });
+}
+export function transportFailureScene(error) {
+    const layers = [];
+    const seen = [];
+    let unreadable = false;
+    const markUnreadable = () => {
+        unreadable = true;
+    };
+    let cycleSeen = false;
+    let marked = false;
+    let blocked = false;
+    let proven = false;
+    let aborted = false;
+    let end = 'complete';
+    let walked = false;
+    const walk = () => {
+        if (walked)
+            return;
+        walked = true;
+        try {
+            const result = walkCauseChain(error, (layer) => {
+                const revisit = seen.includes(layer);
+                if (revisit)
+                    cycleSeen = true;
+                else
+                    seen.push(layer);
+                let known;
+                if (!proven) {
+                    try {
+                        const evidence = readLayerEvidence(layer);
+                        known = { code: evidence.code, syscall: evidence.syscall };
+                        if (evidence.proof !== null)
+                            proven = true;
+                    }
+                    catch {
+                        unreadable = true;
+                        aborted = true;
+                        if (!revisit)
+                            layers.push(layerBitsOf(layer, markUnreadable, undefined));
+                        return 'stop';
+                    }
+                }
+                if (!revisit)
+                    layers.push(layerBitsOf(layer, markUnreadable, known));
+                return undefined;
+            });
+            if (!result.stopped)
+                end = result.end;
+        }
+        catch {
+            unreadable = true;
+            aborted = true;
+        }
+    };
+    const failedBefore = () => {
+        walk();
+        if (aborted && !proven)
+            throw new Error('cause chain unreadable');
+        return proven;
+    };
+    let status;
+    let noAnswer = null;
+    if (error !== null && typeof error === 'object') {
+        try {
+            marked = markedNotSent(error);
+        }
+        catch {
+            blocked = true;
+            unreadable = true;
+        }
+        noAnswer = noAnswerKindWith(error, failedBefore);
+        walk();
+        try {
+            status = bitNumber(error.status);
+        }
+        catch {
+            unreadable = true;
+        }
+    }
+    return Object.freeze({
+        layers: Object.freeze(layers),
+        end: unreadable ? 'unreadable' : cycleSeen ? 'cycle' : end,
+        ...(status !== undefined ? { status } : {}),
+        provablyNotSent: !blocked && (marked || proven),
+        noAnswer,
+    });
+}
 export function settleInjected(ms, signal, run) {
     const settled = settleInjectedOnce(ms, signal, run);
     Object.defineProperty(settled, SETTLED_BY_PACKAGE_BRAND, { value: true, enumerable: false });

package/dist/engineWireSdk.d.ts

@@ -5,7 +5,6 @@ export type WireAuthToken = string | {
 export type WireAuthTokenSource = string | (() => string | undefined);
 export declare function isLoopbackWireUrl(url: string): boolean;
 export declare function resolveWireAuth(baseUrl: string | undefined, token?: string): WireAuthToken;
-export declare function wireAuthTokenFor(baseUrl: string, token?: string): WireAuthToken;
 export type EngineProbeClient = Pick<AgentClient, 'capabilities' | 'scenarioCapabilities'>;
 export interface EngineWireInjection<C> {
     client: C;

package/dist/engineWireSdk.js

@@ -16,9 +16,6 @@ export function resolveWireAuth(baseUrl, token) {
         return { mode: 'loopback-unauthed' };
     return 'anon';
 }
-export function wireAuthTokenFor(baseUrl, token) {
-    return resolveWireAuth(baseUrl, token);
-}
 function headersToRecord(init) {
     const out = {};
     if (init === undefined)

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) {
@@ -95,9 +97,9 @@ export function executionLaneDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('execution lane not observed — the engine reports it on /v1/capabilities; ' +
-                'this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)');
+                'this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
         case 'not_reported':
-            return ('execution lane not reported by this engine — only newer engines advertise it; ' +
+            return ('execution lane not reported by this engine; ' +
                 'this does not say where tools run, so the client keeps inferring it the way it did before');
         case 'present': {
             const lane = capForDisplay(reading.view.provider, LANE_DETAIL_MAX);

package/dist/fileHistoryCaptureCapability.d.ts

@@ -6,7 +6,7 @@ export type FileHistoryCaptureReading = {
     kind: 'present';
     word: string;
 };
-export type FileHistoryCaptureMode = 'off' | 'on-always' | 'on-optional' | 'unknown';
+export type FileHistoryCaptureMode = 'off' | 'on-optional' | 'unknown';
 export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
 export declare function noteEngineCapsForFileHistoryCapture(baseUrl: string, caps: unknown, opts?: {
     generation?: number;

package/dist/fileHistoryCaptureCapability.js

@@ -43,8 +43,6 @@ export function fileHistoryCaptureMode(reading) {
         return 'off';
     if (word === 'on-optional')
         return 'on-optional';
-    if (word === 'on-always')
-        return 'on-always';
     return 'unknown';
 }
 export function fileHistoryDeclarationField(reading, captureOff) {
@@ -66,7 +64,7 @@ export function fileHistoryCaptureDoctorDetail(reading) {
     }
     switch (kind) {
         case 'not_reported':
-            return 'file history capture not reported by this engine — only newer engines advertise it; this does not say whether file history is captured here';
+            return 'file history capture not reported by this engine; this does not say whether file history is captured here';
         case 'present':
             if (typeof word !== 'string' || word.length === 0)
                 return unobserved;
@@ -76,9 +74,6 @@ export function fileHistoryCaptureDoctorDetail(reading) {
             if (word === 'on-optional') {
                 return 'file history capture on — the engine snapshots files before changing them, and a session on this deployment can opt out of capture for its own runs';
             }
-            if (word === 'on-always') {
-                return 'file history capture always on — the engine snapshots files before changing them in every session, and it cannot be turned off for a single session here';
-            }
             return `file history capture reported as "${capForDisplay(word, WORD_DETAIL_MAX)}" — a mode this client does not know yet, so whether it captures is shown as unknown`;
         default:
             return unobserved;

package/dist/fileHistoryLegNotice.d.ts

@@ -1,7 +1,7 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import { type FileHistoryCaptureReading } from './fileHistoryCaptureCapability.js';
 export type FileHistoryDeclarationFact = 'sent' | 'not_sent' | 'unknown';
-export declare const FILE_HISTORY_LEG_VERDICTS: readonly ["not_honored", "not_offered", "honored", "not_declared", "unknown"];
+export declare const FILE_HISTORY_LEG_VERDICTS: readonly ["not_honored", "honored", "not_declared", "unknown"];
 export type FileHistoryLegNoticeVerdict = (typeof FILE_HISTORY_LEG_VERDICTS)[number];
 export interface FileHistoryLegNoticeInput {
     readonly capability: FileHistoryCaptureReading;

package/dist/fileHistoryLegNotice.js

@@ -1,7 +1,7 @@
 import { fileHistoryCaptureMode } from './fileHistoryCaptureCapability.js';
 import { frameProvesDelivery } from './promptDelivery.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
-export const FILE_HISTORY_LEG_VERDICTS = Object.freeze(['not_honored', 'not_offered', 'honored', 'not_declared', 'unknown']);
+export const FILE_HISTORY_LEG_VERDICTS = Object.freeze(['not_honored', 'honored', 'not_declared', 'unknown']);
 function ownRead(o, key) {
     return Object.hasOwn(o, key) ? o[key] : undefined;
 }
@@ -31,19 +31,14 @@ export function fileHistoryLegNoticeVerdict(input) {
     if (!offByUser)
         return 'not_declared';
     const mode = fileHistoryCaptureMode(capability);
-    if (legWord === 'on' && mode === 'on-always')
-        return 'not_offered';
     if (declaration === 'not_sent' && (legWord === FILE_HISTORY_DISABLED || mode === 'on-optional'))
         return 'not_declared';
     return 'unknown';
 }
 const NOT_HONORED_SENTENCE = 'The engine is still capturing file history for this session, though your settings asked it not to.';
-const NOT_OFFERED_SENTENCE = 'This engine always captures file history and cannot turn it off per session, even though file checkpoints are off in your settings.';
 export function fileHistoryLegNoticeSentence(verdict) {
     if (verdict === 'not_honored')
         return NOT_HONORED_SENTENCE;
-    if (verdict === 'not_offered')
-        return NOT_OFFERED_SENTENCE;
     return null;
 }
 export function fileHistoryDeclarationOfBody(body) {

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,18 +5,12 @@ 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 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;
-export declare function ruleStoreUnreadableDetail(kind: RuleStoreUnreadableKind): string;
+export declare function askOriginDetail(origin: unknown): string;
 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,11 +44,11 @@ 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',
-    ancestor_marked: 'an ancestor marked this call (an inherited approver-unavailable float, or a durable mandate): it must reach the park with no synchronous decision-maker in between',
+    ancestor_marked: 'an ancestor marked this call (an inherited approver-unavailable float, or a durable mandate; this client cannot tell which from the origin alone): it must reach the park with no synchronous decision-maker in between',
     org_unavailable: 'the organization policy was unavailable, so this call asks',
     org_rule: 'an organization rule asks about this call',
     rule_store_unavailable: 'this call could not be checked against your standing deny/ask rules, so it asks',
@@ -58,42 +56,18 @@ const ASK_ORIGIN_SENTENCES = Object.freeze({
     ask_rule: 'a persisted ask rule matches this call',
     denial_limit_fallback: 'the auto-mode classifier hit its denial limit and handed this call back to you',
     shell_gate_tighten: 'the coarse shell check rates this command above the tier it lets through, so it asks',
-    safety_tighten: 'the gate tightened on this call’s own facts (network egress, irreversibility, or a protected write)',
+    safety_tighten: 'the gate tightened on this call’s own facts (network egress, irreversibility, or a protected write; this client cannot tell which from the origin alone)',
     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) {
     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)';
     return `this call asks; its origin ${word} is a word newer than this client, so answer it as usual`;
 }
-export const RULE_STORE_UNREADABLE_KINDS = Object.freeze(['store', 'call']);
-const RULE_STORE_UNREADABLE_SET = new Set(RULE_STORE_UNREADABLE_KINDS);
-export function isRuleStoreUnreadableKind(v) {
-    return typeof v === 'string' && RULE_STORE_UNREADABLE_SET.has(v);
-}
-const RULE_STORE_UNREADABLE_SENTENCES = Object.freeze({
-    store: 'your standing deny/ask rules could not be read at all (the rule store did not answer), so this call asks',
-    call: 'this command could not be read against your standing deny/ask rules (the engine’s own sentence is on this ask), so it asks',
-});
-export function ruleStoreUnreadableDetail(kind) {
-    const known = Object.hasOwn(RULE_STORE_UNREADABLE_SENTENCES, kind)
-        ? RULE_STORE_UNREADABLE_SENTENCES[kind]
-        : undefined;
-    if (typeof known === 'string')
-        return known;
-    const word = typeof kind === 'string' && kind.length > 0 ? kind : '(none)';
-    return `your standing deny/ask rules could not be applied to this call; the reported reason ${word} is not one of the mechanisms this client's closed set knows, so answer this ask as usual`;
-}
 export function mandatedApprovalDetail() {
     return 'no saved allow rule and no remembered answer can retire this question; each call is settled on its own — by you here, by a hook, or by an automatic check the deployment runs — and an answer covers only that call';
 }
@@ -106,7 +80,7 @@ const APPROVAL_MANDATE_SENTENCES = Object.freeze({
     operator_always: 'this deployment requires a separate confirmation for each shell command, and this call is one of them',
     tool_marks: 'this tool declares that it reaches outside this machine or makes changes that cannot be undone',
     probe_mandate: 'the check run on this call marked it as needing its own confirmation (the built-in shell check does so for a read outside the directories allowed for this session)',
-    probe_unanswered: 'the check run on this call did not answer (it timed out or failed), so whether the call stays inside the directories allowed for this session is unknown',
+    probe_unanswered: 'the check run on this call did not answer (it timed out or failed; this client cannot tell which), so whether the call stays inside the directories allowed for this session is unknown',
     write_protection: "this change lands on a protected location (the agent's own configuration), which is confirmed one change at a time",
     write_protection_unresolved: 'the protected-location check could not tell where this change lands, so whether it touches a protected location is unknown',
 });

package/dist/generated/engineFactTables.d.ts

@@ -21,4 +21,20 @@ 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" | "classifier_no_ruling" | "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", "tool_name", "near_miss"];
+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", "unmintable_segment"];
+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;
+export declare const CORE_PROMPT_BLOCK_CAUSES: readonly ["block", "crashed", "timeout", "cancelled"];