@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/localConfig/skills.js

@@ -0,0 +1,397 @@
+import { SETTINGS_IS_RESERVED_MEMBER_NAME } from '../generated/settingsSchemaFns.js';
+import { readOwnDataValue, appendOwnElement } from '../ownKey.js';
+import { SKILL_OVERRIDE_STATES, effectiveOfShaped, lockOfShaped, lowerTierOf, ownValueIn, secondaryNamesOf, bareNameOf, shapeSkillLayers, shapeSkillSubject, stateAt, withLayerDoc, } from '../skillOverrideChain.js';
+import { settingsWritePlan } from './settingsWrite.js';
+import { isDotSegment } from '../sessionIdSegment.js';
+import { slotReadOf } from '../wireFailureShape.js';
+import { SKILL_ROOT_LAYERS, SKILL_ROOT_KINDS, SKILL_OVERRIDE_SCOPES } from './skillsWords.js';
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const LIST_BUDGET = 4096;
+function listOf(v) {
+    if (!Array.isArray(v))
+        return [];
+    const n = own(v, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0 || n > LIST_BUDGET)
+        return [];
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out.push(own(v, String(i)));
+    return out;
+}
+const TRUST_LAYERS = ['project', 'additional'];
+function pathFormOf(raw) {
+    if (typeof raw !== 'string' || raw === '' || raw.length > 4096 || raw.includes('\u0000'))
+        return undefined;
+    const sep = raw.includes('\\') && !raw.includes('/') ? '\\' : '/';
+    let floor;
+    if (raw.startsWith('/'))
+        floor = '/';
+    else if (/^[A-Za-z]:[\\/]/.test(raw))
+        floor = raw.slice(0, 3);
+    else if (/^\\\\[^\\/]+[\\/][^\\/]+/.test(raw))
+        floor = raw.match(/^\\\\[^\\/]+[\\/][^\\/]+/)[0];
+    else
+        return undefined;
+    let path = raw;
+    while (path.length > floor.length && (path.endsWith('/') || path.endsWith('\\')))
+        path = path.slice(0, -1);
+    const rest = path.slice(floor.length);
+    if (rest !== '' && rest.split(/[\\/]/).some((seg) => seg === '' || isDotSegment(seg)))
+        return undefined;
+    return { sep, path, floor };
+}
+const joinPath = (f, ...segs) => (f.path === f.floor && /[\\/]$/.test(f.floor) ? f.path + segs.join(f.sep) : [f.path, ...segs].join(f.sep));
+function parentOf(f) {
+    if (f.path.length <= f.floor.length)
+        return undefined;
+    const i = Math.max(f.path.lastIndexOf('/'), f.path.lastIndexOf('\\'));
+    if (i < f.floor.length - 1)
+        return undefined;
+    const up = i < f.floor.length ? f.floor : f.path.slice(0, i);
+    return { sep: f.sep, path: up, floor: f.floor };
+}
+export function skillRootsOf(cwd, hostFacts) {
+    try {
+        const here = pathFormOf(cwd);
+        const home = pathFormOf(own(hostFacts, 'configHome'));
+        if (here === undefined || home === undefined)
+            return undefined;
+        const levels = [here];
+        const gitRaw = own(hostFacts, 'gitRoot');
+        const git = gitRaw === null || gitRaw === undefined ? undefined : pathFormOf(gitRaw);
+        if (git !== undefined) {
+            const chain = [];
+            let at = here;
+            while (at !== undefined) {
+                chain.push(at);
+                if (at.path === git.path)
+                    break;
+                at = parentOf(at);
+            }
+            if (at !== undefined && at.path === git.path)
+                levels.splice(0, levels.length, ...chain);
+        }
+        const managed = pathFormOf(own(hostFacts, 'managedDir'));
+        const extra = listOf(own(hostFacts, 'additionalDirectories')).map(pathFormOf).filter((f) => f !== undefined);
+        const plugins = [];
+        for (const p of listOf(own(hostFacts, 'plugins'))) {
+            const name = own(p, 'name');
+            const root = pathFormOf(own(p, 'root'));
+            if (typeof name === 'string' && name !== '' && root !== undefined)
+                plugins.push({ name, root });
+        }
+        const column = (kind) => {
+            const out = [];
+            const add = (layer, base, dir, plugin) => {
+                if (out.some((r) => r.dir === dir))
+                    return;
+                appendOwnElement(out, Object.freeze({ layer, kind, dir, base: base.path, ...(plugin === undefined ? {} : { plugin }) }));
+            };
+            if (managed !== undefined)
+                add('managed', managed, joinPath(managed, kind));
+            add('user', home, joinPath(home, kind));
+            for (const lv of levels)
+                add('project', lv, joinPath(lv, '.sema', kind));
+            for (const d of extra)
+                add('additional', d, joinPath(d, '.sema', kind));
+            for (const p of plugins)
+                add('plugin', p.root, joinPath(p.root, kind), p.name);
+            return Object.freeze(out);
+        };
+        return Object.freeze({ skills: column('skills'), commands: column('commands'), agents: column('agents') });
+    }
+    catch {
+        return undefined;
+    }
+}
+const LAYER_RANK = { managed: 0, user: 1, project: 2, additional: 3, plugin: 4, synced: 5, mcp: 6, builtin: 7 };
+function rootOf(v) {
+    if (!isRecord(v))
+        return undefined;
+    const layer = SKILL_ROOT_LAYERS.find((w) => w === own(v, 'layer'));
+    const kind = SKILL_ROOT_KINDS.find((w) => w === own(v, 'kind'));
+    const dir = own(v, 'dir');
+    const base = own(v, 'base');
+    if (layer === undefined || kind === undefined || typeof dir !== 'string' || dir === '' || typeof base !== 'string')
+        return undefined;
+    return { layer, kind, dir, base };
+}
+function rootTrust(trust, root) {
+    if (!TRUST_LAYERS.includes(root.layer))
+        return 'ok';
+    if (!isRecord(trust) || own(trust, 'state') !== 'judged')
+        return 'unconfirmed';
+    for (const r of listOf(own(trust, 'roots'))) {
+        if (own(r, 'dir') !== root.dir)
+            continue;
+        const t = own(r, 'trusted');
+        if (t === true)
+            return 'ok';
+        if (t !== false)
+            return 'unconfirmed';
+        const why = own(own(r, 'why'), 'kind');
+        return why === 'not_trusted' || why === 'ineligible' ? 'untrusted' : 'unconfirmed';
+    }
+    return 'unconfirmed';
+}
+const truthy = (v) => v === true || v === 'true';
+export function skillsViewOf(listings, layers, trust) {
+    const untrusted = new Set();
+    const unconfirmed = new Set();
+    try {
+        const L = shapeSkillLayers(layers);
+        const rows = [];
+        const raw = listOf(listings);
+        for (let i = 0; i < raw.length; i++) {
+            const e = raw[i];
+            const fm = own(e, 'frontmatter');
+            const dmi = truthy(own(fm, 'disable-model-invocation'));
+            const s = shapeSkillSubject(isRecord(e) ? { ...snapshotSubject(e), disableModelInvocation: dmi } : undefined);
+            if (s === undefined)
+                continue;
+            const rootRaw = own(e, 'root');
+            const root = rootRaw === undefined ? undefined : rootOf(rootRaw);
+            if (rootRaw !== undefined && root === undefined)
+                continue;
+            const layer = root !== undefined ? root.layer : s.origin === 'mcp' ? 'mcp' : s.origin === 'synced' ? 'synced' : s.origin === 'plugin' ? 'plugin' : 'builtin';
+            const trustWord = root === undefined ? 'ok' : rootTrust(trust, root);
+            if (root !== undefined && trustWord === 'untrusted')
+                untrusted.add(root.dir);
+            if (root !== undefined && trustWord === 'unconfirmed')
+                unconfirmed.add(root.dir);
+            const d = own(fm, 'description');
+            rows.push({ s, layer, order: i, trustWord, description: typeof d === 'string' && d.trim() !== '' ? d.trim() : undefined });
+        }
+        const winner = new Map();
+        for (const r of [...rows].sort((a, b) => { const d = LAYER_RANK[a.layer] - LAYER_RANK[b.layer]; return d !== 0 ? d : a.order - b.order; })) {
+            if (r.trustWord !== 'ok')
+                continue;
+            if (!winner.has(r.s.name))
+                winner.set(r.s.name, r);
+        }
+        const entries = [];
+        for (const r of rows) {
+            const effective = effectiveOfShaped(L, r.s);
+            const lock = lockOfShaped(L, r.s);
+            const editable = lock === undefined ? Object.freeze({ ok: true }) : Object.freeze({ ok: false, lockedBy: lock.source });
+            const base = { name: r.s.name, layer: r.layer, effective, editable };
+            const excluded = (reason) => {
+                const e = { ...base, status: 'excluded', reason };
+                return Object.freeze(e);
+            };
+            const applied = (extra) => {
+                const e = { ...base, status: 'applied', ...extra };
+                return Object.freeze(e);
+            };
+            if (r.trustWord !== 'ok')
+                appendOwnElement(entries, excluded(r.trustWord));
+            else if (winner.get(r.s.name) !== r)
+                appendOwnElement(entries, excluded('shadowed'));
+            else if (r.s.disableModelInvocation)
+                appendOwnElement(entries, excluded('model_invocation_off'));
+            else if (effective.value === 'off' || effective.value === 'user-invocable-only')
+                appendOwnElement(entries, excluded('overridden'));
+            else if (effective.value === 'name-only')
+                appendOwnElement(entries, applied({ nameOnly: true }));
+            else
+                appendOwnElement(entries, applied(r.description === undefined ? {} : { description: r.description }));
+        }
+        return Object.freeze({ entries: Object.freeze(entries), withheldRoots: Object.freeze({ untrusted: untrusted.size, unconfirmed: unconfirmed.size }) });
+    }
+    catch {
+        return Object.freeze({ entries: Object.freeze([]), withheldRoots: Object.freeze({ untrusted: untrusted.size, unconfirmed: unconfirmed.size }) });
+    }
+}
+function snapshotSubject(e) {
+    const out = {};
+    for (const k of ['name', 'origin', 'unqualifiedName', 'bareNameReserved', 'aliases', 'mcpLabels', 'reservedLabels', 'syncedNames', 'followsSyncedSkillState', 'hiddenBehindPlugin']) {
+        const v = own(e, k);
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+export function skillsSetEditOf(entry, state, scope) {
+    return Object.freeze({ kind: 'set_override', name: entry.name, state, scope });
+}
+export function skillsClearEditOf(entry) {
+    const by = own(own(entry, 'effective'), 'decidedBy');
+    const name = own(entry, 'name');
+    if (typeof name !== 'string' || name === '')
+        return undefined;
+    const editable = slotReadOf(entry, 'editable');
+    if (editable.presence === 'unreadable')
+        return undefined;
+    if (editable.presence === 'present' && editable.value !== undefined && own(editable.value, 'ok') !== true)
+        return undefined;
+    if (by === 'localSettings')
+        return Object.freeze({ kind: 'clear_override', name, scope: 'local' });
+    if (by === 'userSettings')
+        return Object.freeze({ kind: 'clear_override', name, scope: 'user' });
+    return undefined;
+}
+const LOCK_REFUSAL = {
+    policy: 'skill_locked_by_higher_layer',
+    flag: 'skill_locked_by_higher_layer',
+    plugin: 'skill_managed_by_plugin',
+    'skill-author': 'skill_locked_by_author',
+    'reserved-name': 'skill_name_unstorable',
+};
+const DOC_DECIDERS = ['policySettings', 'localSettings', 'projectSettings', 'userSettings'];
+function docOf(r) {
+    if (r === undefined)
+        return undefined;
+    if (r.status === 'loaded')
+        return r.doc;
+    if (r.status === 'absent' || r.status === 'outside_fence')
+        return null;
+    return undefined;
+}
+function overrideDiff(L, target, r, desiredState, subjects) {
+    const m = new Map();
+    const ov = L.docs[target];
+    const lower = (s) => lowerTierOf(L, s, target, false);
+    const desired = (s) => s.name === r.name ? desiredState : (lockOfShaped(L, s)?.value ?? ownValueIn(ov, s) ?? lower(s) ?? 'on');
+    const u = desiredState;
+    const O = lower(r) ?? 'on';
+    const v = ownValueIn(ov, r) ?? O;
+    if (r.origin === 'mcp') {
+        if (u === v)
+            return m;
+        const k = u === O ? undefined : u;
+        if (k !== stateAt(ov, r.name) || m.has(r.name))
+            m.set(r.name, k);
+        for (const c of secondaryNamesOf(r)) {
+            if (stateAt(ov, c) === undefined)
+                continue;
+            for (const s of subjects) {
+                if (s.name === r.name || s.origin !== 'mcp' || !secondaryNamesOf(s).includes(c) || m.has(s.name))
+                    continue;
+                const h = ownValueIn(ov, s);
+                if ((lockOfShaped(L, s) !== undefined || desired(s) === (h ?? lower(s) ?? 'on')) && h !== undefined)
+                    m.set(s.name, h);
+            }
+            m.set(c, undefined);
+        }
+        return m;
+    }
+    const bare = r.origin === 'synced' ? bareNameOf(r) : undefined;
+    if (bare !== undefined && stateAt(ov, bare) !== undefined && u !== v) {
+        const p = lowerTierOf(L, r, target, true) ?? 'on';
+        const k = u === p ? undefined : u;
+        if (k !== stateAt(ov, r.name))
+            m.set(r.name, k);
+        m.set(bare, undefined);
+        return m;
+    }
+    if (r.origin === 'synced' && u === v)
+        return m;
+    const d = u === O ? undefined : u;
+    if (d !== stateAt(ov, r.name))
+        m.set(r.name, d);
+    return m;
+}
+function clearDiff(L, target, r, subjects) {
+    const m = new Map();
+    const ov = L.docs[target];
+    if (stateAt(ov, r.name) !== undefined)
+        m.set(r.name, undefined);
+    for (const c of secondaryNamesOf(r)) {
+        if (stateAt(ov, c) === undefined)
+            continue;
+        if (r.origin === 'mcp') {
+            for (const s of subjects) {
+                if (s.name === r.name || s.origin !== 'mcp' || !secondaryNamesOf(s).includes(c) || m.has(s.name))
+                    continue;
+                const h = ownValueIn(ov, s);
+                if (h !== undefined)
+                    m.set(s.name, h);
+            }
+        }
+        m.set(c, undefined);
+    }
+    return m;
+}
+export function skillOverrideWritePlan(edit, context) {
+    try {
+        if (!isRecord(edit))
+            return Object.freeze({ ok: false, reason: 'invalid_request' });
+        const kind = own(edit, 'kind');
+        const name = own(edit, 'name');
+        const scope = SKILL_OVERRIDE_SCOPES.find((w) => w === own(edit, 'scope'));
+        const stateRaw = own(edit, 'state');
+        const state = SKILL_OVERRIDE_STATES.find((w) => w === stateRaw);
+        if ((kind !== 'set_override' && kind !== 'clear_override') || typeof name !== 'string' || name === '' || name.length > 512 || scope === undefined)
+            return Object.freeze({ ok: false, reason: 'invalid_request' });
+        if (kind === 'set_override' ? state === undefined : stateRaw !== undefined)
+            return Object.freeze({ ok: false, reason: 'invalid_request' });
+        if (SETTINGS_IS_RESERVED_MEMBER_NAME(name))
+            return Object.freeze({ ok: false, reason: 'skill_name_unstorable' });
+        const target = scope === 'local' ? 'localSettings' : 'userSettings';
+        const snapshot = ['policySettings', 'projectSettings', 'localSettings', 'userSettings'].filter((d) => d !== target);
+        const subjects = listOf(own(context, 'subjects'))
+            .map((v) => shapeSkillSubject(v))
+            .filter((s) => s !== undefined);
+        const flag = own(context, 'flagSettings');
+        const session = own(context, 'session');
+        const disabledSources = own(context, 'disabledSources');
+        const envOff = own(context, 'bundledSkillsDisabledByEnv') === true;
+        const plan = ({ fresh }) => {
+            const docs = {};
+            for (const d of [target, ...snapshot]) {
+                const doc = docOf(fresh[d]);
+                if (doc === undefined)
+                    return { kind: 'refuse', reason: 'scope_unreadable' };
+                docs[d] = doc;
+            }
+            const L = shapeSkillLayers({ ...docs, flagSettings: flag, session, disabledSources, bundledSkillsDisabledByEnv: envOff });
+            const r = subjects.find((s) => s.name === name);
+            if (r === undefined)
+                return { kind: 'refuse', reason: 'not_found' };
+            const lock = lockOfShaped(L, r);
+            if (lock !== undefined)
+                return { kind: 'refuse', reason: LOCK_REFUSAL[lock.source] };
+            const diff = kind === 'set_override' ? overrideDiff(L, target, r, state, subjects) : clearDiff(L, target, r, subjects);
+            const current = docs[target] ?? null;
+            let next = null;
+            if (diff.size > 0) {
+                const edits = [...diff].map(([member, value]) => value === undefined ? { intent: 'skillOverride', member, op: 'delete' } : { intent: 'skillOverride', member, op: 'set', value });
+                const w = settingsWritePlan({ doc: target, current, trust: 'unreadable', edits });
+                if (!w.ok)
+                    return { kind: 'refuse', reason: w.reason, ...(w.detail === undefined ? {} : { detail: w.detail }) };
+                if (w.changed)
+                    next = w.next;
+            }
+            const after = effectiveOfShaped(next === null ? L : withLayerDoc(L, target, next), r);
+            const layer = DOC_DECIDERS.find((d) => d === after.decidedBy);
+            const wanted = kind === 'set_override' ? state : undefined;
+            const disclose = layer === undefined ? [] : [{ kind: wanted === undefined || after.value === wanted ? 'decided_by' : 'shadowed_by', layer }];
+            return next === null ? { kind: 'unchanged', disclose } : { kind: 'write', next, disclose };
+        };
+        const intent = Object.freeze({
+            appliesOn: 'next_turn',
+            steps: Object.freeze([Object.freeze({ doc: target, role: 'effect', snapshot: Object.freeze([...snapshot]), plan })]),
+        });
+        return Object.freeze({ ok: true, intent });
+    }
+    catch {
+        return Object.freeze({ ok: false, reason: 'invalid_request' });
+    }
+}
+const PENDING = Object.freeze({ kind: 'pending' });
+export function skillCreatePlan(_intent) {
+    return PENDING;
+}
+export function skillRemovePlan(_intent) {
+    return PENDING;
+}

package/dist/localConfig/skillsWords.d.ts

@@ -0,0 +1,10 @@
+export declare const SKILL_ROOT_LAYERS: readonly ["managed", "user", "project", "additional", "plugin"];
+export type SkillRootLayer = (typeof SKILL_ROOT_LAYERS)[number];
+export declare const SKILL_ROOT_KINDS: readonly ["skills", "commands", "agents"];
+export type SkillRootKind = (typeof SKILL_ROOT_KINDS)[number];
+export declare const SKILLS_VIEW_EXCLUDED_REASONS: readonly ["overridden", "model_invocation_off", "untrusted", "unconfirmed", "shadowed"];
+export type SkillsViewExcludedReason = (typeof SKILLS_VIEW_EXCLUDED_REASONS)[number];
+export declare const SKILLS_VIEW_LAYERS: readonly ["managed", "user", "project", "additional", "plugin", "mcp", "builtin", "synced"];
+export type SkillsViewLayer = (typeof SKILLS_VIEW_LAYERS)[number];
+export declare const SKILL_OVERRIDE_SCOPES: readonly ["local", "user"];
+export type SkillOverrideScope = (typeof SKILL_OVERRIDE_SCOPES)[number];

package/dist/localConfig/skillsWords.js

@@ -0,0 +1,5 @@
+export const SKILL_ROOT_LAYERS = Object.freeze(['managed', 'user', 'project', 'additional', 'plugin']);
+export const SKILL_ROOT_KINDS = Object.freeze(['skills', 'commands', 'agents']);
+export const SKILLS_VIEW_EXCLUDED_REASONS = Object.freeze(['overridden', 'model_invocation_off', 'untrusted', 'unconfirmed', 'shadowed']);
+export const SKILLS_VIEW_LAYERS = Object.freeze([...SKILL_ROOT_LAYERS, 'mcp', 'builtin', 'synced']);
+export const SKILL_OVERRIDE_SCOPES = Object.freeze(['local', 'user']);

package/dist/localEngineSeatReading.d.ts

@@ -14,9 +14,9 @@ export declare function localEngineSeatSentence(reading: LocalEngineSeatReading,
 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 lifecycle: LocalEngineSeatReading | undefined;
     readonly mcp?: SeatLocalMcpReading;
-}, lang?: UiLanguage): EngineTargetLocal;
+}, lang?: UiLanguage): EngineTargetLocal | undefined;
 export interface EngineRestartOperation {
     readonly before: LocalEngineState;
     readonly after: LocalEngineState;

package/dist/localEngineSeatReading.js

@@ -95,7 +95,7 @@ export function localEngineSeatReadingOf(state, host) {
         return undefined;
     }
 }
-const STATE_DOWN = Object.freeze(['lock-unavailable', 'spawn-failed', 'spawn-refused', 'stop-failed', 'crash-loop', 'high-water-unreadable']);
+const STATE_DOWN = Object.freeze(['lock-unavailable', 'spawn-failed', 'spawn-refused', 'stop-failed', 'crash-loop', 'high-water-unreadable', 'exited-once']);
 const DOWN_KEYS = Object.freeze({
     'lock-unavailable': 'localEngine.down.lockUnavailable',
     'spawn-failed': 'localEngine.down.spawnFailed',
@@ -103,6 +103,7 @@ const DOWN_KEYS = Object.freeze({
     'stop-failed': 'localEngine.down.stopFailed',
     'crash-loop': 'localEngine.down.crashLoop',
     'high-water-unreadable': 'localEngine.down.highWaterUnreadable',
+    'exited-once': 'localEngine.down.exitedOnce',
 });
 function downSentence(reason, lang) {
     if (reason === 'principal-unknown')
@@ -207,6 +208,7 @@ const FAIL_KEYS = Object.freeze({
     'local_engine.stop_failed': 'localEngine.down.stopFailed',
     'local_engine.crash_loop': 'localEngine.down.crashLoop',
     'local_engine.high_water_unreadable': 'localEngine.down.highWaterUnreadable',
+    'local_engine.exited_once': 'localEngine.down.exitedOnce',
 });
 export function localEngineFailText(code, lang) {
     try {
@@ -224,7 +226,7 @@ export function engineTargetLocalOf(input, lang) {
         const lifecycle = raw === undefined ? undefined : ownSnapshotTyped(raw);
         const phase = own(lifecycle, 'phase');
         if (lifecycle === undefined || typeof phase !== 'string')
-            return Object.freeze({});
+            return undefined;
         const out = { lifecycle };
         if (phase === 'down') {
             const line = downSentence(own(lifecycle, 'reason'), lang);
@@ -238,7 +240,7 @@ export function engineTargetLocalOf(input, lang) {
         return deepFreeze(out);
     }
     catch {
-        return Object.freeze({});
+        return undefined;
     }
 }
 function attachedId(s) {

package/dist/localEngineSpawn.d.ts

@@ -103,11 +103,4 @@ export interface LocalEnginePrincipalView {
 }
 export declare function localEnginePrincipalOf(view: LocalEnginePrincipalView): LocalEnginePrincipal;
 export declare function localEnginePrincipalSentence(p: LocalEnginePrincipal, lang?: UiLanguage): string | undefined;
-export interface LocalEngineBootRefusal {
-    readonly code?: string;
-    readonly hint?: string;
-    readonly text: string;
-}
-export declare function engineBootRefusalOf(lines: readonly string[], scrub: (s: string) => string): LocalEngineBootRefusal | undefined;
-export declare function engineBootRefusalSentence(refusal: LocalEngineBootRefusal, lang?: UiLanguage): string | undefined;
 export declare function localEngineFirstShareSentence(lang?: UiLanguage): string;

package/dist/localEngineSpawn.js

@@ -61,14 +61,6 @@ function stringOf(x) {
         return undefined;
     }
 }
-function parseJsonLine(t) {
-    try {
-        return JSON.parse(t);
-    }
-    catch {
-        return undefined;
-    }
-}
 function freezeRecord(rows) {
     const out = {};
     for (const [k, v] of rows)
@@ -397,90 +389,6 @@ export function localEnginePrincipalSentence(p, lang) {
         return undefined;
     }
 }
-const BOOT_REFUSAL_MAX_CHARS = 800;
-const BOOT_REFUSAL_MAX_HINTS = 2;
-const CONFIG_CODE = /^config\.[A-Za-z0-9_.-]+$/;
-function capSentence(s) {
-    const t = s.trim();
-    return t.length > BOOT_REFUSAL_MAX_CHARS ? `${t.slice(0, BOOT_REFUSAL_MAX_CHARS)}…` : t;
-}
-export function engineBootRefusalOf(lines, scrub) {
-    try {
-        const clean = (s) => {
-            try {
-                const out = scrub(s);
-                return typeof out === 'string' ? out : undefined;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        const hints = [];
-        let code;
-        let hint;
-        let fatal;
-        const list = Array.isArray(lines) ? [...lines] : [];
-        for (const raw of list) {
-            if (typeof raw !== 'string')
-                continue;
-            const line = clean(raw);
-            if (line === undefined)
-                continue;
-            const t = line.trim();
-            if (!t.startsWith('{'))
-                continue;
-            const o = parseJsonLine(t);
-            if (!isRecord(o))
-                continue;
-            const m = own(o, 'msg');
-            const err = own(o, 'err');
-            if (m === 'fatal' && typeof err === 'string' && err.trim() !== '') {
-                const full = clean(err);
-                const s = full === undefined ? undefined : full.replace(/^\s*Error:\s*/, '');
-                if (s !== undefined && s.trim() !== '')
-                    fatal = capSentence(s);
-                continue;
-            }
-            const c = own(o, 'code');
-            const h = own(o, 'hint');
-            if (typeof c === 'string' && CONFIG_CODE.test(c) && typeof h === 'string' && h.trim() !== '') {
-                const model = own(o, 'model');
-                const who = typeof model === 'string' && model !== '' ? `"${model}": ` : '';
-                const s = clean(`${who}${h}`);
-                const cc = clean(c);
-                if (s === undefined || cc === undefined || !CONFIG_CODE.test(cc))
-                    continue;
-                const sentence = capSentence(s);
-                code = cc;
-                const ch = clean(h);
-                hint = ch === undefined ? undefined : capSentence(ch);
-                if (hints.includes(sentence))
-                    continue;
-                hints.push(sentence);
-                if (hints.length > BOOT_REFUSAL_MAX_HINTS)
-                    hints.shift();
-            }
-        }
-        const parts = [...hints, ...(fatal !== undefined ? [fatal] : [])];
-        if (parts.length === 0)
-            return undefined;
-        return Object.freeze({ ...(code !== undefined ? { code } : {}), ...(hint !== undefined ? { hint } : {}), text: parts.join('\n') });
-    }
-    catch {
-        return undefined;
-    }
-}
-export function engineBootRefusalSentence(refusal, lang) {
-    try {
-        const text = own(refusal, 'text');
-        if (typeof text !== 'string' || text.trim() === '')
-            return undefined;
-        return renderMessage(msg('localEngine.bootRefusal', { reason: text }), lang);
-    }
-    catch {
-        return undefined;
-    }
-}
 export function localEngineFirstShareSentence(lang) {
     return renderMessage(msg('localEngine.firstShare'), lang);
 }

package/dist/localEngineStep.d.ts

@@ -14,7 +14,7 @@ export interface LocalEngineStepOccupancy extends LocalEngineOccupancy {
     readonly bgIds: readonly string[] | null;
 }
 export type LocalEngineTarget = EngineSwapCardTarget;
-export type LocalEngineStateDownReason = 'lock-unavailable' | 'spawn-failed' | 'spawn-refused' | 'stop-failed' | 'crash-loop' | 'high-water-unreadable';
+export type LocalEngineStateDownReason = 'lock-unavailable' | 'spawn-failed' | 'spawn-refused' | 'stop-failed' | 'crash-loop' | 'high-water-unreadable' | 'exited-once';
 export interface LocalEngineCauseEntry {
     readonly cause: LocalEngineSwapCause;
     readonly fingerprint: string;
@@ -189,7 +189,7 @@ export type LocalEngineEvent = {
     readonly clean: boolean | 'unknown';
     readonly nowMs: number;
 };
-export declare const LOCAL_ENGINE_FAIL_CODES: readonly ["local_engine.behind", "local_engine.legacy_below_floor", "local_engine.unresponsive", "local_engine.swap_pending", "local_engine.drain_overdue", "local_engine.unanswered_unverifiable", "local_engine.lock_unavailable", "local_engine.spawn_failed", "local_engine.spawn_refused", "local_engine.stop_failed", "local_engine.crash_loop", "local_engine.high_water_unreadable", "local_engine.principal_unknown"];
+export declare const LOCAL_ENGINE_FAIL_CODES: readonly ["local_engine.behind", "local_engine.legacy_below_floor", "local_engine.unresponsive", "local_engine.swap_pending", "local_engine.drain_overdue", "local_engine.unanswered_unverifiable", "local_engine.lock_unavailable", "local_engine.spawn_failed", "local_engine.spawn_refused", "local_engine.stop_failed", "local_engine.crash_loop", "local_engine.high_water_unreadable", "local_engine.exited_once", "local_engine.principal_unknown"];
 export type LocalEngineFailCode = (typeof LOCAL_ENGINE_FAIL_CODES)[number];
 export type LocalEngineNotice = {
     readonly key: 'versionUnknown';

package/dist/localEngineStep.js

@@ -18,6 +18,7 @@ export const LOCAL_ENGINE_FAIL_CODES = Object.freeze([
     'local_engine.stop_failed',
     'local_engine.crash_loop',
     'local_engine.high_water_unreadable',
+    'local_engine.exited_once',
     'local_engine.principal_unknown',
 ]);
 function isRecord(v) {
@@ -210,6 +211,7 @@ const DOWN_FAIL = Object.freeze({
     'stop-failed': 'local_engine.stop_failed',
     'crash-loop': 'local_engine.crash_loop',
     'high-water-unreadable': 'local_engine.high_water_unreadable',
+    'exited-once': 'local_engine.exited_once',
 });
 function showCard(p, hold, occ, fx, policy) {
     if (headless(policy)) {

package/dist/mcpProbeWire.js

@@ -1,5 +1,6 @@
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { wireFailureShapeOf } from './wireFailureShape.js';
+import { LIMIT_RATE_EXCEEDED } from './engineErrorCodes.js';
 import { mcpProbeAvailable } from './mcpProbeCapability.js';
 import { scenarioRefusalFromError } from './scenarioRefusal.js';
 export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
@@ -50,7 +51,7 @@ export function classifyMcpProbeFailure(e) {
             return refusedBy('body_unparseable', message);
         case 'request.payload_too_large':
             return refusedBy('payload_too_large', message);
-        case 'limit.rate_exceeded':
+        case LIMIT_RATE_EXCEEDED:
             return refusedBy('rate_limited', message, retryAfterSec);
         case 'auth.unauthorized':
             return refusedBy('unauthorized', message);

package/dist/mcpReconnect.js

@@ -1,12 +1,12 @@
 import { capForDisplay } from './fleetTaskDesc.js';
+import { STEERING_NOT_RUNNING } from './engineErrorCodes.js';
 import { ownDataField } from './ownKey.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { inSlotReadOf, inValueOf, slotReadOf } from './wireFailureShape.js';
 import { readMcpAuthorization } from './mcpLiveness.js';
 import { msg, renderMessage } from './i18n/translate.js';
 export const MCP_RECONNECT_OUTCOMES = Object.freeze(['accepted', 'refused', 'unsupported']);
-export const MCP_RECONNECT_TRANSACTION_NOTICE = 'Reconnecting closes the current connection before dialing again. On a healthy server this is a transaction, ' +
-    'not a refresh: a failed re-dial leaves the server down and withdraws its tools from the model until a later re-dial succeeds.';
+export const MCP_RECONNECT_TRANSACTION_NOTICE = renderMessage(msg('session.mcpReconnect.transaction'));
 export const MCP_RECONNECT_UNSETTLED_NOTICE = renderMessage(msg('session.mcpReconnect.unsettled'));
 const UNSETTLED_CODE = 'state.mcp_reconnect_unsettled';
 const _sdkClientIsAnInjection = [true];
@@ -141,7 +141,7 @@ export function classifyMcpReconnectFailure(e) {
         return unsettledVerdict(e);
     if (code === 'steering.invalid_content')
         return { kind: 'invalid' };
-    if (code === 'steering.not_running')
+    if (code === STEERING_NOT_RUNNING)
         return { kind: 'not_running' };
     if (typeof code === 'string' && code.startsWith('capability.'))
         return { kind: 'unsupported', reason: 'capability' };