@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/engineGenerationConvergence.js

@@ -0,0 +1,95 @@
+import { usableClockMs } from './clockReading.js';
+export const ENGINE_GENERATION_WINDOW_MARGIN_MS = 5_000;
+export const ENGINE_STOPPED_CALL_PHASES = Object.freeze(['engine-stopped-awaiting-approval', 'engine-stopped-before-result']);
+const EMPTY = Object.freeze({ retract: Object.freeze([]), phases: Object.freeze([]) });
+const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+export function approvalWindowLeftMs(keys, nowMs) {
+    try {
+        const now = usableClockMs(nowMs);
+        if (typeof keys !== 'object' || keys === null || now === null)
+            return undefined;
+        const { receivedAtMs, expiresInMs } = keys;
+        if (usableClockMs(receivedAtMs) === null || typeof expiresInMs !== 'number' || !Number.isFinite(expiresInMs))
+            return undefined;
+        if (now < receivedAtMs)
+            return undefined;
+        return receivedAtMs + expiresInMs - now;
+    }
+    catch {
+        return undefined;
+    }
+}
+function forEachGuarded(items, visit) {
+    let skipped = 0;
+    for (const item of items) {
+        try {
+            visit(item);
+        }
+        catch {
+            skipped += 1;
+        }
+    }
+    return skipped;
+}
+function windowDefinitelyOpen(card) {
+    if (card.closedByEngine === true)
+        return false;
+    const left = card.windowLeftMs;
+    return typeof left === 'number' && Number.isFinite(left) && left > ENGINE_GENERATION_WINDOW_MARGIN_MS;
+}
+export function convergeEndedEngineGeneration(facts) {
+    try {
+        if (typeof facts !== 'object' || facts === null)
+            return EMPTY;
+        const ended = facts.endedGeneration;
+        if (typeof ended !== 'number' || !Number.isFinite(ended))
+            return EMPTY;
+        const retract = [];
+        const phases = [];
+        const held = new Map();
+        const holds = facts.phases;
+        if (Array.isArray(holds)) {
+            forEachGuarded(holds, (p) => {
+                if (typeof p === 'object' && p !== null && nonEmpty(p.toolCallId) && typeof p.generation === 'number')
+                    held.set(p.toolCallId, p.generation);
+            });
+        }
+        const cards = facts.cards;
+        if (Array.isArray(cards)) {
+            forEachGuarded(cards, (card) => {
+                if (typeof card !== 'object' || card === null || !nonEmpty(card.callKey))
+                    return;
+                if (card.parkRow !== false || !windowDefinitelyOpen(card))
+                    return;
+                if (retract.includes(card.callKey))
+                    return;
+                const id = card.toolCallId;
+                retract.push(card.callKey);
+                if (!nonEmpty(id))
+                    return;
+                const heldGen = held.get(id);
+                if (heldGen !== undefined && heldGen !== ended)
+                    return;
+                if (phases.some((p) => p.toolCallId === id))
+                    return;
+                phases.push({ toolCallId: id, phase: 'engine-stopped-awaiting-approval', viaCallKey: card.callKey });
+                held.set(id, ended);
+            });
+        }
+        const opened = facts.opened;
+        if (Array.isArray(opened)) {
+            forEachGuarded(opened, (call) => {
+                if (typeof call !== 'object' || call === null || !nonEmpty(call.toolCallId) || call.generation !== ended)
+                    return;
+                if (held.has(call.toolCallId))
+                    return;
+                phases.push({ toolCallId: call.toolCallId, phase: 'engine-stopped-before-result' });
+                held.set(call.toolCallId, ended);
+            });
+        }
+        return Object.freeze({ retract: Object.freeze(retract), phases: Object.freeze(phases.map((p) => Object.freeze(p))) });
+    }
+    catch {
+        return EMPTY;
+    }
+}

package/dist/engineGenerationPort.d.ts

@@ -0,0 +1,61 @@
+export declare const REATTACH_RUN_STATES: readonly ["done", "died", "parked", "running", "unreachable", "unauthorized", "engine-known-dead"];
+export type ReattachRunState = (typeof REATTACH_RUN_STATES)[number];
+export interface ReattachLivenessReading {
+    readonly state: ReattachRunState;
+    readonly notFound?: boolean;
+}
+export interface ReattachOutageStopLineParts {
+    readonly taskId: string;
+    readonly action: string;
+    readonly nextMessage: string;
+}
+export type ReattachOutageStopLine = (parts: ReattachOutageStopLineParts) => string;
+export interface EndedGenerationMaterials {
+    readonly restartPending: boolean;
+    readonly outageStopLine?: ReattachOutageStopLine;
+}
+export interface EngineGenerationPort {
+    current: () => number;
+    endedMaterials: () => Promise<EndedGenerationMaterials>;
+    replacementInFlight?: () => boolean;
+    awaitEngineInstalled?: (signal: AbortSignal, maxMs: number) => Promise<boolean>;
+}
+export type EngineGenerationReading = {
+    readonly known: true;
+    readonly generation: number;
+} | {
+    readonly known: false;
+};
+export declare function engineGenerationReadingOf(read: (() => number | undefined) | undefined): EngineGenerationReading;
+export declare function engineGenerationOfPort(port: EngineGenerationPort | undefined): EngineGenerationReading;
+export interface EngineGenerationEndedFacts {
+    readonly run: EngineGenerationReading;
+    readonly current: EngineGenerationReading;
+    readonly freshCredentialAdopted?: boolean;
+}
+export declare function engineGenerationEnded(facts: EngineGenerationEndedFacts): boolean;
+export interface ApprovalFrameGenerationFacts {
+    readonly streamOpenedIn: EngineGenerationReading;
+    readonly current: EngineGenerationReading;
+    readonly freshCredentialAdopted?: boolean;
+}
+export declare function approvalFrameGenerationVerdict(facts: ApprovalFrameGenerationFacts): 'admit' | 'drop';
+export declare const REATTACH_AWAIT_NEXT_ENGINE_MS = 245000;
+export declare function unreachableForSettle(liveness: ReattachLivenessReading): boolean;
+export type EndedGenerationSettleStep = 'await-next-engine' | 'refresh-credentials' | 'credentials-rejected' | 'hand-over-terminal' | 'parked' | 'engine-stopped';
+export interface EndedGenerationSettleFacts {
+    readonly liveness: ReattachLivenessReading;
+    readonly canAwaitNextEngine: boolean;
+    readonly awaitedNextEngine: boolean;
+    readonly refreshedCredentials: boolean | null;
+    readonly terminalReadable?: boolean;
+}
+export declare function endedGenerationSettleStep(facts: EndedGenerationSettleFacts): EndedGenerationSettleStep;
+export declare const AWAIT_ENGINE_INSTALL_POLL_MS = 200;
+export interface AwaitNextEngineDeps {
+    readonly installed: () => boolean;
+    readonly replacing: () => boolean;
+    readonly now?: () => number;
+    readonly pollMs?: number;
+}
+export declare function awaitNextEngineInstalled(signal: AbortSignal, maxMs: number, deps: AwaitNextEngineDeps): Promise<boolean>;

package/dist/engineGenerationPort.js

@@ -0,0 +1,144 @@
+import { usableClockMs } from './clockReading.js';
+import { readSignalAborted, tryListenAbortOnce, tryUnlistenAbort } from './engineWireFor.js';
+export const REATTACH_RUN_STATES = Object.freeze(['done', 'died', 'parked', 'running', 'unreachable', 'unauthorized', 'engine-known-dead']);
+const UNKNOWN = Object.freeze({ known: false });
+export function engineGenerationReadingOf(read) {
+    if (typeof read !== 'function')
+        return UNKNOWN;
+    try {
+        const g = read();
+        return typeof g === 'number' && Number.isFinite(g) ? Object.freeze({ known: true, generation: g }) : UNKNOWN;
+    }
+    catch {
+        return UNKNOWN;
+    }
+}
+export function engineGenerationOfPort(port) {
+    if (typeof port !== 'object' || port === null)
+        return UNKNOWN;
+    return engineGenerationReadingOf(() => port.current());
+}
+export function engineGenerationEnded(facts) {
+    try {
+        const { run, current, freshCredentialAdopted } = facts;
+        const runGeneration = knownGenerationOf(run);
+        if (runGeneration === null)
+            return false;
+        if (freshCredentialAdopted === true)
+            return true;
+        const currentGeneration = knownGenerationOf(current);
+        if (currentGeneration === null)
+            return false;
+        return currentGeneration !== runGeneration;
+    }
+    catch {
+        return false;
+    }
+}
+function knownGenerationOf(reading) {
+    if (typeof reading !== 'object' || reading === null)
+        return null;
+    const raw = reading;
+    const known = raw.known;
+    const generation = raw.generation;
+    return known === true && typeof generation === 'number' && Number.isFinite(generation) ? generation : null;
+}
+export function approvalFrameGenerationVerdict(facts) {
+    try {
+        return engineGenerationEnded({ run: facts.streamOpenedIn, current: facts.current, ...(facts.freshCredentialAdopted === true ? { freshCredentialAdopted: true } : {}) }) ? 'drop' : 'admit';
+    }
+    catch {
+        return 'admit';
+    }
+}
+export const REATTACH_AWAIT_NEXT_ENGINE_MS = 245_000;
+export function unreachableForSettle(liveness) {
+    try {
+        return liveness.state === 'engine-known-dead' || (liveness.state === 'unreachable' && liveness.notFound !== true);
+    }
+    catch {
+        return false;
+    }
+}
+export function endedGenerationSettleStep(facts) {
+    try {
+        const liveness = facts.liveness;
+        if (typeof liveness !== 'object' || liveness === null || !REATTACH_RUN_STATES.includes(liveness.state))
+            return 'engine-stopped';
+        if (facts.canAwaitNextEngine === true && facts.awaitedNextEngine !== true && unreachableForSettle(liveness))
+            return 'await-next-engine';
+        if (liveness.state === 'unauthorized')
+            return facts.refreshedCredentials === null ? 'refresh-credentials' : 'credentials-rejected';
+        if (liveness.state === 'done')
+            return facts.terminalReadable === false ? 'engine-stopped' : 'hand-over-terminal';
+        if (liveness.state === 'parked')
+            return 'parked';
+        return 'engine-stopped';
+    }
+    catch {
+        return 'engine-stopped';
+    }
+}
+export const AWAIT_ENGINE_INSTALL_POLL_MS = 200;
+export function awaitNextEngineInstalled(signal, maxMs, deps) {
+    const clock = typeof deps.now === 'function' ? deps.now : () => performance.now();
+    const pollMs = typeof deps.pollMs === 'number' && Number.isFinite(deps.pollMs) && deps.pollMs > 0 ? deps.pollMs : AWAIT_ENGINE_INSTALL_POLL_MS;
+    const budgetMs = typeof maxMs === 'number' && Number.isFinite(maxMs) ? Math.max(0, maxMs) : 0;
+    const maxTicks = Math.ceil(budgetMs / pollMs) + 1;
+    const read = (f) => {
+        try {
+            return f() === true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const now = () => {
+        try {
+            return usableClockMs(clock());
+        }
+        catch {
+            return null;
+        }
+    };
+    return new Promise((resolve) => {
+        if (readSignalAborted(signal) === true) {
+            resolve(false);
+            return;
+        }
+        const start = now();
+        const deadline = start === null ? null : start + budgetMs;
+        let timer;
+        let done = false;
+        let ticks = 0;
+        const finish = (v) => {
+            if (done)
+                return;
+            done = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            tryUnlistenAbort(signal, onAbort);
+            resolve(v);
+        };
+        const onAbort = () => finish(false);
+        tryListenAbortOnce(signal, onAbort);
+        const tick = () => {
+            if (done)
+                return;
+            ticks += 1;
+            if (read(deps.installed))
+                return finish(true);
+            if (done)
+                return;
+            if (!read(deps.replacing))
+                return finish(read(deps.installed));
+            if (done)
+                return;
+            const t = now();
+            if (deadline === null || t === null || t >= deadline || ticks >= maxTicks)
+                return finish(false);
+            timer = setTimeout(tick, pollMs);
+        };
+        tick();
+    });
+}

package/dist/engineHealthFacts.d.ts

@@ -0,0 +1,23 @@
+import type { HealthAuthKind } from '@sema-agent/sdk';
+export interface EngineHealthCenterFacts {
+    readonly issuer?: string;
+    readonly webBaseUrl?: string;
+    readonly sessionsVisible: boolean | 'unknown';
+}
+export interface EngineHealthAuthFacts {
+    readonly required: boolean;
+    readonly kinds: readonly (HealthAuthKind | (string & {}))[];
+    readonly identityAttach: 'available' | 'unavailable';
+}
+export interface EngineHealthDrainingFacts {
+    readonly actionId: string;
+    readonly since: number;
+    readonly deadlineAt: number;
+}
+export interface EngineHealthFacts {
+    readonly center?: EngineHealthCenterFacts;
+    readonly auth?: EngineHealthAuthFacts;
+    readonly operator?: 'present' | 'absent';
+    readonly draining?: EngineHealthDrainingFacts;
+}
+export declare function readEngineHealthFacts(health: object | null | undefined): EngineHealthFacts;

package/dist/engineHealthFacts.js

@@ -0,0 +1,92 @@
+import { readOwnDataValue } from './ownKey.js';
+const _healthFactsMatchSdk = [true, true, true, true, true, true];
+void _healthFactsMatchSdk;
+const ENGINE_SIGNAL_KEY = 'engineSignal';
+function isObject(v) {
+    try {
+        return typeof v === 'object' && v !== null && !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function nonEmptyString(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function epochMs(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : undefined;
+}
+function centerOf(raw) {
+    if (!isObject(raw))
+        return undefined;
+    const sessionsVisible = readOwnDataValue(raw, 'sessionsVisible');
+    if (sessionsVisible !== true && sessionsVisible !== false && sessionsVisible !== 'unknown')
+        return undefined;
+    const issuerRaw = readOwnDataValue(raw, 'issuer');
+    const urlRaw = readOwnDataValue(raw, 'webBaseUrl');
+    const issuer = nonEmptyString(issuerRaw);
+    const webBaseUrl = nonEmptyString(urlRaw);
+    if (issuerRaw !== undefined && issuer === undefined)
+        return undefined;
+    if (urlRaw !== undefined && webBaseUrl === undefined)
+        return undefined;
+    return Object.freeze({ ...(issuer !== undefined ? { issuer } : {}), ...(webBaseUrl !== undefined ? { webBaseUrl } : {}), sessionsVisible });
+}
+function authOf(raw) {
+    if (!isObject(raw))
+        return undefined;
+    const required = readOwnDataValue(raw, 'required');
+    const identityAttach = readOwnDataValue(raw, 'identityAttach');
+    const kindsRaw = readOwnDataValue(raw, 'kinds');
+    if (typeof required !== 'boolean')
+        return undefined;
+    if (identityAttach !== 'available' && identityAttach !== 'unavailable')
+        return undefined;
+    if (!Array.isArray(kindsRaw))
+        return undefined;
+    const kinds = [];
+    for (let i = 0; i < kindsRaw.length; i++) {
+        const word = nonEmptyString(readOwnDataValue(kindsRaw, String(i)));
+        if (word === undefined)
+            return undefined;
+        kinds.push(word);
+    }
+    return Object.freeze({ required, kinds: Object.freeze(kinds), identityAttach });
+}
+function drainingOf(health) {
+    const signal = readOwnDataValue(health, ENGINE_SIGNAL_KEY);
+    if (!isObject(signal))
+        return undefined;
+    const raw = readOwnDataValue(signal, 'draining');
+    if (!isObject(raw))
+        return undefined;
+    const actionId = nonEmptyString(readOwnDataValue(raw, 'actionId'));
+    const since = epochMs(readOwnDataValue(raw, 'since'));
+    const deadlineAt = epochMs(readOwnDataValue(raw, 'deadlineAt'));
+    if (actionId === undefined || since === undefined || deadlineAt === undefined)
+        return undefined;
+    return Object.freeze({ actionId, since, deadlineAt });
+}
+function guarded(read) {
+    try {
+        return read();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readEngineHealthFacts(health) {
+    if (!isObject(health))
+        return Object.freeze({});
+    const center = guarded(() => centerOf(readOwnDataValue(health, 'center')));
+    const auth = guarded(() => authOf(readOwnDataValue(health, 'auth')));
+    const operatorRaw = guarded(() => readOwnDataValue(health, 'operator'));
+    const operator = operatorRaw === 'present' || operatorRaw === 'absent' ? operatorRaw : undefined;
+    const draining = guarded(() => drainingOf(health));
+    return Object.freeze({
+        ...(center !== undefined ? { center } : {}),
+        ...(auth !== undefined ? { auth } : {}),
+        ...(operator !== undefined ? { operator } : {}),
+        ...(draining !== undefined ? { draining } : {}),
+    });
+}

package/dist/engineIdentity.d.ts

@@ -10,3 +10,7 @@ export declare function engineIdentityVerdict(a: unknown, b: unknown): EngineIde
 export declare function engineIdentityChangedBy(a: unknown, b: unknown): keyof EngineIdentityView | undefined;
 export declare function engineIdentityChanged(a: unknown, b: unknown): boolean;
 export declare function toolKillCauseAcrossEngineIdentity(before: object | null | undefined, after: object | null | undefined): 'engine_restarted' | undefined;
+export declare function toolKillCauseFromGenerationEnd(input: {
+    readonly cause?: string | undefined;
+    readonly stopSignalDelivered?: boolean | undefined;
+} | null | undefined): 'engine_restarted' | undefined;

package/dist/engineIdentity.js

@@ -1,3 +1,4 @@
+import { readOwnDataValue } from './ownKey.js';
 const _startedAtIsOneQuantity = [true, true, true, true];
 void _startedAtIsOneQuantity;
 export const ENGINE_IDENTITY_ANCHORS = Object.freeze([
@@ -63,3 +64,13 @@ export function toolKillCauseAcrossEngineIdentity(before, after) {
         return undefined;
     }
 }
+export function toolKillCauseFromGenerationEnd(input) {
+    try {
+        if (typeof input !== 'object' || input === null)
+            return undefined;
+        return readOwnDataValue(input, 'cause') === 'respawned' && readOwnDataValue(input, 'stopSignalDelivered') === true ? 'engine_restarted' : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/engineNoticeCodes.d.ts

@@ -1,3 +1,4 @@
+import type { FinishReasonUnknownDetail } from '@sema-agent/sdk';
 import { CORE_TOOL_TURN_INCOMPLETE_CAUSES, CORE_USER_INPUT_UNDRAINED_CAUSES, CORE_USER_INPUT_UNDRAINED_FAMILIES } from './generated/engineNoticeTables.js';
 export type NoticeAudience = 'user' | 'operator';
 export declare const ENGINE_NOTICE_CODES: readonly string[];
@@ -202,11 +203,7 @@ export declare function readTurnInterrupted(notice: unknown): TurnInterruptedFac
 export declare function turnInterruptedNotice(facts: Pick<TurnInterruptedFactsView, 'lane'>): string | undefined;
 export type SteerCutVerdict = 'this_input' | 'other_input' | 'user_halt' | 'unattributed' | 'not_a_cut';
 export declare function steerCutVerdict(notice: unknown, messageId: string | undefined): SteerCutVerdict;
-export interface FinishReasonUnknownFactsView {
-    finishReason: string;
-    sessionId: string;
-    runId: string;
-}
+export type FinishReasonUnknownFactsView = FinishReasonUnknownDetail;
 export declare function readFinishReasonUnknown(notice: unknown): FinishReasonUnknownFactsView | undefined;
 export interface StreamEndIgnoredFactsView {
     statement: string;

package/dist/engineRowRef.js

@@ -96,6 +96,10 @@ export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([
     '_sema_api_error_status',
     '_sema_api_error_code',
     '_sema_provider_condition',
+    '_sema_terminal_owner',
+    '_sema_row_kind',
+    '_sema_coded_detail',
+    '_sema_task_notification',
 ]);
 export function parkHeldCallIdOf(carrier) {
     return readFrameStringKey(carrier, 'toolCallId');

package/dist/engineSessionMessages.js

@@ -1,5 +1,5 @@
 import { isGateParkedToolEnd } from './gateOutcome.js';
-import { ownDataField, ownSendableField } from './ownKey.js';
+import { appendOwnElement, ownDataField, ownSendableField } from './ownKey.js';
 const isObjectLike = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function optionalOwn(o, key) {
     try {
@@ -17,7 +17,7 @@ function itemsOf(a) {
         return undefined;
     const out = [];
     for (let i = 0; i < n; i += 1)
-        out.push(ownDataField(a, String(i)));
+        appendOwnElement(out, ownDataField(a, String(i)));
     return out;
 }
 const JSON_MAX_DEPTH = 64;

package/dist/engineToolDirectory.d.ts

@@ -10,6 +10,9 @@ export type EngineToolDirectory = {
     readonly state: 'not_landed';
 } | {
     readonly state: 'unreadable';
+} | {
+    readonly state: 'request_only';
+    readonly requestMcpServerPrefixes: ReadonlySet<string>;
 } | {
     readonly state: 'directory';
     readonly mcpServerPrefixes: ReadonlySet<string>;

package/dist/engineToolDirectory.js

@@ -1,5 +1,5 @@
 import { frozenSet } from './frozenSet.js';
-import { ownDataField } from './ownKey.js';
+import { appendOwnElement, ownDataField } from './ownKey.js';
 import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix } from './coreValuePorts.js';
 const notLanded = () => Object.freeze({ state: 'not_landed' });
 const unreadable = () => Object.freeze({ state: 'unreadable' });
@@ -21,7 +21,7 @@ function readHalf(half) {
         const name = ownDataField(row, 'name');
         if (typeof name !== 'string' || name.length === 0)
             return 'unreadable';
-        names.push(name);
+        appendOwnElement(names, name);
     }
     return names;
 }
@@ -35,18 +35,20 @@ export function engineToolDirectoryOf(source) {
         const deployment = readHalf(ownDataField(source, 'deploymentMcpServers'));
         if (request === 'unreadable' || deployment === 'unreadable')
             return unreadable();
-        if (request === 'absent' || deployment === 'absent')
+        if (request === 'absent')
             return notLanded();
         const ns = namingPorts();
         if (ns === undefined)
             return unreadable();
         const prefixes = [];
-        for (const name of [...request, ...deployment]) {
+        for (const name of deployment === 'absent' ? request : [...request, ...deployment]) {
             const prefix = mintNamespacePrefix(ns, name);
             if (typeof prefix !== 'string' || prefix.length === 0)
                 return unreadable();
             prefixes.push(prefix);
         }
+        if (deployment === 'absent')
+            return Object.freeze({ state: 'request_only', requestMcpServerPrefixes: frozenSet(prefixes) });
         return Object.freeze({ state: 'directory', mcpServerPrefixes: frozenSet(prefixes) });
     }
     catch {

package/dist/engineWireFor.d.ts

@@ -1,6 +1,7 @@
 import type { AgentClient } from '@sema-agent/sdk';
 import { type EngineWireClientConfig, type EngineWireInjection } from './engineWireSdk.js';
 import { type EngineWireTarget } from './engineWireTarget.js';
+import { THROWN_SLOT_UNREADABLE, type SlotPresence } from './wireFailureShape.js';
 export declare const INJECTED_WIRE_SETTLE_MS = 60000;
 export type EngineWireTargetClientOptions = Pick<EngineWireClientConfig, 'timeoutMs' | 'maxRetries'>;
 export interface EngineWireInjected<C> {
@@ -22,6 +23,12 @@ export interface EngineWireNoTarget {
 export type EngineWireResolution<C> = EngineWireInjected<C> | EngineWireFromTarget | EngineWireInjectedUnusable | EngineWireNoTarget;
 export declare function engineWireFor<C extends object>(wire: EngineWireInjection<C> | undefined, sessionKey: string, usable: (client: object) => client is C): EngineWireResolution<C>;
 export declare function clientHasVerbs(client: object, verbs: ReadonlyArray<ReadonlyArray<string>>): boolean;
+export declare function readSignalAborted(signal: AbortSignal): boolean | null;
+export declare function readSignalReason(signal: AbortSignal): {
+    readonly reason: {} | null | undefined;
+} | null;
+export declare function tryListenAbortOnce(signal: AbortSignal, listener: () => void): boolean;
+export declare function tryUnlistenAbort(signal: AbortSignal, listener: () => void): boolean;
 export interface LinkedAbortSignal {
     signal: AbortSignal;
     dispose: () => void;
@@ -36,6 +43,97 @@ export declare class EngineWireCancelledError extends Error {
     constructor();
 }
 export declare function connectionLostDetail(): string;
+export type CauseSlotValue = {} | null | undefined;
+type CauseChainEnd = 'complete' | 'depth_cap' | 'unreadable';
+export declare function walkCauseChain(e: CauseSlotValue, visit: (layer: object, depth: number) => 'stop' | undefined, readCause?: (layer: object) => CauseSlotValue | typeof THROWN_SLOT_UNREADABLE, callableReach?: boolean): {
+    stopped: true;
+} | {
+    stopped: false;
+    end: CauseChainEnd;
+};
+export declare const causeSlotProtected: (layer: object) => CauseSlotValue | typeof THROWN_SLOT_UNREADABLE;
+export declare function causeSlotReadOf(layer: object): CauseSlotRead;
+export interface CauseSlotRead {
+    readonly value: CauseSlotValue | typeof THROWN_SLOT_UNREADABLE;
+    readonly presence: SlotPresence;
+}
+export declare const TRANSIENT_TRANSPORT_CODES: readonly string[];
+export type TransportChainReading = 'transient' | 'answered' | 'blocked' | 'none';
+export interface ChainAnswer {
+    readonly layer: object;
+    readonly status: number;
+}
+export interface TransportChainVerdict {
+    readonly reading: TransportChainReading;
+    readonly answer?: ChainAnswer;
+    readonly chainEnd?: 'unreadable';
+}
+export declare function transportChainReading(e: CauseSlotValue, facets: 'retry' | 'code', stopOn?: (layer: object) => boolean, topStatusAlreadyRead?: boolean): TransportChainReading;
+export declare function transportChainVerdict(e: CauseSlotValue, facets: 'retry' | 'code', stopOn?: (layer: object) => boolean, topStatusAlreadyRead?: boolean, noteTopCause?: (read: CauseSlotRead) => void, noteTopLocalCode?: (value: {} | null | undefined) => void): TransportChainVerdict;
+export interface AnswerReading {
+    readonly answer: ChainAnswer | typeof THROWN_SLOT_UNREADABLE | undefined;
+    readonly chain: TransportChainVerdict;
+    readonly topCause?: CauseSlotRead;
+    readonly topLocalCode?: {
+        readonly value: CapturedLocalCode;
+    };
+    readonly topStatusSlot?: SlotPresence;
+}
+export declare function answerReadingOf(e: CauseSlotValue): AnswerReading;
+export declare function answeringLayerOf(e: CauseSlotValue): ChainAnswer | typeof THROWN_SLOT_UNREADABLE | undefined;
+export type CapturedCode = {
+    readonly state: 'read';
+    readonly wire?: string;
+    readonly blockedBy?: string;
+} | {
+    readonly state: 'unreadable';
+};
+export type CapturedLocalCode = string | undefined | typeof THROWN_SLOT_UNREADABLE;
+declare class AnswerCaptureRecord implements ChainAnswer {
+    protected readonly answerCaptureBrand: true;
+    readonly layer: object;
+    readonly status: number;
+    readonly code: CapturedCode;
+    readonly localCode: CapturedLocalCode;
+    constructor(layer: object, status: number, code: CapturedCode, localCode: CapturedLocalCode);
+}
+export type AnswerCapture = AnswerCaptureRecord;
+export declare const CODE_UNREADABLE: CapturedCode;
+export declare function captureAnswer(answer: ChainAnswer, codeSlot: {} | null | undefined): AnswerCapture;
+declare class UnansweredCaptureRecord {
+    protected readonly unansweredCaptureBrand: true;
+    readonly layer: object;
+    readonly status: undefined;
+    readonly code: CapturedCode;
+    readonly localCode: CapturedLocalCode;
+    readonly statusSlot: SlotPresence;
+    constructor(layer: object, code: CapturedCode, localCode: CapturedLocalCode, statusSlot: SlotPresence);
+}
+export type UnansweredCapture = UnansweredCaptureRecord;
+export declare function captureUnanswered(layer: object, codeSlot: {} | null | undefined, localCodeRead: {
+    readonly value: CapturedLocalCode;
+} | undefined, statusSlot?: SlotPresence): UnansweredCapture;
+export declare function effectiveCodeOf(code: CapturedCode): string | undefined;
+export interface TriageReading {
+    readonly answer: AnswerCapture | typeof THROWN_SLOT_UNREADABLE | undefined;
+    readonly unanswered?: UnansweredCapture;
+    readonly topLocalCode?: TopLocalCodeReading;
+    readonly topCause?: TopCauseReading;
+    readonly transport: boolean;
+    readonly chainEnd?: 'unreadable';
+}
+export interface TopLocalCodeReading {
+    readonly layer: object;
+    readonly localCode: CapturedLocalCode;
+}
+export interface TopCauseReading {
+    readonly layer: object;
+    readonly read: CauseSlotRead;
+}
+export declare function ownReadingSlot<T extends object, K extends keyof T & string>(record: T | undefined, key: K): T[K] | undefined;
+export declare function noteTriageReading(verdict: object, reading: TriageReading): void;
+export declare function triageReadingOf(verdict: object): TriageReading | undefined;
+export declare function attemptTimeoutOnChain(e: CauseSlotValue): boolean;
 export type EngineWireNoAnswerKind = 'deadline' | 'time-limit' | 'connection-lost' | 'cancelled';
 export declare function noAnswerKindOf(e: object | null | undefined): EngineWireNoAnswerKind | null;
 export declare function noAnswerDetailFrom(e: object | null | undefined): string | null;
@@ -64,3 +162,4 @@ export interface TransportFailureScene {
 }
 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>;
+export {};