talos-code 0.0.1 → 0.2.0

package/dist/extensions/installer.js

@@ -0,0 +1,178 @@
+import { createHash } from 'node:crypto';
+import { cp, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+import { validateArchiveEntries, validateExtensionManifest } from "./package-schema.js";
+import { readZipEntries } from "../archive/zip.js";
+import { CLI_VERSION } from "../version.js";
+const hash = (v) => createHash('sha256').update(JSON.stringify(v)).digest('hex');
+async function json(file, fallback) { try {
+    return JSON.parse(await readFile(file, 'utf8'));
+}
+catch (e) {
+    if (e?.code === 'ENOENT')
+        return fallback;
+    throw e;
+} }
+async function atomicJson(file, value) { await mkdir(dirname(file), { recursive: true }); const t = `${file}.tmp-${process.pid}`; await writeFile(t, `${JSON.stringify(value, null, 2)}\n`, 'utf8'); await rm(file, { force: true }); await import('node:fs/promises').then(m => m.rename(t, file)); }
+function safeId(id) { if (!/^[a-z0-9][a-z0-9._-]{1,79}$/u.test(id))
+    throw new Error('EXTENSION_ID_INVALID'); return id; }
+async function readExtensionManifest(sourceDir) { for (const name of ['extension.json', 'talos-extension.json']) {
+    try {
+        return JSON.parse(await readFile(join(sourceDir, name), 'utf8'));
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            throw error;
+    }
+} throw Object.assign(new Error('EXTENSION_MANIFEST_MISSING'), { code: 'EXTENSION_MANIFEST_MISSING' }); }
+export async function installExtensionDirectory({ sourceDir, projectRoot, currentVersion = CLI_VERSION }) {
+    const manifest = validateExtensionManifest(await readExtensionManifest(sourceDir), currentVersion);
+    safeId(manifest.id);
+    const stateDir = join(projectRoot, '.talos-cli', 'extensions', manifest.id);
+    const installedFile = join(stateDir, 'installed.json');
+    try {
+        await readFile(installedFile, 'utf8');
+        throw new Error('EXTENSION_ALREADY_INSTALLED');
+    }
+    catch (e) {
+        if (e?.message === 'EXTENSION_ALREADY_INSTALLED')
+            throw e;
+        if (e?.code !== 'ENOENT')
+            throw e;
+    }
+    const record = { id: manifest.id, name: manifest.name, version: manifest.version, source: resolve(sourceDir), components: {} };
+    await mkdir(stateDir, { recursive: true });
+    await cp(sourceDir, join(stateDir, 'package'), { recursive: true });
+    if (manifest.components.plugin) {
+        const src = join(sourceDir, manifest.components.plugin);
+        const text = await readFile(src, 'utf8');
+        const parsed = JSON.parse(text);
+        const dest = join(projectRoot, '.harness-ui-plugins', manifest.id, 'plugin.json');
+        await mkdir(dirname(dest), { recursive: true });
+        await writeFile(dest, text, 'utf8');
+        record.components.plugin = { id: manifest.id, hash: hash(parsed) };
+    }
+    if (manifest.components.mcp) {
+        const src = JSON.parse(await readFile(join(sourceDir, manifest.components.mcp), 'utf8'));
+        if (!Array.isArray(src?.server))
+            throw new Error('EXTENSION_MCP_INVALID');
+        const file = join(projectRoot, '.harness-ui-mcp.json');
+        const cur = await json(file, { server: [] });
+        if (!Array.isArray(cur.server))
+            throw new Error('MCP_CONFIG_MALFORMED');
+        const ids = new Set(cur.server.map((x) => x.id));
+        for (const row of src.server) {
+            if (!row?.id || ids.has(row.id))
+                throw new Error('EXTENSION_COMPONENT_COLLISION');
+            ids.add(row.id);
+        }
+        cur.server.push(...src.server);
+        await atomicJson(file, cur);
+        record.components.mcp = src.server.map((x) => ({ id: x.id, hash: hash(x) }));
+    }
+    if (manifest.components.hooks) {
+        const src = JSON.parse(await readFile(join(sourceDir, manifest.components.hooks), 'utf8'));
+        if (!Array.isArray(src?.hooks))
+            throw new Error('EXTENSION_HOOKS_INVALID');
+        const file = join(projectRoot, '.harness-ui-hooks.json');
+        const cur = await json(file, { hooks: [] });
+        if (!Array.isArray(cur.hooks))
+            throw new Error('HOOK_CONFIG_MALFORMED');
+        const ids = new Set(cur.hooks.map((x) => x.id));
+        for (const row of src.hooks) {
+            if (!row?.id || ids.has(row.id))
+                throw new Error('EXTENSION_COMPONENT_COLLISION');
+            ids.add(row.id);
+        }
+        cur.hooks.push(...src.hooks);
+        await atomicJson(file, cur);
+        record.components.hooks = src.hooks.map((x) => ({ id: x.id, hash: hash(x) }));
+    }
+    if (manifest.components.commands) {
+        const src = join(sourceDir, manifest.components.commands);
+        const dest = join(projectRoot, '.talos-cli', 'commands', manifest.id);
+        await cp(src, dest, { recursive: true });
+        const files = (await readdir(dest, { recursive: true })).filter((x) => String(x).endsWith('.md')).map(String);
+        record.components.commands = files;
+    }
+    await atomicJson(installedFile, record);
+    return record;
+}
+export async function listInstalledExtensions(projectRoot) { const root = join(projectRoot, '.talos-cli', 'extensions'); let ids; try {
+    ids = await readdir(root);
+}
+catch {
+    return [];
+} const rows = []; for (const id of ids) {
+    try {
+        rows.push(JSON.parse(await readFile(join(root, id, 'installed.json'), 'utf8')));
+    }
+    catch { }
+} return rows.sort((a, b) => a.id.localeCompare(b.id)); }
+export async function removeInstalledExtension({ projectRoot, id }) {
+    safeId(id);
+    const stateDir = join(projectRoot, '.talos-cli', 'extensions', id);
+    const record = JSON.parse(await readFile(join(stateDir, 'installed.json'), 'utf8'));
+    if (record.components.mcp) {
+        const file = join(projectRoot, '.harness-ui-mcp.json');
+        const cur = await json(file, { server: [] });
+        for (const owned of record.components.mcp) {
+            const row = cur.server.find((x) => x.id === owned.id);
+            if (row && hash(row) !== owned.hash)
+                throw new Error(`EXTENSION_COMPONENT_MODIFIED:mcp:${owned.id}`);
+        }
+        cur.server = cur.server.filter((x) => !record.components.mcp.some(o => o.id === x.id));
+        await atomicJson(file, cur);
+    }
+    if (record.components.hooks) {
+        const file = join(projectRoot, '.harness-ui-hooks.json');
+        const cur = await json(file, { hooks: [] });
+        for (const owned of record.components.hooks) {
+            const row = cur.hooks.find((x) => x.id === owned.id);
+            if (row && hash(row) !== owned.hash)
+                throw new Error(`EXTENSION_COMPONENT_MODIFIED:hook:${owned.id}`);
+        }
+        cur.hooks = cur.hooks.filter((x) => !record.components.hooks.some(o => o.id === x.id));
+        await atomicJson(file, cur);
+    }
+    if (record.components.plugin) {
+        const file = join(projectRoot, '.harness-ui-plugins', id, 'plugin.json');
+        try {
+            const current = JSON.parse(await readFile(file, 'utf8'));
+            if (hash(current) !== record.components.plugin.hash)
+                throw new Error(`EXTENSION_COMPONENT_MODIFIED:plugin:${id}`);
+        }
+        catch (e) {
+            if (e?.code !== 'ENOENT')
+                throw e;
+        }
+        await rm(join(projectRoot, '.harness-ui-plugins', id), { recursive: true, force: true });
+    }
+    if (record.components.commands)
+        await rm(join(projectRoot, '.talos-cli', 'commands', id), { recursive: true, force: true });
+    await rm(stateDir, { recursive: true, force: true });
+    return { ok: true, id };
+}
+export async function installExtension({ source, projectRoot, currentVersion = CLI_VERSION }) { if (source.toLowerCase().endsWith('.zip')) {
+    const entries = readZipEntries(await readFile(source));
+    const names = [...entries.keys()];
+    validateArchiveEntries(names, process.platform === 'win32');
+    const os = await import('node:os');
+    const fs = await import('node:fs/promises');
+    const temp = await fs.mkdtemp(join(os.tmpdir(), 'talos-ext-'));
+    try {
+        for (const [name, data] of entries) {
+            if (name.endsWith('/')) {
+                await mkdir(join(temp, name), { recursive: true });
+                continue;
+            }
+            const dest = join(temp, name);
+            await mkdir(dirname(dest), { recursive: true });
+            await writeFile(dest, data);
+        }
+        return await installExtensionDirectory({ sourceDir: temp, projectRoot, currentVersion });
+    }
+    finally {
+        await rm(temp, { recursive: true, force: true });
+    }
+} return installExtensionDirectory({ sourceDir: source, projectRoot, currentVersion }); }

package/dist/extensions/package-schema.js

@@ -0,0 +1,24 @@
+const ID = /^[a-z0-9][a-z0-9._-]{1,79}$/u, VER = /^(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?$/u;
+function compatible(range, current) { const cm = VER.exec(current); if (!cm)
+    return false; const major = Number(cm[1]); const ge = />=\s*(\d+)/u.exec(range), lt = /<\s*(\d+)/u.exec(range); if (ge && major < Number(ge[1]))
+    return false; if (lt && major >= Number(lt[1]))
+    return false; return true; }
+export function validateExtensionManifest(x, currentVersion) { if (!x || typeof x !== 'object' || Array.isArray(x))
+    throw new Error('EXTENSION_MANIFEST_INVALID'); const o = x; const allowed = ['schema', 'id', 'name', 'version', 'talosCli', 'components']; if (Object.keys(o).some(k => !allowed.includes(k)) || o.schema !== 'talos.cli.extension.v1' || !ID.test(o.id ?? '') || typeof o.name !== 'string' || !VER.test(o.version ?? '') || typeof o.talosCli !== 'string' || !o.components || typeof o.components !== 'object')
+    throw new Error('EXTENSION_MANIFEST_INVALID'); if (!compatible(o.talosCli, currentVersion))
+    throw new Error('EXTENSION_INCOMPATIBLE'); for (const [k, v] of Object.entries(o.components)) {
+    if (!['plugin', 'commands', 'mcp', 'hooks'].includes(k) || typeof v !== 'string')
+        throw new Error('EXTENSION_MANIFEST_INVALID');
+    validateArchiveEntries([v]);
+} return structuredClone(o); }
+export function validateArchiveEntries(entries, windows = false) { const seen = new Set(); for (const p of entries) {
+    if (!p || p.startsWith('/') || /^[A-Za-z]:[\\/]/u.test(p))
+        throw new Error('EXTENSION_PATH_ABSOLUTE');
+    const parts = p.replace(/\\/gu, '/').split('/');
+    if (parts.some(x => x === '..'))
+        throw new Error('EXTENSION_PATH_TRAVERSAL');
+    const key = windows ? p.toLowerCase() : p;
+    if (seen.has(key))
+        throw new Error('EXTENSION_PATH_COLLISION');
+    seen.add(key);
+} return true; }

package/dist/headless/result.js

@@ -0,0 +1,84 @@
+import { hasToolOutcomeCarrier, toolOutcomesFromCliEvent } from "../events/bridge.js";
+import { renderTalosFailureLine, safeTalosFailure } from "../errors.js";
+function hiddenFailure(value, failure) { Object.defineProperty(value, 'failure', { value: failure, enumerable: false, configurable: false, writable: false }); return value; }
+function hiddenToolOutcomes(value, outcomes) { if (outcomes.length === 0)
+    return value; Object.defineProperty(value, 'toolOutcomes', { value: [...outcomes], enumerable: false, configurable: false, writable: false }); return value; }
+function resultToolOutcomes(value) { const outcomes = value.toolOutcomes; return Array.isArray(outcomes) ? outcomes : []; }
+function eventFailure(e, component = 'runtime') {
+    const attached = e.failure;
+    if (attached)
+        return attached;
+    return safeTalosFailure({ ...e.data, code: String(e.data.code ?? e.data.sourceCode ?? 'AGENT_FAILED'), message: String(e.data.message ?? e.data.detto ?? 'Agent run failed') }, { component }, []);
+}
+export function canonicalizeFailureEvent(e, component = 'runtime') {
+    if (e.type !== 'run.failed')
+        return e;
+    const failure = eventFailure(e, component);
+    const outcomes = toolOutcomesFromCliEvent(e);
+    const normalized = { ...e, data: { ...e.data, code: failure.envelope.code, message: failure.message } };
+    return hiddenToolOutcomes(hiddenFailure(normalized, failure), outcomes);
+}
+export function createFailedRunResult(input) {
+    const details = input.details ?? {};
+    const failure = safeTalosFailure({ ...details, code: input.code, message: input.message }, { component: input.component ?? 'runtime', retryable: input.retryable ?? false });
+    const value = { schema: 'talos.cli.result.v1', ok: false, sessionId: input.sessionId, error: { code: failure.envelope.code, message: failure.message, details }, warnings: [...(input.warnings ?? [])] };
+    return hiddenFailure(value, failure);
+}
+export function withRunWarnings(r, warnings) {
+    const next = { ...r, warnings: [...warnings] };
+    const failure = r.failure;
+    const withFailure = failure ? hiddenFailure(next, failure) : next;
+    return hiddenToolOutcomes(withFailure, resultToolOutcomes(r));
+}
+function ensuredFailure(r) {
+    const attached = r.failure;
+    if (attached)
+        return attached;
+    const error = r.error ?? { code: 'INTERNAL_ERROR', message: 'Unknown error', details: {} };
+    return safeTalosFailure({ ...error.details, code: error.code, message: error.message }, { component: 'runtime' }, []);
+}
+export function createRunResultAccumulator() {
+    let text = '';
+    const changed = new Set();
+    let usage = null;
+    const warnings = [];
+    let failed;
+    let failure;
+    let sid = null;
+    let toolOutcomeSource = null;
+    return {
+        add(input) {
+            const e = canonicalizeFailureEvent(input);
+            sid = e.sessionId || sid;
+            if (hasToolOutcomeCarrier(e))
+                toolOutcomeSource = e;
+            if (e.type === 'message.delta')
+                text += String(e.data.delta ?? e.data.text ?? '');
+            if (e.type === 'file.changed' && typeof e.data.path === 'string')
+                changed.add(e.data.path);
+            if (e.type === 'usage.updated')
+                usage = e.data.value ?? e.data;
+            if (e.type === 'warning')
+                warnings.push(String(e.data.message ?? e.data.code ?? 'warning'));
+            if (e.type === 'run.failed') {
+                failure = eventFailure(e);
+                failed = { code: String(e.data.code ?? 'AGENT_FAILED'), message: String(e.data.message ?? 'Agent run failed'), details: e.data };
+            }
+        },
+        result() {
+            const toolOutcomes = toolOutcomeSource ? toolOutcomesFromCliEvent(toolOutcomeSource) : [];
+            if (failed) {
+                const value = { schema: 'talos.cli.result.v1', ok: false, sessionId: sid, error: failed, warnings: [...warnings] };
+                return hiddenToolOutcomes(hiddenFailure(value, failure ?? safeTalosFailure(failed, { component: 'runtime' })), toolOutcomes);
+            }
+            const value = { schema: 'talos.cli.result.v1', ok: true, sessionId: sid, result: { text, outcome: 'success', changedFiles: [...changed], usage }, warnings: [...warnings] };
+            return hiddenToolOutcomes(value, toolOutcomes);
+        }
+    };
+}
+export function reduceRunResult(events) { const acc = createRunResultAccumulator(); for (const e of events)
+    acc.add(e); return acc.result(); }
+export function renderJson(r) { return `${JSON.stringify(r)}\n`; }
+export function renderStreamJson(events) { return events.map(e => JSON.stringify(canonicalizeFailureEvent(e))).join('\n') + (events.length ? '\n' : ''); }
+export function renderText(r) { return r.ok ? `${r.result?.text ?? ''}${r.result?.text ? '\n' : ''}` : renderTalosFailureLine(ensuredFailure(r)); }
+export function exitCodeForResult(r) { return r.ok ? 0 : ensuredFailure(r).exitCode; }

package/dist/headless/run.js

@@ -0,0 +1,230 @@
+import { createEventBridge } from "../events/bridge.js";
+import { canonicalizeFailureEvent, createFailedRunResult, createRunResultAccumulator } from "./result.js";
+import { createPermissionEngine } from "../security/permission-engine.js";
+import { permissionActionFromApproval } from "../security/from-approval.js";
+import { secretValuesFromEnvironment } from "../diagnostics/redact.js";
+import { keyOriginForRun, keyOriginNotice } from "../provider/environment-keys.js";
+/* R2 (E8 / Q-R2-7): the one missing-key sentence, also the JSON `message` of v1 and v2; the code stays PROVIDER_KEY_MISSING. */
+import { missingKeyText } from "../provider/missing-key.js";
+import { checkpointMutationAllowed } from "../workspace/checkpoint.js";
+import { createCheckpointStore } from "../workspace/checkpoint-store.js";
+import { createV2EventBridge, createV2FailureEvent, createV2RunResultAccumulator, createV2SyntheticEvent } from "../protocol/v2/events.js";
+import { t } from "../i18n/index.js";
+const INTERRUPT_GRACE_MS = 5_000;
+/*
+ * R3 Q-R3-8b, gate E8. Ctrl+C on `talos -p` asks the runtime to stop the run and waits for its terminal event (at most
+ * `interruptGraceMs`), then ends the output with an interrupted run: v1 a failure with code INTERRUPTED, v2 a
+ * `run.cancelled` (outcome `cancelled`, envelope INTERRUPTED); both exit 130 (`exitCodeForEnvelope`, errors.ts). A run that
+ * completed before the stop took effect stays completed; any other failure stays that failure. Precedents in the window:
+ * Hermes `-q` exit 130 (`cli_single_query.py:148-167`), Gemini/Qwen `FatalCancellationError` exit 130 (gate §6.2).
+ */
+function watchInterrupt(input, onStop, onGiveUp) {
+    let timer;
+    let stopped = false;
+    const stop = () => { if (stopped)
+        return; stopped = true; onStop(); timer = setTimeout(onGiveUp, input.interruptGraceMs ?? INTERRUPT_GRACE_MS); };
+    input.signal?.addEventListener('abort', stop, { once: true });
+    return { start() { if (input.signal?.aborted)
+            stop(); }, get stopped() { return stopped; }, dispose() { if (timer)
+            clearTimeout(timer); input.signal?.removeEventListener('abort', stop); } };
+}
+const isKernelStop = (code) => code === 'fermato' || code === 'INTERRUPTED' || code === 'CANCELLED';
+function noticeEvent(sessionId, seq, message) { return { schema: 'talos.cli.event.v1', seq, ts: new Date().toISOString(), sessionId, type: 'warning', data: { code: 'PROVIDER_KEY_ORIGIN', message } }; }
+async function beginTurnCheckpoint(runtime, input, operation, sessionId) {
+    if (!input.checkpointsRoot)
+        return null;
+    if (operation === 'start' && !checkpointMutationAllowed(input.permissionMode))
+        return null;
+    const store = createCheckpointStore({ rootDir: input.checkpointsRoot, projectRoot: input.projectRoot });
+    return store.begin({ operation, ...(sessionId ? { sessionId } : {}) });
+}
+function collectV1(runtime, id, input, onEvent, notices = [], checkpoint = null) {
+    const engine = createPermissionEngine({ projectRoot: input.projectRoot, rules: input.permissionRules ?? { allow: [], ask: [], deny: [] }, mode: input.permissionMode, ...(input.autoClassifier ? { classifier: input.autoClassifier } : {}) });
+    const bridge = createEventBridge(id, undefined, secretValuesFromEnvironment(process.env));
+    const events = [];
+    const accumulator = createRunResultAccumulator();
+    const offset = notices.length;
+    for (const [index, message] of notices.entries()) {
+        const event = noticeEvent(id, index + 1, message);
+        if (!onEvent)
+            events.push(event);
+        accumulator.add(event);
+        onEvent?.(event);
+    }
+    return new Promise((resolve) => {
+        let done = false;
+        let settling = false;
+        let timer;
+        let unsub = () => { };
+        let lastSeq = offset;
+        const finish = (result) => { if (done)
+            return; done = true; if (timer)
+            clearTimeout(timer); interrupt.dispose(); unsub(); resolve({ events, result }); };
+        const emit = (event) => { lastSeq = Math.max(lastSeq, event.seq); if (!onEvent)
+            events.push(event); accumulator.add(event); onEvent?.(event); };
+        const fail = (code, message, details = {}, component = 'runtime') => { if (done)
+            return; const event = canonicalizeFailureEvent({ schema: 'talos.cli.event.v1', seq: lastSeq + 1, ts: new Date().toISOString(), sessionId: id, type: 'run.failed', data: { ...details, code, message } }, component); emit(event); finish(accumulator.result()); };
+        const interrupted = () => fail('INTERRUPTED', t('error.run.interrupted.what'), {}, 'runtime');
+        const interrupt = watchInterrupt(input, () => { void runtime.cancel(id).catch(() => { }); }, interrupted);
+        unsub = runtime.subscribe(id, (raw) => {
+            if (done || settling)
+                return;
+            checkpoint?.observe(raw);
+            const translated = bridge.translate(raw);
+            if (!translated)
+                return;
+            const shifted = offset ? { ...translated, seq: translated.seq + offset } : translated;
+            const event = canonicalizeFailureEvent(shifted);
+            if (interrupt.stopped && event.type === 'run.failed' && isKernelStop(translated.data?.code)) {
+                if (!checkpoint) {
+                    interrupted();
+                    return;
+                }
+                settling = true;
+                void checkpoint.finalize().then(interrupted, interrupted);
+                return;
+            }
+            if (event.type === 'approval.required') {
+                emit(event);
+                void (async () => { const decision = await engine.decide(permissionActionFromApproval(event.data), { interactive: false, mode: input.permissionMode }); if (decision.kind === 'allow') {
+                    await runtime.answerApproval(id, String(event.data.requestId), true);
+                    return;
+                } fail(decision.kind === 'deny' ? decision.code : 'PERMISSION_REQUIRED', decision.kind === 'deny' ? decision.message : 'Operation requires approval in non-interactive mode', event.data, 'permission-engine'); void runtime.answerApproval(id, String(event.data.requestId), false).finally(() => runtime.cancel(id)).catch(() => { }); })().catch(error => { fail('PERMISSION_ENGINE_ERROR', error instanceof Error ? error.message : String(error), {}, 'permission-engine'); void runtime.cancel(id).catch(() => { }); });
+                return;
+            }
+            if (event.type === 'run.completed' || event.type === 'run.failed') {
+                if (!checkpoint) {
+                    emit(event);
+                    finish(accumulator.result());
+                    return;
+                }
+                settling = true;
+                void checkpoint.finalize().then(() => { if (done)
+                    return; emit(event); finish(accumulator.result()); }).catch(error => { settling = false; fail('CHECKPOINT_FINALIZE_FAILED', error instanceof Error ? error.message : String(error), {}, 'checkpoint'); });
+                return;
+            }
+            emit(event);
+        }, input.from ?? 0);
+        interrupt.start();
+        const ms = (input.timeoutSeconds ?? 180) * 1000;
+        timer = setTimeout(() => { fail('RUN_TIMEOUT', 'Run timed out after ' + ms + ' ms', {}, 'runtime'); void runtime.cancel(id).catch(() => { }); }, ms);
+    });
+}
+function collectV2(runtime, id, input, onEvent, notices = [], checkpoint = null) {
+    const engine = createPermissionEngine({ projectRoot: input.projectRoot, rules: input.permissionRules ?? { allow: [], ask: [], deny: [] }, mode: input.permissionMode, ...(input.autoClassifier ? { classifier: input.autoClassifier } : {}) });
+    const secrets = secretValuesFromEnvironment(process.env);
+    const bridge = createV2EventBridge(id, undefined, secrets);
+    const events = [];
+    const accumulator = createV2RunResultAccumulator();
+    for (const [index, message] of notices.entries()) {
+        const event = createV2SyntheticEvent({ sessionId: id, eventId: 'talos:' + encodeURIComponent(id) + ':provider-notice:' + (index + 1), type: 'warning', data: { code: 'PROVIDER_KEY_ORIGIN', message } });
+        if (!onEvent)
+            events.push(event);
+        accumulator.add(event);
+        onEvent?.(event);
+    }
+    return new Promise((resolve) => {
+        let done = false;
+        let settling = false;
+        let timer;
+        let unsub = () => { };
+        const finish = () => { if (done)
+            return; done = true; if (timer)
+            clearTimeout(timer); interrupt.dispose(); unsub(); resolve({ events, result: accumulator.result() }); };
+        const emit = (event) => { if (!onEvent)
+            events.push(event); accumulator.add(event); onEvent?.(event); };
+        const fail = (code, message, details = {}, component = 'runtime') => { if (done)
+            return; emit(createV2FailureEvent({ sessionId: id, error: { code, message, component, retryable: false }, component, details, secretValues: secrets })); finish(); };
+        const interrupted = () => { if (done)
+            return; emit(createV2SyntheticEvent({ sessionId: id, eventId: 'talos:' + encodeURIComponent(id) + ':interrupted', type: 'run.cancelled', data: { reason: t('error.run.interrupted.what'), interrupted: true }, durability: 'durable' })); finish(); };
+        const interrupt = watchInterrupt(input, () => { void runtime.cancel(id).catch(() => { }); }, interrupted);
+        unsub = runtime.subscribe(id, (raw) => {
+            if (done || settling)
+                return;
+            checkpoint?.observe(raw);
+            const event = bridge.translate(raw);
+            if (!event)
+                return;
+            if (interrupt.stopped && (event.type === 'run.failed' || event.type === 'run.cancelled') && (event.type === 'run.cancelled' || isKernelStop(event.data?.error?.envelope?.code))) {
+                if (!checkpoint) {
+                    interrupted();
+                    return;
+                }
+                settling = true;
+                void checkpoint.finalize().then(interrupted, interrupted);
+                return;
+            }
+            if (event.type === 'approval.required') {
+                emit(event);
+                void (async () => { const decision = await engine.decide(permissionActionFromApproval(event.data), { interactive: false, mode: input.permissionMode }); if (decision.kind === 'allow') {
+                    await runtime.answerApproval(id, String(event.data.requestId ?? ''), true);
+                    return;
+                } fail(decision.kind === 'deny' ? decision.code : 'PERMISSION_REQUIRED', decision.kind === 'deny' ? decision.message : 'Operation requires approval in non-interactive mode', event.data, 'permission-engine'); void runtime.answerApproval(id, String(event.data.requestId ?? ''), false).finally(() => runtime.cancel(id)).catch(() => { }); })().catch(error => { fail('PERMISSION_ENGINE_ERROR', error instanceof Error ? error.message : String(error), {}, 'permission-engine'); void runtime.cancel(id).catch(() => { }); });
+                return;
+            }
+            if (event.type === 'run.completed' || event.type === 'run.failed' || event.type === 'run.cancelled') {
+                if (!checkpoint) {
+                    emit(event);
+                    finish();
+                    return;
+                }
+                settling = true;
+                void checkpoint.finalize().then(() => { if (done)
+                    return; emit(event); finish(); }).catch(error => { settling = false; fail('CHECKPOINT_FINALIZE_FAILED', error instanceof Error ? error.message : String(error), {}, 'checkpoint'); });
+                return;
+            }
+            emit(event);
+        }, input.from ?? 0);
+        interrupt.start();
+        const ms = (input.timeoutSeconds ?? 180) * 1000;
+        timer = setTimeout(() => { fail('RUN_TIMEOUT', 'Run timed out after ' + ms + ' ms', {}, 'runtime'); void runtime.cancel(id).catch(() => { }); }, ms);
+    });
+}
+async function collectHeadlessRunV1(runtime, input, onEvent) {
+    const origin = keyOriginForRun(runtime, input.model);
+    if (origin?.required && origin.origin === 'none') {
+        const message = missingKeyText(origin.provider);
+        const failed = canonicalizeFailureEvent({ schema: 'talos.cli.event.v1', seq: 1, ts: new Date().toISOString(), sessionId: '', type: 'run.failed', data: { code: 'PROVIDER_KEY_MISSING', message, provider: origin.provider } }, 'provider');
+        onEvent?.(failed);
+        return { events: onEvent ? [] : [failed], result: createFailedRunResult({ sessionId: null, code: String(failed.data.code), message: String(failed.data.message), details: { provider: origin.provider }, component: 'provider' }) };
+    }
+    const notice = origin ? keyOriginNotice(origin) : null;
+    const checkpoint = await beginTurnCheckpoint(runtime, input, 'start');
+    const id = await runtime.start(input);
+    checkpoint?.bindSession(id);
+    return collectV1(runtime, id, input, onEvent, notice ? [notice] : [], checkpoint);
+}
+async function collectHeadlessRunV2(runtime, input, onEvent) {
+    const origin = keyOriginForRun(runtime, input.model);
+    if (origin?.required && origin.origin === 'none') {
+        const message = missingKeyText(origin.provider);
+        const event = createV2FailureEvent({ sessionId: '', error: { code: 'PROVIDER_KEY_MISSING', message, component: 'provider', retryable: false, provider: origin.provider }, component: 'provider', details: { provider: origin.provider }, secretValues: secretValuesFromEnvironment(process.env) });
+        const accumulator = createV2RunResultAccumulator();
+        accumulator.add(event);
+        onEvent?.(event);
+        return { events: onEvent ? [] : [event], result: accumulator.result() };
+    }
+    const notice = origin ? keyOriginNotice(origin) : null;
+    const checkpoint = await beginTurnCheckpoint(runtime, input, 'start');
+    const id = await runtime.start(input);
+    checkpoint?.bindSession(id);
+    return collectV2(runtime, id, input, onEvent, notice ? [notice] : [], checkpoint);
+}
+export async function collectHeadlessRun(runtime, input, onEvent) {
+    return input.protocolVersion === 'v2' ? collectHeadlessRunV2(runtime, input, onEvent) : collectHeadlessRunV1(runtime, input, onEvent);
+}
+export async function collectHeadlessResume(runtime, sessionId, prompt, input, onEvent) {
+    const checkpoint = await beginTurnCheckpoint(runtime, input, 'resume', sessionId);
+    const id = await runtime.resume(sessionId, prompt);
+    checkpoint?.bindSession(id);
+    return input.protocolVersion === 'v2' ? collectV2(runtime, id, input, onEvent, [], checkpoint) : collectV1(runtime, id, input, onEvent, [], checkpoint);
+}
+export async function collectHeadlessFork(runtime, sessionId, prompt, input, onEvent) {
+    const checkpoint = await beginTurnCheckpoint(runtime, input, 'fork', sessionId);
+    const id = await runtime.fork(sessionId, prompt);
+    checkpoint?.bindSession(id);
+    return input.protocolVersion === 'v2' ? collectV2(runtime, id, input, onEvent, [], checkpoint) : collectV1(runtime, id, input, onEvent, [], checkpoint);
+}
+export async function collectHeadlessSession(runtime, sessionId, input, onEvent) {
+    return input.protocolVersion === 'v2' ? collectV2(runtime, sessionId, input, onEvent) : collectV1(runtime, sessionId, input, onEvent);
+}

package/dist/i18n/en/approval.js

@@ -0,0 +1,46 @@
+/* R3 lane S+P: the approval dialog's question, choices and hints (gate E11, Q-R3-5/6/13/14). */
+export const approval = {
+    'approval.question': 'Allow this?',
+    /* One question per permission tool (gate E11: "a question sentence"). */
+    'approval.question.Bash': 'Run this command?',
+    'approval.question.Write': 'Write this file?',
+    'approval.question.Edit': 'Make this edit?',
+    'approval.question.Read': 'Read this file?',
+    'approval.question.WebFetch': 'Open this address?',
+    'approval.question.Mcp': 'Call this tool?',
+    'approval.question.Hook': 'Run this hook?',
+    'approval.question.Plugin': 'Run this plugin tool?',
+    'approval.question.TalosService': 'Allow this?',
+    /* Q-R3-13 (R0 decision 4): the title of a command approval on a host with no verified sandbox. */
+    'approval.unsandboxed': '(unsandboxed)',
+    /* P13 (owner decision 8): who asks, when a sub-agent does. */
+    'approval.origin.agent': '· from agent · {task}',
+    'approval.origin.agentUnnamed': '· from an agent',
+    /* Q-R3-6: four choices, Deny highlighted; "deny always" only in the full review (or /permissions). */
+    'approval.choice.once': 'Allow once',
+    'approval.choice.session': 'Allow for this session',
+    'approval.choice.always': 'Always allow',
+    'approval.choice.deny': 'Deny',
+    'approval.choice.denyAlways': 'Deny always',
+    /* Q-R3-5 / Q-R3-14: Esc denies and stops the turn from the summary, and goes back from the full review. */
+    'approval.hint.summary': '↑↓ Enter · v full review · Esc deny and stop',
+    'approval.hint.review': 'Enter choose · [5] deny always · v/Esc back',
+    'approval.hint.compact': 'Esc deny and stop',
+    /* The full review, for a person (gate E11, §0.10: no raw JSON, no kernel keys). */
+    'approval.review.tool': 'Tool',
+    'approval.review.path': 'Path',
+    'approval.review.command': 'Command',
+    'approval.review.format': 'Format',
+    'approval.review.address': 'Address',
+    'approval.review.server': 'Server',
+    'approval.review.operation': 'Operation',
+    'approval.review.sensitive': 'It touches a file that may hold keys or passwords: {path}',
+    'approval.review.sensitiveHidden': 'It touches a file that may hold keys or passwords.',
+    'approval.review.trifecta': 'This conversation now holds private data, untrusted content and a way to send data out, so TALOS asks again.',
+    'approval.review.other': 'Other details',
+    /* Q-R3-4: a write or an edit shows its change in the approval, before it happens. */
+    'approval.change.newFile': 'new file · {lines} lines',
+    'approval.change.counts': '+{added} −{removed}',
+    'approval.change.none': 'no change to the file',
+    'approval.change.more': '… {count} more diff lines — press v to review in full',
+};

package/dist/i18n/en/common.js

@@ -0,0 +1,9 @@
+/* R2 common words shared by every area (owner: coordinator). */
+export const common = {
+    'common.details': 'Details',
+    /* R7 (owner 2026-09-25): `talos update` of an npm install. */
+    'common.update.npmAvailable': 'TALOS CLI {version} is available (this is {current}). Update with: {command}',
+    'common.update.upToDate': 'TALOS CLI is up to date',
+    'common.item.one': '{count} item',
+    'common.item.other': '{count} items',
+};