@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/controlRouter.d.ts

@@ -1,5 +1,7 @@
-import type { TaskRequest, RunReceipt, CancelAck, Scenario, SteerPriority } from '@sema-agent/sdk';
+import type { TaskRequest, RunReceipt, CancelAck, Scenario, SteerPriority, AssistantTaskStatus } from '@sema-agent/sdk';
 import { type SteerPriorityReading } from './steerPriorityCapability.js';
+import { type PreemptOutcome } from './preemptWire.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface RunsResourceLike {
     create(req: TaskRequest, opts?: {
         idempotencyKey?: string | null;
@@ -12,8 +14,14 @@ export interface RunsResourceLike {
         signal?: AbortSignal;
     }): Promise<CancelAck>;
 }
+export interface AssistantPreemptLike {
+    preempt(taskId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<AssistantTaskStatus>;
+}
 export interface ControlClientLike {
     runs: RunsResourceLike;
+    assistant?: AssistantPreemptLike;
 }
 export type ControlSafetyCode = 'not_running' | 'invalid_content' | 'queue_full' | 'duplicate_input_id' | 'ambiguous_target' | 'still_running' | 'blocked_by_hook' | 'ledger_unavailable' | 'steering_other' | 'cancel_lost_race' | 'cancel_run_not_running' | 'not_found' | 'priority_not_applied' | 'steer_input_invalid';
 export declare class ControlSafetyError extends Error {
@@ -31,6 +39,10 @@ export interface ControlRouterSteerOptions {
     priority?: SteerPriority;
     steerPriority?: SteerPriorityReading;
 }
+export interface PreemptOptions {
+    signal?: AbortSignal;
+    onUnavailable?: 'cancel' | 'report';
+}
 export interface ControlRouterOptions {
     sessionId?: string;
     jobId?: string;
@@ -55,6 +67,8 @@ export declare class ControlRouter {
     cancel(opts?: {
         signal?: AbortSignal;
     }): Promise<CancelAck>;
+    private cancelRun;
+    preempt(opts?: PreemptOptions): Promise<PreemptOutcome>;
 }
 export interface ErrCodes {
     code?: string | undefined;
@@ -62,6 +76,7 @@ export interface ErrCodes {
     status?: number | undefined;
 }
 export declare function errCodes(e: unknown): ErrCodes;
+export type SteerHostQueueFact = 'queued_until_turn_end' | 'dropped' | 'unknown';
 export declare function steeringStatusIs4xx(e: object): boolean;
 export interface SteerRefusalAdvice {
     safety: ControlSafetyCode;
@@ -70,8 +85,8 @@ export interface SteerRefusalAdvice {
     nextStep: string;
 }
 export type SteeringRefusedBeforeEngine = SteerRefusalAdvice;
-export declare function steeringRefusedBeforeEngine(e: object): SteeringRefusedBeforeEngine | undefined;
-export declare function steerRefusalAdviceOf(e: object): SteerRefusalAdvice | undefined;
+export declare function steeringRefusedBeforeEngine(e: object, hostQueue?: SteerHostQueueFact, lang?: UiLanguage): SteeringRefusedBeforeEngine | undefined;
+export declare function steerRefusalAdviceOf(e: object, hostQueue?: SteerHostQueueFact, lang?: UiLanguage): SteerRefusalAdvice | undefined;
 export interface SteerBody {
     readonly text: string;
     readonly mode?: 'all' | 'one-at-a-time';

package/dist/controlRouter.js

@@ -1,5 +1,8 @@
 import { cancelConflictContent, cancelConflictFromError } from './wireRefusalCopy.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameOf, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { steerPriorityMode } from './steerPriorityCapability.js';
+import { preemptReadingOfAck, preemptReadingOfError } from './preemptWire.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export class ControlSafetyError extends Error {
     code;
     cause;
@@ -86,8 +89,11 @@ export class ControlRouter {
         if (this.taskId === null) {
             throw controlSafetyRefusal('not_found', 'no run in flight to cancel');
         }
+        return this.cancelRun(this.taskId, opts);
+    }
+    async cancelRun(taskId, opts) {
         try {
-            return await this.client.runs.cancel(this.taskId, opts?.signal !== undefined ? { signal: opts.signal } : undefined);
+            return await this.client.runs.cancel(taskId, opts?.signal !== undefined ? { signal: opts.signal } : undefined);
         }
         catch (e) {
             const conflict = cancelConflictFromError(e);
@@ -100,14 +106,62 @@ export class ControlRouter {
             throw e;
         }
     }
+    async preempt(opts) {
+        const taskId = this.taskId;
+        if (taskId === null)
+            return Object.freeze({ kind: 'no-run' });
+        let signal;
+        let fallback = 'cancel';
+        try {
+            const s = opts?.signal;
+            if (s !== undefined && s !== null)
+                signal = s;
+            const f = opts?.onUnavailable;
+            if (f !== undefined && f !== 'cancel')
+                fallback = 'report';
+        }
+        catch {
+            fallback = 'report';
+        }
+        let verb;
+        let slice;
+        try {
+            slice = this.client.assistant;
+            const v = slice?.preempt;
+            if (typeof v === 'function')
+                verb = v;
+        }
+        catch {
+            verb = undefined;
+        }
+        let reading;
+        if (verb === undefined) {
+            reading = { kind: 'lane-absent' };
+        }
+        else {
+            try {
+                reading = preemptReadingOfAck(taskId, await verb.call(slice, taskId, signal !== undefined ? { signal } : undefined));
+            }
+            catch (e) {
+                reading = preemptReadingOfError(e);
+            }
+        }
+        if (reading.kind !== 'lane-absent')
+            return Object.freeze(reading);
+        if (fallback === 'report')
+            return Object.freeze({ kind: 'unavailable' });
+        const ack = await this.cancelRun(taskId, signal !== undefined ? { signal } : undefined);
+        return Object.freeze({ kind: 'cancelled-instead', ack });
+    }
 }
 export function errCodes(e) {
     if (!e || typeof e !== 'object')
         return {};
-    const o = e;
-    const code = typeof o.errorCode === 'string' ? o.errorCode : undefined;
-    const name = typeof o.name === 'string' ? o.name : undefined;
-    const rawStatus = o.status ?? o.statusCode;
+    const rawCode = readThrownSlot(e, 'errorCode', 'data');
+    const code = typeof rawCode === 'string' ? rawCode : undefined;
+    const rawName = readThrownSlot(e, 'name');
+    const name = typeof rawName === 'string' ? rawName : undefined;
+    const rawStatus = readThrownStatusSlot(e);
     const status = typeof rawStatus === 'number' ? rawStatus : undefined;
     return { code, name, status };
 }
@@ -122,59 +176,43 @@ const STEERING_CODE_TO_SAFETY = new Map([
     ['steering.blocked_by_hook', 'blocked_by_hook'],
     ['steering.ledger_unavailable', 'ledger_unavailable'],
 ]);
-const STEERING_NAME_TO_SAFETY = new Map([
-    ['SteeringNotRunningError', 'not_running'],
-    ['SteeringInvalidContentError', 'invalid_content'],
-    ['SteeringAmbiguousTargetError', 'ambiguous_target'],
-    ['SteeringStillRunningError', 'still_running'],
-    ['SteeringLedgerUnavailableError', 'ledger_unavailable'],
-    ['SteeringQueueFullError', 'queue_full'],
-    ['SteeringDuplicateInputIdError', 'duplicate_input_id'],
-    ['SteeringError', 'steering_other'],
-]);
+const STEERING_NAME_TO_SAFETY = {
+    SteeringNotRunningError: 'not_running',
+    SteeringInvalidContentError: 'invalid_content',
+    SteeringAmbiguousTargetError: 'ambiguous_target',
+    SteeringStillRunningError: 'still_running',
+    SteeringLedgerUnavailableError: 'ledger_unavailable',
+    SteeringQueueFullError: 'queue_full',
+    SteeringDuplicateInputIdError: 'duplicate_input_id',
+    SteeringError: 'steering_other',
+};
 const STEERING_COPY = {
-    not_running: {
-        happened: 'that run is not accepting messages right now — it has just finished, is running on another server, or is not the active run of its session',
-        nextStep: 'check its current state and send the message to the run that is active',
-    },
-    invalid_content: {
-        happened: 'the message was refused because its text contains control markers the engine does not accept, so nothing was delivered',
-        nextStep: 'rewrite the message and send it again',
-    },
-    queue_full: {
-        happened: 'that run is paused and already holds as many waiting messages as it can, so this one was not accepted',
-        nextStep: 'send it again once the waiting messages have been delivered (when the run resumes or the session is woken)',
-    },
-    duplicate_input_id: {
-        happened: 'a different instruction was already accepted under this idempotency key, and that earlier instruction stands',
-        nextStep: 'if you changed the text, send the new text under a new key; otherwise do not resend it — a new key would deliver the same instruction twice',
-    },
-    ambiguous_target: {
-        happened: 'more than one running agent matches that target, so the message was not delivered',
-        nextStep: 'address a sub-agent by its tool-call id; a workflow agent cannot be singled out while another running agent shares its label, so send it again once only one does',
-    },
-    still_running: {
-        happened: 'that agent is still running, so it cannot be resumed',
-        nextStep: 'send it a message instead, or wait for it to finish',
-    },
-    blocked_by_hook: {
-        happened: "the message was not accepted: a prompt check on this deployment blocked it, so nothing was delivered",
-        nextStep: 'edit the message and send it again — that is not a duplicate submission',
-    },
-    ledger_unavailable: {
-        happened: 'the server could not record the message and refused it before anything reached the engine, so nothing was delivered',
-        nextStep: 'send the same text again later',
-    },
-    steering_other: {
-        happened: 'the message was refused for a reason this version does not recognise, so it did not land',
-        nextStep: 'report its error code if this keeps happening; do not guess what it means',
-    },
+    not_running: { happened: 'session.steerRefusal.notRunning.happened', nextStep: 'session.steerRefusal.notRunning.nextStep' },
+    invalid_content: { happened: 'session.steerRefusal.invalidContent.happened', nextStep: 'session.steerRefusal.invalidContent.nextStep' },
+    queue_full: { happened: 'session.steerRefusal.queueFull.happened', nextStep: 'session.steerRefusal.queueFull.nextStep' },
+    duplicate_input_id: { happened: 'session.steerRefusal.duplicateInputId.happened', nextStep: 'session.steerRefusal.duplicateInputId.nextStep' },
+    ambiguous_target: { happened: 'session.steerRefusal.ambiguousTarget.happened', nextStep: 'session.steerRefusal.ambiguousTarget.nextStep' },
+    still_running: { happened: 'session.steerRefusal.stillRunning.happened', nextStep: 'session.steerRefusal.stillRunning.nextStep' },
+    blocked_by_hook: { happened: 'session.steerRefusal.blockedByHook.happened', nextStep: 'session.steerRefusal.blockedByHook.nextStep' },
+    ledger_unavailable: { happened: 'session.steerRefusal.ledgerUnavailable.happened', nextStep: 'session.steerRefusal.ledgerUnavailable.nextStep' },
+    steering_other: { happened: 'session.steerRefusal.steeringOther.happened', nextStep: 'session.steerRefusal.steeringOther.nextStep' },
 };
-const adviceOfCopy = (c) => `${c.happened} — ${c.nextStep}`;
-const STEERING_ADVICE = Object.freeze(Object.fromEntries(Object.entries(STEERING_COPY).map(([k, c]) => [k, adviceOfCopy(c)])));
+const adviceOfCopy = (c, lang) => renderMessage(msg('session.steerRefusal.advice', { happened: c.happened, nextStep: c.nextStep }), lang);
+function hostQueueFactOf(v) {
+    return v === 'queued_until_turn_end' || v === 'dropped' ? v : 'unknown';
+}
+function renderedCopyOf(keys, lang, hostQueue) {
+    const happened = renderMessage(msg(keys.happened), lang);
+    const tableNextStep = renderMessage(msg(keys.nextStep), lang);
+    if (hostQueue === 'queued_until_turn_end')
+        return { happened, nextStep: renderMessage(msg('session.steerRefusal.hostQueue.queued'), lang) };
+    if (hostQueue === 'dropped')
+        return { happened, nextStep: renderMessage(msg('session.steerRefusal.hostQueue.dropped', { nextStep: tableNextStep }), lang) };
+    return { happened, nextStep: tableNextStep };
+}
 const STEERING_OTHER_UNKNOWN_COPY = {
-    happened: 'the message was refused for a reason this version does not recognise, and whether it was delivered is not known',
-    nextStep: 'do not resend it as if it had certainly been dropped — check the run first, and report its error code if this keeps happening',
+    happened: 'session.steerRefusal.steeringOtherUnknown.happened',
+    nextStep: 'session.steerRefusal.steeringOtherUnknown.nextStep',
 };
 const CANCEL_NOT_FOUND_COPY = {
     happened: 'this server has no run with that id for you — it does not exist, or it belongs to someone else',
@@ -210,7 +248,7 @@ function steeringCopyOf(e, safety) {
     return STEERING_COPY[safety];
 }
 const STEERING_REFUSED_BEFORE_ENGINE = new Map([['ledger_unavailable', 503]]);
-export function steeringRefusedBeforeEngine(e) {
+export function steeringRefusedBeforeEngine(e, hostQueue, lang) {
     try {
         const { status } = errCodes(e);
         if (status === undefined)
@@ -218,8 +256,8 @@ export function steeringRefusedBeforeEngine(e) {
         const safety = steeringVerdict(e);
         if (safety === undefined || STEERING_REFUSED_BEFORE_ENGINE.get(safety) !== status)
             return undefined;
-        const copy = STEERING_COPY[safety];
-        return { safety, advice: STEERING_ADVICE[safety], happened: copy.happened, nextStep: copy.nextStep };
+        const copy = renderedCopyOf(STEERING_COPY[safety], lang, hostQueueFactOf(hostQueue));
+        return { safety, advice: adviceOfCopy(copy, lang), happened: copy.happened, nextStep: copy.nextStep };
     }
     catch {
         return undefined;
@@ -232,22 +270,23 @@ function steeringSafetyOf(e, verdict) {
     return refused !== undefined && refused.safety === verdict ? verdict : 'steering_other';
 }
 function steeringVerdict(e) {
-    const { code, name } = errCodes(e);
+    const { code } = errCodes(e);
     if (typeof code === 'string' && code.startsWith('steering.')) {
         return STEERING_CODE_TO_SAFETY.get(code) ?? 'steering_other';
     }
-    if (typeof name === 'string')
-        return STEERING_NAME_TO_SAFETY.get(name);
-    return undefined;
+    if (readThrownSlot(e, 'errorCode', 'data') === THROWN_SLOT_UNREADABLE)
+        return undefined;
+    const protocolName = protocolErrorNameOf(e);
+    return protocolName !== undefined ? STEERING_NAME_TO_SAFETY[protocolName] : undefined;
 }
-export function steerRefusalAdviceOf(e) {
+export function steerRefusalAdviceOf(e, hostQueue, lang) {
     try {
         const verdict = steeringVerdict(e);
         if (verdict === undefined)
             return undefined;
         const safety = steeringSafetyOf(e, verdict);
-        const copy = steeringCopyOf(e, safety);
-        return { safety, advice: adviceOfCopy(copy), happened: copy.happened, nextStep: copy.nextStep };
+        const copy = renderedCopyOf(steeringCopyOf(e, safety), lang, hostQueueFactOf(hostQueue));
+        return { safety, advice: adviceOfCopy(copy, lang), happened: copy.happened, nextStep: copy.nextStep };
     }
     catch {
         return undefined;
@@ -308,6 +347,6 @@ export function steerBodyOf(input, reading) {
     return Object.freeze({ ...base, priority });
 }
 function isNotFound(e) {
-    const { name, status } = errCodes(e);
-    return name === 'NotFoundError' || status === 404;
+    const { status } = errCodes(e);
+    return status === 404 || (typeof e === 'object' && e !== null && protocolErrorNameOf(e) === PROTOCOL_ERROR_NAME.NotFoundError);
 }

package/dist/coreValuePorts.d.ts

@@ -73,7 +73,7 @@ export interface RouteCredentialView {
 }
 export type RouteAdjudicationView = {
     ok: true;
-    posture: 'per-model' | 'paired' | 'unpinned' | 'keyless' | (string & {});
+    posture: 'per-model' | 'paired' | 'keyless' | (string & {});
 } | {
     ok: false;
     code: 'route.credential_mismatch' | 'route.credential_missing' | (string & {});
@@ -97,15 +97,36 @@ export interface RuleToolNameVerdictView {
     readonly guidance?: string;
     readonly currentName?: string;
 }
+export type RuleEntryReadingView = {
+    readonly kind: 'row';
+    readonly compiled: RuleEntryCompiledView;
+} | {
+    readonly kind: 'inert';
+    readonly reason: string;
+    readonly verdict?: string;
+    readonly guidance?: string;
+    readonly currentName?: string;
+    readonly valueType?: string;
+};
+export interface RuleEntryCompiledView {
+    readonly kind: string;
+}
+export type McpToolAxesReadView = {
+    readonly ok: true;
+    readonly toolAxes?: Readonly<Record<string, object>>;
+} | {
+    readonly ok: false;
+    readonly problem: string;
+};
 export interface CoreValuePorts {
     resolveAutonomousLoopPrompt: (prompt: string, opts?: AutonomousLoopPromptOptionsView) => string | null;
     loosenReasons: (prior: SessionPermissionRules, next: SessionPermissionRules) => string[];
-    combinePolicies: (...policies: CoreToolPolicyHandle[]) => CoreToolPolicyHandle;
+    combinePolicies(...policies: CoreToolPolicyHandle[]): CoreToolPolicyHandle;
     createAllowDenyPolicy: (opts: AllowDenyPolicyOptionsView) => CoreToolPolicyHandle;
     MCP_NAMESPACE: CoreProtocolNamespaceView;
     protocolOf: (name: string) => CoreProtocolNamespaceView | undefined;
     ruleToolGrammarOf: (toolName: string) => RuleGrammarView | undefined;
-    validatePermissionRules: (rules: PermissionRuleView[], opts?: ValidatePermissionRulesOptionsView) => PermissionRuleIssueView[];
+    validatePermissionRules(rules: PermissionRuleView[], opts?: ValidatePermissionRulesOptionsView): PermissionRuleIssueView[];
     mintNamespacePrefix(ns: CoreProtocolNamespaceView, peer: string): string;
     compileAllowList(entries: readonly string[], behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): AllowListReadingView;
     routeKeyOf(url: string | undefined): string;
@@ -118,8 +139,10 @@ export interface CoreValuePorts {
         adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
     }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView;
     judgeRuleToolName(name: string, roster: ReadonlySet<string>): RuleToolNameVerdictView;
+    readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView;
+    readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -145,3 +168,5 @@ export declare function adjudicateModelRoute(model: RouteModelView, credential:
 export declare function routePairingStatus(brain: {
     adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
 }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView | undefined;
+export declare function readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView | undefined;
+export declare function readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView | undefined;

package/dist/coreValuePorts.js

@@ -15,6 +15,8 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'adjudicateModelRoute',
     'routePairingStatus',
     'judgeRuleToolName',
+    'readRuleEntry',
+    'readMcpToolAxes',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -99,3 +101,11 @@ export function routePairingStatus(brain, model, perModelAuth) {
     const fn = port('routePairingStatus');
     return fn === undefined ? undefined : fn(brain, model, perModelAuth);
 }
+export function readRuleEntry(raw, behavior, roster) {
+    const fn = port('readRuleEntry');
+    return fn === undefined ? undefined : fn(raw, behavior, roster);
+}
+export function readMcpToolAxes(declared) {
+    const fn = port('readMcpToolAxes');
+    return fn === undefined ? undefined : fn(declared);
+}

package/dist/corruptSessionCopy.d.ts

@@ -1 +1,2 @@
-export declare function corruptSessionContent(): string;
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare function corruptSessionContent(lang?: UiLanguage): string;

package/dist/corruptSessionCopy.js

@@ -1,4 +1,4 @@
-export function corruptSessionContent() {
-    return ("This session's saved history cannot be read — its stored log is damaged — so the engine cannot open this session. " +
-        'Retrying will not help: whoever operates this engine has to repair or remove that stored log. Until then, continue in a new session.');
+import { msg, renderMessage } from './i18n/translate.js';
+export function corruptSessionContent(lang) {
+    return renderMessage(msg('session.corrupt.content'), lang);
 }

package/dist/decideReceipt.d.ts

@@ -1,6 +1,6 @@
 import { type GateOutcomeView } from './gateOutcome.js';
 import { type ResumeReopenDetail } from './hitl/suspendedReopen.js';
-import { type CrashConvergedRow } from './hitl/crashConverged.js';
+import { type CrashConvergedRowReading } from './hitl/crashConverged.js';
 import type { AskRowEndingCause } from '@sema-agent/sdk';
 export interface DecideReceiptView {
     status?: string;
@@ -35,7 +35,7 @@ export interface AskGoneDetail {
     code: 'gone.ask';
     state?: 'VOID' | 'DENIED';
     endingCause?: AskRowEndingCause;
-    holderGone?: CrashConvergedRow['cause'];
+    holderGone?: CrashConvergedRowReading['cause'];
 }
 export declare function askGoneFromError(e: unknown): AskGoneDetail | null;
 export declare function askGoneContent(detail: AskGoneDetail): string;

package/dist/decideReceipt.js

@@ -1,6 +1,7 @@
 import { gateOutcomeOf } from './gateOutcome.js';
+import { readOwnDataValue } from './ownKey.js';
 import { resumeReopenFromError } from './hitl/suspendedReopen.js';
-import { ASK_GONE, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
+import { ASK_GONE, DECIDE_CLAIM_LOST, CONFLICT_NOT_RESUMABLE, GATE_NOT_TOOL_APPROVAL, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { readErrorString, readErrorStrictStringList, readThrownExtra } from './wireFailureShape.js';
 import { isCrashConvergedCause } from './hitl/crashConverged.js';
@@ -16,7 +17,7 @@ export function readDecideReceipt(result) {
     const status = Object.hasOwn(r, 'status') ? str(r.status) : undefined;
     const taskId = Object.hasOwn(r, 'taskId') ? str(r.taskId) : undefined;
     const sessionId = Object.hasOwn(r, 'sessionId') ? str(r.sessionId) : undefined;
-    const idempotent = Object.hasOwn(r, 'idempotent') && r.idempotent === true ? true : undefined;
+    const idempotent = readOwnDataValue(r, 'idempotent') === true ? true : undefined;
     const handoffTaskId = status === STATUS_RESUMING && taskId !== undefined ? taskId : undefined;
     const executionOutcome = Object.hasOwn(r, 'executionOutcome')
         ? gateOutcomeOf({ gate: r.executionOutcome })
@@ -117,6 +118,8 @@ const DECIDE_PARK_MOVED_WHAT = Object.freeze({
     [DECIDE_NOT_PARKED]: 'This approval was no longer waiting when the decision arrived (the agent was stopped, the approval was decided elsewhere, or the session it belongs to was deleted; this client cannot tell which)',
     [DECIDE_GATE_MOVED]: 'This approval moved while the decision was on its way (it was parked again, or settled elsewhere; this client cannot tell which)',
     [DECIDE_CLAIM_LOST]: 'Another decision on this approval got there first, or an earlier attempt is still holding it until the engine clears that hold on its own; this client cannot tell which',
+    [CONFLICT_NOT_RESUMABLE]: 'The run was no longer waiting to be resumed when the decision arrived (it had been resumed, decided, or expired before this decision; this client cannot tell which)',
+    [GATE_NOT_TOOL_APPROVAL]: 'The run is waiting at a different kind of gate than a tool approval, so this tool approval decision had nothing to act on',
 });
 export function decideParkMovedContent(detail) {
     let code;

package/dist/declared/supportFloorDeclared.js

@@ -1,5 +1,5 @@
 export const DECLARED_SUPPORT_FLOOR = Object.freeze({
-    server: "7.126.0",
-    core: "7.49.5",
-    sdk: "21.1.0",
+    server: "7.129.1",
+    core: "7.51.2",
+    sdk: "23.1.0",
 });

package/dist/detachWire.js

@@ -1,5 +1,6 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
+import { readThrownSlot } from './wireFailureShape.js';
 import { resolveWireAuth } from './engineWireSdk.js';
 export const DETACH_HEADER = 'x-detach-on-disconnect';
 export const HEADLESS_DETACH_ENV = 'SEMA_HEADLESS_DETACH';
@@ -13,10 +14,10 @@ export async function resolveHeadlessDetach(env = hostEnv()) {
 }
 export const DETACH_DURABLE_OFF_400_ANCHOR = 'x-detach-on-disconnect requires a durable run';
 export function isDetachDurableOff400(err) {
+    if (readThrownSlot(err, 'status', 'data') !== 400)
+        return false;
     try {
         const e = err;
-        if (e?.status !== 400)
-            return false;
         const msg = e?.message;
         return typeof msg === 'string' && msg.includes(DETACH_DURABLE_OFF_400_ANCHOR);
     }

package/dist/deviceExecutorManagementCapability.d.ts

@@ -15,11 +15,7 @@ export type DeviceExecutorManagementReading = {
     wsPath?: string;
 };
 export declare function projectDeviceExecutorManagementCapability(caps: unknown): DeviceExecutorManagementReading | undefined;
-export declare function noteEngineCapsForDeviceExecutorManagement(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedDeviceExecutorManagement(baseUrl?: string | undefined): DeviceExecutorManagementReading;
 export declare function deviceManagementVerbsAvailable(reading: DeviceExecutorManagementReading): 'yes' | 'no' | 'unknown';
 export declare function deviceLaneOpen(reading: DeviceExecutorManagementReading): 'yes' | 'no' | 'unknown';
 export declare function deviceExecutorManagementDoctorDetail(reading: DeviceExecutorManagementReading): string;
-export declare function __resetDeviceExecutorManagementReadingsForTests(): void;

package/dist/deviceExecutorManagementCapability.js

@@ -44,9 +44,6 @@ const reader = createEngineCapReader({
     name: 'deviceExecutor.management',
     project: projectDeviceExecutorManagementCapability,
 });
-export function noteEngineCapsForDeviceExecutorManagement(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedDeviceExecutorManagement(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -103,6 +100,3 @@ export function deviceExecutorManagementDoctorDetail(reading) {
         }
     }
 }
-export function __resetDeviceExecutorManagementReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/deviceRebind.d.ts

@@ -1,7 +1,10 @@
-import type { AgentClient } from '@sema-agent/sdk';
+import type { AgentClient, DeviceEnrollRequest } from '@sema-agent/sdk';
 export type DeviceListVerb = Pick<AgentClient['devices'], 'list'>;
 export type DeviceSessionBindingVerb = Pick<AgentClient['devices'], 'sessionBinding'>;
 export type DeviceRebindVerb = Pick<AgentClient['devices'], 'rebind'>;
+export type DeviceIssueEnrollTokenVerb = Pick<AgentClient['devices'], 'issueEnrollToken'>;
+export type DeviceEnrollVerb = Pick<AgentClient['devices'], 'enroll'>;
+export type DeviceRevokeVerb = Pick<AgentClient['devices'], 'revoke'>;
 export interface DeviceRosterRow {
     readonly deviceId: string;
     readonly name?: string;
@@ -86,3 +89,48 @@ export declare function reconcileRebindOutcome(before: DeviceBindingReading, toD
     readonly serverMayStillBeRunning: boolean;
 }): DeviceRebindReconcileVerdict;
 export declare function rebindProvesRequestNotApplied(outcome: DeviceRebindOutcome): boolean;
+export type DeviceRegistrationVerb = 'issue' | 'enroll' | 'revoke';
+export interface DeviceRateLimited {
+    readonly kind: 'rate-limited';
+    readonly retryAfterSec?: number;
+}
+export type DeviceEnrollTokenOutcome = {
+    readonly kind: 'ok';
+    readonly token: string;
+    readonly expiresAt?: string;
+    readonly ttlSec?: number;
+} | DeviceRateLimited | DeviceUnreadable | DeviceLaneAbsent | DeviceRefused | DeviceTransport | DeviceUnarmed;
+export type DeviceEnrollOutcome = {
+    readonly kind: 'ok';
+    readonly deviceId: string;
+} | {
+    readonly kind: 'enrollment-invalid';
+} | DeviceRateLimited | DeviceRebindUnconfirmed | DeviceLaneAbsent | DeviceRefused | DeviceUnarmed;
+export type DeviceRevokeOutcome = {
+    readonly kind: 'ok';
+    readonly deviceId: string;
+    readonly revokedAt?: string;
+} | {
+    readonly kind: 'not-found';
+} | DeviceRebindUnconfirmed | DeviceLaneAbsent | DeviceRefused | DeviceUnarmed;
+export declare function issueEnrollToken(devices: DeviceIssueEnrollTokenVerb | null | undefined, opts?: {
+    readonly signal?: AbortSignal | undefined;
+}): Promise<DeviceEnrollTokenOutcome>;
+export interface DeviceEnrollOptions {
+    readonly signal?: AbortSignal | undefined;
+    readonly acceptDeviceId?: ((deviceId: string) => boolean) | undefined;
+}
+export declare function enrollDevice(devices: DeviceEnrollVerb | null | undefined, req: DeviceEnrollRequest, opts?: DeviceEnrollOptions): Promise<DeviceEnrollOutcome>;
+export declare function revokeDevice(devices: DeviceRevokeVerb | null | undefined, deviceId: string, opts?: {
+    readonly reason?: string | undefined;
+    readonly signal?: AbortSignal | undefined;
+}): Promise<DeviceRevokeOutcome>;
+declare const IDENTITY_MISMATCH = "device.identity_mismatch";
+export interface DeviceIdentityMismatch {
+    readonly code: typeof IDENTITY_MISMATCH;
+    readonly boundDeviceId?: string;
+}
+export declare function deviceIdentityMismatchOf(err: {} | null | undefined): DeviceIdentityMismatch | null;
+export declare function deviceIdentityMismatchLine(detail: DeviceIdentityMismatch): string;
+export declare function deviceRegistrationOutcomeLine(verb: DeviceRegistrationVerb, outcome: DeviceEnrollTokenOutcome | DeviceEnrollOutcome | DeviceRevokeOutcome): string | undefined;
+export {};