@sema-agent/client-core 0.84.1 → 0.85.0

package/dist/adapt.js

@@ -1,5 +1,5 @@
 import { isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, listNotifiedRuns, listWorkflowCompletionCardsEnqueued, markEngineWorkflowNotified, noteWorkflowCompletionCardEnqueued, parseTranscriptNotificationSeeds, } from './notifications.js';
-export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
+export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
 import { IDLE_FLUSH_MS } from './adapt/wireShapes.js';
 import { chrome, mainLane, makeIdOf } from './adapt/ids.js';
 import { createTextStream } from './adapt/textStream.js';

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -5,7 +5,11 @@ import { REDACTION_MARKER_PREFIX, washCredentials } from '../../displayUntrusted
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
 import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalGateToolName, } from '../../runTerminal.js';
 import { toCcModelUsage } from './turnUsageToModelUsage.js';
-import { LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, OUTPUT_INVALID, isRewindFamilyCode, } from '../../engineErrorCodes.js';
+import { LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, OUTPUT_INVALID, isCorruptSessionCode, isRewindFamilyCode, } from '../../engineErrorCodes.js';
+import { corruptSessionContent } from '../../corruptSessionCopy.js';
+function withSessionUnreadableNote(text, code) {
+    return isCorruptSessionCode(code) ? `${text}\n${corruptSessionContent()}` : text;
+}
 function finiteOr0(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : 0;
 }
@@ -527,9 +531,9 @@ export function doneToSdkResult(ev, ctx, observed) {
             ...errorBase,
             subtype: failedSubtype,
             errors: [
-                isRewindFamilyCode(failedCode) && failedMessage
+                withSessionUnreadableNote(isRewindFamilyCode(failedCode) && failedMessage
                     ? `${failedMessage} (${failedCode})`
-                    : (failedMessage ?? 'run failed'),
+                    : (failedMessage ?? 'run failed'), failedCode),
             ],
         });
     }
@@ -619,9 +623,9 @@ export function failedToSdkResult(ev, ctx, observed) {
         durationMs: elapsedMs(ctx),
         errorCode: ev.errorCode,
         errors: [
-            isRewindFamilyCode(ev.errorCode) && ev.errorMessage
+            withSessionUnreadableNote(isRewindFamilyCode(ev.errorCode) && ev.errorMessage
                 ? `${ev.errorMessage} (${ev.errorCode})`
-                : (ev.errorMessage ?? ev.errorCode ?? 'run failed'),
+                : (ev.errorMessage ?? ev.errorCode ?? 'run failed'), ev.errorCode),
         ],
     });
 }

package/dist/adapter/runStream.js

@@ -3,7 +3,8 @@ import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.
 import { turnUsageToModelUsage } from './downstream/turnUsageToModelUsage.js';
 import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { corruptSessionContent } from '../corruptSessionCopy.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
 import { washCredentials } from '../displayUntrusted.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
@@ -474,7 +475,10 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             ?
                                 `${MODEL_OUTPUT_ERROR_PREFIX}: ${errText}${maxTokHint}`
                             : `API Error: ${errText}${maxTokHint}`;
-                yield syntheticTerminalRow(ctx, rowText);
+                const sessionUnreadable = ev.type === 'failed'
+                    ? isCorruptSessionCode(ev.errorCode)
+                    : doneTerminal?.kind === 'failed' && isCorruptSessionCode(doneTerminal.code);
+                yield syntheticTerminalRow(ctx, sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText);
             }
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {

package/dist/agentSession/engineSessionBackgroundStop.d.ts

@@ -0,0 +1,50 @@
+import type { AgentClient, SessionBackgroundStopOutcome } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type EngineSessionBackgroundStopClient = {
+    sessions: Pick<AgentClient['sessions'], 'backgroundStop'>;
+};
+export type EngineSessionBackgroundStopWire = EngineWireInjection<EngineSessionBackgroundStopClient>;
+export interface EngineSessionBackgroundStopOptions {
+    wire?: EngineSessionBackgroundStopWire;
+    signal?: AbortSignal;
+    sessionKey?: string;
+}
+export interface EngineSessionBackgroundReceipt {
+    readonly id: string;
+    readonly outcome: SessionBackgroundStopOutcome | (string & {});
+}
+export type EngineSessionBackgroundStopUnavailableWhy = 'bad_input' | 'no_wire' | 'capability_unknown' | 'no_exit_face';
+export type EngineSessionBackgroundStopRefusedWhy = 'credentials_required' | 'not_permitted' | 'ownership_required' | 'session_not_found' | 'route_absent' | 'bad_request' | 'rate_limited' | 'other';
+export type EngineSessionBackgroundStopResult = {
+    kind: 'stopped';
+    receipts?: readonly EngineSessionBackgroundReceipt[];
+    unreadableReceipts?: number;
+} | {
+    kind: 'unavailable';
+    why: EngineSessionBackgroundStopUnavailableWhy;
+    detail: string;
+} | {
+    kind: 'refused';
+    why: EngineSessionBackgroundStopRefusedWhy;
+    detail: string;
+    status?: number;
+    errorCode?: string;
+    retryAfterMs?: number;
+} | {
+    kind: 'error';
+    detail: string;
+    status?: number;
+    errorCode?: string;
+    unconfirmed?: true;
+};
+export declare function stopEngineSessionBackground(sessionId: string, body: {
+    readonly includeRetained: boolean;
+}, opts?: EngineSessionBackgroundStopOptions): Promise<EngineSessionBackgroundStopResult>;
+export type EngineSessionBackgroundReceiptState = 'stopped' | 'still_running' | 'may_be_running';
+export declare const ENGINE_SESSION_BACKGROUND_RECEIPT_STATES: readonly EngineSessionBackgroundReceiptState[];
+export interface EngineSessionBackgroundReceiptReading {
+    readonly state: EngineSessionBackgroundReceiptState;
+    readonly text: string;
+    readonly unrecognizedOutcome?: string;
+}
+export declare function engineSessionBackgroundReceiptReadingOf(outcome: string): EngineSessionBackgroundReceiptReading;

package/dist/agentSession/engineSessionBackgroundStop.js

@@ -0,0 +1,291 @@
+import { engineCapValue } from '../engineCapsCache.js';
+import { isStatusDerivedCoarseCode } from '../engineErrorCodes.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
+import { engineWireDebugEnabled } from '../engineWireTarget.js';
+import { hostLog } from '../host.js';
+import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+const NOTHING_SENT = ' — nothing sent';
+const DETAIL_BAD_SESSION = `the session id must be a non-empty string${NOTHING_SENT}`;
+const DETAIL_BAD_INCLUDE_RETAINED = `includeRetained must be true or false (the engine has no default for it)${NOTHING_SENT}`;
+const DETAIL_BAD_OPTIONS = `the options could not be read${NOTHING_SENT}`;
+const DETAIL_BAD_ARGUMENTS = `the arguments could not be read${NOTHING_SENT}`;
+const DETAIL_BAD_SESSION_KEY = `the session key must be a non-empty string${NOTHING_SENT}`;
+const DETAIL_BAD_SIGNAL = `the signal must be an AbortSignal${NOTHING_SENT}`;
+const DETAIL_INJECTED_UNUSABLE = `the connection supplied by the host cannot send this request (no usable sessions.backgroundStop)${NOTHING_SENT}`;
+const DETAIL_NO_TARGET = `no engine connection is installed for this session${NOTHING_SENT}`;
+const DETAIL_NO_CLIENT = `an engine client could not be built from the installed connection${NOTHING_SENT}`;
+const DETAIL_CAPS_KEY_REQUIRED = `capability evidence for background.exitFaces is not available under the key the host named (capsBaseUrl)${NOTHING_SENT}`;
+const DETAIL_CAPS_UNOBSERVED = `the engine capabilities have not been read for this connection yet — wait for the capability probe to settle, then call again${NOTHING_SENT}`;
+const DETAIL_NO_EXIT_FACE = `this engine does not offer the session background stop (capabilities.background.exitFaces is not true); background tasks may keep running${NOTHING_SENT}`;
+function refusedDetail(why) {
+    switch (why) {
+        case 'credentials_required':
+            return 'this engine does not accept stop requests until it is configured with a service credential';
+        case 'not_permitted':
+            return 'this caller is not permitted to stop the background tasks of this session';
+        case 'ownership_required':
+            return 'this engine has no session ownership face, so it cannot stop session background tasks';
+        case 'session_not_found':
+            return 'the engine does not know this session';
+        case 'route_absent':
+            return 'this engine has no session background stop route';
+        case 'bad_request':
+            return 'the engine rejected the request shape';
+        case 'rate_limited':
+            return 'the engine is rate-limiting stop requests — try again later';
+        case 'other':
+            return 'the engine refused the stop';
+        default: {
+            const unreachable = why;
+            return unreachable;
+        }
+    }
+}
+function note(msg) {
+    try {
+        hostLog('debug', `[session-background] stop: ${msg}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function debugOn() {
+    try {
+        return engineWireDebugEnabled();
+    }
+    catch {
+        return false;
+    }
+}
+function unavailable(why, detail) {
+    note(`unavailable (${why})`);
+    return { kind: 'unavailable', why, detail };
+}
+function usableStopClient(client) {
+    return clientHasVerbs(client, [['sessions', 'backgroundStop']]);
+}
+function exitFaceGate(capsKey) {
+    try {
+        const v = engineCapValue(capsKey, 'background');
+        if (v.kind === 'unobserved')
+            return { why: 'capability_unknown', detail: DETAIL_CAPS_UNOBSERVED };
+        if (v.kind !== 'value')
+            return { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
+        const bg = v.value;
+        if (typeof bg !== 'object' || bg === null || !Object.hasOwn(bg, 'exitFaces'))
+            return { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
+        return bg.exitFaces === true ? null : { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
+    }
+    catch {
+        return { why: 'capability_unknown', detail: DETAIL_CAPS_UNOBSERVED };
+    }
+}
+function readReceipt(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    const id = Object.hasOwn(v, 'id') ? v.id : undefined;
+    const outcome = Object.hasOwn(v, 'outcome') ? v.outcome : undefined;
+    if (typeof id !== 'string' || id.length === 0 || typeof outcome !== 'string' || outcome.length === 0)
+        return undefined;
+    return { id, outcome };
+}
+function readStopped(body) {
+    if (typeof body !== 'object' || body === null || !Object.hasOwn(body, 'receipts')) {
+        note('stopped (receipt list unreadable)');
+        return { kind: 'stopped' };
+    }
+    const raw = body.receipts;
+    if (!Array.isArray(raw)) {
+        note('stopped (receipt list unreadable)');
+        return { kind: 'stopped' };
+    }
+    const receipts = [];
+    let unreadable = 0;
+    for (const r of raw) {
+        const got = readReceipt(r);
+        if (got === undefined)
+            unreadable++;
+        else
+            receipts.push(got);
+    }
+    if (unreadable > 0)
+        note(`stopped (${unreadable} receipt(s) unreadable)`);
+    else if (debugOn())
+        note(`stopped (${receipts.length} receipt(s))`);
+    return { kind: 'stopped', receipts, ...(unreadable > 0 ? { unreadableReceipts: unreadable } : {}) };
+}
+function refusedWhyOf(rawCode, status) {
+    const code = rawCode !== undefined && status !== undefined && isStatusDerivedCoarseCode(rawCode) ? undefined : rawCode;
+    if (code !== undefined) {
+        if (code === 'auth.service_token_required')
+            return 'credentials_required';
+        if (code === 'capability.session_ownership_required')
+            return 'ownership_required';
+        if (code === 'not_found.session')
+            return 'session_not_found';
+        if (code === 'not_found.route')
+            return 'route_absent';
+        if (code === 'limit.rate_exceeded')
+            return 'rate_limited';
+        if (code.startsWith('auth.'))
+            return 'not_permitted';
+        if (code.startsWith('request.'))
+            return 'bad_request';
+    }
+    if (status === undefined)
+        return undefined;
+    if (status === 429)
+        return 'rate_limited';
+    if (status === 401 || status === 403)
+        return 'not_permitted';
+    if (status === 400)
+        return 'bad_request';
+    if (status >= 400 && status < 500)
+        return 'other';
+    return undefined;
+}
+function diagOf(e) {
+    const o = e;
+    const rawStatus = o.status ?? o.statusCode;
+    const status = typeof rawStatus === 'number' && Number.isInteger(rawStatus) ? rawStatus : undefined;
+    const errorCode = typeof o.errorCode === 'string' && o.errorCode.length > 0 ? o.errorCode : undefined;
+    const ra = o.retryAfterMs;
+    const retryAfterMs = typeof ra === 'number' && Number.isFinite(ra) && ra >= 0 ? ra : undefined;
+    const message = typeof o.message === 'string' && o.message.length > 0 ? o.message : undefined;
+    return {
+        ...(status !== undefined ? { status } : {}),
+        ...(errorCode !== undefined ? { errorCode } : {}),
+        ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+        ...(message !== undefined ? { message } : {}),
+    };
+}
+function classifyFailure(e) {
+    try {
+        if (typeof e !== 'object' || e === null) {
+            note('error (non-object failure)');
+            return { kind: 'error', detail: `the stop request failed: ${String(e).slice(0, 200)}` };
+        }
+        const d = diagOf(e);
+        if (d.status === undefined && d.errorCode === undefined) {
+            const noAnswer = noAnswerDetailFrom(e);
+            if (noAnswer !== null) {
+                note('error (no answer — the stop may have taken effect)');
+                return { kind: 'error', detail: noAnswer, unconfirmed: true };
+            }
+        }
+        const diag = { ...(d.status !== undefined ? { status: d.status } : {}), ...(d.errorCode !== undefined ? { errorCode: d.errorCode } : {}) };
+        const bits = [d.status !== undefined ? `status=${d.status}` : '', d.errorCode !== undefined ? `errorCode=${d.errorCode}` : ''].filter((b) => b.length > 0).join(' ');
+        const why = refusedWhyOf(d.errorCode, d.status);
+        if (why !== undefined) {
+            note(`refused (${why})${bits.length > 0 ? ` ${bits}` : ''}`);
+            return {
+                kind: 'refused',
+                why,
+                detail: `${refusedDetail(why)}${bits.length > 0 ? ` (${bits})` : ''}`,
+                ...diag,
+                ...(why === 'rate_limited' && d.retryAfterMs !== undefined ? { retryAfterMs: d.retryAfterMs } : {}),
+            };
+        }
+        note(`error${bits.length > 0 ? ` ${bits}` : ''}`);
+        return { kind: 'error', detail: (d.message ?? 'the stop request failed').slice(0, 300), ...diag };
+    }
+    catch {
+        note('error (the failure could not be read)');
+        return { kind: 'error', detail: 'the stop request failed (the error could not be read)' };
+    }
+}
+export async function stopEngineSessionBackground(sessionId, body, opts) {
+    let includeRetained;
+    let wireIn;
+    let signal;
+    let sessionKey;
+    try {
+        if (typeof sessionId !== 'string' || sessionId.length === 0)
+            return unavailable('bad_input', DETAIL_BAD_SESSION);
+        const flag = typeof body === 'object' && body !== null && Object.hasOwn(body, 'includeRetained') ? body.includeRetained : undefined;
+        if (typeof flag !== 'boolean')
+            return unavailable('bad_input', DETAIL_BAD_INCLUDE_RETAINED);
+        includeRetained = flag;
+        if (opts !== undefined && opts !== null && typeof opts !== 'object')
+            return unavailable('bad_input', DETAIL_BAD_OPTIONS);
+        wireIn = opts?.wire;
+        const sig = opts?.signal;
+        if (sig !== undefined && sig !== null && (typeof sig !== 'object' || typeof sig.addEventListener !== 'function' || typeof sig.aborted !== 'boolean')) {
+            return unavailable('bad_input', DETAIL_BAD_SIGNAL);
+        }
+        signal = sig ?? undefined;
+        const key = opts?.sessionKey;
+        if (key !== undefined && (typeof key !== 'string' || key.length === 0))
+            return unavailable('bad_input', DETAIL_BAD_SESSION_KEY);
+        sessionKey = key ?? DEFAULT_SESSION_KEY;
+    }
+    catch {
+        return unavailable('bad_input', DETAIL_BAD_ARGUMENTS);
+    }
+    let resolved;
+    try {
+        resolved = engineWireFor(wireIn, sessionKey, usableStopClient);
+    }
+    catch {
+        return unavailable('no_wire', wireIn !== undefined ? DETAIL_INJECTED_UNUSABLE : DETAIL_NO_TARGET);
+    }
+    if (resolved.kind === 'injected-unusable')
+        return unavailable('no_wire', DETAIL_INJECTED_UNUSABLE);
+    if (resolved.kind === 'no-target')
+        return unavailable('no_wire', DETAIL_NO_TARGET);
+    if (resolved.kind === 'injected' && resolved.capsBaseUrl === undefined)
+        return unavailable('capability_unknown', DETAIL_CAPS_KEY_REQUIRED);
+    const gate = exitFaceGate(resolved.kind === 'injected' ? resolved.capsBaseUrl : resolved.target.baseUrl);
+    if (gate !== null)
+        return unavailable(gate.why, gate.detail);
+    let client;
+    try {
+        client = resolved.kind === 'injected' ? resolved.client : resolved.make();
+    }
+    catch {
+        client = null;
+    }
+    if (client === null)
+        return unavailable('no_wire', DETAIL_NO_CLIENT);
+    const stopBody = { includeRetained };
+    const stopOnce = (s) => client.sessions.backgroundStop(sessionId, stopBody, s !== undefined ? { signal: s } : undefined);
+    let answered;
+    try {
+        answered = resolved.kind === 'injected' ? await settleInjected(INJECTED_WIRE_SETTLE_MS, signal, stopOnce) : await sendOnce(signal, () => stopOnce(signal));
+    }
+    catch (e) {
+        return classifyFailure(e);
+    }
+    try {
+        return readStopped(answered);
+    }
+    catch {
+        note('stopped (receipt list unreadable)');
+        return { kind: 'stopped' };
+    }
+}
+const RECEIPT_STATE_TEXT = {
+    stopped: 'Stopped.',
+    still_running: 'Still running — it was set to keep running, so it was left in place.',
+    may_be_running: 'May still be running — the engine could not confirm that it ended.',
+};
+export const ENGINE_SESSION_BACKGROUND_RECEIPT_STATES = Object.freeze(Object.keys(RECEIPT_STATE_TEXT));
+function receiptReading(state) {
+    return { state, text: RECEIPT_STATE_TEXT[state] };
+}
+export function engineSessionBackgroundReceiptReadingOf(outcome) {
+    if (typeof outcome !== 'string')
+        return receiptReading('may_be_running');
+    switch (outcome) {
+        case 'killed':
+        case 'already_gone':
+            return receiptReading('stopped');
+        case 'retained_skipped':
+            return receiptReading('still_running');
+        case 'no_pgid':
+            return receiptReading('may_be_running');
+        default:
+            return { ...receiptReading('may_be_running'), unrecognizedOutcome: outcome };
+    }
+}

package/dist/agentsWireCaps.d.ts

@@ -1,4 +1,5 @@
 import { type EngineProbeOpts, type WireAuthTokenSource } from './engineWireSdk.js';
+import type { ReasoningEffort } from './effortWire.js';
 export declare const MAX_TASK_AGENTS = 32;
 export declare const MAX_AGENT_NAME_CHARS = 64;
 export declare const MAX_AGENT_TEXT_CHARS = 4096;
@@ -8,7 +9,7 @@ export declare const MAX_AGENT_TOOL_NAME_CHARS = 128;
 export declare const MAX_AGENT_SKILL_CONTENT_CHARS = 1048576;
 export declare const MAX_AGENT_MAX_TURNS = 1000;
 export declare const TASK_AGENT_WIRE_FIELDS: readonly ["name", "whenToUse", "whenToUseLean", "allowTools", "denyTools", "skills", "background", "isolation", "model", "thinking", "systemPrompt", "maxTurns", "memory", "observer", "observerMessage"];
-export type WireThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export type WireThinkingLevel = ReasoningEffort;
 export type TaskAgentWireSkill = {
     name: string;
     description: string;

package/dist/cloudConfigWireCaps.js

@@ -1,5 +1,6 @@
 import { MCP_CAPS } from './mcpWireCaps.js';
 import { toCappedSpec } from './skillsWireCaps.js';
+import { TIER_ORDER } from './model/tierVocabulary.js';
 const asRec = (v) => (typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined);
 const asArr = (v) => (Array.isArray(v) ? v : []);
 const asStr = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
@@ -127,7 +128,7 @@ function withoutRegistryAnnotations(e) {
     }
     return out;
 }
-const TIER_WORDS = Object.freeze(['ultra', 'max', 'pro', 'flash', 'lite']);
+const TIER_WORDS = TIER_ORDER;
 const TIER_GROUP_NAME = /^[a-z0-9][a-z0-9._-]*$/i;
 const setOwn = (o, k, v) => {
     Object.defineProperty(o, k, { value: v, enumerable: true, writable: true, configurable: true });

package/dist/corruptSession.d.ts

@@ -0,0 +1,3 @@
+export declare function isCorruptSessionError(err: unknown): boolean;
+export declare function isCorruptSessionResult(result: unknown): boolean;
+export declare function isCorruptSessionRunRow(row: unknown): boolean;

package/dist/corruptSession.js

@@ -0,0 +1,29 @@
+import { isCorruptSessionCode } from './engineErrorCodes.js';
+import { effectiveWireErrorCode } from './wireErrorTriage.js';
+import { readRunTerminal } from './runTerminal.js';
+export function isCorruptSessionError(err) {
+    return isCorruptSessionCode(effectiveWireErrorCode(err));
+}
+export function isCorruptSessionResult(result) {
+    try {
+        const read = readRunTerminal(result);
+        return read !== null && read.kind === 'failed' && isCorruptSessionCode(read.code);
+    }
+    catch {
+        return false;
+    }
+}
+export function isCorruptSessionRunRow(row) {
+    if (typeof row !== 'object' || row === null || Array.isArray(row))
+        return false;
+    try {
+        const read = readRunTerminal(row.result);
+        if (read !== null)
+            return read.kind === 'failed' && isCorruptSessionCode(read.code);
+        const column = row.errorCode;
+        return typeof column === 'string' && isCorruptSessionCode(column);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/corruptSessionCopy.d.ts

@@ -0,0 +1 @@
+export declare function corruptSessionContent(): string;

package/dist/corruptSessionCopy.js

@@ -0,0 +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.');
+}

package/dist/decideFailureNote.js

@@ -1,10 +1,13 @@
 import { corruptStoredRowContent, corruptStoredRowWhere } from './wireErrorTriage.js';
 import { parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
+import { decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
     const startup = parkedResumeStartupFromError(err, decision);
+    const moved = decideParkMovedFromError(err);
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
-        (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`));
+        (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
+        (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`));
 }

package/dist/decideReceipt.d.ts

@@ -21,3 +21,9 @@ export interface DecideRefusalDetail {
     resendable: boolean;
 }
 export declare function decideRefusalFromError(e: unknown): DecideRefusalDetail | null;
+export interface DecideParkMovedDetail {
+    code: string;
+    taskId?: string;
+}
+export declare function decideParkMovedFromError(e: unknown): DecideParkMovedDetail | null;
+export declare function decideParkMovedContent(detail: Pick<DecideParkMovedDetail, 'code'>): string;

package/dist/decideReceipt.js

@@ -1,6 +1,8 @@
 import { gateOutcomeOf } from './gateOutcome.js';
 import { resumeReopenFromError } from './resumeRefusalCopy.js';
-import { DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, } from './engineErrorCodes.js';
+import { DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
+import { effectiveWireErrorCode } from './wireErrorTriage.js';
+import { readErrorString } from './wireFailureShape.js';
 const STATUS_RESUMING = 'resuming';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -77,3 +79,30 @@ export function decideRefusalFromError(e) {
         resendable: Object.hasOwn(DECIDE_RESENDABLE, code) ? DECIDE_RESENDABLE[code] === true : false,
     };
 }
+export function decideParkMovedFromError(e) {
+    const code = effectiveWireErrorCode(e);
+    if (code === undefined || !isDecideParkMovedCode(code))
+        return null;
+    const taskId = readErrorString(e, 'taskId');
+    return { code, ...(taskId !== undefined && taskId.length > 0 ? { taskId } : {}) };
+}
+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)',
+    [DECIDE_GATE_MOVED]: 'This approval moved while the decision was on its way (it was parked again, or settled elsewhere)',
+    [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',
+});
+export function decideParkMovedContent(detail) {
+    let code;
+    try {
+        const raw = detail !== null && typeof detail === 'object' ? detail.code : undefined;
+        code = typeof raw === 'string' ? raw : undefined;
+    }
+    catch {
+        code = undefined;
+    }
+    const what = code !== undefined && Object.hasOwn(DECIDE_PARK_MOVED_WHAT, code)
+        ? DECIDE_PARK_MOVED_WHAT[code]
+        : 'This approval changed state while the decision was on its way';
+    const extra = code === DECIDE_CLAIM_LOST ? '; if this approval is still listed, wait a little before deciding it again' : '';
+    return `${what} · This decision was not applied — fetch the pending approvals again and decide from what is pending now${extra}`;
+}

package/dist/effortWire.d.ts

@@ -1,2 +1,3 @@
-export type ReasoningEffort = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+import { type TaskRequestReasoningEffort } from './taskRequestWords.js';
+export type ReasoningEffort = TaskRequestReasoningEffort;
 export declare function effortToReasoningEffort(effort: unknown): ReasoningEffort | undefined;

package/dist/effortWire.js

@@ -1,7 +1,5 @@
-const REASONING_EFFORT_TUPLE = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
-const _effortPins = [true, true];
-void _effortPins;
-const REASONING_EFFORTS = new Set(REASONING_EFFORT_TUPLE);
+import { REASONING_EFFORT_WORDS } from './taskRequestWords.js';
+const REASONING_EFFORTS = new Set(REASONING_EFFORT_WORDS);
 export function effortToReasoningEffort(effort) {
     return typeof effort === 'string' && REASONING_EFFORTS.has(effort) ? effort : undefined;
 }

package/dist/engineErrorCodes.d.ts

@@ -28,6 +28,8 @@ export declare function isInterruptedToolEndCode(code: string | undefined): bool
 export declare const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = "capability.self_orchestration_required";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
+export declare const CORRUPT_SESSION_ERROR_CODE = "corrupt_session";
+export declare function isCorruptSessionCode(code: string | null | undefined): boolean;
 export declare const STOP_PARK_ARBITER_UNREACHABLE = "stop.park_arbiter_unreachable";
 export declare const STOP_PARK_RESUME_WON = "stop.park_resume_won";
 export declare const STOP_NOT_LANDED = "stop.not_landed";
@@ -36,6 +38,8 @@ export declare const STOP_PARKED = "stop.parked";
 export declare const STOP_CONFLICT_CODES: readonly ["stop.park_arbiter_unreachable", "stop.park_resume_won", "stop.not_landed", "stop.not_local", "stop.parked"];
 export declare const OUTPUT_INVALID = "output.invalid";
 export declare const RESUME_POLICY_FOLD_CODE = "resume_blocked_by_policy";
+export declare const STATUS_DERIVED_COARSE_CODES: readonly ["request.rejected", "auth.unauthorized", "auth.forbidden", "not_found.resource", "request.payload_too_large", "request.unprocessable", "limit.rate_exceeded", "capability.unavailable", "internal.error"];
+export declare function isStatusDerivedCoarseCode(code: string | null | undefined): boolean;
 export declare const RESUME_AT_ERROR_CODE_PREFIX = "resume_at.";
 export declare const REWIND_ERROR_CODE_PREFIXES: readonly ["resume_at.", "rewind_snapshot."];
 export declare function isRewindFamilyCode(code: string | undefined): boolean;
@@ -52,6 +56,11 @@ export declare const PARKED_RESUME_STARTUP_FAILED = "parked_resume.startup_faile
 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_LANE_CODES: readonly string[];
+export declare const DECIDE_NOT_PARKED = "decide.not_parked";
+export declare const DECIDE_GATE_MOVED = "decide.gate_moved";
+export declare const DECIDE_CLAIM_LOST = "decide.claim_lost";
+export declare const DECIDE_PARK_MOVED_CODES: readonly string[];
+export declare function isDecideParkMovedCode(code: string | null | undefined): boolean;
 export declare const WORKFLOW_PARK_REFUSAL_CODES: readonly string[];
 export declare function isWorkflowParkRefusalCode(code: unknown): boolean;
 export declare const DRAINING_ERROR_CODE = "draining";

package/dist/engineErrorCodes.js

@@ -59,6 +59,10 @@ export function isInterruptedToolEndCode(code) {
 export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestration_required';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
+export const CORRUPT_SESSION_ERROR_CODE = 'corrupt_session';
+export function isCorruptSessionCode(code) {
+    return code === CORRUPT_SESSION_ERROR_CODE;
+}
 export const STOP_PARK_ARBITER_UNREACHABLE = 'stop.park_arbiter_unreachable';
 export const STOP_PARK_RESUME_WON = 'stop.park_resume_won';
 export const STOP_NOT_LANDED = 'stop.not_landed';
@@ -73,6 +77,20 @@ export const STOP_CONFLICT_CODES = Object.freeze([
 ]);
 export const OUTPUT_INVALID = 'output.invalid';
 export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
+export const STATUS_DERIVED_COARSE_CODES = Object.freeze([
+    'request.rejected',
+    'auth.unauthorized',
+    'auth.forbidden',
+    'not_found.resource',
+    'request.payload_too_large',
+    'request.unprocessable',
+    'limit.rate_exceeded',
+    'capability.unavailable',
+    'internal.error',
+]);
+export function isStatusDerivedCoarseCode(code) {
+    return typeof code === 'string' && STATUS_DERIVED_COARSE_CODES.includes(code);
+}
 export const RESUME_AT_ERROR_CODE_PREFIX = 'resume_at.';
 export const REWIND_ERROR_CODE_PREFIXES = Object.freeze([RESUME_AT_ERROR_CODE_PREFIX, 'rewind_snapshot.']);
 export function isRewindFamilyCode(code) {
@@ -101,6 +119,17 @@ export const DECIDE_WORKFLOW_LANE_CODES = Object.freeze([
     DECIDE_WORKFLOW_HOST_UNKNOWN,
     DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED,
 ]);
+export const DECIDE_NOT_PARKED = 'decide.not_parked';
+export const DECIDE_GATE_MOVED = 'decide.gate_moved';
+export const DECIDE_CLAIM_LOST = 'decide.claim_lost';
+export const DECIDE_PARK_MOVED_CODES = Object.freeze([
+    DECIDE_NOT_PARKED,
+    DECIDE_GATE_MOVED,
+    DECIDE_CLAIM_LOST,
+]);
+export function isDecideParkMovedCode(code) {
+    return typeof code === 'string' && DECIDE_PARK_MOVED_CODES.includes(code);
+}
 const WORKFLOW_PARK_TRUTH_UNREADABLE = 'workflow.park_truth_unreadable';
 const WORKFLOW_PARK_NOT_PENDING = 'workflow.park_not_pending';
 const WORKFLOW_PARK_BINDING_BROKEN = 'workflow.park_binding_broken';