talos-code 0.0.1 → 0.2.0

package/dist/diagnostics/doctor.js

@@ -0,0 +1,104 @@
+import { t } from "../i18n/index.js";
+import { providerLabel } from "../provider/missing-key.js";
+export { redactObject } from "./redact.js";
+export async function runDoctor(d) {
+    const checks = [];
+    async function c(id, fn) {
+        try {
+            const ok = await fn();
+            checks.push({ id, ok });
+            return ok;
+        }
+        catch (e) {
+            checks.push({ id, ok: false, detail: e instanceof Error ? e.message : String(e) });
+            return false;
+        }
+    }
+    await c('config-path', () => d.fsAccess(d.paths.configRoot));
+    await c('data-path', () => d.fsAccess(d.paths.dataRoot));
+    await c('cache-path', () => d.fsAccess(d.paths.cacheRoot));
+    await c('git', d.gitProbe);
+    await c('keyring', d.keyringProbe);
+    const probe = async (name, fn) => {
+        if (typeof fn !== 'function')
+            return { state: 'unknown', detail: name + ' probe unavailable' };
+        try {
+            return await fn();
+        }
+        catch (error) {
+            return { state: 'unavailable', detail: error instanceof Error ? error.message : String(error) };
+        }
+    };
+    const sections = {
+        terminal: await probe('terminal', d.terminalProbe),
+        runtime: await probe('runtime', d.runtimeProbe),
+        trust: await probe('trust', d.trustProbe),
+        providers: await probe('providers', typeof d.providerProbe === 'function' ? () => d.providerProbe({ active: Boolean(d.profile) }) : undefined),
+        broker: await probe('broker', d.brokerProbe),
+        context: await probe('context', d.contextProbe),
+        sessions: await probe('sessions', d.sessionProbe),
+        update: await probe('update', d.updateProbe),
+        /* R2 (gate E13): the active credential store, read LAST so that `nativeModuleLoaded` covers every probe above (the providers
+           probe composes a runtime, which opens the store). Wording only: `ok` still comes from the checks (Q-R2-9, R4). */
+        credentials: await probe('credentials', d.credentialsProbe),
+        /* R5b: models.dev on or off, and why (catalog.modelsDev, TALOS_MODELS_DEV). */
+        catalog: await probe('catalog', d.catalogProbe),
+    };
+    const performance = Boolean(d.profile) && typeof d.performanceProbe === 'function' ? await probe('performance', d.performanceProbe) : null;
+    return { schema: 'talos.cli.doctor.v1', ok: checks.every(x => x.ok), checks, sections, performance, profiled: Boolean(d.profile) };
+}
+export async function turnReadiness({ catalog, control, model }) {
+    const unknown = { ready: false, reasons: [{ code: 'RUNTIME_NOT_AVAILABLE', message: t('firstrun.doctor.unknown') }] };
+    if (typeof catalog?.readiness !== 'function')
+        return unknown;
+    let decision;
+    try {
+        decision = await catalog.readiness(model ?? '');
+    }
+    catch {
+        return unknown;
+    }
+    if (!decision || typeof decision.ready !== 'boolean')
+        return unknown;
+    if (!decision.ready) {
+        const code = String(decision.code ?? 'RUNTIME_NOT_AVAILABLE');
+        const message = code === 'PROVIDER_NOT_CHOSEN' ? t('firstrun.doctor.noProvider')
+            : code === 'MODEL_NOT_CHOSEN' && decision.provider ? t('firstrun.doctor.noModel', { provider: providerLabel(String(decision.provider)) })
+                : String(decision.message ?? t('firstrun.doctor.unknown'));
+        return { ready: false, reasons: [{ code, message }] };
+    }
+    const provider = String(decision.provider ?? '');
+    let profile = null;
+    try {
+        profile = typeof control?.get === 'function' ? control.get(provider) : null;
+    }
+    catch {
+        profile = null;
+    }
+    if (profile?.local === true && profile?.auth?.required !== true) {
+        let observed = null;
+        try {
+            observed = typeof control?.probe === 'function' ? await control.probe(provider) : null;
+        }
+        catch {
+            observed = null;
+        }
+        if (observed?.lastHealth?.state !== 'available') {
+            const address = typeof profile?.endpoint?.host === 'string' && profile.endpoint.host ? profile.endpoint.host : null;
+            return { ready: false, reasons: [{ code: 'PROVIDER_UNREACHABLE', message: t(address ? 'firstrun.doctor.localDown' : 'firstrun.doctor.localDownNoAddress', { provider: String(profile?.label ?? provider), address: address ?? '' }) }] };
+        }
+    }
+    return { ready: true, reasons: [] };
+}
+/** The verdict a person reads first: `ready` only when the checks pass and a turn could run; otherwise the first reason. */
+export function doctorVerdict({ ok, checks, turn }) {
+    const failed = checks.find(check => !check.ok);
+    const reasons = [...turn.reasons];
+    const first = turn.reasons[0]?.message ?? (failed ? t('firstrun.doctor.checkFailed', { check: failed.id }) : null);
+    const status = ok && turn.ready ? 'ready' : 'needs attention';
+    return {
+        ready: turn.ready, status, reasons,
+        headline: status === 'ready' ? t('firstrun.doctor.headlineReady') : t('firstrun.doctor.headlineAttention', { reason: first ?? t('firstrun.doctor.unknown') }),
+        exitCode: !ok ? 70 : !turn.ready ? 1 : 0,
+    };
+}

package/dist/diagnostics/redact.js

@@ -0,0 +1,80 @@
+const SECRET_KEY = /^(?:.*(?:api[-_]?key|authorization|password|secret|token).*)$/iu;
+function marker(value) { return `[REDACTED:${Buffer.byteLength(value, 'utf8')}]`; }
+function escapeRe(value) { return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&'); }
+function redactAssignments(input) {
+    let out = input;
+    out = out.replace(/\b(authorization)\b(\s*:\s*)([^\r\n]+)/giu, (_m, key, sep, value) => `${key}${sep}${marker(String(value).trim())}`);
+    out = out.replace(/\b(x-api-key|api[-_]?key|token|secret|password)\b(\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s;\r\n,]+)/giu, (_m, key, sep, raw) => { const text = String(raw); const quoted = (text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'")); const value = quoted ? text.slice(1, -1) : text; return `${key}${sep}${quoted ? text[0] : ''}${marker(value)}${quoted ? text.at(-1) : ''}`; });
+    return out;
+}
+/*
+ * Gate E12 (owner yes 2026-09-24, v1 output included): secret VALUES recognised by their vendor prefix, additive to the name
+ * rules above and to the exact values. Every pattern has a token boundary on both sides (Hermes agent/redact.py:578,
+ * 2026-09-23), a length floor and an upper bound on every quantifier (Qwen secret-scanner ReDoS note, test 2026-09-03).
+ * Lists: gate §6.1 (Hermes redact.py:148-207, Codex doctor/output.rs:915-945 2026-09-22, GitLab token prefixes doc
+ * 2026-09-23). `ASIA` is here because Hermes, the Codex sanitizer and Gemini miss it; `sk-` takes `-`/`_` so `sk-proj-`
+ * and `sk-ant-api03-` match (the `[A-Za-z0-9]{20,}` shape of Codex/Qwen misses them), and needs one digit so a
+ * kebab-case name such as `sk-learn-compatible-…` stays readable. The mask is the full `[REDACTED:<bytes>]` (Q-R2-11).
+ */
+const T = 'A-Za-z0-9_\\-'; // token characters: a match may not be glued to more of them on either side
+const bounded = (source, flags = 'gu') => new RegExp(`(?<![${T}])(?:${source})(?![${T}])`, flags);
+const DASH5 = '-{5}';
+const PRIVATE_KEY_LABEL = '[A-Z0-9 ]{0,40}PRIVATE KEY(?: BLOCK)?';
+const SECRET_VALUE_PATTERNS = [
+    // PEM first: a whole block, then a block cut off before its END line (its base64 body up to the first non-body line).
+    new RegExp(`${DASH5}BEGIN ${PRIVATE_KEY_LABEL}${DASH5}(?:(?!${DASH5})[\\s\\S]){0,16384}${DASH5}END ${PRIVATE_KEY_LABEL}${DASH5}`, 'gu'),
+    new RegExp(`${DASH5}BEGIN ${PRIVATE_KEY_LABEL}${DASH5}(?:\\r?\\n(?:[A-Za-z0-9+/=]{1,128}|[A-Za-z][A-Za-z-]{0,31}: [^\\r\\n]{0,128})){0,1024}`, 'gu'),
+    bounded('eyJ[A-Za-z0-9_-]{8,4096}\\.eyJ[A-Za-z0-9_-]{8,8192}\\.[A-Za-z0-9_-]{10,4096}'), // JWT: three base64url segments
+    bounded('sk-(?=[A-Za-z0-9_-]{0,255}\\d)[A-Za-z0-9_-]{20,256}'), // OpenAI (proj/svcacct/admin), Anthropic (ant-api03/admin01), OpenRouter
+    bounded('gh[pousr]_[A-Za-z0-9]{36,255}|github_pat_[A-Za-z0-9_]{30,255}'),
+    bounded('gl(?:pat|oas|dt|rtr|rt|cbt|ptt|ft|imt|agent|wt|soat|ffct)-[A-Za-z0-9_-]{20,255}'),
+    bounded('xox[abprs]-[A-Za-z0-9-]{10,255}|xapp-[A-Za-z0-9-]{10,255}'),
+    bounded('AIza[A-Za-z0-9_-]{35,64}'),
+    bounded('(?:AKIA|ASIA)[A-Z0-9]{16}'),
+    bounded('hf_[A-Za-z0-9]{30,255}|npm_[A-Za-z0-9]{36,255}'),
+];
+// `Bearer <token>`: only the credential is masked, the scheme stays readable; 20+ token68 characters with a digit, so
+// "the bearer of bad news" and "Bearer internationalization" pass (Hermes redact.py:1139, Codex sanitizer tests).
+const BEARER = /(?<![A-Za-z0-9])(bearer[ \t]+)(?=[A-Za-z0-9._~+/-]{0,4095}\d)([A-Za-z0-9._~+/-]{20,4096}=*)(?![A-Za-z0-9._~+/=-])/giu;
+function redactSecretValues(input) {
+    let out = input;
+    for (const pattern of SECRET_VALUE_PATTERNS)
+        out = out.replace(pattern, match => marker(match));
+    return out.replace(BEARER, (_m, scheme, token) => `${scheme}${marker(token)}`);
+}
+export function createRedactor(secrets) { const values = [...new Set([...secrets].filter(x => typeof x === 'string' && x.length > 0))].sort((a, b) => b.length - a.length); return { text(input) { let out = redactSecretValues(redactAssignments(String(input))); for (const secret of values)
+        out = out.replace(new RegExp(escapeRe(secret), 'gu'), marker(secret)); return out; }, value(input) { return redactObject(input, values); } }; }
+export function redactObject(value, secrets = []) { const r = createRedactor(secrets); function visit(v) { if (Array.isArray(v))
+    return v.map(visit); if (v && typeof v === 'object') {
+    const out = {};
+    for (const [k, x] of Object.entries(v)) {
+        if (SECRET_KEY.test(k)) {
+            out[k] = typeof x === 'string' ? marker(x) : '[REDACTED]';
+            continue;
+        }
+        out[k] = visit(x);
+    }
+    return out;
+} if (typeof v === 'string')
+    return r.text(v); return v; } return visit(value); }
+export function secretValuesFromEnvironment(env) { const rows = []; for (const [k, v] of Object.entries(env))
+    if (v && SECRET_KEY.test(k))
+        rows.push(v); return rows; }
+export function createPathPseudonymizer(paths) {
+    const canonical = [...new Set([...paths].filter((value) => typeof value === 'string' && value.length > 1))].sort((a, b) => b.length - a.length);
+    const rows = canonical.flatMap((value, index) => {
+        const label = '[PATH:' + String(index + 1) + ']';
+        const variants = [value, value.replace(/\\/gu, '/'), value.replace(/\//gu, '\\')];
+        return [...new Set(variants.filter(v => v.length > 1))].map(pattern => ({ pattern, label }));
+    }).sort((a, b) => b.pattern.length - a.pattern.length);
+    const text = (input) => { let out = String(input); for (const row of rows)
+        out = out.replace(new RegExp(escapeRe(row.pattern), process.platform === 'win32' ? 'giu' : 'gu'), () => row.label); return out; };
+    const value = (input) => {
+        if (Array.isArray(input))
+            return input.map(value);
+        if (input && typeof input === 'object')
+            return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, value(v)]));
+        return typeof input === 'string' ? text(input) : input;
+    };
+    return { text, value };
+}

package/dist/diagnostics/zip.js

@@ -0,0 +1,52 @@
+import { writeFile } from 'node:fs/promises';
+function crcTable() { const t = new Uint32Array(256); for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++)
+        c = (c & 1) ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[n] = c >>> 0;
+} return t; }
+const TABLE = crcTable();
+export function crc32(buf) { let c = 0xffffffff; for (const b of buf)
+    c = TABLE[(c ^ b) & 0xff] ^ (c >>> 8); return (c ^ 0xffffffff) >>> 0; }
+function dosDateTime(d = new Date()) { const year = Math.max(1980, d.getFullYear()); const time = (d.getHours() << 11) | (d.getMinutes() << 5) | (d.getSeconds() >> 1); const date = ((year - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate(); return { time, date }; }
+export function createStoredZip(entries) { const locals = []; const centrals = []; let offset = 0; const dt = dosDateTime(); for (const e of entries) {
+    const name = Buffer.from(e.name.replace(/\\/gu, '/'), 'utf8');
+    if (e.name.startsWith('/') || e.name.split(/[\\/]/u).includes('..'))
+        throw new Error('ZIP_ENTRY_INVALID');
+    const data = Buffer.isBuffer(e.data) ? e.data : Buffer.from(e.data, 'utf8');
+    const crc = crc32(data);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0x800, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(dt.time, 10);
+    local.writeUInt16LE(dt.date, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(data.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+    locals.push(local, name, data);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0x800, 8);
+    central.writeUInt16LE(0, 10);
+    central.writeUInt16LE(dt.time, 12);
+    central.writeUInt16LE(dt.date, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(data.length, 20);
+    central.writeUInt32LE(data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    centrals.push(central, name);
+    offset += local.length + name.length + data.length;
+} const centralBuf = Buffer.concat(centrals); const end = Buffer.alloc(22); end.writeUInt32LE(0x06054b50, 0); end.writeUInt16LE(0, 4); end.writeUInt16LE(0, 6); end.writeUInt16LE(entries.length, 8); end.writeUInt16LE(entries.length, 10); end.writeUInt32LE(centralBuf.length, 12); end.writeUInt32LE(offset, 16); end.writeUInt16LE(0, 20); return Buffer.concat([...locals, centralBuf, end]); }
+export async function writeStoredZip(file, entries) { await writeFile(file, createStoredZip(entries), { mode: 0o600 }); }

package/dist/errors.js

@@ -0,0 +1,156 @@
+import { randomUUID } from 'node:crypto';
+import { redactObject, secretValuesFromEnvironment } from "./diagnostics/redact.js";
+import { describeError } from "./i18n/error-view.js";
+import { t } from "./i18n/index.js";
+function serializeCause(cause) {
+    if (cause instanceof Error)
+        return { name: cause.name, message: cause.message, ...(typeof cause.code === 'string' ? { code: cause.code } : {}) };
+    if (cause === undefined)
+        return undefined;
+    return { name: 'Error', message: String(cause) };
+}
+export class TalosError extends Error {
+    code;
+    component;
+    retryable;
+    hint;
+    docs;
+    traceId;
+    constructor(fields, cause) {
+        super(fields.code, { cause });
+        this.name = 'TalosError';
+        this.code = fields.code;
+        this.component = fields.component;
+        this.retryable = fields.retryable;
+        this.traceId = fields.traceId;
+        if (fields.hint !== undefined)
+            this.hint = fields.hint;
+        if (fields.docs !== undefined)
+            this.docs = fields.docs;
+    }
+}
+const CODE_TOKEN = /^(?:([A-Z][A-Z0-9_]*)$|([A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+):)/u;
+function isCliUsageMessage(message) {
+    return /^(?:Unsupported\b|Invalid\b|Unknown option:)/u.test(message)
+        || /(?:must be a positive integer|mutually exclusive)$/u.test(message)
+        || message === 'Subcommand required'
+        || message === 'A prompt is required for headless mode';
+}
+/** A stable code is assigned before exit-code classification. Free-form prose stays INTERNAL_ERROR;
+ * CLI usage prose receives CLI_USAGE_ERROR so the envelope and process exit can no longer disagree. */
+export function codeForError(error) {
+    const declared = error?.code;
+    if (typeof declared === 'string' && declared.length > 0)
+        return declared;
+    const message = error instanceof Error ? error.message : typeof error?.message === 'string' ? error.message : '';
+    const token = CODE_TOKEN.exec(message);
+    if (token?.[1] || token?.[2])
+        return token[1] ?? token[2];
+    if (isCliUsageMessage(message))
+        return 'CLI_USAGE_ERROR';
+    return 'INTERNAL_ERROR';
+}
+function stringField(record, key) { const value = record?.[key]; return typeof value === 'string' && value.length > 0 ? value : undefined; }
+export function toTalosErrorEnvelope(error, fallback = {}) {
+    if (error instanceof TalosError) {
+        const cause = serializeCause(error.cause);
+        return { code: error.code, component: error.component, retryable: error.retryable, ...(cause ? { cause } : {}), ...(error.hint !== undefined ? { hint: error.hint } : {}), ...(error.docs !== undefined ? { docs: error.docs } : {}), traceId: error.traceId };
+    }
+    const record = error && typeof error === 'object' ? error : null;
+    const cause = error instanceof Error ? serializeCause(error) : (record?.cause !== undefined ? serializeCause(record.cause) : undefined);
+    const component = stringField(record, 'component') ?? fallback.component ?? 'cli';
+    const retryable = typeof record?.retryable === 'boolean' ? record.retryable : fallback.retryable ?? false;
+    const hint = stringField(record, 'hint');
+    const docs = stringField(record, 'docs');
+    const traceId = stringField(record, 'traceId') ?? fallback.traceId ?? 'untraced';
+    return { code: codeForError(error), component, retryable, ...(cause ? { cause } : {}), ...(hint ? { hint } : {}), ...(docs ? { docs } : {}), traceId };
+}
+export function exitCodeForEnvelope(envelope) {
+    const code = String(envelope.code ?? '');
+    if (code === 'INTERRUPTED' || code === 'CANCELLED' || code === 'ABORT_ERR')
+        return 130;
+    if (/PERMISSION|APPROVAL|DENIED|SANDBOX|PATH_NOT_ALLOWED|PLAN_MODE_READ_ONLY/u.test(code))
+        return 10;
+    if (/KEY|AUTH|CREDENTIAL/u.test(code))
+        return 11;
+    if (/PROVIDER|MODEL_DESTINATION|OPENROUTER|OLLAMA|GEMINI|ANTHROPIC|OPENAI/u.test(code))
+        return 12;
+    if (/MCP|HOOK|PLUGIN|EXTENSION|TOOL/u.test(code))
+        return 13;
+    if (/TIMEOUT/u.test(code))
+        return 14;
+    if (/SESSION|RESEARCH_NOT_FOUND|AUTOMATION_NOT_FOUND/u.test(code))
+        return 15;
+    if (/UPDATE/u.test(code))
+        return 16;
+    if (/CLI_USAGE_ERROR|ERR_PARSE_ARGS|REQUIRED|INVALID|UNKNOWN|CONFIG|QUERY|USAGE|STDIN|TALOS_RUNTIME_NOT_FOUND/u.test(code))
+        return 2;
+    return 70;
+}
+export function exitCodeForError(error) { return exitCodeForEnvelope(toTalosErrorEnvelope(error)); }
+const INHERITED_TRACE_ID = /^[\x21-\x7e]{1,128}$/u;
+export function traceIdForFailure(env = process.env) { const inherited = env.TALOS_TRACE_ID; return inherited !== undefined && INHERITED_TRACE_ID.test(inherited) ? inherited : randomUUID(); }
+function messageForFailure(error, envelope) {
+    if (error instanceof TalosError)
+        return envelope.cause?.message ?? envelope.code;
+    if (error instanceof Error)
+        return error.message;
+    if (error && typeof error === 'object' && typeof error.message === 'string')
+        return String(error.message);
+    return envelope.code;
+}
+function fixedFailure(component = 'cli') { return { envelope: { code: 'INTERNAL_ERROR', component, retryable: false, traceId: randomUUID() }, message: 'The failure could not be rendered safely', exitCode: 70 }; }
+export function safeTalosFailure(error, fallback = {}, secrets = secretValuesFromEnvironment(process.env)) {
+    const traceId = fallback.traceId ?? traceIdForFailure();
+    try {
+        const envelope = toTalosErrorEnvelope(error, { ...fallback, traceId });
+        const raw = { envelope, message: messageForFailure(error, envelope), exitCode: exitCodeForEnvelope(envelope) };
+        return redactObject(raw, secrets);
+    }
+    catch {
+        return fixedFailure(fallback.component ?? 'cli');
+    }
+}
+/** C0, DEL, C1, bidi controls, zero-width controls, BOM and lone surrogates cannot drive the human terminal. */
+const TERMINAL_CONTROL = /[\x00-\x1f\x7f-\x9f\u061c\u200b-\u200d\u202a-\u202e\u2028\u2029\u2066-\u2069\ufeff\ud800-\udfff]/gu;
+export function inertTerminalText(value) { return String(value).replace(TERMINAL_CONTROL, c => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`); }
+/*
+ * R2 lane E (Q-R2-4, gate E6): the human failure is three lines — what happened · what to do · "Details: <cause> (CODE) ·
+ * where to look" — worded by `describeError` from the CODE, so the code appears once and the kernel's Italian never does
+ * (Q-R2-2). Trace id and component are for JSON and `verbose` only. Every field is inert: no value can forge a line.
+ * Before R2 this was one line, `Error [CODE]: message; hint (component, trace)`, and a `CODE: prose` message printed the
+ * code twice (review D-06, s02).
+ */
+export function renderTalosFailureLine(failure, options = {}) {
+    const { envelope } = failure;
+    const view = describeError(failure);
+    const details = [view.detail, view.code ? `(${view.code})` : null, view.where].filter(Boolean).map(inertTerminalText).join(' · ');
+    const rows = [`${t('error.prefix')}: ${inertTerminalText(view.what)}`, ...(view.todo ? [inertTerminalText(view.todo)] : []), ...(details ? [`${t('common.details')}: ${details}`] : [])];
+    if (options.verbose)
+        rows.push(t('error.trace', { trace: inertTerminalText(envelope.traceId), component: inertTerminalText(envelope.component) }));
+    return `${rows.join('\n')}\n`;
+}
+function renderTalosFailure(format, failure, notices, verbose = false) {
+    if (format === 'json')
+        return { toStderr: false, text: `${JSON.stringify({ schema: 'talos.cli.result.v1', ok: false, sessionId: null, error: { code: failure.envelope.code, message: failure.message, details: failure.envelope }, warnings: notices.map(notice => notice.message) })}\n` };
+    if (format === 'stream-json') {
+        const events = [...notices.map((notice, index) => ({ schema: 'talos.cli.event.v1', seq: index + 1, ts: new Date().toISOString(), sessionId: '', type: 'warning', data: { code: notice.code, message: notice.message } })), { schema: 'talos.cli.event.v1', seq: notices.length + 1, ts: new Date().toISOString(), sessionId: '', type: 'run.failed', data: { ...failure.envelope, message: failure.message } }];
+        return { toStderr: false, text: events.map(event => `${JSON.stringify(event)}\n`).join('') };
+    }
+    return { toStderr: true, text: renderTalosFailureLine(failure, { verbose }) };
+}
+export function renderSafeTalosFailure(format, error, options = {}) {
+    const component = options.component ?? 'cli';
+    const secrets = secretValuesFromEnvironment(process.env);
+    try {
+        const failure = safeTalosFailure(error, { component, ...(options.retryable !== undefined ? { retryable: options.retryable } : {}), ...(options.traceId !== undefined ? { traceId: options.traceId } : {}) }, secrets);
+        const notices = redactObject(options.notices ?? [], secrets);
+        const rendered = renderTalosFailure(format, failure, notices, options.verbose === true);
+        return { ...rendered, failure, exitCode: failure.exitCode };
+    }
+    catch {
+        const failure = fixedFailure(component);
+        const rendered = renderTalosFailure(format, failure, []);
+        return { ...rendered, failure, exitCode: failure.exitCode };
+    }
+}

package/dist/events/bridge.js

@@ -0,0 +1,130 @@
+import { createRedactor } from "../diagnostics/redact.js";
+const MAP = { RunStarted: 'run.started', TextMessageContent: 'message.delta', ReasoningMessageContent: 'reasoning.delta', ToolCallStart: 'tool.started', ToolCallArgs: 'tool.args', ToolCallOutput: 'tool.completed', ApprovalRequested: 'approval.required', ApprovalResolved: 'approval.resolved', RunFinished: 'run.completed', RunError: 'run.failed' };
+const SECRET = /api[_-]?key|authorization|password|secret|token/iu;
+const FAILED_RECEIPT_STATUSES = new Set(['denied', 'premise_absent', 'failed', 'refused_busy']);
+function clean(v, redactText) {
+    if (Array.isArray(v))
+        return v.map(value => clean(value, redactText));
+    if (v && typeof v === 'object') {
+        const o = {};
+        for (const [k, x] of Object.entries(v)) {
+            if (SECRET.test(k))
+                continue;
+            o[k] = clean(x, redactText);
+        }
+        return o;
+    }
+    return typeof v === 'string' ? redactText(v) : v;
+}
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : null; }
+function stringValue(value) { return typeof value === 'string' && value.length > 0 ? value : null; }
+function numberValue(value) { return typeof value === 'number' && Number.isFinite(value) ? value : null; }
+function booleanValue(value) { return typeof value === 'boolean' ? value : null; }
+export function normalizeToolOutcome(raw) {
+    const toolCallId = stringValue(raw.toolCallId);
+    if (!toolCallId)
+        return null;
+    const receipt = objectValue(raw.receipt);
+    const evidence = objectValue(receipt?.evidence);
+    const receiptStatus = stringValue(receipt?.status);
+    const explicitCancelled = raw.outcome === 'cancelled';
+    const status = explicitCancelled
+        ? 'cancelled'
+        : receiptStatus === 'effect_unknown'
+            ? 'unknown'
+            : receiptStatus === 'succeeded'
+                ? 'completed'
+                : receiptStatus && FAILED_RECEIPT_STATUSES.has(receiptStatus)
+                    ? 'failed'
+                    : 'completed';
+    return {
+        toolCallId,
+        status,
+        content: String(raw.content ?? ''),
+        receiptStatus,
+        exitCode: numberValue(evidence?.exitCode),
+        enforcement: stringValue(evidence?.sandboxEnforcement),
+        allowed: booleanValue(receipt?.consentito),
+        permissionVia: stringValue(receipt?.via),
+        permissionReason: stringValue(receipt?.motivo),
+        risk: stringValue(receipt?.risk),
+    };
+}
+const HIDDEN_TOOL_OUTCOMES = Symbol.for('talos.cli.toolOutcomes');
+const HIDDEN_TOOL_OUTCOME_CARRIER = Symbol.for('talos.cli.toolOutcomeCarrier');
+function attachToolOutcomeCarrier(event, carrier) {
+    Object.defineProperty(event.data, HIDDEN_TOOL_OUTCOME_CARRIER, { value: carrier, enumerable: false, configurable: false, writable: false });
+    return event;
+}
+function hiddenToolOutcomes(event, outcomes) {
+    if (outcomes.length === 0)
+        return event;
+    const snapshot = [...outcomes];
+    Object.defineProperty(event, 'toolOutcomes', { value: snapshot, enumerable: false, configurable: false, writable: false });
+    Object.defineProperty(event.data, HIDDEN_TOOL_OUTCOMES, { value: snapshot, enumerable: false, configurable: false, writable: false });
+    return event;
+}
+export function hasToolOutcomeCarrier(event) {
+    if (Array.isArray(event.toolOutcomes))
+        return true;
+    const data = event.data;
+    return Array.isArray(data[HIDDEN_TOOL_OUTCOMES]) || data[HIDDEN_TOOL_OUTCOME_CARRIER] instanceof Map;
+}
+export function toolOutcomesFromCliEvent(event) {
+    const direct = event.toolOutcomes;
+    if (Array.isArray(direct))
+        return direct;
+    const data = event.data;
+    const snapshot = data[HIDDEN_TOOL_OUTCOMES];
+    if (Array.isArray(snapshot))
+        return snapshot;
+    const carrier = data[HIDDEN_TOOL_OUTCOME_CARRIER];
+    return carrier instanceof Map ? [...carrier.values()] : [];
+}
+export function createEventBridge(sessionId, clock = () => new Date().toISOString(), secretValues = []) {
+    let seq = 0;
+    const redactor = createRedactor(secretValues);
+    const pendingToolOutcomes = new Map();
+    return { translate(raw) {
+            if (!raw || typeof raw !== 'object')
+                return null;
+            const r = raw;
+            if (r.type === 'ToolCallResult') {
+                const sanitized = clean(r, redactor.text);
+                const outcome = normalizeToolOutcome(sanitized);
+                if (outcome) {
+                    const previous = pendingToolOutcomes.get(outcome.toolCallId);
+                    const shouldReplace = !previous
+                        || (previous.receiptStatus === null && outcome.receiptStatus !== null)
+                        || (previous.status === 'completed' && outcome.status !== 'completed');
+                    if (shouldReplace)
+                        pendingToolOutcomes.set(outcome.toolCallId, outcome);
+                }
+                return null;
+            }
+            let type = MAP[String(r.type)];
+            let source = { ...r };
+            if (r.type === 'StateDelta' && Array.isArray(r.delta)) {
+                const usage = r.delta.find(d => d.path === '/usage');
+                if (usage) {
+                    type = 'usage.updated';
+                    source = { ...source, value: usage.value };
+                }
+            }
+            if (!type)
+                return null;
+            const data = clean(source, redactor.text);
+            delete data.type;
+            if (type === 'approval.required')
+                data.requestId = r.requestId;
+            seq += 1;
+            const event = attachToolOutcomeCarrier({ schema: 'talos.cli.event.v1', seq, ts: clock(), sessionId, type, data }, pendingToolOutcomes);
+            if (type === 'run.completed' || type === 'run.failed') {
+                const outcomes = [...pendingToolOutcomes.values()];
+                const terminal = hiddenToolOutcomes(event, outcomes);
+                pendingToolOutcomes.clear();
+                return terminal;
+            }
+            return event;
+        } };
+}