@sema-agent/client-core 0.107.0 → 0.109.0

package/dist/localEngineJudge.js

@@ -0,0 +1,242 @@
+import { engineIdentityOf, engineIdentityVerdict } from './engineIdentity.js';
+import { readEngineHealthFacts } from './engineHealthFacts.js';
+import { compareReleaseVersions, engineSupportFloorEffective, engineVersionTier } from './supportFloor.js';
+import { readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+function isRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function isArray(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function nonEmpty(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function isPid(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+function isPort(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 1 && v <= 65535;
+}
+function own(v, key) {
+    if (!isRecord(v) && !isArray(v))
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function freezeIdentity(id) {
+    return Object.freeze({ ...id });
+}
+function planFingerprintsOf(raw) {
+    if (!isArray(raw))
+        return undefined;
+    const out = [];
+    for (let i = 0; i < raw.length; i++) {
+        const e = own(raw, String(i));
+        const group = nonEmpty(own(e, 'group'));
+        const fingerprint = nonEmpty(own(e, 'fingerprint'));
+        if (group !== undefined && fingerprint !== undefined)
+            out.push(Object.freeze({ group, fingerprint }));
+    }
+    return Object.freeze(out);
+}
+function anchorOf(raw) {
+    if (!isRecord(raw))
+        return null;
+    const pid = readOwnDataValue(raw, 'pid');
+    const port = readOwnDataValue(raw, 'port');
+    if (!isPid(pid) || !isPort(port))
+        return null;
+    const identity = freezeIdentity(engineIdentityOf({ pid, instanceId: readOwnDataValue(raw, 'instanceId'), startedAt: readOwnDataValue(raw, 'engineStartedAt') }));
+    const planFingerprints = planFingerprintsOf(readOwnDataValue(raw, 'planFingerprints'));
+    const logPath = nonEmpty(readOwnDataValue(raw, 'logPath'));
+    return Object.freeze({
+        pid,
+        port,
+        identity,
+        ...(planFingerprints !== undefined ? { planFingerprints } : {}),
+        ...(logPath !== undefined ? { logPath } : {}),
+    });
+}
+export function localEngineAnchorOf(raw) {
+    try {
+        return anchorOf(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function localEnginePlanDriftOf(anchor, ownPlan) {
+    try {
+        const a = localEngineAnchorOf(anchor);
+        const AMBIGUOUS = Symbol('ambiguous');
+        const theirs = new Map();
+        for (const e of a?.planFingerprints ?? []) {
+            const prior = theirs.get(e.group);
+            theirs.set(e.group, prior === undefined || prior === e.fingerprint ? e.fingerprint : AMBIGUOUS);
+        }
+        if (!isArray(ownPlan))
+            return Object.freeze([]);
+        const mine = new Map();
+        for (let i = 0; i < ownPlan.length; i++) {
+            const e = own(ownPlan, String(i));
+            const group = nonEmpty(own(e, 'group'));
+            if (group === undefined)
+                continue;
+            const fp = nonEmpty(own(e, 'fingerprint')) ?? AMBIGUOUS;
+            const prior = mine.get(group);
+            mine.set(group, prior === undefined ? fp : prior === fp ? fp : AMBIGUOUS);
+        }
+        const out = [];
+        for (const [group, fp] of mine) {
+            const t = theirs.get(group);
+            const drift = fp === AMBIGUOUS || t === undefined || t === AMBIGUOUS ? 'unknown' : t === fp ? 'same' : 'different';
+            out.push(Object.freeze({ group, drift }));
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return Object.freeze([]);
+    }
+}
+const NONE = Object.freeze({ kind: 'none' });
+function pidStateOf(v) {
+    return v === 'gone' || v === 'alive' || v === 'recycled' ? v : 'unknown';
+}
+function relationOf(v) {
+    return v === 'same' || v === 'different' ? v : 'unknown';
+}
+function anchoredOf(a) {
+    return Object.freeze({ pid: a.pid, ...(a.identity.startedAt !== undefined ? { startedAt: a.identity.startedAt } : {}) });
+}
+function unanswered(a, reason) {
+    return Object.freeze({ kind: 'unanswered', pid: a.pid, ...(a.identity.startedAt !== undefined ? { startedAt: a.identity.startedAt } : {}), reason });
+}
+function stranger(mismatch, anchored) {
+    return Object.freeze({ kind: 'stranger', mismatch, anchored });
+}
+function comparableBeyondPid(x, y) {
+    return (x.instanceId !== undefined && y.instanceId !== undefined) || (x.startedAt !== undefined && y.startedAt !== undefined);
+}
+export function sameLocalEngineInstance(x, y, anchorPidAlive) {
+    if (engineIdentityVerdict(x, y) !== 'same')
+        return false;
+    return comparableBeyondPid(engineIdentityOf(x), engineIdentityOf(y)) || anchorPidAlive === true;
+}
+function judgeAnchored(input, a) {
+    const pidState = pidStateOf(own(input, 'anchorPid'));
+    const health = own(input, 'health');
+    if (!isRecord(health)) {
+        if (pidState === 'gone' || pidState === 'recycled')
+            return NONE;
+        return unanswered(a, pidState === 'alive' ? 'no-answer' : 'unverifiable');
+    }
+    const hid = engineIdentityOf({ pid: own(health, 'pid'), instanceId: own(health, 'instanceId'), startedAt: own(health, 'startedAt') });
+    const facts = readEngineHealthFacts(health);
+    if (hid.pid === undefined)
+        return unanswered(a, 'unverifiable');
+    if (hid.pid !== a.pid) {
+        if (pidState === 'alive')
+            return unanswered(a, 'no-answer');
+        if (pidState === 'unknown')
+            return unanswered(a, 'unverifiable');
+        return facts.dataRoot !== undefined ? stranger('pid', null) : unanswered(a, 'unverifiable');
+    }
+    if (facts.dataRoot === undefined)
+        return unanswered(a, 'unverifiable');
+    if (a.identity.startedAt !== undefined && hid.startedAt === undefined)
+        return unanswered(a, 'unverifiable');
+    const idv = engineIdentityVerdict(a.identity, hid);
+    if (idv === 'changed')
+        return stranger('generation', null);
+    if (idv !== 'same' || !sameLocalEngineInstance(a.identity, hid, pidState === 'alive'))
+        return unanswered(a, 'unverifiable');
+    const relation = relationOf(own(input, 'dataRootRelation'));
+    if (relation === 'unknown')
+        return unanswered(a, 'unverifiable');
+    if (relation === 'different')
+        return stranger('data-root', pidState === 'alive' ? anchoredOf(a) : null);
+    const engine = Object.freeze({ pid: a.pid, port: a.port, identity: freezeIdentity(hid), ...(facts.version !== undefined ? { version: facts.version } : {}) });
+    if (facts.draining !== undefined)
+        return Object.freeze({ kind: 'draining', engine, deadlineAt: facts.draining.deadlineAt });
+    const running = facts.version;
+    const ownRaw = own(input, 'ownVersion');
+    const mine = typeof ownRaw === 'string' ? ownRaw : undefined;
+    const cmp = running !== undefined && mine !== undefined ? compareReleaseVersions(running, mine) : undefined;
+    if (running !== undefined && mine !== undefined) {
+        if (cmp === 0)
+            return Object.freeze({ kind: 'attach', engine });
+        if (cmp === -1)
+            return Object.freeze({ kind: 'ahead', engine, running, own: mine, servesWhileWaiting: engineVersionTier(running) === 'engine' });
+        if (cmp === 1)
+            return Object.freeze({ kind: 'behind', engine, running, own: mine, source: 'running' });
+    }
+    return Object.freeze({ kind: 'version-unknown', engine });
+}
+export function judgeLocalEngine(input) {
+    const a = localEngineAnchorOf(own(input, 'anchor'));
+    if (a === null || !isRecord(input))
+        return NONE;
+    try {
+        return judgeAnchored(input, a);
+    }
+    catch {
+        return unanswered(a, 'unverifiable');
+    }
+}
+export function localEngineLaneOf(verdict) {
+    try {
+        const kind = own(verdict, 'kind');
+        const engine = own(verdict, 'engine');
+        if (kind === 'attach' || kind === 'ahead' || kind === 'version-unknown')
+            return isRecord(engine) ? 'self-spawned' : undefined;
+        if (kind === 'behind')
+            return isRecord(engine) || (engine === null && Object.hasOwn(verdict, 'engine')) ? 'self-spawned' : undefined;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function localEngineVerdictSentence(verdict, upgrade, lang) {
+    try {
+        const kind = own(verdict, 'kind');
+        if (kind === 'version-unknown')
+            return renderMessage(msg('localEngine.versionUnknown'), lang);
+        const running = own(verdict, 'running');
+        const mine = own(verdict, 'own');
+        if (typeof running !== 'string' || typeof mine !== 'string')
+            return undefined;
+        const cmp = compareReleaseVersions(running, mine);
+        if (kind === 'behind' && cmp === 1) {
+            if (upgrade === 'cli-update')
+                return renderMessage(msg('localEngine.behind.cliUpdate', { running, own: mine }), lang);
+            if (upgrade === 'app-update')
+                return renderMessage(msg('localEngine.behind.appUpdate', { running, own: mine }), lang);
+            return undefined;
+        }
+        if (kind === 'ahead' && cmp === -1 && own(verdict, 'servesWhileWaiting') === false) {
+            return renderMessage(msg('localEngine.legacyBelowFloor', { running, floor: engineSupportFloorEffective() }), lang);
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/localEngineOccupancy.d.ts

@@ -0,0 +1,88 @@
+import type { FleetMeta, FleetTaskRow, FleetWorkflowRow } from '@sema-agent/sdk';
+import { type LocalEngineRef } from './localEngineJudge.js';
+import type { SessionEngineReading } from './sessionEngine.js';
+import type { LocalEnginePrincipal } from './localEngineSpawn.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export type ClientRegistryDirectory = 'ok' | 'absent' | 'unreadable';
+export interface ClientRegistryRecordReading {
+    readonly pid: number;
+    readonly alive: boolean;
+    readonly readable: boolean;
+    readonly kind?: string;
+    readonly status?: string;
+    readonly recycled?: boolean;
+}
+export interface ClientRegistryCount {
+    readonly total: number;
+    readonly midTurn: number;
+    readonly known: boolean;
+}
+export declare function countClientRegistry(records: readonly ClientRegistryRecordReading[], selfPid: number, directory: ClientRegistryDirectory): ClientRegistryCount;
+export interface LocalEngineFleetReading {
+    readonly connected: boolean;
+    readonly meta: FleetMeta | null;
+    readonly snapshotSeen: boolean;
+    readonly boundTo: LocalEngineRef | null;
+    readonly target: LocalEngineRef | null;
+    readonly tasks: readonly FleetTaskRow[];
+    readonly workflows: readonly FleetWorkflowRow[];
+}
+export interface FleetBackgroundLive {
+    readonly live: number;
+    readonly ids: readonly string[];
+}
+export declare function fleetBackgroundLiveOf(r: LocalEngineFleetReading): FleetBackgroundLive | 'unknown';
+export type LocalEngineSelfItem = 'turn' | 'cards' | 'workflow' | 'queued' | 'rowWrites' | 'shells';
+export type LocalEngineSelfReading = boolean | number | 'unknown';
+export interface LocalEngineSelfInput {
+    readonly turnInflight: LocalEngineSelfReading;
+    readonly cardsOnScreen: LocalEngineSelfReading;
+    readonly workflowsInflight: LocalEngineSelfReading;
+    readonly queuedMessages: LocalEngineSelfReading;
+    readonly rowWritesInflight: LocalEngineSelfReading;
+    readonly sessionShells: LocalEngineSelfReading | 'covered';
+}
+export interface LocalEngineSelf {
+    readonly verdict: 'idle' | 'busy' | 'unknown';
+    readonly busy: readonly LocalEngineSelfItem[];
+    readonly unknown: readonly LocalEngineSelfItem[];
+}
+export declare function localEngineSelfOf(r: LocalEngineSelfInput): LocalEngineSelf;
+export type LocalEngineRegistryStatus = 'busy' | 'waiting' | 'idle';
+export declare function localEngineRegistryStatusOf(self: LocalEngineSelf): LocalEngineRegistryStatus;
+export interface LocalEngineOccupancy {
+    readonly others: ClientRegistryCount;
+    readonly inflight: number | 'unknown';
+    readonly bgLive: number | 'unknown';
+    readonly self: LocalEngineSelf['verdict'];
+}
+export declare function localEngineIdle(o: LocalEngineOccupancy): boolean;
+export type LocalEngineDefaultLane = 'local' | 'cloud' | 'unknown';
+export interface LocalEngineDemandSession {
+    readonly reading: SessionEngineReading | null | undefined;
+    readonly legacyLandsLocal?: boolean;
+    readonly running: boolean;
+    readonly parked: boolean | 'unknown';
+    readonly queued: boolean;
+    readonly focused: boolean;
+}
+export interface LocalEngineDemandInput {
+    readonly principal: LocalEnginePrincipal | undefined;
+    readonly defaultLane: LocalEngineDefaultLane;
+    readonly sessions: readonly LocalEngineDemandSession[];
+    readonly printLocal: boolean;
+    readonly userStartAction: boolean;
+    readonly attachOnlyUse: boolean;
+}
+export type LocalEngineDemandSource = 'default-lane' | 'session' | 'print' | 'user-action' | 'attach-only';
+export interface LocalEngineDemand {
+    readonly demand: 'spawn' | 'attach-only' | 'none';
+    readonly because: readonly LocalEngineDemandSource[];
+}
+export declare function localEngineDemandOf(r: LocalEngineDemandInput): LocalEngineDemand;
+export interface LocalEngineExitFate {
+    readonly kind: 'stays';
+    readonly why: 'peers' | 'lease' | 'unknown';
+}
+export declare function localEngineExitFate(others: ClientRegistryCount): LocalEngineExitFate;
+export declare function localEngineExitFateSentence(fate: LocalEngineExitFate, lang?: UiLanguage): string | undefined;

package/dist/localEngineOccupancy.js

@@ -0,0 +1,269 @@
+import { isCoreWorkflowRunTerminal, isSdkFleetTaskTerminal } from './terminalStatuses.js';
+import { appendOwnElement, readOwnDataValue } from './ownKey.js';
+import { sameLocalEngineInstance } from './localEngineJudge.js';
+import { msg, renderMessage } from './i18n/translate.js';
+function isRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function isArray(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function own(v, key) {
+    if (!isRecord(v) && !isArray(v))
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCount(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function elementsOf(v) {
+    try {
+        if (!Array.isArray(v))
+            return undefined;
+        const out = [];
+        for (let i = 0; i < v.length; i++) {
+            if (!Object.hasOwn(v, i))
+                return undefined;
+            appendOwnElement(out, readOwnDataValue(v, String(i)));
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
+const REGISTRY_STATUS_WORDS = new Set(Object.keys({ busy: true, waiting: true, idle: true }));
+function registryStatusOf(r) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(r, 'status');
+        if (d === undefined)
+            return 'status' in r ? 'unreadable' : 'absent';
+        if (!Object.hasOwn(d, 'value'))
+            return 'unreadable';
+        const v = d.value;
+        if (v === undefined)
+            return 'absent';
+        return REGISTRY_STATUS_WORDS.has(v) ? v : 'unreadable';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export function countClientRegistry(records, selfPid, directory) {
+    if (directory === 'absent')
+        return Object.freeze({ total: 0, midTurn: 0, known: true });
+    if (directory !== 'ok')
+        return Object.freeze({ total: 0, midTurn: 0, known: false });
+    const list = elementsOf(records);
+    if (list === undefined)
+        return Object.freeze({ total: 0, midTurn: 0, known: false });
+    let total = 0;
+    let midTurn = 0;
+    let known = true;
+    for (const r of list) {
+        const pid = own(r, 'pid');
+        const alive = own(r, 'alive');
+        const readable = own(r, 'readable');
+        if (typeof pid !== 'number' || typeof alive !== 'boolean' || typeof readable !== 'boolean') {
+            known = false;
+            continue;
+        }
+        if (pid === selfPid || !alive)
+            continue;
+        if (!readable) {
+            known = false;
+            continue;
+        }
+        if (own(r, 'kind') === 'daemon')
+            continue;
+        total++;
+        const status = registryStatusOf(r);
+        if (status === 'unreadable') {
+            known = false;
+            continue;
+        }
+        if ((status === 'busy' || status === 'waiting') && own(r, 'recycled') !== true)
+            midTurn++;
+    }
+    return Object.freeze({ total, midTurn, known });
+}
+function taskCounts(status) {
+    if (isSdkFleetTaskTerminal(status))
+        return false;
+    const s = status;
+    switch (s) {
+        case 'queued':
+        case 'running':
+        case 'stopping':
+        case 'idle':
+            return true;
+        case 'waiting':
+        case 'awaiting approval':
+            return false;
+        default: {
+            const unhandled = s;
+            void unhandled;
+            return undefined;
+        }
+    }
+}
+function workflowCounts(status) {
+    if (isCoreWorkflowRunTerminal(status))
+        return false;
+    return status === 'running' ? true : undefined;
+}
+export function fleetBackgroundLiveOf(r) {
+    try {
+        if (own(r, 'connected') !== true || own(r, 'snapshotSeen') !== true)
+            return 'unknown';
+        const meta = own(r, 'meta');
+        if (own(meta, 'scoped') !== false || own(meta, 'sessionScoped') !== false)
+            return 'unknown';
+        const boundTo = own(r, 'boundTo');
+        const target = own(r, 'target');
+        const bi = own(boundTo, 'identity');
+        const ti = own(target, 'identity');
+        if (!isRecord(bi) || !isRecord(ti) || !sameLocalEngineInstance(bi, ti, false))
+            return 'unknown';
+        const tasks = elementsOf(own(r, 'tasks'));
+        const workflows = elementsOf(own(r, 'workflows'));
+        if (tasks === undefined || workflows === undefined)
+            return 'unknown';
+        const ids = [];
+        for (const [rows, counts] of [[tasks, taskCounts], [workflows, workflowCounts]]) {
+            for (const row of rows) {
+                const id = own(row, 'id');
+                const status = own(row, 'status');
+                if (typeof id !== 'string' || id.length === 0 || typeof status !== 'string')
+                    return 'unknown';
+                const c = counts(status);
+                if (c === undefined)
+                    return 'unknown';
+                if (c)
+                    ids.push(id);
+            }
+        }
+        ids.sort();
+        return Object.freeze({ live: ids.length, ids: Object.freeze(ids) });
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const SELF_ITEMS = Object.freeze([
+    ['turn', 'turnInflight'],
+    ['cards', 'cardsOnScreen'],
+    ['workflow', 'workflowsInflight'],
+    ['queued', 'queuedMessages'],
+    ['rowWrites', 'rowWritesInflight'],
+    ['shells', 'sessionShells'],
+]);
+export function localEngineSelfOf(r) {
+    const busy = [];
+    const unknown = [];
+    for (const [item, key] of SELF_ITEMS) {
+        const v = own(r, key);
+        if (v === 'covered' && item === 'shells')
+            continue;
+        if (v === true || (isCount(v) && v > 0))
+            busy.push(item);
+        else if (v === false || v === 0)
+            continue;
+        else
+            unknown.push(item);
+    }
+    const verdict = busy.length > 0 ? 'busy' : unknown.length > 0 ? 'unknown' : 'idle';
+    return Object.freeze({ verdict, busy: Object.freeze(busy), unknown: Object.freeze(unknown) });
+}
+const SELF_ITEM_SET = new Set(SELF_ITEMS.map(([item]) => item));
+export function localEngineRegistryStatusOf(self) {
+    try {
+        const verdict = own(self, 'verdict');
+        const busy = elementsOf(own(self, 'busy'));
+        const unknown = elementsOf(own(self, 'unknown'));
+        if (busy === undefined || unknown === undefined || ![...busy, ...unknown].every((x) => SELF_ITEM_SET.has(x)))
+            return 'busy';
+        if (verdict === 'idle')
+            return busy.length === 0 && unknown.length === 0 ? 'idle' : 'busy';
+        if (verdict === 'busy')
+            return busy.length > 0 && busy.every((x) => x === 'cards') ? 'waiting' : 'busy';
+        return 'busy';
+    }
+    catch {
+        return 'busy';
+    }
+}
+export function localEngineIdle(o) {
+    const others = own(o, 'others');
+    return own(others, 'known') === true && own(others, 'midTurn') === 0 && own(o, 'inflight') === 0 && own(o, 'bgLive') === 0 && own(o, 'self') === 'idle';
+}
+function sessionLandsLocal(s) {
+    const reading = own(s, 'reading');
+    const kind = own(reading, 'kind');
+    if (kind === 'bound')
+        return own(own(reading, 'engine'), 'identityKind') === 'self';
+    if (kind === 'legacy')
+        return own(s, 'legacyLandsLocal') === true;
+    return false;
+}
+function sessionActive(s) {
+    const parked = own(s, 'parked');
+    return own(s, 'running') === true || parked === true || parked === 'unknown' || own(s, 'queued') === true || own(s, 'focused') === true;
+}
+export function localEngineDemandOf(r) {
+    if (own(own(r, 'principal'), 'kind') !== 'principal')
+        return Object.freeze({ demand: 'none', because: Object.freeze([]) });
+    const because = [];
+    if (own(r, 'defaultLane') === 'local')
+        because.push('default-lane');
+    const sessions = elementsOf(own(r, 'sessions')) ?? [];
+    if (sessions.some((s) => sessionLandsLocal(s) && sessionActive(s)))
+        because.push('session');
+    if (own(r, 'printLocal') === true)
+        because.push('print');
+    if (own(r, 'userStartAction') === true)
+        because.push('user-action');
+    if (because.length > 0)
+        return Object.freeze({ demand: 'spawn', because: Object.freeze(because) });
+    if (own(r, 'attachOnlyUse') === true)
+        return Object.freeze({ demand: 'attach-only', because: Object.freeze(['attach-only']) });
+    return Object.freeze({ demand: 'none', because: Object.freeze([]) });
+}
+export function localEngineExitFate(others) {
+    const total = own(others, 'total');
+    const why = own(others, 'known') === true && isCount(total) ? (total > 0 ? 'peers' : 'lease') : 'unknown';
+    return Object.freeze({ kind: 'stays', why });
+}
+const EXIT_FATE_KEYS = Object.freeze({
+    peers: 'localEngine.exitFate.peers',
+    lease: 'localEngine.exitFate.lease',
+    unknown: 'localEngine.exitFate.unknown',
+});
+export function localEngineExitFateSentence(fate, lang) {
+    try {
+        const why = own(fate, 'why');
+        if (own(fate, 'kind') !== 'stays' || (why !== 'peers' && why !== 'lease' && why !== 'unknown'))
+            return undefined;
+        return renderMessage(msg(EXIT_FATE_KEYS[why]), lang);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/localEngineSeatReading.d.ts

@@ -0,0 +1,29 @@
+import type { EngineRestartOutcome, EngineTargetLocal, LocalEngineSeatReading, SeatLocalMcpReading } from './seatContract.js';
+import { type LocalEngineEffect, type LocalEngineFailCode, type LocalEngineNotice, type LocalEngineState } from './localEngineStep.js';
+import type { LocalEngineSwapCause } from './localEngineSwapCard.js';
+import type { LocalEngineUpgradePath } from './localEngineJudge.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export interface LocalEngineSeatHostFacts {
+    readonly upgrade: 'available' | 'unavailable';
+    readonly principal?: {
+        readonly kind: string;
+    };
+}
+export declare function localEngineSeatReadingOf(state: LocalEngineState, host: LocalEngineSeatHostFacts): LocalEngineSeatReading | undefined;
+export declare function localEngineSeatSentence(reading: LocalEngineSeatReading, upgrade: LocalEngineUpgradePath | undefined, lang?: UiLanguage): string | undefined;
+export declare function localEngineNoticeText(notice: LocalEngineNotice, lang?: UiLanguage): string | undefined;
+export declare function localEngineFailText(code: LocalEngineFailCode, lang?: UiLanguage): string | undefined;
+export declare function engineTargetLocalOf(input: {
+    readonly lifecycle: LocalEngineSeatReading;
+    readonly mcp?: SeatLocalMcpReading;
+}, lang?: UiLanguage): EngineTargetLocal;
+export interface EngineRestartOperation {
+    readonly before: LocalEngineState;
+    readonly after: LocalEngineState;
+    readonly effects: readonly LocalEngineEffect[];
+    readonly cause: LocalEngineSwapCause;
+    readonly demand: 'spawn' | 'attach-only' | 'none';
+    readonly model?: string;
+    readonly lang?: UiLanguage;
+}
+export declare function engineRestartOutcomeOf(r: EngineRestartOperation): EngineRestartOutcome;