@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/engineUnavailable.d.ts

@@ -0,0 +1,44 @@
+import type { RequestLane } from './request/taskRequest.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const ENGINE_UNAVAILABLE_REASONS: readonly ["not_running", "not_answering", "address_refused", "version_refused", "model_setup", "credential_conflict", "credential_refused", "data_root_refused"];
+export type EngineUnavailableReason = (typeof ENGINE_UNAVAILABLE_REASONS)[number];
+export type EngineBootRefusalReason = Extract<EngineUnavailableReason, 'model_setup' | 'credential_conflict' | 'credential_refused' | 'data_root_refused'>;
+export declare const ENGINE_INSTALL_SHAPES: readonly ["npm-global", "managed", "npm-local", "dev", "app", "unknown"];
+export type EngineInstallShape = (typeof ENGINE_INSTALL_SHAPES)[number];
+export type EngineBootRefusalForm = {
+    readonly kind: 'embedded';
+    readonly install: EngineInstallShape;
+    readonly dataDir?: string;
+} | {
+    readonly kind: 'deployment';
+};
+export type EngineDataRootVariant = 'newer_root' | 'unreadable' | 'unknown';
+export type EngineBootWayOut = 'newer_build' | 'separate_data_root' | 'restore_backup' | 'repair_access';
+export declare const ENGINE_BOOT_REFUSAL_CODES: Readonly<Record<string, EngineBootRefusalReason>>;
+export interface LocalEngineBootRefusal {
+    readonly code?: string;
+    readonly hint?: string;
+    readonly text: string;
+    readonly reason?: EngineBootRefusalReason;
+    readonly restartWouldHelp?: false;
+    readonly variant?: EngineDataRootVariant;
+    readonly findings?: readonly string[];
+    readonly highWater?: string;
+    readonly engineVersion?: string;
+    readonly markerPath?: string;
+    readonly waysOut?: readonly EngineBootWayOut[];
+}
+export declare function engineBootRefusalOf(lines: readonly string[], scrub: (s: string) => string): LocalEngineBootRefusal | undefined;
+export declare function engineBootRefusalSentence(refusal: LocalEngineBootRefusal, lang?: UiLanguage, form?: EngineBootRefusalForm): string | undefined;
+export interface EngineUnavailableFacts {
+    readonly reason?: EngineUnavailableReason;
+    readonly code?: string;
+    readonly detail?: string;
+    readonly refusal?: LocalEngineBootRefusal;
+    readonly engineExitCode?: number | null;
+    readonly engineSignal?: string | null;
+    readonly pid?: number;
+    readonly answer?: 'silent' | 'answered' | 'drain-stuck';
+    readonly form?: EngineBootRefusalForm;
+}
+export declare function engineUnavailableLine(facts: EngineUnavailableFacts, lane: RequestLane, lang?: UiLanguage): string | undefined;

package/dist/engineUnavailable.js

@@ -0,0 +1,492 @@
+import { appendOwnElement, readOwnDataValue } from './ownKey.js';
+import { compareReleaseVersions } from './supportFloor.js';
+import { LOCAL_ENGINE_SPAWN_ENV } from './localEngineSpawn.js';
+import { SETTINGS_MODEL_PLANE_REFUSAL_CODES, SETTINGS_WEB_ADMIN_TOKEN_ENV } from './generated/settingsSchemaTables.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const ENGINE_UNAVAILABLE_REASONS = Object.freeze([
+    'not_running',
+    'not_answering',
+    'address_refused',
+    'version_refused',
+    'model_setup',
+    'credential_conflict',
+    'credential_refused',
+    'data_root_refused',
+]);
+export const ENGINE_INSTALL_SHAPES = Object.freeze(['npm-global', 'managed', 'npm-local', 'dev', 'app', 'unknown']);
+const SCHEMA_MISMATCH_CODE = 'config.schema_mismatch';
+const WAYS_OUT_ANCHOR = /Ways out \(these three and no others\):/;
+const MARKER_ROLE = /^the local engine high-water marker$/;
+export const ENGINE_BOOT_REFUSAL_CODES = Object.freeze(Object.fromEntries([
+    ...SETTINGS_MODEL_PLANE_REFUSAL_CODES.map((c) => [c, 'model_setup']),
+    ['config.anthropic_credential_conflict', 'credential_conflict'],
+    ['config.center_credential_malformed', 'credential_refused'],
+    ['config.center_credential_user_session_multi_tenant', 'credential_refused'],
+    [SCHEMA_MISMATCH_CODE, 'data_root_refused'],
+]));
+function isRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function own(v, key) {
+    if (!isRecord(v))
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseJsonLine(t) {
+    try {
+        return JSON.parse(t);
+    }
+    catch {
+        return undefined;
+    }
+}
+function deepFreeze(v) {
+    if (typeof v === 'object' && v !== null && !Object.isFrozen(v)) {
+        for (const k of Object.keys(v))
+            deepFreeze(v[k]);
+        Object.freeze(v);
+    }
+    return v;
+}
+function flat(s) {
+    return s.replace(/\s+/g, ' ').trim();
+}
+function stripEndStop(s) {
+    return s.replace(/[.。]+$/u, '');
+}
+const isRelease = (v) => compareReleaseVersions(v, v) !== undefined;
+const CODE_TOKEN = '(config\\.[A-Za-z0-9_.-]*[A-Za-z0-9_])';
+function refusalCodesIn(text) {
+    const out = [];
+    for (const m of text.matchAll(new RegExp(`\\[${CODE_TOKEN}\\]`, 'g')))
+        out.push({ at: m.index ?? 0, code: m[1] });
+    for (const m of text.matchAll(new RegExp(`(?:^|\\n)[ \\t]*(?:[A-Za-z]*Error(?: \\[[^\\]\\n]*\\])?:[ \\t]*)?${CODE_TOKEN}:`, 'g')))
+        out.push({ at: m.index ?? 0, code: m[1] });
+    out.sort((a, b) => a.at - b.at);
+    const seen = [];
+    for (const { code } of out)
+        if (!seen.includes(code))
+            seen.push(code);
+    return seen;
+}
+const BOOT_REFUSAL_MAX_CHARS = 800;
+const BOOT_REFUSAL_MAX_HINTS = 2;
+const BOOT_REFUSAL_MAX_FINDINGS = 8;
+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;
+}
+function dataRootReadingOf(text) {
+    if (!text.includes(SCHEMA_MISMATCH_CODE) || !WAYS_OUT_ANCHOR.test(text))
+        return undefined;
+    const lines = text.split(/\r?\n/);
+    const at = lines.findIndex((l) => l.includes(`${SCHEMA_MISMATCH_CODE}:`));
+    if (at < 0)
+        return undefined;
+    const first = lines[at];
+    const lead = first.lastIndexOf(`${SCHEMA_MISMATCH_CODE}: `);
+    const head = capSentence(lead >= 0 ? first.slice(lead) : first);
+    if (head.length === 0)
+        return undefined;
+    const findings = [];
+    let highWater;
+    let engineVersion;
+    let markerPath;
+    let newer = false;
+    let unreadable = false;
+    for (let i = at + 1; i < lines.length && findings.length < BOOT_REFUSAL_MAX_FINDINGS; i++) {
+        const l = lines[i];
+        if (WAYS_OUT_ANCHOR.test(l) || !/^\s+\S/.test(l))
+            break;
+        const f = capSentence(l);
+        findings.push(f);
+        const hw = /: engine high-water (\S+) — .*NEWER than this build \(([^()\s]+)\)/.exec(f);
+        if (hw !== null) {
+            newer = true;
+            if (isRelease(hw[1]))
+                highWater = hw[1];
+            if (isRelease(hw[2]))
+                engineVersion = hw[2];
+            const p = /^\S+ \(the local engine high-water marker\) at (.+?): engine high-water /.exec(f);
+            if (p !== null)
+                markerPath = p[1];
+            continue;
+        }
+        if (/: UNKNOWN field\(s\) .*NEWER than this build/.test(f)) {
+            newer = true;
+            continue;
+        }
+        const un = /^\S+ \(([^()]*)\) at (.+?): unreadable \([^()\s]+\)/.exec(f);
+        if (un !== null) {
+            unreadable = true;
+            if (MARKER_ROLE.test(un[1]))
+                markerPath = un[2];
+        }
+    }
+    return {
+        variant: newer ? 'newer_root' : unreadable ? 'unreadable' : 'unknown',
+        findings: [head, ...findings],
+        ...(highWater !== undefined ? { highWater } : {}),
+        ...(engineVersion !== undefined ? { engineVersion } : {}),
+        ...(markerPath !== undefined ? { markerPath } : {}),
+    };
+}
+function classifyRefusalText(text) {
+    for (const code of refusalCodesIn(text)) {
+        if (!Object.hasOwn(ENGINE_BOOT_REFUSAL_CODES, code))
+            continue;
+        const reason = ENGINE_BOOT_REFUSAL_CODES[code];
+        if (reason !== 'data_root_refused')
+            return { reason, code };
+        const dataRoot = dataRootReadingOf(text);
+        if (dataRoot !== undefined)
+            return { reason, code, dataRoot };
+    }
+    return undefined;
+}
+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;
+        let fatalClass;
+        let fatalCode;
+        let entryClass;
+        const list = Array.isArray(lines) ? [...lines] : [];
+        const plain = [];
+        for (const raw of list) {
+            if (typeof raw !== 'string')
+                continue;
+            const t0 = raw.trim();
+            if (!t0.startsWith('{')) {
+                plain.push(raw);
+                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);
+                    fatalClass = classifyRefusalText(s);
+                    fatalCode = refusalCodesIn(s).find((x) => CONFIG_CODE.test(x));
+                }
+                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 (Object.hasOwn(ENGINE_BOOT_REFUSAL_CODES, cc) && ENGINE_BOOT_REFUSAL_CODES[cc] !== 'data_root_refused')
+                    entryClass = { reason: ENGINE_BOOT_REFUSAL_CODES[cc], code: cc };
+                if (hints.includes(sentence))
+                    continue;
+                hints.push(sentence);
+                if (hints.length > BOOT_REFUSAL_MAX_HINTS)
+                    hints.shift();
+            }
+        }
+        let text;
+        let cls = fatalClass ?? entryClass;
+        const parts = [...hints, ...(fatal !== undefined ? [fatal] : [])];
+        if (parts.length > 0)
+            text = parts.join('\n');
+        if (cls === undefined) {
+            let from = -1;
+            for (let i = plain.length - 1; i >= 0; i--)
+                if (plain[i].includes(SCHEMA_MISMATCH_CODE)) {
+                    from = i;
+                    break;
+                }
+            if (from >= 0) {
+                const block = clean(plain.slice(from).join('\n'));
+                const got = block === undefined ? undefined : classifyRefusalText(block);
+                if (block !== undefined && got !== undefined) {
+                    cls = got;
+                    if (text === undefined)
+                        text = capSentence(block);
+                }
+            }
+        }
+        if (text === undefined)
+            return undefined;
+        if (code === undefined)
+            code = cls?.code ?? fatalCode;
+        const dr = cls?.dataRoot;
+        return deepFreeze({
+            ...(code !== undefined ? { code } : {}),
+            ...(hint !== undefined ? { hint } : {}),
+            text,
+            ...(cls !== undefined ? { reason: cls.reason, restartWouldHelp: false } : {}),
+            ...(dr !== undefined
+                ? {
+                    variant: dr.variant,
+                    findings: dr.findings,
+                    ...(dr.highWater !== undefined ? { highWater: dr.highWater } : {}),
+                    ...(dr.engineVersion !== undefined ? { engineVersion: dr.engineVersion } : {}),
+                    ...(dr.markerPath !== undefined ? { markerPath: dr.markerPath } : {}),
+                    waysOut: ['newer_build', 'separate_data_root', 'restore_backup', 'repair_access'],
+                }
+                : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function againOf(retry, form) {
+    if (retry === 'command')
+        return msg('engine.unavailable.again.command');
+    return msg(form !== undefined && form.kind === 'embedded' && form.install === 'app' ? 'engine.unavailable.again.app' : 'engine.unavailable.again.session');
+}
+function configDirKey() {
+    for (const row of LOCAL_ENGINE_SPAWN_ENV)
+        if (row.value.kind === 'path' && row.value.slot === 'configHome' && !row.userOverridable)
+            return row.key;
+    return undefined;
+}
+function formOf(v) {
+    const kind = own(v, 'kind');
+    if (kind === 'deployment')
+        return { kind: 'deployment' };
+    if (kind !== 'embedded')
+        return undefined;
+    const install = own(v, 'install');
+    if (typeof install !== 'string' || !ENGINE_INSTALL_SHAPES.includes(install))
+        return undefined;
+    const dataDir = own(v, 'dataDir');
+    return { kind: 'embedded', install: install, ...(typeof dataDir === 'string' && dataDir.trim() !== '' ? { dataDir: flat(dataDir) } : {}) };
+}
+function dataRootWaysOut(form, highWater, retry) {
+    const again = againOf(retry, form);
+    if (form.kind === 'deployment') {
+        const who = highWater !== undefined ? msg('engine.bootRefusal.who.buildAtLeast', { version: highWater }) : msg('engine.bootRefusal.who.build');
+        return msg('engine.bootRefusal.waysOut', {
+            newer: msg('engine.bootRefusal.newer.deployment', { who }),
+            separate: msg('engine.bootRefusal.separate.deployment'),
+            restore: msg('engine.bootRefusal.restoreDeployment'),
+            repair: msg('engine.bootRefusal.repairDeployment'),
+        });
+    }
+    const app = form.install === 'app';
+    const who = app
+        ? highWater !== undefined ? msg('engine.bootRefusal.who.appAtLeast', { version: highWater }) : msg('engine.bootRefusal.who.app')
+        : highWater !== undefined ? msg('engine.bootRefusal.who.semaAtLeast', { version: highWater }) : msg('engine.bootRefusal.who.sema');
+    const newerKey = form.install === 'npm-global' || form.install === 'managed'
+        ? 'engine.bootRefusal.newer.update'
+        : form.install === 'npm-local'
+            ? 'engine.bootRefusal.newer.projectLocal'
+            : form.install === 'dev'
+                ? 'engine.bootRefusal.newer.devTree'
+                : app
+                    ? 'engine.bootRefusal.newer.app'
+                    : 'engine.bootRefusal.newer.unknown';
+    const key = configDirKey() ?? '';
+    return msg('engine.bootRefusal.waysOut', {
+        newer: msg(newerKey, { who, again }),
+        separate: msg(app ? 'engine.bootRefusal.separate.app' : 'engine.bootRefusal.separate.embedded', { key }),
+        restore: msg('engine.bootRefusal.restore', { folder: form.dataDir ?? msg('engine.bootRefusal.folder.default'), again }),
+        repair: msg('engine.bootRefusal.repair', { again }),
+    });
+}
+function armFix(reason, retry, facts, form) {
+    const again = againOf(retry, form);
+    switch (reason) {
+        case 'model_setup':
+            return msg('engine.unavailable.fix.modelSetup', { again });
+        case 'credential_conflict':
+            return msg('engine.unavailable.fix.credentialConflict', { again });
+        case 'credential_refused':
+            if (facts.code === 'config.center_credential_malformed')
+                return msg('engine.unavailable.fix.credentialMalformed', { again, tokenFile: SETTINGS_WEB_ADMIN_TOKEN_ENV.tokenFile });
+            if (facts.code === 'config.center_credential_user_session_multi_tenant') {
+                return msg('engine.unavailable.fix.credentialMultiTenant', { again, token: SETTINGS_WEB_ADMIN_TOKEN_ENV.token, tokenFile: SETTINGS_WEB_ADMIN_TOKEN_ENV.tokenFile });
+            }
+            return msg('engine.unavailable.fix.credential', { again });
+        case 'not_answering': {
+            const wait = msg(facts.answer === 'silent' ? 'engine.unavailable.wait.respond' : facts.answer === 'drain-stuck' ? 'engine.unavailable.wait.exit' : 'engine.unavailable.wait.healthy');
+            return facts.pid !== undefined ? msg('engine.unavailable.fix.waitPid', { wait, again, pid: facts.pid }) : msg('engine.unavailable.fix.wait', { wait, again });
+        }
+        case 'address_refused':
+        case 'version_refused':
+            return undefined;
+        default:
+            return msg('engine.unavailable.fix.diagnose', { retry: msg(retry === 'command' ? 'engine.unavailable.retry.command' : 'engine.unavailable.retry.session') });
+    }
+}
+function refusalView(r) {
+    const text = own(r, 'text');
+    const code = own(r, 'code');
+    const reason = own(r, 'reason');
+    const findingsRaw = own(r, 'findings');
+    let findings;
+    try {
+        if (Array.isArray(findingsRaw)) {
+            const fs = [];
+            const n = readOwnDataValue(findingsRaw, 'length');
+            for (let i = 0; typeof n === 'number' && i < n && i < BOOT_REFUSAL_MAX_FINDINGS + 1; i++) {
+                const f = readOwnDataValue(findingsRaw, String(i));
+                if (typeof f === 'string' && f.trim() !== '')
+                    appendOwnElement(fs, f);
+            }
+            if (fs.length > 0)
+                findings = fs;
+        }
+    }
+    catch {
+        findings = undefined;
+    }
+    const hw = own(r, 'highWater');
+    const validReason = typeof reason === 'string' && Object.values(ENGINE_BOOT_REFUSAL_CODES).includes(reason) ? reason : undefined;
+    return {
+        ...(typeof text === 'string' && text.trim() !== '' ? { text } : {}),
+        ...(typeof code === 'string' && CONFIG_CODE.test(code) ? { code } : {}),
+        ...(validReason !== undefined ? { reason: validReason } : {}),
+        ...(findings !== undefined ? { findings } : {}),
+        ...(typeof hw === 'string' && isRelease(hw) ? { highWater: hw } : {}),
+    };
+}
+export function engineBootRefusalSentence(refusal, lang, form) {
+    try {
+        const r = refusalView(refusal);
+        if (r.text === undefined)
+            return undefined;
+        const f = formOf(form);
+        if (f !== undefined && r.reason !== undefined) {
+            if (r.reason === 'data_root_refused' && r.findings !== undefined) {
+                return renderMessage(msg('engine.bootRefusal.withWaysOut', { reason: flat(r.findings.join(' ')), waysOut: dataRootWaysOut(f, r.highWater, 'session') }), lang);
+            }
+            const fix = r.reason !== 'data_root_refused' ? armFix(r.reason, 'session', r.code !== undefined ? { code: r.code } : {}, f) : undefined;
+            if (fix !== undefined)
+                return renderMessage(msg('engine.bootRefusal.withFix', { reason: `${stripEndStop(r.text.trim())}.`, fix }), lang);
+        }
+        return renderMessage(msg('localEngine.bootRefusal', { reason: r.text }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+const LANE_RETRY = Object.freeze({ interactive: 'session', print: 'command', utility: 'session' });
+const HOST_CODE = /^[a-z][a-z0-9_]{0,63}$/;
+export function engineUnavailableLine(facts, lane, lang) {
+    try {
+        if (typeof lane !== 'string' || !Object.hasOwn(LANE_RETRY, lane))
+            return undefined;
+        if (!isRecord(facts))
+            return undefined;
+        const retry = LANE_RETRY[lane];
+        const hostReasonRaw = own(facts, 'reason');
+        const hostReason = typeof hostReasonRaw === 'string' && ENGINE_UNAVAILABLE_REASONS.includes(hostReasonRaw) ? hostReasonRaw : undefined;
+        const codeRaw = own(facts, 'code');
+        const hostCode = typeof codeRaw === 'string' && HOST_CODE.test(codeRaw) ? codeRaw : undefined;
+        const detailRaw = own(facts, 'detail');
+        const hostDetail = typeof detailRaw === 'string' && detailRaw.trim() !== '' ? flat(detailRaw) : undefined;
+        const exitRaw = own(facts, 'engineExitCode');
+        const sigRaw = own(facts, 'engineSignal');
+        const pidRaw = own(facts, 'pid');
+        const pid = typeof pidRaw === 'number' && Number.isInteger(pidRaw) && pidRaw > 0 ? pidRaw : undefined;
+        const answerRaw = own(facts, 'answer');
+        const answer = answerRaw === 'silent' || answerRaw === 'answered' || answerRaw === 'drain-stuck' ? answerRaw : undefined;
+        const refusal = refusalView(own(facts, 'refusal'));
+        const form = formOf(own(facts, 'form'));
+        const reason = refusal.reason ?? hostReason;
+        const tag = `reason=${hostCode ?? reason ?? 'unknown'} ` +
+            `engine_exit=${typeof exitRaw === 'number' && Number.isFinite(exitRaw) ? String(exitRaw) : 'none'} ` +
+            `engine_signal=${typeof sigRaw === 'string' && /^[A-Z][A-Z0-9]{0,15}$/.test(sigRaw) ? sigRaw : 'none'}`;
+        let detail;
+        let fix;
+        if (refusal.reason !== undefined && refusal.text !== undefined) {
+            if (refusal.reason === 'data_root_refused' && form !== undefined && refusal.findings !== undefined) {
+                detail = flat(refusal.findings.join(' '));
+                fix = dataRootWaysOut(form, refusal.highWater, retry);
+            }
+            else if (refusal.reason === 'data_root_refused') {
+                detail = flat(refusal.text);
+                fix = undefined;
+            }
+            else {
+                detail = flat(refusal.text);
+                fix = armFix(refusal.reason, retry, refusal.code !== undefined ? { code: refusal.code } : {}, form);
+            }
+        }
+        else if (reason === 'data_root_refused') {
+            detail = hostDetail;
+            fix = form !== undefined ? dataRootWaysOut(form, undefined, retry) : undefined;
+        }
+        else {
+            detail = hostDetail;
+            fix = armFix(reason, retry, { ...(hostCode !== undefined ? { code: hostCode } : {}), ...(pid !== undefined ? { pid } : {}), ...(answer !== undefined ? { answer } : {}) }, form);
+        }
+        const head = reason === undefined
+            ? msg('engine.unavailable.head.unknown')
+            : reason === 'not_answering'
+                ? msg(answer === 'silent' ? 'engine.unavailable.head.notAnswering' : answer === 'drain-stuck' ? 'engine.unavailable.head.drainStuck' : 'engine.unavailable.head.noHealthyAnswer')
+                : reason === 'address_refused'
+                    ? msg('engine.unavailable.head.addressRefused')
+                    : reason === 'version_refused'
+                        ? msg('engine.unavailable.head.versionRefused')
+                        : reason === 'not_running' || (reason === 'model_setup' && refusal.reason === undefined)
+                            ? msg('engine.unavailable.head.notRunning')
+                            : msg('engine.unavailable.head.refused');
+        let ref;
+        if (reason === 'address_refused' || reason === 'version_refused') {
+            ref = detail !== undefined ? msg('engine.unavailable.lineRefusedUse', { tag, head, detail }) : msg('engine.unavailable.lineRefusedUseNoDetail', { tag, head });
+        }
+        else {
+            ref =
+                fix === undefined
+                    ? detail !== undefined
+                        ? msg('engine.unavailable.lineNoFix', { tag, head, detail })
+                        : msg('engine.unavailable.lineBare', { tag, head })
+                    : detail !== undefined
+                        ? msg('engine.unavailable.line', { tag, head, detail: stripEndStop(detail), fix })
+                        : msg('engine.unavailable.lineNoDetail', { tag, head, fix });
+        }
+        return flat(renderMessage(ref, lang));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/eventLeg.js

@@ -9,7 +9,6 @@ import { hostLog } from './host.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { settleEngineClosedApproval } from './hitl/approvalHolds.js';
 import { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
-import { setBridgeRunHandleFallback } from './hitl/frameRouter.js';
 export const EVENT_LEG_KINDS = Object.freeze(['live', 'durable', 'continuation']);
 export const EVENT_LEG_TABLE = Object.freeze({
     live: Object.freeze({ stages: Object.freeze(['bindRun', 'stampOwner', 'hitlFrames', 'askBridge', 'idleTriage']), windowIsCurrent: true }),
@@ -249,7 +248,9 @@ export function composeEventLeg(source, leg, ports) {
                 return;
             if (!isCurrentNow() || ports.signal?.aborted === true)
                 return;
-            callPort('askBridge.onBreak', () => port.call(hostBridge, event));
+            const legRun = lastBound?.taskId;
+            const named = event.runId === undefined && legRun !== undefined ? Object.freeze({ ...event, runId: legRun }) : event;
+            callPort('askBridge.onBreak', () => port.call(hostBridge, named));
         };
         const deps = hostView(hostBridge, {
             runsEvents: () => runsEvents,
@@ -259,7 +260,6 @@ export function composeEventLeg(source, leg, ports) {
             },
             onBreak: () => onBreak,
         });
-        setBridgeRunHandleFallback(deps, () => lastBound?.taskId);
         inner = bridgeAskUserQuestionGates(inner, deps, { ...(ports.signal !== undefined ? { signal: ports.signal } : {}), ...(legRunId !== undefined ? { taskId: legRunId } : {}) });
     }
     const baseUrl = ports.idleTriage?.baseUrl;

package/dist/generated/sdkFactTables.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_ABORT_CAUSES: readonly ["client_disconnected", "ask_park_grace_exhausted", "cancel_verb"];
+export declare const SDK_ABORT_CAUSES: readonly ["client_disconnected", "ask_park_grace_exhausted", "cancel_verb", "stall_verdict"];
 export declare const SDK_STATUS_DERIVED_COARSE_CODES: readonly ["request.rejected", "auth.unauthorized", "auth.forbidden", "not_found.resource", "request.payload_too_large", "request.unprocessable", "limit.rate_exceeded", "capability.unavailable", "internal.error"];
 export declare const SDK_DENY_REASON_ROUTING_FAILURE: "routing_failure_fail_closed";
 export declare const SDK_ASK_ROW_ENDING_CAUSES: readonly ["routing_failure_fail_closed", "run_cancelled", "run_exited", "batch_aborted", "batch_sibling_withdrawn", "batch_bound_elsewhere", "adhoc_leg_no_durable_domain", "orphan_ttl_exceeded", "crashed_before_park", "shutdown_before_park"];

package/dist/generated/sdkFactTables.js

@@ -2,6 +2,7 @@ export const SDK_ABORT_CAUSES = Object.freeze([
     "client_disconnected",
     "ask_park_grace_exhausted",
     "cancel_verb",
+    "stall_verdict",
 ]);
 export const SDK_STATUS_DERIVED_COARSE_CODES = Object.freeze([
     "request.rejected",

package/dist/generated/settingsSchemaTables.d.ts

@@ -14,4 +14,8 @@ export declare const SETTINGS_MCP_CONTENT_ORIGINS: readonly ["local", "execution
 export declare const SETTINGS_MIN_TRUST_WORDS: readonly ["local", "session", "project", "global", "managed", "task"];
 export declare const SETTINGS_WORKSPACE_TRUST_STATES: readonly ["accepted", "declined", "no_trust_step"];
 export declare const SETTINGS_MODEL_PLANE_REFUSAL_CODES: readonly ["config.default_model_missing", "config.model_refused_name_minted", "config.model_route_endpoint_missing", "config.gateway_fallback_without_primary", "config.catalog_replaces_env_models"];
+export declare const SETTINGS_WEB_ADMIN_TOKEN_ENV: Readonly<{
+    readonly token: "SEMA_WEB_ADMIN_TOKEN";
+    readonly tokenFile: "SEMA_WEB_ADMIN_TOKEN_FILE";
+}>;
 export declare const SETTINGS_NO_EXECUTION_TARGET_LANES: readonly ["none"];

package/dist/generated/settingsSchemaTables.js

@@ -70,6 +70,7 @@ export const SETTINGS_MODEL_PLANE_REFUSAL_CODES = Object.freeze([
     "config.gateway_fallback_without_primary",
     "config.catalog_replaces_env_models",
 ]);
+export const SETTINGS_WEB_ADMIN_TOKEN_ENV = Object.freeze({ token: "SEMA_WEB_ADMIN_TOKEN", tokenFile: "SEMA_WEB_ADMIN_TOKEN_FILE" });
 export const SETTINGS_NO_EXECUTION_TARGET_LANES = Object.freeze([
     "none",
 ]);

package/dist/hitl/approvalDelivery.d.ts

@@ -1,6 +1,7 @@
 import { type AnswerCapture, type TopCauseReading, type TopLocalCodeReading, type UnansweredCapture } from '../engineWireFor.js';
 import { type AttributionLadderState, type AttributionLadderStep } from './attributionLadder.js';
 import { type RefusalCarrier, type SafetyStopHead } from './hitlBridge.js';
+export declare const RETRY_BUDGET_MS = 8000;
 export declare const PARKING_WAIT_CAP_MS = 5000;
 export interface DeliveryTiming {
     readonly delays?: readonly number[];

package/dist/hitl/approvalDelivery.js

@@ -5,7 +5,7 @@ import { isSlotCarrier, readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFa
 import { deliverWithAttributionLadder, localCodeReadOf, topCauseReadOf } from './attributionLadder.js';
 import { GATE_FAILURE_CODES, refusalCarrierOf, safetyStopHeadOf } from './hitlBridge.js';
 const RETRY_DELAYS_MS = Object.freeze([500, 1_000, 2_000]);
-const RETRY_BUDGET_MS = 8_000;
+export const RETRY_BUDGET_MS = 8_000;
 export const PARKING_WAIT_CAP_MS = 5_000;
 let timingOverride;
 export function setDeliveryTimingForTests(t) {

package/dist/hitl/approvalResolution.d.ts

@@ -60,7 +60,7 @@ export declare function isApprovalDecided(r: ApprovalResolution): r is ApprovalR
 export declare function approvalNotSentCause(r: ApprovalResolution): ApprovalNotSentCause | undefined;
 export declare function approvalUnsettledCause(r: ApprovalResolution): ApprovalUnsettledCause | undefined;
 export declare const APPROVAL_NOTE_RETRACTED_DETAIL = "the card was retracted (this host no longer has a decision port for it)";
-export declare const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = "edits are not accepted on this card";
+export declare const APPROVAL_NOTE_EDIT_REFUSED_DETAIL: string;
 export declare function approvalResolutionDetail(r: ApprovalResolution): string | undefined;
 export declare function approvalResolutionStatusTag(r: ApprovalResolution): string;
 export declare function unsettledCauseOfReading(reading: DecisionRefusalReading): 'engine_refused' | 'engine_error' | 'no_answer';

package/dist/hitl/approvalResolution.js

@@ -5,6 +5,7 @@ import { carrierReadOf, isLocalSafetyStop, localCodeReadOf, topCauseReadOf } fro
 import { directFailureReadingOf, transportReadingOf } from './approvalDelivery.js';
 import { ownReadingSlot } from '../engineWireFor.js';
 import { CHECKPOINT_ROW_BAR_SENTENCE, unboundWayOutContent } from '../checkpointRowVerdict.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export const APPROVAL_RESOLUTION_LANES = Object.freeze(['respond', 'decide', 'ask']);
 export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'retracted',
@@ -45,7 +46,7 @@ export function approvalUnsettledCause(r) {
     return r.cause;
 }
 export const APPROVAL_NOTE_RETRACTED_DETAIL = 'the card was retracted (this host no longer has a decision port for it)';
-export const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = 'edits are not accepted on this card';
+export const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = renderMessage(msg('approval.editRefusal.stem'));
 const NOT_SENT_SENTENCES = Object.freeze({
     retracted: APPROVAL_NOTE_RETRACTED_DETAIL,
     edit_refused: APPROVAL_NOTE_EDIT_REFUSED_DETAIL,