@sema-agent/client-core 0.101.0 → 0.102.0

package/dist/sessionBackground.js

@@ -0,0 +1,781 @@
+import { createEngineCapReader } from './engineCapReader.js';
+import { engineCapsGeneration } from './engineCapsCache.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { DETACH_HEADER, HEADLESS_DETACH_ENV, headlessDetachDisabledByEnv, isDetachDurableOff400 } from './detachWire.js';
+import { isLoopbackWireUrl } from './engineWireSdk.js';
+import { hostEnv } from './hostEnv.js';
+import { approvalDecisionHolds } from './hitl/approvalHolds.js';
+import { readRunTerminal } from './runTerminal.js';
+import { appendOwnElement, ownDataField, putOwnKey, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export function projectSessionBackgroundable(caps) {
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'sessionBackgroundable');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (v === true)
+            return { kind: 'advertised' };
+        if (v === false)
+            return { kind: 'declined' };
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const reader = createEngineCapReader({ name: 'sessionBackgroundable', project: projectSessionBackgroundable });
+export function readSessionBackgroundable(baseUrl = engineWireTargetBaseUrl()) {
+    try {
+        return reader.observed(baseUrl);
+    }
+    catch {
+        return Object.freeze({ kind: 'unobserved' });
+    }
+}
+export const OPENING_RECORD_CAP = 256;
+const wireStates = new WeakMap();
+const isObj = (v) => (typeof v === 'object' && v !== null) || typeof v === 'function';
+export function ownSlotOf(o, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        if (d === undefined)
+            return { state: 'absent' };
+        if (!Object.hasOwn(d, 'value'))
+            return { state: 'unreadable' };
+        const v = d.value;
+        return v === undefined ? { state: 'absent' } : { state: 'data', value: v };
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+}
+export function wireStateOf(wire) {
+    try {
+        return typeof wire === 'object' && wire !== null ? wireStates.get(wire) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function methodOf(o, key) {
+    try {
+        let cur = o;
+        for (let depth = 0; cur !== null && depth < 32; depth++) {
+            const d = Object.getOwnPropertyDescriptor(cur, key);
+            if (d !== undefined) {
+                if (!Object.hasOwn(d, 'value'))
+                    return undefined;
+                return typeof d.value === 'function' ? d.value : undefined;
+            }
+            cur = Object.getPrototypeOf(cur);
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function guardedGet(o, key) {
+    try {
+        return o[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function interactiveEngineWire(init) {
+    try {
+        if (!isObj(init))
+            return undefined;
+        const baseUrl = readOwnDataValue(init, 'baseUrl');
+        const lane = readOwnDataValue(init, 'lane');
+        const tasks = readOwnDataValue(init, 'tasks');
+        const runs = readOwnDataValue(init, 'runs');
+        if (typeof baseUrl !== 'string' || baseUrl === '')
+            return undefined;
+        if (lane !== 'self-spawned' && lane !== 'external')
+            return undefined;
+        if (!isObj(tasks) || !isObj(runs))
+            return undefined;
+        const streamFn = methodOf(tasks, 'stream');
+        const eventsFn = methodOf(runs, 'events');
+        const getFn = methodOf(runs, 'get');
+        if (typeof streamFn !== 'function' || typeof eventsFn !== 'function' || typeof getFn !== 'function')
+            return undefined;
+        const stream = streamFn;
+        const events = eventsFn;
+        const get = getFn;
+        const state = {
+            retired: false,
+            baseUrl,
+            lane,
+            stream: (req, opts) => stream.call(tasks, req, opts),
+            events: (taskId, opts) => events.call(runs, taskId, opts),
+            get: (taskId, opts) => get.call(runs, taskId, opts),
+            bySession: new Map(),
+            byTask: new Map(),
+            order: [],
+            handedOff: new Map(),
+            nextOpeningId: 1,
+        };
+        const handle = Object.freeze({ baseUrl, lane });
+        wireStates.set(handle, state);
+        return handle;
+    }
+    catch {
+        return undefined;
+    }
+}
+const isTerminalPhase = (p) => p !== 'opening' && p !== 'bound' && p !== 'running';
+const isHandedOffPhase = (p) => p === 'handing-off' || p === 'handed-off';
+export function retireInteractiveEngineWire(wire) {
+    const state = wireStateOf(wire);
+    if (state === undefined || state.retired)
+        return;
+    state.retired = true;
+    for (const rec of state.order)
+        if (!isTerminalPhase(rec.phase))
+            rec.phase = 'engine-ended';
+    for (const entry of [...state.handedOff.values()]) {
+        if (entry.state === 'ended')
+            continue;
+        try {
+            entry.stop('engine-ended');
+        }
+        catch {
+        }
+    }
+}
+function snapshotOpeningInput(input) {
+    let sessionKey;
+    try {
+        if (!isObj(input))
+            return { readable: false, sessionKey: undefined, reattachable: false, envOff: false };
+        const sk = readOwnDataValue(input, 'sessionKey');
+        sessionKey = typeof sk === 'string' && sk !== '' ? sk : undefined;
+        const reattachable = readOwnDataValue(input, 'reattachable') === true;
+        const envSlot = ownSlotOf(input, 'env');
+        if (envSlot.state === 'unreadable')
+            return { readable: false, sessionKey, reattachable, envOff: false };
+        if (envSlot.state === 'data' && !isObj(envSlot.value))
+            return { readable: false, sessionKey, reattachable, envOff: false };
+        const env = envSlot.state === 'data' && isObj(envSlot.value) ? envSlot.value : hostEnv();
+        const switchSlot = ownSlotOf(env, HEADLESS_DETACH_ENV);
+        if (switchSlot.state === 'unreadable')
+            return { readable: false, sessionKey, reattachable, envOff: false };
+        const raw = switchSlot.state === 'data' ? switchSlot.value : undefined;
+        if (raw !== undefined && typeof raw !== 'string')
+            return { readable: false, sessionKey, reattachable, envOff: false };
+        const one = {};
+        if (raw !== undefined)
+            one[HEADLESS_DETACH_ENV] = raw;
+        const envOff = headlessDetachDisabledByEnv(one);
+        return { readable: sessionKey !== undefined, sessionKey, reattachable, envOff };
+    }
+    catch {
+        return { readable: false, sessionKey, reattachable: false, envOff: false };
+    }
+}
+function capabilityKindAt(baseUrl) {
+    return readSessionBackgroundable(baseUrl).kind;
+}
+const noStamp = (reason) => Object.freeze({ stamp: false, reason });
+function postureFor(state, snap) {
+    if (state === undefined || !snap.readable)
+        return noStamp('unreadable-input');
+    if (state.retired)
+        return noStamp('retired-wire');
+    if (snap.envOff)
+        return noStamp('env-off');
+    if (!snap.reattachable)
+        return noStamp('not-reattachable');
+    const cap = capabilityKindAt(state.baseUrl);
+    if (cap === 'declined')
+        return noStamp('declined');
+    if (state.lane === 'self-spawned' && isLoopbackWireUrl(state.baseUrl))
+        return Object.freeze({ stamp: true, reason: 'self-spawned' });
+    if (cap === 'advertised')
+        return noStamp('unacknowledged');
+    return noStamp(cap);
+}
+export function interactiveDetachPosture(wire, input) {
+    try {
+        return postureFor(wireStateOf(wire), snapshotOpeningInput(input));
+    }
+    catch {
+        return noStamp('unreadable-input');
+    }
+}
+function ownDataEntries(o, strict = false) {
+    let keys;
+    try {
+        keys = Reflect.ownKeys(o);
+    }
+    catch {
+        return undefined;
+    }
+    const out = [];
+    for (const k of keys) {
+        if (typeof k !== 'string')
+            continue;
+        try {
+            const d = Object.getOwnPropertyDescriptor(o, k);
+            if (d === undefined || d.enumerable !== true)
+                continue;
+            if (Object.hasOwn(d, 'value'))
+                appendOwnElement(out, [k, d.value]);
+            else if (strict)
+                return undefined;
+        }
+        catch {
+            if (strict)
+                return undefined;
+        }
+    }
+    return out;
+}
+function snapshotRequestBody(req) {
+    try {
+        if (typeof req !== 'object' || req === null || Array.isArray(req))
+            return undefined;
+        const entries = ownDataEntries(req, true);
+        if (entries === undefined)
+            return undefined;
+        const out = {};
+        for (const [k, v] of entries)
+            Object.defineProperty(out, k, { value: v, enumerable: true, writable: true, configurable: true });
+        return Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}
+function snapshotHeaders(raw) {
+    const out = {};
+    if (!isObj(raw))
+        return out;
+    for (const [k, v] of ownDataEntries(raw) ?? []) {
+        if (typeof v !== 'string')
+            continue;
+        if (k.toLowerCase() === DETACH_HEADER)
+            continue;
+        putOwnKey(out, k, v);
+    }
+    return out;
+}
+function snapshotStreamOptions(opts) {
+    const read = (key) => {
+        try {
+            return isObj(opts) ? readOwnDataValue(opts, key) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const signal = read('signal');
+    const onResponse = read('onResponse');
+    const idem = read('idempotencyKey');
+    const grace = read('heartbeatGraceMs');
+    return {
+        signal: isObj(signal) ? signal : undefined,
+        headers: snapshotHeaders(read('headers')),
+        onResponse: typeof onResponse === 'function' ? onResponse : undefined,
+        hasIdempotencyKey: typeof idem === 'string' || idem === null,
+        idempotencyKey: typeof idem === 'string' || idem === null ? idem : undefined,
+        heartbeatGraceMs: typeof grace === 'number' && Number.isFinite(grace) ? grace : undefined,
+    };
+}
+function outboundHeaders(host, stamp) {
+    const out = {};
+    for (const [k, v] of Object.entries(host))
+        if (k.toLowerCase() !== DETACH_HEADER)
+            putOwnKey(out, k, v);
+    if (stamp)
+        putOwnKey(out, DETACH_HEADER, 'true');
+    return Object.freeze(out);
+}
+function registerOpening(state, rec) {
+    state.order.push(rec);
+    if (rec.sessionKey !== undefined)
+        state.bySession.set(rec.sessionKey, rec);
+    trimOpenings(state);
+}
+function liveForRetention(state, rec) {
+    if (!isTerminalPhase(rec.phase))
+        return true;
+    if (!isHandedOffPhase(rec.phase) || rec.taskId === undefined)
+        return false;
+    const entry = state.handedOff.get(rec.taskId);
+    return entry !== undefined && entry.state !== 'ended';
+}
+function trimOpenings(state) {
+    let i = 0;
+    while (state.order.length > OPENING_RECORD_CAP && i < state.order.length) {
+        const rec = state.order[i];
+        if (rec === undefined || liveForRetention(state, rec)) {
+            i++;
+            continue;
+        }
+        state.order.splice(i, 1);
+        if (rec.taskId !== undefined && state.byTask.get(rec.taskId) === rec)
+            state.byTask.delete(rec.taskId);
+        if (rec.sessionKey !== undefined && state.bySession.get(rec.sessionKey) === rec)
+            state.bySession.delete(rec.sessionKey);
+    }
+}
+function taskIdHeaderOf(res) {
+    try {
+        const h = guardedGet(res, 'headers');
+        if (!isObj(h))
+            return undefined;
+        const get = guardedGet(h, 'get');
+        if (typeof get !== 'function')
+            return undefined;
+        const v = get.call(h, 'x-task-id');
+        return typeof v === 'string' && v !== '' ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function noteResponse(state, rec, res, hostHook) {
+    const taskId = taskIdHeaderOf(res);
+    if (taskId !== undefined && rec.phase === 'opening') {
+        rec.taskId = taskId;
+        rec.capsGenAtBind = engineCapsGeneration(state.baseUrl);
+        rec.phase = 'bound';
+        if (!state.byTask.has(taskId))
+            state.byTask.set(taskId, rec);
+    }
+    if (hostHook !== undefined) {
+        try {
+            hostHook(res);
+        }
+        catch {
+        }
+    }
+}
+function frameSlot(ev, key) {
+    try {
+        return readOwnDataValue(ev, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function frameString(ev, key) {
+    try {
+        return readOwnDataNonEmptyString(ev, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function askDeadlineOf(ev) {
+    try {
+        const now = Date.now();
+        const rel = readOwnDataFiniteNumber(ev, 'expiresInMs');
+        if (rel !== undefined)
+            return now + rel;
+        const at = readOwnDataFiniteNumber(ev, 'expiresAtMs');
+        if (at === undefined)
+            return undefined;
+        const serverNow = readOwnDataFiniteNumber(ev, 'serverNowMs');
+        return serverNow !== undefined ? now + (at - serverNow) : at;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isParkedDone(ev) {
+    try {
+        return readRunTerminal(frameSlot(ev, 'result'))?.kind === 'paused';
+    }
+    catch {
+        return false;
+    }
+}
+function observeFrame(rec, ev) {
+    if (isTerminalPhase(rec.phase))
+        return;
+    const type = frameSlot(ev, 'type');
+    if (type === 'meta') {
+        const sessionId = frameString(ev, 'sessionId');
+        if (sessionId !== undefined && rec.sessionId === undefined)
+            rec.sessionId = sessionId;
+        const metaTaskId = frameString(ev, 'taskId');
+        if (metaTaskId !== undefined && rec.taskId !== undefined && metaTaskId !== rec.taskId)
+            rec.inconsistent = true;
+        return;
+    }
+    if (type === 'done' || type === 'failed') {
+        if (rec.phase === 'running') {
+            rec.phase = type === 'done' && isParkedDone(ev) ? 'stream-ended' : 'finished';
+        }
+        else {
+            rec.phase = 'ended-unstarted';
+            rec.replay = type === 'done' && frameSlot(ev, 'replay') === true;
+        }
+        return;
+    }
+    if (type === 'question') {
+        const questionId = frameString(ev, 'questionId');
+        if (questionId !== undefined)
+            rec.openAsks.set(questionId, askDeadlineOf(ev));
+    }
+    else if (type === 'question_complete') {
+        const questionId = frameString(ev, 'questionId');
+        if (questionId !== undefined)
+            rec.openAsks.delete(questionId);
+    }
+    if (rec.phase === 'bound' && rec.sessionId !== undefined && frameString(ev, 'id') !== undefined)
+        rec.phase = 'running';
+}
+function isAskFrame(ev) {
+    const type = frameSlot(ev, 'type');
+    return type === 'question' || type === 'approval_request';
+}
+async function* endedWith(error) {
+    throw error;
+}
+export function streamInteractiveRun(wire, req, opts, input) {
+    const state = wireStateOf(wire);
+    const inSnap = snapshotOpeningInput(input);
+    const body = snapshotRequestBody(req);
+    const o = snapshotStreamOptions(opts);
+    if (state === undefined)
+        return endedWith(new TypeError('streamInteractiveRun: the engine wire was not minted by this package copy'));
+    const posture = postureFor(state, inSnap);
+    const headers = outboundHeaders(o.headers, posture.stamp);
+    const stamped = Object.hasOwn(headers, DETACH_HEADER) && headers[DETACH_HEADER] === 'true';
+    const controller = new AbortController();
+    const rec = {
+        openingId: state.nextOpeningId++,
+        sessionKey: inSnap.sessionKey,
+        phase: state.retired ? 'engine-ended' : 'opening',
+        inconsistent: false,
+        capsGenAtBind: undefined,
+        stopRequested: false,
+        stamped,
+        postureReason: posture.reason,
+        ...(stamped && posture.reason === 'self-spawned' ? { proof: 'loopback-self-spawned' } : { proof: 'none' }),
+        taskId: undefined,
+        sessionId: undefined,
+        openAsks: new Map(),
+        askUnacked: false,
+        replay: false,
+        tear: (reason) => controller.abort(reason),
+    };
+    registerOpening(state, rec);
+    if (body === undefined) {
+        if (!isTerminalPhase(rec.phase))
+            rec.phase = 'ended-unstarted';
+        return endedWith(new TypeError('streamInteractiveRun: the request body could not be read'));
+    }
+    return openingStream(state, rec, body, o, headers, controller);
+}
+function linkHostSignal(host, controller) {
+    if (host === undefined)
+        return () => { };
+    try {
+        if (host.aborted === true) {
+            controller.abort(host.reason);
+            return () => { };
+        }
+        const onAbort = () => {
+            try {
+                controller.abort(host.reason);
+            }
+            catch {
+                controller.abort();
+            }
+        };
+        host.addEventListener('abort', onAbort, { once: true });
+        return () => {
+            try {
+                host.removeEventListener('abort', onAbort);
+            }
+            catch {
+            }
+        };
+    }
+    catch {
+        return () => { };
+    }
+}
+async function* openingStream(state, rec, body, o, headers, controller) {
+    const unlink = linkHostSignal(o.signal, controller);
+    const open = (withHeader) => {
+        const sent = withHeader ? headers : outboundHeaders(headers, false);
+        const callOpts = {
+            transientOk: true,
+            signal: controller.signal,
+            headers: { ...sent },
+            onResponse: (res) => noteResponse(state, rec, res, o.onResponse),
+        };
+        if (o.hasIdempotencyKey)
+            callOpts.idempotencyKey = o.idempotencyKey ?? null;
+        if (o.heartbeatGraceMs !== undefined)
+            callOpts.heartbeatGraceMs = o.heartbeatGraceMs;
+        return state.stream(body, callOpts);
+    };
+    let inner;
+    let innerClosed = false;
+    let retried = false;
+    let delivered = false;
+    try {
+        inner = open(rec.stamped);
+        for (;;) {
+            let step;
+            try {
+                step = await inner.next();
+            }
+            catch (e) {
+                if (isHandedOffPhase(rec.phase)) {
+                    innerClosed = true;
+                    return;
+                }
+                const pinned = typeof o.idempotencyKey === 'string';
+                if (!retried && !delivered && rec.stamped && rec.taskId === undefined && !pinned && isDetachDurableOff400(e)) {
+                    retried = true;
+                    rec.stamped = false;
+                    rec.postureReason = 'durable-off-400';
+                    rec.proof = 'none';
+                    inner = open(false);
+                    continue;
+                }
+                innerClosed = true;
+                throw e;
+            }
+            if (step.done === true) {
+                innerClosed = true;
+                return;
+            }
+            const ev = step.value;
+            if (isHandedOffPhase(rec.phase))
+                return;
+            observeFrame(rec, ev);
+            const ask = isAskFrame(ev);
+            if (ask)
+                rec.askUnacked = true;
+            delivered = true;
+            let hostThrew = false;
+            let hostError;
+            try {
+                yield ev;
+            }
+            catch (e) {
+                hostThrew = true;
+                hostError = e;
+            }
+            finally {
+                if (ask)
+                    rec.askUnacked = false;
+            }
+            if (hostThrew) {
+                innerClosed = true;
+                try {
+                    await inner.throw(hostError);
+                }
+                catch {
+                }
+                throw hostError;
+            }
+        }
+    }
+    finally {
+        unlink();
+        if (!isTerminalPhase(rec.phase))
+            rec.phase = 'stream-ended';
+        if (inner !== undefined && !innerClosed) {
+            try {
+                await inner.return(undefined);
+            }
+            catch {
+            }
+        }
+    }
+}
+const refuse = (reason) => ({ verdict: 'ineligible', reason });
+const unknownOf = (reason) => ({ verdict: 'unknown', reason });
+function hasOpenAsk(rec, nowMs) {
+    for (const deadline of rec.openAsks.values())
+        if (deadline === undefined || deadline > nowMs)
+            return true;
+    return false;
+}
+export function handoffVerdictOf(f) {
+    const rec = f.rec;
+    if (!f.inputReadable || (f.wirePresent && !f.wireRecognized) || rec?.inconsistent === true)
+        return unknownOf('unreadable-input');
+    if (!f.wirePresent || rec === undefined || rec.phase === 'ended-unstarted')
+        return refuse('no-run');
+    if (rec.phase === 'stream-ended')
+        return refuse('stream-ended');
+    if (isHandedOffPhase(rec.phase))
+        return refuse('already-handed-off');
+    if (rec.phase === 'finished')
+        return refuse('finished');
+    if (rec.phase === 'engine-ended' || (rec.capsGenAtBind !== undefined && rec.capsGenAtBind !== f.capsGenerationNow))
+        return refuse('engine-replaced');
+    if (rec.stopRequested)
+        return refuse('stopping');
+    if (!rec.stamped)
+        return { verdict: 'ineligible', reason: 'not-stamped', cause: rec.postureReason };
+    if (f.capability === 'declined')
+        return refuse('declined');
+    if (f.capability !== 'advertised')
+        return unknownOf('capability-unconfirmed');
+    if (rec.proof === 'none')
+        return unknownOf('detach-unconfirmed');
+    if (rec.phase === 'opening' || rec.phase === 'bound')
+        return refuse('not-started');
+    if (hasOpenAsk(rec, f.nowMs) || rec.askUnacked || f.holds.some((h) => h.taskId !== undefined && h.taskId === rec.taskId))
+        return refuse('awaiting-user');
+    if (f.holds.some((h) => h.taskId === undefined && (h.sessionId === undefined || h.sessionId === rec.sessionId)))
+        return unknownOf('awaiting-user-unattributable');
+    return rec.taskId !== undefined ? { verdict: 'eligible', taskId: rec.taskId } : unknownOf('unreadable-input');
+}
+function holdOwners() {
+    const out = [];
+    for (const h of approvalDecisionHolds.inFlight.values()) {
+        const id = h.identity;
+        const taskId = typeof id.taskId === 'string' && id.taskId !== '' ? id.taskId : undefined;
+        const sessionId = typeof id.sessionId === 'string' && id.sessionId !== '' ? id.sessionId : undefined;
+        out.push({ taskId, sessionId });
+    }
+    return out;
+}
+export function judgeHandoff(input) {
+    try {
+        let inputReadable = false;
+        let wire;
+        let sessionKey;
+        let wireUnreadable = false;
+        if (isObj(input)) {
+            const ws = ownSlotOf(input, 'wire');
+            wireUnreadable = ws.state === 'unreadable';
+            wire = ws.state === 'data' ? ws.value : undefined;
+            const sk = readOwnDataValue(input, 'sessionKey');
+            sessionKey = typeof sk === 'string' && sk !== '' ? sk : undefined;
+            inputReadable = sessionKey !== undefined;
+        }
+        const wirePresent = wireUnreadable || (wire !== undefined && wire !== null);
+        const state = wirePresent && isObj(wire) ? wireStateOf(wire) : undefined;
+        const rec = state !== undefined && sessionKey !== undefined ? state.bySession.get(sessionKey) : undefined;
+        const facts = {
+            inputReadable,
+            wirePresent,
+            wireRecognized: state !== undefined,
+            rec,
+            capability: state !== undefined ? capabilityKindAt(state.baseUrl) : 'unobserved',
+            capsGenerationNow: state !== undefined ? engineCapsGeneration(state.baseUrl) : undefined,
+            holds: holdOwners(),
+            nowMs: Date.now(),
+        };
+        return { verdict: Object.freeze(handoffVerdictOf(facts)), rec, state };
+    }
+    catch {
+        return { verdict: Object.freeze(unknownOf('unreadable-input')), rec: undefined, state: undefined };
+    }
+}
+export function backgroundHandoffEligibility(input) {
+    return judgeHandoff(input).verdict;
+}
+function notStampedKey(cause) {
+    switch (cause) {
+        case 'declined':
+            return 'session.background.refusal.declined';
+        case 'env-off':
+            return 'session.background.refusal.envOff';
+        case 'not-reattachable':
+            return 'session.background.refusal.notReattachable';
+        case 'unacknowledged':
+        case 'not_reported':
+        case 'unobserved':
+        case 'unreadable':
+            return 'session.background.refusal.unconfirmed';
+        case 'durable-off-400':
+            return 'session.background.refusal.durableOff';
+        default:
+            return 'session.background.unknown';
+    }
+}
+function verdictSentenceKey(v) {
+    const slot = (key) => {
+        try {
+            return isObj(v) ? readOwnDataValue(v, key) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const verdict = slot('verdict');
+    if (verdict === 'eligible')
+        return undefined;
+    const reason = slot('reason');
+    if (verdict === 'ineligible') {
+        switch (reason) {
+            case 'no-run':
+                return 'session.background.refusal.noRun';
+            case 'stream-ended':
+                return 'session.background.refusal.streamEnded';
+            case 'already-handed-off':
+                return 'session.background.refusal.alreadyHandedOff';
+            case 'finished':
+                return 'session.background.refusal.finished';
+            case 'engine-replaced':
+                return 'session.background.refusal.engineReplaced';
+            case 'stopping':
+                return 'session.background.refusal.stopping';
+            case 'not-stamped':
+                return notStampedKey(slot('cause'));
+            case 'declined':
+                return 'session.background.refusal.declined';
+            case 'not-started':
+                return 'session.background.refusal.notStarted';
+            case 'awaiting-user':
+                return 'session.background.refusal.awaitingUser';
+            default:
+                return 'session.background.unknown';
+        }
+    }
+    if (verdict === 'unknown' && reason === 'capability-unconfirmed')
+        return 'session.background.refusal.unconfirmed';
+    return 'session.background.unknown';
+}
+export function backgroundHandoffSentence(v, lang) {
+    const key = verdictSentenceKey(v);
+    return key === undefined ? undefined : renderMessage(msg(key), lang);
+}
+export function interactiveStopFacts(wire, taskId) {
+    try {
+        const state = wireStateOf(wire);
+        if (state === undefined || typeof taskId !== 'string' || taskId === '')
+            return Object.freeze({ detachArmed: false, handedOff: false });
+        const rec = state.byTask.get(taskId);
+        const handedOff = state.handedOff.has(taskId) || (rec !== undefined && isHandedOffPhase(rec.phase));
+        return Object.freeze({ detachArmed: rec?.stamped === true, handedOff });
+    }
+    catch {
+        return Object.freeze({ detachArmed: false, handedOff: false });
+    }
+}
+export function noteInteractiveStopRequested(wire, taskId) {
+    try {
+        const state = wireStateOf(wire);
+        if (state === undefined)
+            return 'proceed';
+        const rec = typeof taskId === 'string' ? state.byTask.get(taskId) : undefined;
+        if (rec !== undefined)
+            rec.stopRequested = true;
+        if ((typeof taskId === 'string' && state.handedOff.has(taskId)) || (rec !== undefined && isHandedOffPhase(rec.phase)))
+            return 'withheld';
+        return 'proceed';
+    }
+    catch {
+        return 'proceed';
+    }
+}