@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/engineRepoint.d.ts

@@ -0,0 +1,140 @@
+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 expectDeviceId?: 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 address: string;
+    readonly devices: 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' | 'address-unbound' | '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' | 'unarmed';
+export type EngineRepointResult = EngineRepointDone | EngineRepointPartial | EngineRepointUnverified | EngineRepointUndetermined | EngineRepointStoreFailed | EngineRepointRefused;
+export interface EngineRepointDone {
+    readonly kind: 'repointed';
+    readonly deviceId: string;
+    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 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;
+}
+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,285 @@
+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' });
+async function rosterProofOf(roster, target, deviceId, signal) {
+    if (!isObject(roster))
+        return freeze({ state: 'unreadable', why: 'unarmed' });
+    const credential = dataOf(roster, 'credential');
+    if (credential === 'operator')
+        return freeze({ state: 'unreadable', why: 'operator-credential' });
+    if (credential !== 'non-operator')
+        return freeze({ state: 'unreadable', why: 'credential-unknown' });
+    const listed = addressOf(dataOf(roster, 'address'), false);
+    if (listed === undefined || engineNamespaceKeyFor(listed) !== engineNamespaceKeyFor(target))
+        return freeze({ state: 'unreadable', why: 'address-unbound' });
+    const devices = dataOf(roster, 'devices');
+    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 planOf(from, to, expectDeviceId) {
+    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')
+        return expectDeviceId !== undefined && to.deviceId === expectDeviceId ? { 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 expectRaw = dataOf(input, 'expectDeviceId');
+        const expectDeviceId = typeof expectRaw === 'string' && expectRaw !== '' ? expectRaw : undefined;
+        const [fromFact, toFact] = await Promise.all([recordFactOf(read, recordPort, from), recordFactOf(read, recordPort, to)]);
+        const plan = planOf(fromFact, toFact, expectDeviceId);
+        if (plan.kind === 'refused')
+            return refusedOf(plan.reason, plan.recordStatus);
+        const deviceId = plan.deviceId;
+        const [hs, ro] = await Promise.all([handshakeProofOf(handshake, freeze({ address: to, deviceId }), signal), rosterProofOf(roster, to, 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 });
+        }
+        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, 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, record, sessions, proofs })
+            : freeze({ kind: 'repointed', deviceId, 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',
+    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.js

@@ -102,6 +102,8 @@ 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 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/errorSupplementRoles.js

@@ -5,7 +5,7 @@ import { resumeReopenContent } from './hitl/suspendedReopen.js';
 import { idempotencyPayloadMismatchContent } from './engineErrorCodes.js';
 import { inheritEnvRefusalContent } from './inheritEnvWire.js';
 import { projectSeedRefusalContent } from './projectSeed.js';
-import { usageWindowExhaustedContent, fleetLeaseUnavailableContent, settingsPermissionBucketRefusalContent, fieldLimitRefusalContent, autonomyLaneRefusalContent, sessionArchiveStampedContent, unsupportedRuleRefusalContent, admissionWallRefusalContent, hostPostureRefusalContent, toolDeclarationRefusalContent, } from './wireRefusalCopy.js';
+import { usageWindowExhaustedContent, fleetLeaseUnavailableContent, settingsPermissionBucketRefusalContent, fieldLimitRefusalContent, autonomyLaneRefusalContent, sessionArchiveStampedContent, unsupportedRuleRefusalContent, admissionWallRefusalContent, hostPostureRefusalContent, toolDeclarationRefusalContent, envCredentialRefusalContent, sessionIdRetiredContent, runConcurrencyCapContent, unreadRequestMembersContent, } from './wireRefusalCopy.js';
 import { catalogDefaultRefusalContent } from './model/catalogDefault.js';
 const ROLE_BY_READER = new Map([
     [corruptSessionContent, 'replacement'],
@@ -25,6 +25,10 @@ const ROLE_BY_READER = new Map([
     [unsupportedRuleRefusalContent, 'replacement'],
     [projectSeedRefusalContent, 'replacement'],
     [catalogDefaultRefusalContent, 'replacement'],
+    [envCredentialRefusalContent, 'replacement'],
+    [sessionIdRetiredContent, 'replacement'],
+    [runConcurrencyCapContent, 'replacement'],
+    [unreadRequestMembersContent, 'replacement'],
     [admissionWallRefusalContent, 'supplement'],
     [hostPostureRefusalContent, 'supplement'],
     [toolDeclarationRefusalContent, 'supplement'],

package/dist/fleet/fleetProjection.js

@@ -3,7 +3,8 @@ import { rowIdTail } from '../workflow.js';
 import { cycleSeqValue } from '../cycleOrder.js';
 import { frozenSet } from '../frozenSet.js';
 import { guardedRead, readOwnDataValue } from '../ownKey.js';
-import { CORE_RESERVED_AGENT_NAMES, CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE } from '../generated/engineFactTables.js';
+import { CORE_RESERVED_AGENT_NAMES } from '../generated/engineFactTables.js';
+import { isCoreWorkflowRunParkedEnd } from '../terminalStatuses.js';
 import { runParkedOf as coreRunParkedOf } from '../coreValuePorts.js';
 export function coerceTaskStatus(s) {
     if (s === 'parked')
@@ -34,7 +35,7 @@ export function workflowRunDisplayStatusOf(run) {
     const status = runField(run, 'status');
     if (parkedWindowOf(run, status))
         return 'awaiting approval';
-    if (status === 'failed' && runField(run, 'errorCode') === CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE)
+    if (isCoreWorkflowRunParkedEnd(status, runField(run, 'errorCode')))
         return 'awaiting approval';
     switch (status) {
         case 'completed':

package/dist/fleetTaskDesc.js

@@ -1,12 +1,12 @@
-import { applyDisplayFace, ESCAPE_FACE, LABEL_FACE, paintAndCap } from './displayUntrusted.js';
+import { applyDisplayFace, displayUntrusted, ESCAPE_FACE } from './displayUntrusted.js';
 export function escapeDisplayControlChars(s) {
     return applyDisplayFace(s, ESCAPE_FACE);
 }
 export function capForDisplay(raw, max) {
-    return paintAndCap(raw, ESCAPE_FACE, typeof max === 'number' && max > 0 ? max : 0);
+    return displayUntrusted(raw, { foldLines: false, escapeBackslashes: 'auto', max: typeof max === 'number' && max > 0 ? max : 0 });
 }
 export function collapseLabel(s) {
-    return applyDisplayFace(s, LABEL_FACE);
+    return displayUntrusted(s, { escapeBackslashes: 'auto' });
 }
 export function taskDescFromName(name, agentType, agentName) {
     if (!name || !agentType)

package/dist/generated/engineFactTables.d.ts

@@ -74,3 +74,6 @@ export declare const CORE_USER_ATTACHMENT_LABEL_MAX: number;
 export declare const CORE_PRESENT_PLAN_TOOL_NAME: "ExitPlanMode";
 export declare const CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE: "workflow.agent_parked";
 export declare const CORE_REFUSAL_ECHO_KINDS: readonly ["path", "command", "pattern"];
+export declare const CORE_DISCARDED_DELIVERY_PATHS: readonly ["live", "box", "drain", "notice"];
+export declare const CORE_INPUT_AUTHORS: readonly ["operator", "parent_model", "workflow", "peer", "observer", "engine", "extension"];
+export declare const CORE_RUN_ORIGINS: readonly ["scheduled"];

package/dist/generated/engineFactTables.js

@@ -471,3 +471,21 @@ export const CORE_REFUSAL_ECHO_KINDS = Object.freeze([
     "command",
     "pattern",
 ]);
+export const CORE_DISCARDED_DELIVERY_PATHS = Object.freeze([
+    "live",
+    "box",
+    "drain",
+    "notice",
+]);
+export const CORE_INPUT_AUTHORS = Object.freeze([
+    "operator",
+    "parent_model",
+    "workflow",
+    "peer",
+    "observer",
+    "engine",
+    "extension",
+]);
+export const CORE_RUN_ORIGINS = Object.freeze([
+    "scheduled",
+]);

package/dist/generated/engineNoticeTables.js

@@ -37,6 +37,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "permission.rule_store_unavailable",
     "permission.rule_row_dropped",
     "config.session_rules_earlier_grammar",
+    "config.legacy_tool_name",
     "permission.allowed_tool_not_granted",
     "mods.registration_refused",
     "peer.inbound_disposition",
@@ -157,6 +158,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "permission.rule_store_unavailable": "user",
     "permission.rule_row_dropped": "user",
     "config.session_rules_earlier_grammar": "user",
+    "config.legacy_tool_name": "user",
     "permission.allowed_tool_not_granted": "user",
     "mods.registration_refused": "user",
     "peer.inbound_disposition": "user",
@@ -283,6 +285,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "permission.rule_store_unavailable": "engine",
     "permission.rule_row_dropped": "engine",
     "config.session_rules_earlier_grammar": "engine",
+    "config.legacy_tool_name": "engine",
     "permission.allowed_tool_not_granted": "engine",
     "mods.registration_refused": "engine",
     "peer.inbound_disposition": "engine",

package/dist/generated/sdkFactTables.d.ts

@@ -10,3 +10,4 @@ export declare const SDK_PERMISSION_MODE_PERSIST_MISSES: readonly ["claim_releas
 export declare const SDK_DECIDE_BINDING_KEYS: readonly ["boundCallId", "boundInputHash"];
 export declare const SDK_APPROVAL_QUEUE_KINDS: readonly ["checkpoint", "peer_inbound"];
 export declare const SDK_SESSION_MEMORY_UNOBSERVED_REASONS: readonly ["no_settled_run", "run_result_missing", "run_result_unobserved", "memory_not_mounted", "no_leaf"];
+export declare const SDK_STREAM_ENDED_REASONS: readonly ["empty_legs", "consecutive_failures"];

package/dist/generated/sdkFactTables.js

@@ -63,3 +63,7 @@ export const SDK_SESSION_MEMORY_UNOBSERVED_REASONS = Object.freeze([
     "memory_not_mounted",
     "no_leaf",
 ]);
+export const SDK_STREAM_ENDED_REASONS = Object.freeze([
+    "empty_legs",
+    "consecutive_failures",
+]);

package/dist/hitl/approvalAskers.d.ts

@@ -9,5 +9,11 @@ export interface ApprovalAskReasonByPolicy {
     readonly words: string;
 }
 export type ApprovalAskReason = ApprovalAskReasonByHook | ApprovalAskReasonByPolicy;
+export interface ApprovalRequestedBy {
+    readonly kind: 'extension';
+    readonly name: string;
+}
 export declare function approvalAskReasonsOf(carrier: object | null | undefined): readonly ApprovalAskReason[] | undefined;
+export declare function requestedByViewOf(v: object | null | undefined): ApprovalRequestedBy | undefined;
+export declare function approvalRequestedByOf(carrier: object | null | undefined): ApprovalRequestedBy | undefined;
 export declare function approvalAgentIdOf(carrier: object | null | undefined): string | undefined;

package/dist/hitl/approvalAskers.js

@@ -67,6 +67,36 @@ export function approvalAskReasonsOf(carrier) {
         return undefined;
     }
 }
+export function requestedByViewOf(v) {
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const kind = slotReadOf(v, 'kind');
+        if (kind.presence !== 'present' || kind.value !== 'extension')
+            return undefined;
+        const name = ownNonEmptyText(v, 'name');
+        if (name === undefined)
+            return undefined;
+        return Object.freeze({ kind: 'extension', name });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function approvalRequestedByOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null)
+            return undefined;
+        const slot = slotReadOf(carrier, 'requestedBy');
+        if (slot.presence !== 'present')
+            return undefined;
+        const v = slot.value;
+        return typeof v === 'object' && v !== null ? requestedByViewOf(v) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function approvalAgentIdOf(carrier) {
     try {
         if (typeof carrier !== 'object' || carrier === null)