@sema-agent/client-core 0.92.0 → 0.93.0

package/dist/engineConfigDrift.js

@@ -0,0 +1,54 @@
+function countOf(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : undefined;
+}
+function ownValue(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && 'value' in d ? d.value : undefined;
+}
+export function readEngineConfigApplyState(health) {
+    try {
+        if (typeof health !== 'object' || health === null || Array.isArray(health))
+            return null;
+        const configTargetOrdinal = countOf(ownValue(health, 'configTargetOrdinal'));
+        const configAppliedOrdinal = countOf(ownValue(health, 'configAppliedOrdinal'));
+        if (configTargetOrdinal === undefined || configAppliedOrdinal === undefined)
+            return null;
+        const configTargetVersion = countOf(ownValue(health, 'configTargetVersion'));
+        const configAppliedVersion = countOf(ownValue(health, 'configAppliedVersion'));
+        const configApplyStaleMs = countOf(ownValue(health, 'configApplyStaleMs'));
+        return {
+            configTargetOrdinal,
+            configAppliedOrdinal,
+            ...(configTargetVersion !== undefined && configAppliedVersion !== undefined ? { configTargetVersion, configAppliedVersion } : {}),
+            ...(configApplyStaleMs !== undefined ? { configApplyStaleMs } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function configDriftVerdict(input) {
+    try {
+        const { baselineConfigHash, baselineInstanceId, health } = input;
+        const view = typeof health === 'object' && health !== null ? health : undefined;
+        if (view !== undefined && ownValue(view, 'restartRequired') === true)
+            return 'ask';
+        const hashRaw = view === undefined ? undefined : ownValue(view, 'configHash');
+        const nowHash = typeof hashRaw === 'string' ? hashRaw : undefined;
+        if (!baselineConfigHash || !nowHash)
+            return 'skip';
+        if (nowHash === baselineConfigHash)
+            return 'in-sync';
+        const instanceRaw = view === undefined ? undefined : ownValue(view, 'instanceId');
+        const nowInstance = typeof instanceRaw === 'string' ? instanceRaw : undefined;
+        if (!baselineInstanceId || !nowInstance || nowInstance !== baselineInstanceId)
+            return 'ask';
+        const apply = readEngineConfigApplyState(view);
+        if (apply === null)
+            return 'ask';
+        return apply.configTargetOrdinal === apply.configAppliedOrdinal ? 'advance-baseline' : 'ask';
+    }
+    catch {
+        return 'ask';
+    }
+}

package/dist/engineErrorCodes.d.ts

@@ -65,6 +65,8 @@ export declare const RESUME_REOPEN_CODES: readonly string[];
 export declare const PARKED_RESUME_STARTUP_FAILED = "parked_resume.startup_failed";
 export declare const DECIDE_WORKFLOW_HOST_UNKNOWN = "decide.workflow_host_unknown";
 export declare const DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED = "decide.workflow_remember_unsupported";
+export declare const DECIDE_WORKFLOW_PARK_FORKED = "decide.workflow_park_forked";
+export declare const DECIDE_WORKFLOW_PARKS_UNREADABLE = "decide.workflow_parks_unreadable";
 export declare const DECIDE_WORKFLOW_LANE_CODES: readonly string[];
 export declare const DECIDE_NOT_PARKED = "decide.not_parked";
 export declare const DECIDE_GATE_MOVED = "decide.gate_moved";
@@ -87,6 +89,7 @@ export declare const WORKFLOW_PARK_REFUSAL_CODES: readonly string[];
 export declare function isWorkflowParkRefusalCode(code: unknown): boolean;
 export declare const DRAINING_ERROR_CODE = "draining";
 export declare const SCENARIO_NOT_ALLOWED_ERROR_CODE = "scenario_not_allowed";
+export declare const SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE = "state.scenario_assignment_unknown";
 export declare const STREAM_MAX_DURATION = "STREAM_MAX_DURATION";
 export type ModelFallbackReason = 'inherit_no_tier_binding';
 export declare const MODEL_FALLBACK_INHERIT_NO_TIER_BINDING: ModelFallbackReason;

package/dist/engineErrorCodes.js

@@ -141,9 +141,13 @@ export const RESUME_REOPEN_CODES = Object.freeze([
 export const PARKED_RESUME_STARTUP_FAILED = 'parked_resume.startup_failed';
 export const DECIDE_WORKFLOW_HOST_UNKNOWN = 'decide.workflow_host_unknown';
 export const DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED = 'decide.workflow_remember_unsupported';
+export const DECIDE_WORKFLOW_PARK_FORKED = 'decide.workflow_park_forked';
+export const DECIDE_WORKFLOW_PARKS_UNREADABLE = 'decide.workflow_parks_unreadable';
 export const DECIDE_WORKFLOW_LANE_CODES = Object.freeze([
     DECIDE_WORKFLOW_HOST_UNKNOWN,
     DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED,
+    DECIDE_WORKFLOW_PARKS_UNREADABLE,
+    DECIDE_WORKFLOW_PARK_FORKED,
 ]);
 export const DECIDE_NOT_PARKED = 'decide.not_parked';
 export const DECIDE_GATE_MOVED = 'decide.gate_moved';
@@ -162,13 +166,16 @@ 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_HOLDER_LOST_OUTLET = '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_ORPHANED_NOTE = 'This run ended because the engine process that was running it went away (it was restarted) before the run finished. ' + RUN_HOLDER_LOST_OUTLET;
+const RUN_STALLED_NOTE = 'This run ended because the engine process that was running it stopped reporting in before the run finished. ' + RUN_HOLDER_LOST_OUTLET;
 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 === RUN_ORPHANED)
+        return RUN_ORPHANED_NOTE;
+    if (code === RUN_STALLED)
+        return RUN_STALLED_NOTE;
     if (code === APPROVAL_EXPIRED)
         return RUN_APPROVAL_EXPIRED_NOTE;
     return undefined;
@@ -202,6 +209,7 @@ export function isWorkflowParkRefusalCode(code) {
 }
 export const DRAINING_ERROR_CODE = 'draining';
 export const SCENARIO_NOT_ALLOWED_ERROR_CODE = 'scenario_not_allowed';
+export const SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE = 'state.scenario_assignment_unknown';
 export const STREAM_MAX_DURATION = 'STREAM_MAX_DURATION';
 export const MODEL_FALLBACK_INHERIT_NO_TIER_BINDING = 'inherit_no_tier_binding';
 export function asModelFallbackReason(v) {

package/dist/engineInlineTaskStats.d.ts

@@ -4,6 +4,7 @@ export interface EngineInlineTaskStats {
     totalTokens: number;
     durationMs: number;
     currentAction?: string;
+    model?: string;
     done: boolean;
     isError: boolean;
 }

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;

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

@@ -97,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/gateVocabulary.d.ts

@@ -9,11 +9,7 @@ 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;

package/dist/gateVocabulary.js

@@ -48,7 +48,7 @@ export function gateDeniedByDetail(deniedBy) {
 }
 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',
@@ -56,10 +56,10 @@ 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',
 });
-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;
@@ -68,24 +68,6 @@ export function askOriginDetail(origin, _message) {
     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';
 }
@@ -98,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,11 +21,11 @@ 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" | "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_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"];
+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"];
+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"];
@@ -37,3 +37,4 @@ export declare const CORE_MCP_LIVENESS_STATES: readonly ["reachable", "unreachab
 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"];

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 }),
+    "classifier_no_ruling": 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 }),
@@ -177,6 +178,8 @@ export const CORE_ALLOW_ENTRY_INERT_REASONS = Object.freeze([
     "domain",
     "content_unsupported",
     "grammar",
+    "tool_name",
+    "near_miss",
 ]);
 export const CORE_ALLOW_RULE_MEMBERS = Object.freeze([
     "hook",
@@ -189,6 +192,7 @@ export const CORE_RULE_TOOL_NAME_VERDICTS = Object.freeze([
     "current",
     "retired",
     "unprefixed_namespace",
+    "unmintable_segment",
 ]);
 export const CORE_SETTLEMENT_KINDS = Object.freeze([
     "human_allowed",
@@ -245,3 +249,9 @@ export const CORE_RULE_BEHAVIORS = Object.freeze([
 ]);
 export const CORE_MCP_IMAGE_MAX_BASE64 = 5242880;
 export const CORE_MAX_PENDING_STEER_CHARS = 16000;
+export const CORE_PROMPT_BLOCK_CAUSES = Object.freeze([
+    "block",
+    "crashed",
+    "timeout",
+    "cancelled",
+]);

package/dist/generated/engineNoticeTables.d.ts

@@ -2,5 +2,5 @@ export declare const CORE_ENGINE_NOTICE_CODES: readonly string[];
 export declare const CORE_NOTICE_AUDIENCE: Readonly<Record<string, 'user' | 'operator'>>;
 export declare const CORE_MCP_INJECTION_DROP_REASONS: readonly string[];
 export declare const CORE_NOTICE_MINTER: Readonly<Record<string, 'engine' | 'server'>>;
-export declare const CORE_USER_STEER_UNDRAINED_CAUSES: readonly ["leg_end", "crashed"];
+export declare const CORE_USER_INPUT_UNDRAINED_CAUSES: readonly ["leg_end", "crashed"];
 export declare const CORE_TOOL_TURN_INCOMPLETE_CAUSES: readonly ["truncated", "unnamed", "bad_frame", "missing_result_synthesized"];

package/dist/generated/engineNoticeTables.js

@@ -268,7 +268,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "memory.layer_locked_legacy": "server",
     "server.model_unreachable": "server",
 });
-export const CORE_USER_STEER_UNDRAINED_CAUSES = Object.freeze([
+export const CORE_USER_INPUT_UNDRAINED_CAUSES = Object.freeze([
     "leg_end",
     "crashed",
 ]);

package/dist/goalStopHook.d.ts

@@ -1,15 +1,8 @@
 import { type EnvLike } from './hostEnv.js';
 import type { WireHooksConfig } from './finalVerifyWire.js';
 export declare const GOAL_STOP_HOOK_WIRE_ENV = "SEMA_GOAL_STOP_HOOK_WIRE";
-export declare const CC_STOP_SEMANTICS_MIN_SERVER = "1.279.3";
-export declare function ccStopSemanticsFromVersion(version: string | undefined | null): boolean;
-export declare function engineCcStopSemantics(env?: EnvLike): boolean;
 export declare function isGoalStopHookWireArmed(env?: EnvLike): boolean;
-export declare function setWireSessionStopHook(prompt: string | null, opts?: {
-    ccSemantics?: boolean;
-}): void;
+export declare function setWireSessionStopHook(prompt: string | null): void;
 export declare function getWireSessionStopHook(): string | null;
-export declare function getWireSessionStopHookCcSemantics(): boolean;
-export declare function buildGoalStopHookPrompt(condition: string): string;
 export declare function goalStopHookMatcher(managedOnly: boolean): NonNullable<WireHooksConfig[string]>[number] | null;
 export declare function __resetGoalStopHookForTests(): void;