@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/engineRepoint.d.ts

@@ -0,0 +1,147 @@
+import { type DeviceListVerb } from './deviceRebind.js';
+import { type SessionMapStorePort } from './sessionMap.js';
+import { type MessageRef } from './i18n/translate.js';
+declare const HELLO_REJECT_WORDS: readonly ["auth_failed", "revoked", "protocol_version_unsupported", "draining", "already_connected"];
+export type DeviceHelloRejectWord = (typeof HELLO_REJECT_WORDS)[number];
+export type DeviceHelloReading = {
+    readonly kind: 'ack';
+} | {
+    readonly kind: 'reject';
+    readonly code: DeviceHelloRejectWord;
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function deviceHelloReadingOf(frame: {} | null | undefined): DeviceHelloReading;
+export interface EngineRepointInput {
+    readonly from: string;
+    readonly to: string;
+    readonly continuity?: EngineRepointContinuity;
+}
+export interface EngineRepointContinuity {
+    readonly deviceId: string;
+    readonly from: string;
+    readonly to: string;
+}
+export interface EngineRepointHandshakeTarget {
+    readonly address: string;
+    readonly deviceId: string;
+}
+export type EngineRepointHandshakePort = (target: EngineRepointHandshakeTarget, opts?: {
+    readonly signal?: AbortSignal;
+}) => Promise<{} | null | undefined> | {} | null | undefined;
+export interface EngineRepointRoster {
+    readonly credential: 'operator' | 'non-operator';
+    readonly devices: (address: string) => DeviceListVerb | null | undefined;
+}
+export type EngineRepointRecordReading = {
+    readonly kind: 'absent';
+} | EngineRepointRecordPresent | {
+    readonly kind: 'unreadable';
+};
+export interface EngineRepointRecordPresent {
+    readonly kind: 'present';
+    readonly status: 'active' | 'enrolling' | 'revoked';
+    readonly deviceId?: string;
+}
+export type EngineRepointMoveResult = {
+    readonly kind: 'moved';
+} | {
+    readonly kind: 'failed';
+};
+export interface EngineRepointRecordPort {
+    read(address: string): EngineRepointRecordReading | Promise<EngineRepointRecordReading>;
+    move(from: string, to: string): EngineRepointMoveResult | Promise<EngineRepointMoveResult>;
+}
+export interface EngineRepointSessionsPort {
+    stores(): readonly SessionMapStorePort[] | Promise<readonly SessionMapStorePort[]>;
+}
+export interface EngineRepointPorts {
+    readonly handshake?: EngineRepointHandshakePort;
+    readonly roster?: EngineRepointRoster;
+    readonly record: EngineRepointRecordPort;
+    readonly sessions: EngineRepointSessionsPort;
+    readonly signal?: AbortSignal;
+}
+export type EngineRepointProofState = 'proven' | 'unproven' | 'unreadable';
+export type EngineRepointHandshakeProof = {
+    readonly state: 'proven';
+} | {
+    readonly state: 'unproven';
+    readonly why: 'auth_failed' | 'revoked';
+} | {
+    readonly state: 'unreadable';
+    readonly why: 'draining' | 'already_connected' | 'protocol_version_unsupported' | 'unreadable_frame' | 'transport' | 'unarmed';
+};
+export type EngineRepointRosterProof = {
+    readonly state: 'proven';
+} | {
+    readonly state: 'unproven';
+    readonly why: 'not-listed' | 'lane-absent';
+} | {
+    readonly state: 'unreadable';
+    readonly why: 'operator-credential' | 'credential-unknown' | 'list-incomplete' | 'refused' | 'transport' | 'unreadable' | 'unarmed';
+};
+export interface EngineRepointProofs {
+    readonly handshake: EngineRepointHandshakeProof;
+    readonly roster: EngineRepointRosterProof;
+}
+export type EngineRepointVerdict = 'apply' | 'unverified' | 'undetermined';
+export interface EngineRepointExit {
+    readonly path: 'reenroll-at-engine-address';
+    readonly address: string;
+    readonly removeDeviceId: string;
+}
+export interface EngineRepointSessionTally {
+    readonly moved: number;
+    readonly unaffected: number;
+    readonly conflict: number;
+    readonly unreadable: number;
+    readonly storeFailed: number;
+}
+export type EngineRepointRefusal = 'address-invalid' | 'same-address' | 'record-absent' | 'record-not-active' | 'record-unreadable' | 'target-occupied' | 'roster-unbound' | 'unarmed';
+export type EngineRepointResult = EngineRepointDone | EngineRepointPartial | EngineRepointUnverified | EngineRepointUndetermined | EngineRepointStoreFailed | EngineRepointRefused;
+export interface EngineRepointDone {
+    readonly kind: 'repointed';
+    readonly deviceId: string;
+    readonly continuity: EngineRepointContinuity;
+    readonly record: 'moved' | 'already-there';
+    readonly sessions: EngineRepointSessionTally;
+    readonly proofs: EngineRepointProofs;
+}
+export interface EngineRepointPartial {
+    readonly kind: 'partial';
+    readonly stage: 'sessions' | 'sessions-list';
+    readonly deviceId: string;
+    readonly continuity: EngineRepointContinuity;
+    readonly record: 'moved' | 'already-there';
+    readonly sessions: EngineRepointSessionTally;
+    readonly proofs: EngineRepointProofs;
+}
+export interface EngineRepointUnverified {
+    readonly kind: 'unverified';
+    readonly deviceId: string;
+    readonly proofs: EngineRepointProofs;
+    readonly exit: EngineRepointExit;
+}
+export interface EngineRepointUndetermined {
+    readonly kind: 'undetermined';
+    readonly deviceId: string;
+    readonly proofs: EngineRepointProofs;
+    readonly exit: EngineRepointExit;
+    readonly retryable: true;
+}
+export interface EngineRepointStoreFailed {
+    readonly kind: 'store-failed';
+    readonly stage: 'record';
+    readonly deviceId: string;
+    readonly continuity: EngineRepointContinuity;
+}
+export interface EngineRepointRefused {
+    readonly kind: 'refused';
+    readonly reason: EngineRepointRefusal;
+    readonly recordStatus?: 'enrolling' | 'revoked';
+}
+export declare function engineRepointVerdictOf(proofs: {} | null | undefined): EngineRepointVerdict;
+export declare function repointEngine(input: EngineRepointInput, ports: EngineRepointPorts): Promise<EngineRepointResult>;
+export declare function engineRepointMessageOf(result: {} | null | undefined): MessageRef | undefined;
+export {};

package/dist/engineRepoint.js

@@ -0,0 +1,310 @@
+import { listDevices } from './deviceRebind.js';
+import { engineUrlTransportVerdict, normalizeEngineBaseUrl } from './engineUrl.js';
+import { engineNamespaceKeyFor } from './sessionMap.js';
+import { repointSessionEngine } from './sessionEngine.js';
+import { slotReadOf } from './wireFailureShape.js';
+import { msg } from './i18n/translate.js';
+const HELLO_REJECT_WORDS = Object.freeze(['auth_failed', 'revoked', 'protocol_version_unsupported', 'draining', 'already_connected']);
+const HELLO_ACK = Object.freeze({ kind: 'ack' });
+const HELLO_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+function dataOf(o, key) {
+    if (o === null || typeof o !== 'object')
+        return undefined;
+    const s = slotReadOf(o, key);
+    return s.presence === 'present' ? s.value : undefined;
+}
+const isObject = (v) => v !== null && typeof v === 'object';
+export function deviceHelloReadingOf(frame) {
+    const t = dataOf(frame, 't');
+    if (t === 'helloAck')
+        return dataOf(frame, 'ok') === true ? HELLO_ACK : HELLO_UNREADABLE;
+    if (t === 'helloReject') {
+        const code = dataOf(frame, 'code');
+        const word = HELLO_REJECT_WORDS.find((w) => w === code);
+        return word === undefined ? HELLO_UNREADABLE : Object.freeze({ kind: 'reject', code: word });
+    }
+    return HELLO_UNREADABLE;
+}
+const freeze = (v) => Object.freeze(v);
+function methodOf(o, key) {
+    if (!isObject(o))
+        return undefined;
+    try {
+        const v = o[key];
+        return typeof v === 'function' ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const HS_PROVEN = freeze({ state: 'proven' });
+async function handshakeProofOf(port, target, signal) {
+    if (typeof port !== 'function')
+        return freeze({ state: 'unreadable', why: 'unarmed' });
+    let frame;
+    try {
+        frame = await port(target, signal !== undefined ? { signal } : undefined);
+    }
+    catch {
+        return freeze({ state: 'unreadable', why: 'transport' });
+    }
+    const r = deviceHelloReadingOf(frame);
+    if (r.kind === 'ack')
+        return HS_PROVEN;
+    if (r.kind === 'unreadable')
+        return freeze({ state: 'unreadable', why: 'unreadable_frame' });
+    if (r.code === 'auth_failed' || r.code === 'revoked')
+        return freeze({ state: 'unproven', why: r.code });
+    return freeze({ state: 'unreadable', why: r.code });
+}
+const RO_PROVEN = freeze({ state: 'proven' });
+function rosterSliceOf(roster, target) {
+    if (!isObject(roster))
+        return { kind: 'proof', proof: freeze({ state: 'unreadable', why: 'unarmed' }) };
+    const credential = dataOf(roster, 'credential');
+    if (credential === 'operator')
+        return { kind: 'proof', proof: freeze({ state: 'unreadable', why: 'operator-credential' }) };
+    if (credential !== 'non-operator')
+        return { kind: 'proof', proof: freeze({ state: 'unreadable', why: 'credential-unknown' }) };
+    const factory = dataOf(roster, 'devices');
+    if (typeof factory !== 'function')
+        return { kind: 'unbound' };
+    let slice;
+    try {
+        slice = factory(target);
+    }
+    catch {
+        return { kind: 'proof', proof: freeze({ state: 'unreadable', why: 'unreadable' }) };
+    }
+    return slice === null || slice === undefined ? { kind: 'unbound' } : { kind: 'slice', devices: slice };
+}
+async function rosterProofOf(devices, deviceId, signal) {
+    const out = await listDevices(devices, signal !== undefined ? { signal } : undefined);
+    switch (out.kind) {
+        case 'ok':
+            if (out.devices.some((d) => d.deviceId === deviceId))
+                return RO_PROVEN;
+            return out.dropped > 0
+                ? freeze({ state: 'unreadable', why: 'list-incomplete' })
+                : freeze({ state: 'unproven', why: 'not-listed' });
+        case 'lane-absent':
+            return freeze({ state: 'unproven', why: 'lane-absent' });
+        case 'refused':
+            return freeze({ state: 'unreadable', why: 'refused' });
+        case 'transport':
+            return freeze({ state: 'unreadable', why: 'transport' });
+        case 'unarmed':
+            return freeze({ state: 'unreadable', why: 'unarmed' });
+        default:
+            return freeze({ state: 'unreadable', why: 'unreadable' });
+    }
+}
+function proofStateOf(proofs, key) {
+    const state = dataOf(dataOf(proofs, key), 'state');
+    return state === 'proven' || state === 'unproven' ? state : 'unreadable';
+}
+export function engineRepointVerdictOf(proofs) {
+    const a = proofStateOf(proofs, 'handshake');
+    const b = proofStateOf(proofs, 'roster');
+    if (a === 'unreadable' || b === 'unreadable')
+        return 'undetermined';
+    return a === 'unproven' || b === 'unproven' ? 'unverified' : 'apply';
+}
+const UNREADABLE_RECORD = freeze({ k: 'unreadable' });
+async function recordFactOf(read, port, address) {
+    let raw;
+    try {
+        raw = await read.call(port, address);
+    }
+    catch {
+        return UNREADABLE_RECORD;
+    }
+    const kind = dataOf(raw, 'kind');
+    if (kind === 'absent')
+        return freeze({ k: 'absent' });
+    if (kind !== 'present')
+        return UNREADABLE_RECORD;
+    const status = dataOf(raw, 'status');
+    if (status === 'enrolling' || status === 'revoked')
+        return freeze({ k: 'other', status });
+    if (status !== 'active')
+        return UNREADABLE_RECORD;
+    const deviceId = dataOf(raw, 'deviceId');
+    return typeof deviceId === 'string' && deviceId !== '' ? freeze({ k: 'active', deviceId }) : UNREADABLE_RECORD;
+}
+function continuityReadingOf(raw) {
+    if (!isObject(raw))
+        return undefined;
+    const deviceId = dataOf(raw, 'deviceId');
+    const f = addressOf(dataOf(raw, 'from'), false);
+    const t = addressOf(dataOf(raw, 'to'), true);
+    if (typeof deviceId !== 'string' || deviceId === '' || f === undefined || t === undefined)
+        return undefined;
+    return freeze({ deviceId, fromKey: engineNamespaceKeyFor(f), toKey: engineNamespaceKeyFor(t) });
+}
+function planOf(from, to, evidence, pair) {
+    if (from.k === 'unreadable' || to.k === 'unreadable')
+        return { kind: 'refused', reason: 'record-unreadable' };
+    if (from.k === 'other')
+        return { kind: 'refused', reason: 'record-not-active', recordStatus: from.status };
+    if (from.k === 'active') {
+        if (to.k === 'absent')
+            return { kind: 'move', deviceId: from.deviceId };
+        if (to.k === 'active' && to.deviceId === from.deviceId)
+            return { kind: 'move', deviceId: from.deviceId };
+        return { kind: 'refused', reason: 'target-occupied' };
+    }
+    if (to.k === 'active') {
+        const bound = evidence !== undefined && to.deviceId === evidence.deviceId && evidence.fromKey === pair.fromKey && evidence.toKey === pair.toKey;
+        return bound ? { kind: 'finish', deviceId: to.deviceId } : { kind: 'refused', reason: 'record-absent' };
+    }
+    if (to.k === 'other')
+        return { kind: 'refused', reason: 'record-not-active', recordStatus: to.status };
+    return { kind: 'refused', reason: 'record-absent' };
+}
+const refusedOf = (reason, recordStatus) => freeze(recordStatus === undefined ? { kind: 'refused', reason } : { kind: 'refused', reason, recordStatus });
+function addressOf(raw, forTarget) {
+    const n = normalizeEngineBaseUrl(typeof raw === 'string' ? raw : undefined);
+    if (!n.ok)
+        return undefined;
+    if (forTarget && !engineUrlTransportVerdict(n.url).ok)
+        return undefined;
+    return n.url;
+}
+function tallyOf(c) {
+    return freeze({ moved: c.moved, unaffected: c.unaffected, conflict: c.conflict, unreadable: c.unreadable, storeFailed: c.storeFailed });
+}
+function storeListOf(list) {
+    try {
+        if (!Array.isArray(list))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const len = dataOf(list, 'length');
+    if (typeof len !== 'number' || !Number.isSafeInteger(len) || len < 0)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < len; i += 1)
+        out.push(dataOf(list, String(i)));
+    return out;
+}
+export async function repointEngine(input, ports) {
+    try {
+        const from = addressOf(dataOf(input, 'from'), false);
+        const to = addressOf(dataOf(input, 'to'), true);
+        if (from === undefined || to === undefined)
+            return refusedOf('address-invalid');
+        if (engineNamespaceKeyFor(from) === engineNamespaceKeyFor(to))
+            return refusedOf('same-address');
+        const recordPort = dataOf(ports, 'record');
+        const sessionsPort = dataOf(ports, 'sessions');
+        const read = methodOf(recordPort, 'read');
+        const move = methodOf(recordPort, 'move');
+        const listStores = methodOf(sessionsPort, 'stores');
+        if (read === undefined || move === undefined || listStores === undefined)
+            return refusedOf('unarmed');
+        const handshake = dataOf(ports, 'handshake');
+        const roster = dataOf(ports, 'roster');
+        const signalRaw = dataOf(ports, 'signal');
+        const signal = isObject(signalRaw) ? signalRaw : undefined;
+        const evidence = continuityReadingOf(dataOf(input, 'continuity'));
+        const [fromFact, toFact] = await Promise.all([recordFactOf(read, recordPort, from), recordFactOf(read, recordPort, to)]);
+        const plan = planOf(fromFact, toFact, evidence, { fromKey: engineNamespaceKeyFor(from), toKey: engineNamespaceKeyFor(to) });
+        if (plan.kind === 'refused')
+            return refusedOf(plan.reason, plan.recordStatus);
+        const deviceId = plan.deviceId;
+        const continuity = freeze({ deviceId, from, to });
+        const slice = rosterSliceOf(roster, to);
+        if (slice.kind === 'unbound')
+            return refusedOf('roster-unbound');
+        const [hs, ro] = await Promise.all([handshakeProofOf(handshake, freeze({ address: to, deviceId }), signal), slice.kind === 'proof' ? slice.proof : rosterProofOf(slice.devices, deviceId, signal)]);
+        const proofs = freeze({ handshake: hs, roster: ro });
+        const verdict = engineRepointVerdictOf(proofs);
+        if (verdict !== 'apply') {
+            const exit = freeze({ path: 'reenroll-at-engine-address', address: to, removeDeviceId: deviceId });
+            return verdict === 'unverified'
+                ? freeze({ kind: 'unverified', deviceId, proofs, exit })
+                : freeze({ kind: 'undetermined', deviceId, proofs, exit, retryable: true });
+        }
+        if (plan.kind === 'move') {
+            let moved = false;
+            try {
+                moved = dataOf(await move.call(recordPort, from, to), 'kind') === 'moved';
+            }
+            catch {
+                moved = false;
+            }
+            if (moved) {
+                const [afterFrom, afterTo] = await Promise.all([recordFactOf(read, recordPort, from), recordFactOf(read, recordPort, to)]);
+                moved = afterFrom.k === 'absent' && afterTo.k === 'active' && afterTo.deviceId === deviceId;
+            }
+            if (!moved)
+                return freeze({ kind: 'store-failed', stage: 'record', deviceId, continuity });
+        }
+        const record = plan.kind === 'move' ? 'moved' : 'already-there';
+        const counts = { moved: 0, unaffected: 0, conflict: 0, unreadable: 0, storeFailed: 0 };
+        let stores;
+        try {
+            stores = storeListOf(await listStores.call(sessionsPort));
+        }
+        catch {
+            stores = undefined;
+        }
+        if (stores === undefined)
+            return freeze({ kind: 'partial', stage: 'sessions-list', deviceId, continuity, record, sessions: tallyOf(counts), proofs });
+        for (const store of stores) {
+            const r = repointSessionEngine(store, from, to);
+            if (r === 'moved')
+                counts.moved += 1;
+            else if (r === 'unaffected')
+                counts.unaffected += 1;
+            else if (r === 'conflict')
+                counts.conflict += 1;
+            else if (r === 'store-failed')
+                counts.storeFailed += 1;
+            else
+                counts.unreadable += 1;
+        }
+        const sessions = tallyOf(counts);
+        return counts.conflict + counts.unreadable + counts.storeFailed > 0
+            ? freeze({ kind: 'partial', stage: 'sessions', deviceId, continuity, record, sessions, proofs })
+            : freeze({ kind: 'repointed', deviceId, continuity, record, sessions, proofs });
+    }
+    catch {
+        return refusedOf('unarmed');
+    }
+}
+const REFUSAL_KEYS = {
+    'address-invalid': 'session.devices.repoint.refused.addressInvalid',
+    'same-address': 'session.devices.repoint.refused.sameAddress',
+    'record-absent': 'session.devices.repoint.refused.recordAbsent',
+    'record-not-active': 'session.devices.repoint.refused.recordNotActive',
+    'record-unreadable': 'session.devices.repoint.refused.recordUnreadable',
+    'target-occupied': 'session.devices.repoint.refused.targetOccupied',
+    'roster-unbound': 'session.devices.repoint.refused.rosterUnbound',
+    unarmed: 'session.devices.repoint.refused.unarmed',
+};
+export function engineRepointMessageOf(result) {
+    const kind = dataOf(result, 'kind');
+    switch (kind) {
+        case 'repointed':
+            return msg('session.devices.repoint.done');
+        case 'partial':
+            return msg('session.devices.repoint.partial');
+        case 'unverified':
+            return msg('session.devices.repoint.unverified');
+        case 'undetermined':
+            return msg('session.devices.repoint.undetermined');
+        case 'store-failed':
+            return msg('session.devices.repoint.storeFailed');
+        case 'refused': {
+            const reason = dataOf(result, 'reason');
+            const word = Object.keys(REFUSAL_KEYS).find((w) => w === reason);
+            return word === undefined ? undefined : msg(REFUSAL_KEYS[word]);
+        }
+        default:
+            return undefined;
+    }
+}

package/dist/engineRowRef.d.ts

@@ -1,4 +1,5 @@
 import type { AgentEvent } from '@sema-agent/sdk';
+import { type GateOutcomeView } from './gateOutcome.js';
 export interface EngineRowRef {
     readonly eventId?: string;
     readonly taskId?: string;
@@ -22,7 +23,9 @@ export declare function terminalRunIdOf(ev: Extract<AgentEvent, {
 } | {
     type: 'failed';
 }>): string | undefined;
+export declare const SEMA_REFUSAL_NOTED_KEY = "_sema_refusal_noted";
 export declare const TRANSCRIPT_ROW_SIDECAR_KEYS: readonly string[];
+export declare function refusalNotedOf(denialKind: string | undefined, gate: GateOutcomeView | undefined): boolean;
 export declare function parkHeldCallIdOf(carrier: {} | null | undefined): string | undefined;
 export declare function parkedToolEndRoleOf(frame: {} | null | undefined): 'held' | 'collateral' | undefined;
 export declare function isUnsettledHeldToolEnd(frame: {} | null | undefined): boolean;

package/dist/engineRowRef.js

@@ -1,6 +1,7 @@
 import { guardedRead, readFrameStringKey, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { GATE_PARKED_ERROR_CODE } from './engineErrorCodes.js';
-import { isCcToolDenialKind } from './gateVocabulary.js';
+import { ccToolDenialKindForSettledBy, isCcToolDenialKind } from './gateVocabulary.js';
+import { gateDeniedBy } from './gateOutcome.js';
 import { doneResultView } from './replayBody.js';
 import { TRANSCRIPT_ID_NAMESPACE, uuidV5 } from './uuidV5.js';
 const ENGINE_REF_KEY = '_sema_engine_ref';
@@ -77,6 +78,7 @@ export function terminalRunIdOf(ev) {
     const v = doneResultView(ev.result).body?.runId;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+export const SEMA_REFUSAL_NOTED_KEY = '_sema_refusal_noted';
 export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([
     '_sema_segment_id',
     '_sema_engine_ref',
@@ -93,6 +95,7 @@ export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([
     '_sema_interrupted_never_started',
     '_sema_approval_window_expired',
     '_sema_denial_limit_window_expired',
+    SEMA_REFUSAL_NOTED_KEY,
     '_sema_api_error_status',
     '_sema_api_error_code',
     '_sema_provider_condition',
@@ -102,7 +105,16 @@ export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([
     '_sema_task_notification',
     '_sema_answered_by',
     '_sema_rewrite',
+    '_sema_run_origin',
+    '_sema_run_origin_unreadable',
 ]);
+export function refusalNotedOf(denialKind, gate) {
+    if (denialKind !== ccToolDenialKindForSettledBy('human'))
+        return false;
+    if (gateDeniedBy(gate) !== 'ask_resolution')
+        return false;
+    return gate?.settlement?.kind === 'human_refused' && gate.settlement.note !== undefined;
+}
 export function parkHeldCallIdOf(carrier) {
     return readFrameStringKey(carrier, 'toolCallId');
 }

package/dist/engineSessionMessages.d.ts

@@ -1,3 +1,4 @@
+import { type RunOriginRowKeys } from './inputAuthor.js';
 export type EngineHistoryJson = string | number | boolean | null | readonly EngineHistoryJson[] | {
     readonly [key: string]: EngineHistoryJson;
 };
@@ -44,7 +45,7 @@ export interface EngineHistoryMessageBody {
     readonly content: string | readonly EngineHistoryBlock[];
     readonly model?: string;
 }
-export interface EngineHistoryMessage {
+export interface EngineHistoryMessage extends RunOriginRowKeys {
     readonly type: 'user' | 'assistant';
     readonly uuid: string;
     readonly session_id: string;

package/dist/engineSessionMessages.js

@@ -1,4 +1,5 @@
 import { isGateParkedToolEnd } from './gateOutcome.js';
+import { runOriginRowKeys } from './inputAuthor.js';
 import { appendOwnElement, ownDataField, ownSendableField } from './ownKey.js';
 const isObjectLike = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function optionalOwn(o, key) {
@@ -344,14 +345,17 @@ export function projectEngineSessionMessages(rows, opts) {
     for (let i = 0; i < count; i += 1) {
         let outcome;
         let timestamp;
+        let originRow;
         try {
             const row = ownDataField(rows, String(i));
             outcome = projectRow(row, tally);
             timestamp = outcome.kind === 'message' && isObjectLike(row) ? timestampOf(row) : undefined;
+            originRow = outcome.kind === 'message' && isObjectLike(row) && ownDataField(row, 'role') === 'user' ? row : undefined;
         }
         catch {
             outcome = unreadable();
             timestamp = undefined;
+            originRow = undefined;
         }
         if (outcome.kind === 'skip') {
             tally[outcome.why] += 1;
@@ -362,6 +366,7 @@ export function projectEngineSessionMessages(rows, opts) {
             uuid: `restored-${sessionId}-${messages.length + 1}`,
             session_id: sessionId,
             ...(timestamp !== undefined ? { timestamp } : {}),
+            ...(originRow !== undefined ? runOriginRowKeys(originRow) : {}),
             message: outcome.body,
             parent_tool_use_id: null,
         });

package/dist/engineSwapCrossing.d.ts

@@ -0,0 +1,57 @@
+import type { ApprovalsFeedEmission } from './hitl/approvalsFeed.js';
+import type { LocalEngineUpgradePath, LocalEngineVerdict } from './localEngineJudge.js';
+import type { RequestLane } from './request/taskRequest.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const ENGINE_DRAIN_CLASSES: readonly ["parked_tool_approvals"];
+export type EngineDrainClass = (typeof ENGINE_DRAIN_CLASSES)[number];
+export interface EngineDrainSession {
+    readonly sessionId: string;
+    readonly count: number;
+}
+export type EngineDrainReading = {
+    readonly class: EngineDrainClass;
+    readonly state: 'count';
+    readonly count: number;
+    readonly sessions: readonly EngineDrainSession[];
+} | {
+    readonly class: EngineDrainClass;
+    readonly state: 'failed';
+} | {
+    readonly class: EngineDrainClass;
+    readonly state: 'unsupported';
+};
+export type EngineSwapCrossing = 'newer' | 'same' | 'older' | 'none' | 'unknown';
+export interface EngineSwapCrossingFacts {
+    readonly engine: LocalEngineVerdict;
+    readonly drain?: readonly EngineDrainReading[];
+    readonly informed?: string;
+}
+export type EngineSwapCrossingVerdict = {
+    readonly kind: 'clear';
+    readonly crossing: 'none' | 'same' | 'older' | 'unknown';
+} | {
+    readonly kind: 'hold';
+    readonly reason: 'newer_engine';
+    readonly crossing: 'newer';
+    readonly running: string;
+    readonly own: string;
+    readonly source: 'running' | 'high-water';
+} | {
+    readonly kind: 'hold';
+    readonly reason: 'drain_unconfirmed';
+    readonly crossing: 'older';
+    readonly classes: readonly EngineDrainReading[];
+    readonly fingerprint: string;
+} | {
+    readonly kind: 'unknown';
+    readonly crossing: 'unknown';
+    readonly classes: readonly EngineDrainReading[];
+    readonly fingerprint: string;
+} | {
+    readonly kind: 'swap_and_tell';
+    readonly crossing: 'older' | 'unknown';
+    readonly classes: readonly EngineDrainReading[];
+};
+export declare function engineSwapCrossingVerdict(facts: EngineSwapCrossingFacts): EngineSwapCrossingVerdict;
+export declare function parkedToolApprovalsBySession(emission: ApprovalsFeedEmission | null | undefined): EngineDrainReading;
+export declare function engineSwapCrossingText(verdict: EngineSwapCrossingVerdict, lane: Exclude<RequestLane, 'utility'>, upgrade: LocalEngineUpgradePath | undefined, lang?: UiLanguage): string | undefined;