talos-code 0.0.1 → 0.2.0

package/dist/protocol/v2/events.js

@@ -0,0 +1,555 @@
+import { createRedactor } from "../../diagnostics/redact.js";
+import { safeTalosFailure } from "../../errors.js";
+import { describeError } from "../../i18n/error-view.js";
+import { parseToolOutputMarker, parseToolResultCut } from "../../runtime/output-store.js";
+import { CLI_EVENT } from "../../runtime/provider-attempts.js";
+import { toolDisplay } from "../../tui/tool-display.js";
+// Gate E11 (2026-09-23): a key is secret by exact normalized name or by a whole secret word, never by
+// substring, so usage counters such as prompt_tokens survive. Counters are allowed first; secret values
+// are masked in place (the key stays, as in diagnostics/redact.ts), never dropped. v1 bridge.ts is frozen.
+const USAGE_COUNTER_KEYS = new Set([
+    'prompt_tokens', 'completion_tokens', 'total_tokens', 'cached_tokens', 'reasoning_tokens', 'token_count',
+    'input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens',
+    'promptTokens', 'completionTokens', 'totalTokens', 'inputTokens', 'outputTokens', 'reasoningTokens'
+]);
+const OTEL_USAGE_COUNTER = /^gen_ai\.usage\.[a-z0-9_.]+_tokens$/u;
+const SECRET_KEYS = new Set([
+    'authorization', 'proxyauthorization', 'apikey', 'xapikey', 'accesstoken', 'refreshtoken', 'idtoken',
+    'clientsecret', 'password', 'passwd', 'secret', 'token'
+]);
+const SECRET_WORDS = new Set(['authorization', 'apikey', 'apikeys', 'password', 'passwords', 'passwd', 'secret', 'secrets', 'token']);
+function usageCounter(key, value) {
+    return typeof value === 'number' && Number.isFinite(value) && (USAGE_COUNTER_KEYS.has(key) || OTEL_USAGE_COUNTER.test(key));
+}
+function secretKey(key) {
+    if (SECRET_KEYS.has(key.toLowerCase().replace(/[^a-z0-9]/gu, '')))
+        return true;
+    const words = key.replace(/([a-z0-9])([A-Z])/gu, '$1 $2').toLowerCase().split(/[^a-z0-9]+/u).filter(Boolean);
+    return words.some((word, index) => SECRET_WORDS.has(word) || (word === 'api' && (words[index + 1] === 'key' || words[index + 1] === 'keys')));
+}
+const MASK = /^\[REDACTED(?::\d+)?\]$/u;
+function masked(value) {
+    if (typeof value === 'string' && MASK.test(value))
+        return value; // withoutMeta() cleans an already clean event
+    return typeof value === 'string' ? `[REDACTED:${Buffer.byteLength(value, 'utf8')}]` : '[REDACTED]';
+}
+const FAILED_RECEIPT_STATUSES = new Set(['denied', 'premise_absent', 'failed', 'refused_busy']);
+const TOOL_RECEIPT_KEYS = new Set(['status', 'consentito', 'allowed', 'via', 'motivo', 'reason', 'risk', 'evidence']);
+const ENFORCEMENT_KEYS = new Set([
+    'exitCode', 'requestedEnforcement', 'appliedEnforcement', 'sandboxEnforcement', 'backend', 'appContainer',
+    'filesystem', 'network', 'processTree', 'processTreeEvidence', 'sandboxSpecVersion'
+]);
+const TOOL_TOP_LEVEL_KEYS = new Set(['type', '_sequenza', 'toolCallId', 'content', 'receipt', 'outcome', 'isError']);
+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; }
+function detailsOutside(source, known) {
+    if (!source)
+        return undefined;
+    const details = Object.fromEntries(Object.entries(source).filter(([key]) => !known.has(key)));
+    return Object.keys(details).length ? details : undefined;
+}
+function clean(value, redactText) {
+    if (Array.isArray(value))
+        return value.map(item => clean(item, redactText));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (usageCounter(key, item))
+                out[key] = item;
+            else if (secretKey(key))
+                out[key] = masked(item);
+            else
+                out[key] = clean(item, redactText);
+        }
+        return out;
+    }
+    return typeof value === 'string' ? redactText(value) : value;
+}
+function nativeSequence(value) {
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
+        return value;
+    if (typeof value === 'string' && /^\d+$/u.test(value)) {
+        const parsed = Number(value);
+        if (Number.isSafeInteger(parsed))
+            return parsed;
+    }
+    return null;
+}
+function cursorFor(sessionId, sequence) {
+    return sequence === null ? null : { sessionId, sequence };
+}
+function eventIdFor(sessionId, sequence, synthetic) {
+    const identity = encodeURIComponent(sessionId || 'none');
+    return sequence === null ? 'talos:' + identity + ':transient:' + synthetic : 'talos:' + identity + ':native:' + sequence;
+}
+function baseEvent(input) {
+    return {
+        schema: 'talos.cli.event.v2',
+        version: 2,
+        sessionId: input.sessionId,
+        eventId: eventIdFor(input.sessionId, input.sequence, input.synthetic),
+        cursor: cursorFor(input.sessionId, input.sequence),
+        ts: input.clock(),
+        durability: input.durability,
+        type: input.type,
+        data: input.data,
+    };
+}
+function toolStatus(raw, receiptStatus) {
+    if (raw.outcome === 'cancelled')
+        return 'cancelled';
+    if (receiptStatus === 'effect_unknown')
+        return 'unknown';
+    if (receiptStatus === 'succeeded')
+        return 'completed';
+    if (receiptStatus && FAILED_RECEIPT_STATUSES.has(receiptStatus))
+        return 'failed';
+    if (raw.isError === true)
+        return 'failed';
+    return 'completed';
+}
+function enforcementFrom(receipt) {
+    const evidence = objectValue(receipt?.evidence);
+    if (!evidence)
+        return null;
+    const extra = detailsOutside(evidence, ENFORCEMENT_KEYS);
+    return {
+        exitCode: numberValue(evidence.exitCode),
+        requested: stringValue(evidence.requestedEnforcement),
+        applied: stringValue(evidence.appliedEnforcement),
+        sandbox: stringValue(evidence.sandboxEnforcement),
+        backend: stringValue(evidence.backend),
+        appContainer: booleanValue(evidence.appContainer),
+        filesystem: stringValue(evidence.filesystem),
+        network: stringValue(evidence.network),
+        processTree: stringValue(evidence.processTree),
+        sandboxSpecVersion: stringValue(evidence.sandboxSpecVersion),
+        ...(evidence.processTreeEvidence !== undefined ? { processTreeEvidence: evidence.processTreeEvidence } : {}),
+        ...(extra ? { details: extra } : {}),
+    };
+}
+function toolResultFromNative(raw) {
+    const toolCallId = stringValue(raw.toolCallId);
+    if (!toolCallId)
+        return null;
+    const receipt = objectValue(raw.receipt);
+    const receiptStatus = stringValue(receipt?.status);
+    const receiptExtra = detailsOutside(receipt, TOOL_RECEIPT_KEYS);
+    const topExtra = detailsOutside(raw, TOOL_TOP_LEVEL_KEYS);
+    const normalizedReceipt = {
+        status: receiptStatus,
+        allowed: booleanValue(receipt?.consentito ?? receipt?.allowed),
+        via: stringValue(receipt?.via),
+        reason: stringValue(receipt?.motivo ?? receipt?.reason),
+        risk: stringValue(receipt?.risk),
+        ...(receiptExtra ? { details: englishRecord(receiptExtra, RECEIPT_DETAILS_SHAPE) } : {}),
+    };
+    /* R5a lane R (Q-R5-10/11, additive): the two cut markers the model read, as facts. */
+    const content = String(raw.content ?? '');
+    const saved = parseToolOutputMarker(content);
+    const cut = parseToolResultCut(content);
+    return {
+        toolCallId,
+        status: toolStatus(raw, receiptStatus),
+        content,
+        receipt: normalizedReceipt,
+        enforcement: enforcementFrom(receipt),
+        ...(topExtra ? { details: englishRecord(topExtra, TOOL_DETAILS_SHAPE) } : {}),
+        ...(saved ? { outputSaved: { path: saved.path, keptChars: saved.keptChars, totalChars: saved.totalChars } } : {}),
+        ...(cut ? { readCut: { shownLines: cut.shownLines, totalLines: cut.totalLines, limitChars: cut.limitChars, shownChars: cut.shownChars, totalChars: cut.totalChars } } : {}),
+    };
+}
+function withoutMeta(raw, redactText) {
+    const cleaned = clean(raw, redactText);
+    delete cleaned.type;
+    delete cleaned._sequenza;
+    return cleaned;
+}
+function english(value, shape) {
+    if (Array.isArray(value))
+        return value.map(item => english(item, shape));
+    const row = objectValue(value);
+    if (!row)
+        return value;
+    const out = {};
+    for (const [key, item] of Object.entries(row)) {
+        const rule = shape[key];
+        const name = rule === undefined ? key : typeof rule === 'string' ? rule : rule.as ?? key;
+        if (name !== key && Object.hasOwn(row, name))
+            continue;
+        const values = typeof rule === 'object' ? rule.values : undefined;
+        const mapped = typeof item === 'string' && values && Object.hasOwn(values, item) ? values[item] : item;
+        out[name] = typeof rule === 'object' && rule.shape ? english(mapped, rule.shape) : mapped;
+    }
+    return out;
+}
+const USAGE_SHAPE = { giri: 'turns' }; // E-03: the token counters stay (clean() allows them), the turn count reads `turns`
+const RUN_STARTED_SHAPE = {
+    input: { shape: {
+            consegna: 'prompt', consegnaCorta: 'shortPrompt', progetto: 'project', seguito: 'followUp', reindirizzato: 'redirected',
+            immagini: { as: 'images', shape: { tipo: { as: 'type', values: { immagine: 'image' } }, nome: 'name', byte: 'bytes' } },
+        } },
+    contesto: { as: 'context', shape: { progetto: 'project', cartella: 'folder', repoAnnidati: 'nestedRepos', modello: 'model', permessi: 'permissions' } },
+};
+const APPROVAL_REQUIRED_SHAPE = { azione: { as: 'action', shape: {
+            tipo: 'tool', percorso: 'path', comando: 'command', formato: 'format',
+            segreto: { as: 'sensitive', shape: { classe: 'class', percorso: 'path', frase: 'sentence', nascosto: 'hidden' } },
+        } } };
+const APPROVAL_RESOLVED_SHAPE = { approvato: 'approved' };
+const RUN_COMPLETED_SHAPE = {
+    outcome: { values: { concluso: 'completed', fermato: 'stopped' } }, // session-registry.mjs:2677,2691
+    result: { shape: { detto: 'text', compattazioni: 'compactions', premesseNegate: 'deniedPremises', usage: { shape: USAGE_SHAPE } } },
+};
+const TOOL_DETAILS_SHAPE = { durataMs: 'durationMs', comando: 'command' };
+const RECEIPT_DETAILS_SHAPE = { azione: 'tool', percorso: 'path', comando: 'command', hashContenuto: 'contentHash' };
+function englishRecord(value, shape) { return english(value, shape); }
+/** Gate §8: the approval names its tool twice — the kernel id (`tool`, a stable contract) and the English label. */
+function approvalRequired(data) {
+    const out = englishRecord(data, APPROVAL_REQUIRED_SHAPE);
+    const action = objectValue(out.action);
+    const tool = stringValue(action?.tool);
+    if (action && tool && action.displayName === undefined)
+        out.action = { ...action, displayName: toolDisplay(tool).label };
+    return out;
+}
+/*
+ * Q-R2-4 (owner 2026-09-24): the v2 envelope carries what happened / what to do / where to look as fields, filled by lane E's
+ * `describeError` (the one error describer, gate E6); `code`, `message` and the rest of the envelope stay as they were. The
+ * words pass the same redactor as every v2 string. A describer that throws is reported as the failure message itself: an
+ * error about an error must never lose the original failure (a guard that explodes is absent).
+ */
+function v2Error(source, failure, redactText) {
+    let view = null;
+    try {
+        view = describeError(source);
+    }
+    catch {
+        view = null;
+    }
+    const text = (value) => typeof value === 'string' && value.length > 0 ? redactText(value) : null;
+    /* Owner decision 2026-09-24 (Q-R2-2 applied to JSON): `message` is the English headline, as on screen; the original
+       (already redacted) message moves to `raw`, for diagnosis, and only when it says something else. */
+    const what = text(view?.what) ?? failure.message;
+    /* R5a lane R (Q-R5-6, additive): the HTTP status and the provider's requested wait travel as fields, so a later
+       `describeError` of this v2 error (the TUI's) still tells 401 from 403 and names a known wait. */
+    const row = source && typeof source === 'object' ? source : null;
+    const status = numberValue(row?.stato) ?? numberValue(row?.status);
+    const retryAfterMs = numberValue(row?.retryAfterMs);
+    return { message: what, ...(failure.message && failure.message !== what ? { raw: failure.message } : {}), envelope: { ...failure.envelope, what, todo: text(view?.todo), where: text(view?.where) },
+        ...(status !== null ? { status } : {}), ...(retryAfterMs !== null ? { retryAfterMs } : {}) };
+}
+function transient(type) {
+    return type === 'message.started' || type === 'message.delta' || type === 'message.completed'
+        || type === 'reasoning.started' || type === 'reasoning.delta' || type === 'reasoning.completed'
+        || type === 'tool.started' || type === 'tool.args' || type === 'tool.output'
+        || type === 'usage.updated' || type === 'warning' || type === 'provider.attempt';
+}
+/*
+ * R5a lane R (Q-R5-4/5/6, gate E3/E9, additive): the CUSTOM rows v2 now reads. v1 maps no CUSTOM row, so it is unchanged.
+ * - `talos.cli.provider.attempt` / `talos.cli.context.compacted`: the CLI's own live facts (runtime/provider-attempts.ts);
+ * - `talos.context` of kind `context.version.committed`: the Context Engine committed a compacted version
+ *   (context-engine/src/node/sqlite-worker.mjs `activate`), persisted by the kernel, so it replays;
+ * - `talos.cli.provider.failure`: folded into the next `run.failed` (status, requested wait), never an event of its own;
+ * - `consumo-fornitore`: one model request's own usage and declared cost (runtime-owner-adapter.mjs:978), folded into the
+ *   next `usage.updated` as `lastRequest` and `declaredCostUsd` (measured order: the row precedes its /usage delta).
+ */
+function countOrNull(value) { return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.round(value) : null; }
+function compactionData(value, engine) {
+    const trigger = value?.trigger === 'manual' || value?.trigger === 'automatic' ? value.trigger : null;
+    return { engine, messagesSummarized: countOrNull(value?.messagesSummarized), tokensBefore: countOrNull(value?.tokensBefore), tokensAfter: countOrNull(value?.tokensAfter),
+        ...(trigger ? { trigger } : {}), ...(typeof value?.versionId === 'string' ? { versionId: value.versionId } : {}) };
+}
+/*
+ * Desktop CE fix 5f78b1316+4ceb232a5 (aligned 2026-09-25): after a refused or failed automatic compaction the engine waits
+ * 60 s, then 300, then 900 before trying again, and says so ONCE per failed job (`context.compaction.cooling`, id
+ * `cooling-<jobId>`, payload {code, attempts, waitSeconds, retryAfter}). A row without a readable time or code says nothing.
+ */
+function pausedFields(value) {
+    const payload = objectValue(value?.payload);
+    const code = stringValue(payload?.code);
+    const retryAfter = stringValue(payload?.retryAfter);
+    if (!code || !retryAfter || !Number.isFinite(Date.parse(retryAfter)))
+        return null;
+    return { noticeId: stringValue(value?.id), code, attempts: countOrNull(payload?.attempts), waitSeconds: countOrNull(payload?.waitSeconds), retryAfter };
+}
+function requestUsage(value) {
+    const usage = objectValue(value?.usage);
+    if (!usage)
+        return null;
+    const details = objectValue(usage.prompt_tokens_details);
+    const inputTokens = countOrNull(usage.prompt_tokens ?? usage.input_tokens), outputTokens = countOrNull(usage.completion_tokens ?? usage.output_tokens);
+    if (inputTokens === null && outputTokens === null)
+        return null;
+    return { provider: stringValue(value?.provider), model: stringValue(value?.model), inputTokens, outputTokens, cachedTokens: countOrNull(details?.cached_tokens ?? usage.cache_read_input_tokens ?? usage.prompt_cache_hit_tokens) };
+}
+export function createV2EventBridge(sessionId, clock = () => new Date().toISOString(), secretValues = []) {
+    let synthetic = 0;
+    const redactor = createRedactor(secretValues);
+    const messageBuffers = new Map();
+    const reasoningBuffers = new Map();
+    /* R5a lane R: facts held for the next event of their run (see the CUSTOM rows above). */
+    let pendingFailure = null;
+    let lastRequest = null;
+    let declaredCost = null;
+    const resetRun = () => { pendingFailure = null; lastRequest = null; declaredCost = null; };
+    return {
+        translate(raw) {
+            if (!raw || typeof raw !== 'object')
+                return null;
+            const original = raw;
+            const r = clean(original, redactor.text);
+            const sequence = nativeSequence(original._sequenza);
+            const next = (type, data, durability = transient(type) ? 'transient' : 'durable') => baseEvent({ sessionId, sequence, synthetic: ++synthetic, clock, durability, type, data });
+            const pausedData = (value) => { const fields = pausedFields(value); return fields ? next('context.compaction.paused', fields, 'durable') : null; };
+            switch (String(r.type)) {
+                case 'RunStarted':
+                    resetRun();
+                    return next('run.started', englishRecord(withoutMeta(r, redactor.text), RUN_STARTED_SHAPE), 'durable');
+                case 'CUSTOM': {
+                    const name = String(r.name ?? '');
+                    const value = objectValue(r.value);
+                    if (name === CLI_EVENT.attempt) {
+                        const attempt = countOrNull(value?.attempt), maxAttempts = countOrNull(value?.maxAttempts);
+                        return attempt === null || maxAttempts === null ? null : next('provider.attempt', { attempt, maxAttempts, status: countOrNull(value?.status), retryAfterMs: countOrNull(value?.retryAfterMs), waitMs: countOrNull(value?.waitMs) });
+                    }
+                    if (name === CLI_EVENT.compacted)
+                        return next('context.compacted', compactionData(value, 'kernel'), 'transient');
+                    if (name === CLI_EVENT.summaryRequested)
+                        return next('context.summary.requested', {}, 'transient');
+                    if (name === 'talos.context' && value?.kind === 'context.version.committed')
+                        return next('context.compacted', compactionData({ versionId: value.versionId }, 'context-engine'), 'durable');
+                    if (name === 'talos.context' && value?.kind === 'context.compaction.cooling')
+                        return pausedData(value);
+                    if (name === CLI_EVENT.failure) {
+                        pendingFailure = { status: countOrNull(value?.status), retryAfterMs: countOrNull(value?.retryAfterMs) };
+                        return null;
+                    }
+                    if (name === 'consumo-fornitore') {
+                        const request = requestUsage(value);
+                        if (request)
+                            lastRequest = request;
+                        const cost = numberValue(value?.costoDichiarato);
+                        if (cost !== null && cost >= 0)
+                            declaredCost = (declaredCost ?? 0) + cost;
+                        return null;
+                    }
+                    return null;
+                }
+                case 'TextMessageStart': {
+                    const messageId = String(r.messageId ?? 'assistant');
+                    messageBuffers.set(messageId, '');
+                    return next('message.started', { messageId, role: r.role === 'user' ? 'user' : 'assistant' });
+                }
+                case 'TextMessageContent': {
+                    const messageId = String(r.messageId ?? 'assistant');
+                    const delta = redactor.text(String(r.delta ?? ''));
+                    messageBuffers.set(messageId, (messageBuffers.get(messageId) ?? '') + delta);
+                    return next('message.delta', { messageId, delta });
+                }
+                case 'TextMessageEnd': {
+                    const messageId = String(r.messageId ?? 'assistant');
+                    const text = messageBuffers.get(messageId) ?? '';
+                    messageBuffers.delete(messageId);
+                    return next('message.completed', { messageId, text }, 'durable');
+                }
+                case 'ReasoningMessageStart': {
+                    const messageId = String(r.messageId ?? 'reasoning');
+                    reasoningBuffers.set(messageId, '');
+                    return next('reasoning.started', { messageId });
+                }
+                case 'ReasoningMessageContent': {
+                    const messageId = String(r.messageId ?? 'reasoning');
+                    const delta = redactor.text(String(r.delta ?? ''));
+                    reasoningBuffers.set(messageId, (reasoningBuffers.get(messageId) ?? '') + delta);
+                    return next('reasoning.delta', { messageId, delta });
+                }
+                case 'ReasoningMessageEnd': {
+                    const messageId = String(r.messageId ?? 'reasoning');
+                    const text = reasoningBuffers.get(messageId) ?? '';
+                    reasoningBuffers.delete(messageId);
+                    return next('reasoning.completed', { messageId, text }, 'durable');
+                }
+                case 'ToolCallStart':
+                    return next('tool.started', { toolCallId: String(r.toolCallId ?? ''), toolName: String(r.toolCallName ?? r.name ?? 'tool') });
+                case 'ToolCallArgs':
+                    return next('tool.args', { toolCallId: String(r.toolCallId ?? ''), delta: redactor.text(String(r.delta ?? '')) });
+                case 'ToolCallOutput':
+                    return next('tool.output', { toolCallId: String(r.toolCallId ?? ''), delta: redactor.text(String(r.delta ?? '')) });
+                case 'ToolCallResult': {
+                    const result = toolResultFromNative(r);
+                    return result ? next('tool.completed', result, 'durable') : null;
+                }
+                case 'FileChanged':
+                    return next('file.changed', withoutMeta(r, redactor.text), 'durable');
+                case 'ApprovalRequested':
+                    return next('approval.required', approvalRequired(withoutMeta(r, redactor.text)), 'durable');
+                case 'ApprovalResolved':
+                    return next('approval.resolved', englishRecord(withoutMeta(r, redactor.text), APPROVAL_RESOLVED_SHAPE), 'durable');
+                case 'StateDelta': {
+                    const rows = Array.isArray(r.delta) ? r.delta : [];
+                    const usage = rows.find(row => row?.path === '/usage');
+                    return usage ? next('usage.updated', { value: english(usage.value, USAGE_SHAPE), ...(lastRequest ? { lastRequest: { ...lastRequest } } : {}), ...(declaredCost !== null ? { declaredCostUsd: declaredCost } : {}) }) : null;
+                }
+                case 'RuntimeFallback':
+                    return next('warning', { message: redactor.text(String(r.message ?? r.reason ?? 'runtime fallback')) });
+                case 'RunFinished':
+                    resetRun();
+                    return next('run.completed', englishRecord(withoutMeta(r, redactor.text), RUN_COMPLETED_SHAPE), 'durable');
+                case 'RunError': {
+                    const failureFacts = pendingFailure;
+                    pendingFailure = null;
+                    const traceId = stringValue(r.traceId);
+                    const failure = safeTalosFailure(r, {
+                        component: stringValue(r.component) ?? 'runtime',
+                        retryable: typeof r.retryable === 'boolean' ? r.retryable : false,
+                        ...(traceId ? { traceId } : {})
+                    }, secretValues);
+                    const runId = stringValue(r.runId);
+                    const source = withoutMeta(r, redactor.text);
+                    /* R5a lane R: the kernel's RunError has no status (agent-service.mjs:1991); the run's own failure facts, announced just
+                       before it, are its status and requested wait. A field the kernel wrote is never replaced. */
+                    const facts = failureFacts ? { ...(failureFacts.status !== null && source.stato === undefined ? { stato: failureFacts.status } : {}), ...(failureFacts.retryAfterMs !== null && source.retryAfterMs === undefined ? { retryAfterMs: failureFacts.retryAfterMs } : {}) } : {};
+                    lastRequest = null;
+                    declaredCost = null;
+                    return next('run.failed', { error: v2Error({ ...source, ...facts }, failure, redactor.text), ...(runId ? { runId } : {}) }, 'durable');
+                }
+                case 'RunCancelled': {
+                    const runId = stringValue(r.runId);
+                    return next('run.cancelled', { reason: redactor.text(String(r.reason ?? r.message ?? 'cancelled')), ...(runId ? { runId } : {}) }, 'durable');
+                }
+                default:
+                    return null;
+            }
+        }
+    };
+}
+export function createV2SyntheticEvent(input) {
+    return {
+        schema: 'talos.cli.event.v2',
+        version: 2,
+        sessionId: input.sessionId,
+        eventId: input.eventId,
+        cursor: null,
+        ts: (input.clock ?? (() => new Date().toISOString()))(),
+        durability: input.durability ?? 'transient',
+        type: input.type,
+        data: input.data ?? {},
+    };
+}
+export function createV2FailureEvent(input) {
+    const secrets = input.secretValues ?? [];
+    const redactor = createRedactor(secrets);
+    const safeDetails = input.details ? clean(input.details, redactor.text) : undefined;
+    const failure = safeTalosFailure(input.error, {
+        component: input.component ?? 'runtime',
+        retryable: input.retryable ?? false,
+    }, secrets);
+    return {
+        schema: 'talos.cli.event.v2',
+        version: 2,
+        sessionId: input.sessionId,
+        eventId: 'talos:' + encodeURIComponent(input.sessionId || 'none') + ':failure:' + failure.envelope.traceId,
+        cursor: null,
+        ts: (input.clock ?? (() => new Date().toISOString()))(),
+        durability: 'durable',
+        type: 'run.failed',
+        data: {
+            error: v2Error(input.error, failure, redactor.text),
+            ...(safeDetails && Object.keys(safeDetails).length ? { details: safeDetails } : {}),
+        },
+    };
+}
+export function createV2SessionSnapshot(input) {
+    if (input.cursor.sessionId !== input.summary.sessionId)
+        throw Object.assign(new Error('Replay cursor is bound to a different session'), { code: 'PROTOCOL_CURSOR_SESSION_MISMATCH' });
+    return {
+        schema: 'talos.cli.event.v2',
+        version: 2,
+        sessionId: input.summary.sessionId,
+        eventId: eventIdFor(input.summary.sessionId, input.cursor.sequence, 0),
+        cursor: { ...input.cursor },
+        ts: (input.clock ?? (() => new Date().toISOString()))(),
+        durability: 'durable',
+        type: 'session.snapshot',
+        data: { summary: input.summary, ...(input.context !== undefined ? { context: input.context } : {}) },
+    };
+}
+function toolResultFromEvent(event) {
+    if (event.type !== 'tool.completed')
+        return null;
+    const data = event.data;
+    return typeof data.toolCallId === 'string' && typeof data.content === 'string' && typeof data.status === 'string' && data.receipt
+        ? data
+        : null;
+}
+export function createV2RunResultAccumulator() {
+    let text = '';
+    const changed = new Set();
+    let usage = null;
+    const warnings = [];
+    const tools = new Map();
+    let sessionId = null;
+    let cursor = null;
+    let outcome = 'completed';
+    let error;
+    const redactText = createRedactor([]).text;
+    return {
+        add(event) {
+            sessionId = event.sessionId || sessionId;
+            if (event.cursor && (!cursor || event.cursor.sequence >= cursor.sequence))
+                cursor = { ...event.cursor };
+            if (event.type === 'message.delta')
+                text += String(event.data.delta ?? '');
+            if (event.type === 'file.changed' && typeof event.data.path === 'string')
+                changed.add(event.data.path);
+            if (event.type === 'usage.updated')
+                usage = event.data.value ?? event.data;
+            if (event.type === 'warning')
+                warnings.push(String(event.data.message ?? 'warning'));
+            const tool = toolResultFromEvent(event);
+            if (tool)
+                tools.set(tool.toolCallId, tool);
+            if (event.type === 'run.failed') {
+                outcome = 'failed';
+                const candidate = objectValue(event.data.error);
+                const envelope = objectValue(candidate?.envelope);
+                if (candidate && envelope && typeof candidate.message === 'string')
+                    error = { message: candidate.message, ...(typeof candidate.raw === 'string' ? { raw: candidate.raw } : {}), envelope: envelope };
+            }
+            if (event.type === 'run.cancelled') {
+                outcome = 'cancelled';
+                const reason = String(event.data.reason ?? 'cancelled');
+                /* R3 Q-R3-8: a stop the person asked for is INTERRUPTED (exit 130), not a generic cancel. */
+                const source = { code: event.data.interrupted === true ? 'INTERRUPTED' : 'CANCELLED', message: reason, component: 'runtime', retryable: false };
+                error = v2Error(source, safeTalosFailure(source, { component: 'runtime' }), redactText);
+            }
+            if (event.type === 'run.completed')
+                outcome = 'completed';
+        },
+        result() {
+            if (outcome === 'failed' || outcome === 'cancelled') {
+                const fallback = error ?? (() => {
+                    const code = outcome === 'cancelled' ? 'CANCELLED' : 'AGENT_FAILED';
+                    const message = outcome === 'cancelled' ? 'cancelled' : 'Agent run failed';
+                    const source = { code, message, component: 'runtime', retryable: false };
+                    return v2Error(source, safeTalosFailure(source, { component: 'runtime' }), redactText);
+                })();
+                return {
+                    schema: 'talos.cli.result.v2', version: 2, ok: false, sessionId, cursor, outcome, error: fallback,
+                    warnings: [...warnings], toolResults: [...tools.values()]
+                };
+            }
+            return {
+                schema: 'talos.cli.result.v2', version: 2, ok: true, sessionId, cursor, outcome: 'completed',
+                result: { text, changedFiles: [...changed], usage }, warnings: [...warnings], toolResults: [...tools.values()]
+            };
+        }
+    };
+}
+export function withV2RunWarnings(result, warnings) {
+    return { ...result, warnings: [...warnings] };
+}

package/dist/protocol/v2/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./events.js";
+export * from "./replay.js";
+export * from "./codec.js";

package/dist/protocol/v2/replay.js

@@ -0,0 +1,28 @@
+export class TalosV2ReplayError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'TalosV2ReplayError';
+        this.code = code;
+        this.details = details;
+    }
+}
+export function replayDurableAfter(events, cursor) {
+    const replayable = events.filter(event => event.cursor !== null);
+    if (cursor === null)
+        return replayable.filter(event => event.durability === 'durable');
+    const wrongSession = events.find(event => event.sessionId !== cursor.sessionId);
+    if (wrongSession)
+        throw new TalosV2ReplayError('PROTOCOL_CURSOR_SESSION_MISMATCH', 'Replay cursor is bound to a different session', { cursorSessionId: cursor.sessionId, eventSessionId: wrongSession.sessionId });
+    if (replayable.length === 0)
+        throw new TalosV2ReplayError('PROTOCOL_CURSOR_UNAVAILABLE', 'No retained replay range is available for this cursor', { cursor });
+    const sequences = replayable.map(event => event.cursor.sequence);
+    const oldest = Math.min(...sequences);
+    const newest = Math.max(...sequences);
+    if (cursor.sequence < oldest - 1 || cursor.sequence > newest)
+        throw new TalosV2ReplayError('PROTOCOL_CURSOR_UNAVAILABLE', 'Requested replay cursor is outside the retained range', { cursor, oldestSequence: oldest, newestSequence: newest });
+    return replayable.filter(event => event.sessionId === cursor.sessionId
+        && event.cursor.sequence > cursor.sequence
+        && event.durability === 'durable');
+}

package/dist/protocol/v2/types.js

@@ -0,0 +1 @@
+export {};