talos-code 0.0.1 → 0.1.0

package/dist/tui/editor.js

@@ -0,0 +1,210 @@
+import { createEditorHistory, pushEditorHistory, redoEditorHistory, undoEditorHistory } from "./editor-history.js";
+import { splitGraphemes } from "./text-width.js";
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+const clonePastes = (pastes) => pastes.map(paste => ({ ...paste }));
+function clearPreferred(state) { const { preferredColumn: _, ...rest } = state; return rest; }
+function clearSelection(state) { const { selectionAnchor: _, ...rest } = state; return rest; }
+function clearTransient(state) { return clearSelection(clearPreferred(state)); }
+function snapshot(state) { return { text: state.text, cursor: clamp(state.cursor, 0, state.text.length), collapsedPastes: clonePastes(state.collapsedPastes) }; }
+function withCursor(state, cursor, extendSelection = false) {
+    const nextCursor = clamp(cursor, 0, state.text.length);
+    const base = clearPreferred(state);
+    if (!extendSelection)
+        return { ...clearSelection(base), cursor: nextCursor };
+    const anchor = state.selectionAnchor ?? clamp(state.cursor, 0, state.text.length);
+    if (anchor === nextCursor)
+        return { ...clearSelection(base), cursor: nextCursor };
+    return { ...base, cursor: nextCursor, selectionAnchor: anchor };
+}
+function restoreSnapshot(state, value, editHistory) {
+    return { ...clearTransient(state), text: value.text, cursor: clamp(value.cursor, 0, value.text.length), collapsedPastes: clonePastes(value.collapsedPastes), editHistory };
+}
+export function previousGraphemeBoundary(text, cursor) { let offset = 0, previous = 0; for (const g of splitGraphemes(text)) {
+    const next = offset + g.length;
+    if (next >= cursor)
+        return previous;
+    previous = next;
+    offset = next;
+} return previous; }
+export function nextGraphemeBoundary(text, cursor) { let offset = 0; for (const g of splitGraphemes(text)) {
+    offset += g.length;
+    if (offset > cursor)
+        return offset;
+} return text.length; }
+function graphemeBoundaryAtOrBefore(text, cursor) { const target = clamp(cursor, 0, text.length); let offset = 0; for (const g of splitGraphemes(text)) {
+    const next = offset + g.length;
+    if (next > target)
+        return offset;
+    if (next === target)
+        return next;
+    offset = next;
+} return text.length; }
+export function createEditorState(text = '') { return { text, cursor: text.length, killBuffer: '', collapsedPastes: [], editHistory: createEditorHistory() }; }
+export function replaceEditorText(_state, text) { return createEditorState(text); }
+export function draftOf(state) { return { text: state.text, collapsedPastes: clonePastes(state.collapsedPastes) }; }
+export function draftText(draft) { return typeof draft === 'string' ? draft : draft.text; }
+export function editorFromDraft(draft) {
+    const text = draftText(draft), state = createEditorState(text);
+    if (typeof draft === 'string')
+        return state;
+    const valid = draft.collapsedPastes.filter(paste => Number.isSafeInteger(paste.start) && Number.isSafeInteger(paste.end) && paste.start >= 0 && paste.end > paste.start && paste.end <= text.length);
+    const pastes = [...valid].sort((a, b) => a.start - b.start).filter((paste, index, sorted) => index === 0 || paste.start >= sorted[index - 1].end);
+    return { ...state, collapsedPastes: clonePastes(pastes) };
+}
+export function selectionRange(state) {
+    if (state.selectionAnchor === undefined)
+        return null;
+    const anchor = clamp(state.selectionAnchor, 0, state.text.length), cursor = clamp(state.cursor, 0, state.text.length);
+    if (anchor === cursor)
+        return null;
+    return { start: Math.min(anchor, cursor), end: Math.max(anchor, cursor) };
+}
+export function remapCollapsedPastes(pastes, editStart, removed, inserted) {
+    const editEnd = editStart + removed, delta = inserted - removed;
+    const out = [];
+    for (const p of pastes) {
+        if (editEnd <= p.start) {
+            out.push({ ...p, start: p.start + delta, end: p.end + delta });
+            continue;
+        }
+        if (editStart >= p.end) {
+            out.push({ ...p });
+            continue;
+        }
+    }
+    return out;
+}
+export function replaceRange(state, start, end, value) {
+    const from = clamp(start, 0, state.text.length), to = Math.max(from, clamp(end, 0, state.text.length));
+    if (from === to && value.length === 0)
+        return clearTransient(state);
+    const editHistory = pushEditorHistory(state.editHistory, snapshot(state));
+    return { ...clearTransient(state), text: state.text.slice(0, from) + value + state.text.slice(to), cursor: from + value.length, collapsedPastes: remapCollapsedPastes(state.collapsedPastes, from, to - from, value.length), editHistory };
+}
+export function editInsert(state, value) {
+    if (!value)
+        return clearPreferred(state);
+    const selected = selectionRange(state);
+    return selected ? replaceRange(state, selected.start, selected.end, value) : replaceRange(state, state.cursor, state.cursor, value);
+}
+export function moveCursor(state, to, extendSelection = false) {
+    const selected = selectionRange(state);
+    if (selected && !extendSelection && (to === 'left' || to === 'right'))
+        return withCursor(state, to === 'left' ? selected.start : selected.end, false);
+    const bounds = lineBounds(state.text, state.cursor);
+    const cursor = to === 'left' ? previousGraphemeBoundary(state.text, state.cursor) : to === 'right' ? nextGraphemeBoundary(state.text, state.cursor) : to === 'home' ? bounds.start : bounds.end;
+    return withCursor(state, cursor, extendSelection);
+}
+function isWord(ch) { return !!ch && /[\p{L}\p{N}_]/u.test(ch); }
+export function moveWord(state, direction, extendSelection = false) { let c = clamp(state.cursor, 0, state.text.length); if (direction < 0) {
+    while (c > 0 && !isWord(state.text[previousGraphemeBoundary(state.text, c)]))
+        c = previousGraphemeBoundary(state.text, c);
+    while (c > 0 && isWord(state.text[previousGraphemeBoundary(state.text, c)]))
+        c = previousGraphemeBoundary(state.text, c);
+}
+else {
+    while (c < state.text.length && !isWord(state.text[c]))
+        c = nextGraphemeBoundary(state.text, c);
+    while (c < state.text.length && isWord(state.text[c]))
+        c = nextGraphemeBoundary(state.text, c);
+} return withCursor(state, c, extendSelection); }
+function lineBounds(text, cursor) { const c = clamp(cursor, 0, text.length); const start = text.lastIndexOf('\n', Math.max(0, c - 1)) + 1; const next = text.indexOf('\n', c); const end = next < 0 ? text.length : next; return { start, end }; }
+export function moveVertical(state, direction, extendSelection = false) {
+    const c = clamp(state.cursor, 0, state.text.length);
+    const current = lineBounds(state.text, c);
+    const preferred = state.preferredColumn ?? (c - current.start);
+    if (direction < 0) {
+        if (current.start === 0)
+            return extendSelection ? state : withCursor(state, c, false);
+        const previousEnd = current.start - 1;
+        const previous = lineBounds(state.text, previousEnd);
+        const target = graphemeBoundaryAtOrBefore(state.text, previous.start + Math.min(preferred, previous.end - previous.start));
+        const moved = withCursor(state, target, extendSelection);
+        return { ...moved, preferredColumn: preferred };
+    }
+    if (current.end === state.text.length)
+        return extendSelection ? state : withCursor(state, c, false);
+    const nextStart = current.end + 1;
+    const next = lineBounds(state.text, nextStart);
+    const target = graphemeBoundaryAtOrBefore(state.text, next.start + Math.min(preferred, next.end - next.start));
+    const moved = withCursor(state, target, extendSelection);
+    return { ...moved, preferredColumn: preferred };
+}
+export function deleteBackward(state) { const selected = selectionRange(state); if (selected)
+    return replaceRange(state, selected.start, selected.end, ''); const c = clamp(state.cursor, 0, state.text.length); if (c === 0)
+    return clearPreferred(state); return replaceRange(state, previousGraphemeBoundary(state.text, c), c, ''); }
+export function deleteForward(state) { const selected = selectionRange(state); if (selected)
+    return replaceRange(state, selected.start, selected.end, ''); const c = clamp(state.cursor, 0, state.text.length); if (c >= state.text.length)
+    return clearPreferred(state); return replaceRange(state, c, nextGraphemeBoundary(state.text, c), ''); }
+export function copySelection(state) { const selected = selectionRange(state); return selected ? { ...state, killBuffer: state.text.slice(selected.start, selected.end) } : state; }
+export function cutSelection(state) { const selected = selectionRange(state); if (!selected)
+    return state; const killed = state.text.slice(selected.start, selected.end); return { ...replaceRange(state, selected.start, selected.end, ''), killBuffer: killed }; }
+export function killToStart(state) { if (selectionRange(state))
+    return cutSelection(state); const c = clamp(state.cursor, 0, state.text.length); const { start } = lineBounds(state.text, c); if (c === start)
+    return clearPreferred(state); const killed = state.text.slice(start, c); return { ...replaceRange(state, start, c, ''), killBuffer: killed }; }
+export function killToEnd(state) { if (selectionRange(state))
+    return cutSelection(state); const c = clamp(state.cursor, 0, state.text.length); const { end } = lineBounds(state.text, c); if (c >= end)
+    return clearPreferred(state); const killed = state.text.slice(c, end); return { ...replaceRange(state, c, end, ''), killBuffer: killed }; }
+export function killWordBackward(state) { if (selectionRange(state))
+    return cutSelection(state); const end = clamp(state.cursor, 0, state.text.length); const moved = moveWord(state, -1); if (moved.cursor === end)
+    return clearPreferred(state); const killed = state.text.slice(moved.cursor, end); return { ...replaceRange(state, moved.cursor, end, ''), killBuffer: killed }; }
+export function yank(state) { return state.killBuffer ? editInsert(state, state.killBuffer) : clearPreferred(state); }
+export function undoEditor(state) { const step = undoEditorHistory(state.editHistory, snapshot(state)); return step ? restoreSnapshot(state, step.value, step.history) : clearTransient(state); }
+export function redoEditor(state) { const step = redoEditorHistory(state.editHistory, snapshot(state)); return step ? restoreSnapshot(state, step.value, step.history) : clearTransient(state); }
+export function visibleEditorText(state) { const c = clamp(state.cursor, 0, state.text.length); const next = nextGraphemeBoundary(state.text, c); return { before: state.text.slice(0, c), cursor: state.text.slice(c, next) || ' ', after: state.text.slice(next), atEnd: c === state.text.length }; }
+export function insertPaste(state, text) {
+    const selected = selectionRange(state);
+    const start = selected?.start ?? state.cursor;
+    const end = selected?.end ?? state.cursor;
+    const next = replaceRange(state, start, end, text);
+    const lines = text.split(/\r?\n/u).length;
+    return text.length >= 4096 || lines >= 20 ? { ...next, collapsedPastes: [...next.collapsedPastes, { start, end: start + text.length, chars: text.length, lines }] } : next;
+}
+export function composerSegments(state) {
+    const out = [];
+    const ranges = [...state.collapsedPastes].sort((a, b) => a.start - b.start);
+    const selected = selectionRange(state);
+    const pushText = (start, end) => {
+        if (end < start)
+            return;
+        if (selected) {
+            const selectedStart = Math.max(start, selected.start), selectedEnd = Math.min(end, selected.end);
+            if (selectedEnd <= selectedStart) {
+                if (end > start)
+                    out.push({ kind: 'text', text: state.text.slice(start, end) });
+                return;
+            }
+            if (selectedStart > start)
+                out.push({ kind: 'text', text: state.text.slice(start, selectedStart) });
+            out.push({ kind: 'text', text: state.text.slice(selectedStart, selectedEnd), selected: true });
+            if (selectedEnd < end)
+                out.push({ kind: 'text', text: state.text.slice(selectedEnd, end) });
+            return;
+        }
+        if (state.cursor < start || state.cursor > end) {
+            if (end > start)
+                out.push({ kind: 'text', text: state.text.slice(start, end) });
+            return;
+        }
+        if (state.cursor > start)
+            out.push({ kind: 'text', text: state.text.slice(start, state.cursor) });
+        const next = Math.min(end, nextGraphemeBoundary(state.text, state.cursor));
+        out.push({ kind: 'cursor', text: state.text.slice(state.cursor, next) || ' ' });
+        if (next < end)
+            out.push({ kind: 'text', text: state.text.slice(next, end) });
+    };
+    let pos = 0;
+    for (const p of ranges) {
+        if (p.start < pos)
+            continue;
+        pushText(pos, p.start);
+        const pasteSelected = Boolean(selected && selected.end > p.start && selected.start < p.end);
+        if (!selected && state.cursor >= p.start && state.cursor < p.end)
+            pushText(p.start, p.end);
+        else
+            out.push({ kind: 'paste', text: '[paste: ' + p.lines + ' lines, ' + p.chars + ' chars]', ...(pasteSelected ? { selected: true } : {}) });
+        pos = p.end;
+    }
+    pushText(pos, state.text.length);
+    return out;
+}

package/dist/tui/event-adapter.js

@@ -0,0 +1,436 @@
+import { createRedactor } from "../diagnostics/redact.js";
+import { createV2EventBridge } from "../protocol/v2/events.js";
+import { describeError, describeKernelNotice, describeKernelRefusalReason, describeKernelToolText, errorViewLines } from "../i18n/error-view.js";
+import { t } from "../i18n/index.js";
+import { REFUSAL_VIA, looksItalian } from "../i18n/kernel-map.js";
+import { toolDisplay } from "./tool-display.js";
+function objectValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function isCanonicalEvent(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return row.schema === 'talos.cli.event.v2' && row.version === 2 && typeof row.sessionId === 'string'
+        && typeof row.eventId === 'string' && typeof row.type === 'string' && Boolean(row.data && typeof row.data === 'object');
+}
+function asToolResult(data) {
+    const receipt = objectValue(data.receipt);
+    const status = data.status;
+    if (typeof data.toolCallId !== 'string' || typeof data.content !== 'string' || typeof status !== 'string' || !receipt)
+        return null;
+    return data;
+}
+function compactToolOutcome(result) {
+    const structured = result.status !== 'completed' || result.receipt.status !== null || result.receipt.allowed !== null
+        || result.receipt.via !== null || result.receipt.reason !== null || result.receipt.risk !== null || result.enforcement !== null;
+    if (!structured)
+        return undefined;
+    return {
+        toolCallId: result.toolCallId,
+        status: result.status,
+        content: result.content,
+        receiptStatus: result.receipt.status,
+        exitCode: result.enforcement?.exitCode ?? null,
+        enforcement: result.enforcement?.sandbox ?? null,
+        allowed: result.receipt.allowed,
+        permissionVia: result.receipt.via,
+        permissionReason: result.receipt.reason,
+        risk: result.receipt.risk,
+    };
+}
+function canonicalError(data) {
+    const row = objectValue(data.error);
+    const envelope = objectValue(row?.envelope);
+    return row && typeof row.message === 'string' && envelope ? row : undefined;
+}
+function identity(event) { return { eventId: event.eventId }; }
+/*
+ * R1 lane R (D-04, gate E9): the kernel records the person's prompt ONLY as `RunStarted.input.consegna` (measured through the
+ * real composition, r1-resume-history.test.ts); no `TextMessageStart role:user` exists, so a replay rebuilt no user message.
+ * The prompt is shown as it was typed: the project-reference blocks `renderPromptWithAttachments` appends
+ * (runtime/attachments.ts:65-70) are cut, the `@path` the person wrote stays. The local runtime passes chat messages instead.
+ */
+const REFERENCE_BLOCKS = '\n\n[TALOS project reference: ', REFERENCE_END = '[End TALOS project reference]';
+function typedPrompt(value) { const cut = value.indexOf(REFERENCE_BLOCKS); return cut >= 0 && value.endsWith(REFERENCE_END) ? value.slice(0, cut) : value; }
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return undefined;
+    const parts = content.map(part => objectValue(part)).filter(part => part?.type === 'text' && typeof part.text === 'string').map(part => String(part.text));
+    return parts.length ? parts.join('\n') : undefined;
+}
+export function runPrompt(input) {
+    if (Array.isArray(input)) {
+        for (let i = input.length - 1; i >= 0; i--) {
+            const row = objectValue(input[i]);
+            if (row?.role === 'user')
+                return stringValue(messageText(row.content));
+        }
+        return undefined;
+    }
+    /* R2 lane J (E11): protocol v2 renames `consegna` to `prompt`; the TUI reads both. */
+    const text = stringValue(objectValue(input)?.prompt) ?? stringValue(objectValue(input)?.consegna);
+    return text === undefined ? undefined : stringValue(typedPrompt(text));
+}
+function role(value) { return value === 'user' ? 'user' : 'assistant'; }
+function countOrNull(value) { return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.round(value) : null; }
+/* R5a lane R (S10): a kernel tool id in the screen's words, for the English refusal reasons. */
+const toolLabel = (id) => { try {
+    return toolDisplay(id).label;
+}
+catch {
+    return id;
+} };
+/** The screen's copy of a tool result: the kernel's Italian refusal reason in English (display only; v2 keeps the kernel's). */
+function displayReceipt(result) {
+    const reason = result.receipt.reason;
+    if (!reason)
+        return result;
+    const english = describeKernelRefusalReason(reason, { toolLabel });
+    return english && english !== reason ? { ...result, receipt: { ...result.receipt, reason: english } } : result;
+}
+function projectCanonical(event) {
+    const id = identity(event);
+    const data = event.data;
+    switch (event.type) {
+        case 'run.started': {
+            const runId = stringValue(data.runId), prompt = runPrompt(data.input);
+            return { type: 'run.started', sessionId: event.sessionId, ...(runId ? { runId } : {}), ...(prompt ? { prompt } : {}), ...id };
+        }
+        case 'message.started':
+            return { type: 'message.started', messageId: String(data.messageId ?? 'assistant'), role: role(data.role), ...id };
+        case 'message.delta': {
+            /* R2 lane E (gate E4): a kernel notice arrives as one whole assistant message (no code); only its exact template is
+               replaced, so the model's own words are never touched. */
+            const delta = String(data.delta ?? '');
+            return { type: 'message.delta', messageId: String(data.messageId ?? 'assistant'), delta: describeKernelNotice(delta) ?? delta, ...id };
+        }
+        case 'message.completed':
+            return { type: 'message.end', messageId: String(data.messageId ?? 'assistant'), ...id };
+        case 'reasoning.started':
+            return { type: 'reasoning.started', messageId: String(data.messageId ?? 'reasoning'), ...id };
+        case 'reasoning.delta':
+            return { type: 'reasoning.delta', messageId: String(data.messageId ?? 'reasoning'), delta: String(data.delta ?? ''), ...id };
+        case 'reasoning.completed':
+            return { type: 'reasoning.end', messageId: String(data.messageId ?? 'reasoning'), ...id };
+        case 'tool.started':
+            return { type: 'tool.started', toolCallId: String(data.toolCallId ?? ''), toolName: String(data.toolName ?? 'tool'), ...id };
+        case 'tool.args':
+            return { type: 'tool.args', toolCallId: String(data.toolCallId ?? ''), delta: String(data.delta ?? ''), ...id };
+        case 'tool.output':
+            return { type: 'tool.output', toolCallId: String(data.toolCallId ?? ''), delta: String(data.delta ?? ''), ...id };
+        case 'tool.completed': {
+            const canonical = asToolResult(data);
+            if (!canonical)
+                return null;
+            /* R3 Q-R3-8 (R3-INT): the kernel's stop sentences in English, on the display copy only; a tool the person stopped is
+               `cancelled` (shown as interrupted), never `failed`. The canonical v2 result is untouched. */
+            const shown = describeKernelToolText(canonical.content);
+            const result = displayReceipt(shown.text === canonical.content && !shown.stopped ? canonical : { ...canonical, content: shown.text, ...(shown.stopped ? { status: 'cancelled' } : {}) });
+            const outcome = compactToolOutcome(result);
+            return {
+                type: 'tool.completed', toolCallId: result.toolCallId, content: result.content, result,
+                ...(outcome ? { outcome } : {}), ...id
+            };
+        }
+        case 'file.changed':
+            return { type: 'file.changed', data: { ...data }, ...id };
+        case 'approval.required': {
+            const payload = objectValue(data.azione ?? data.action) ?? {};
+            const toolCallId = stringValue(payload.toolCallId);
+            return {
+                type: 'approval.required',
+                requestId: String(data.requestId ?? ''),
+                payload: { ...payload },
+                ...(toolCallId ? { toolCallId } : {}),
+                ...id
+            };
+        }
+        case 'approval.resolved': {
+            const approved = booleanValue(data.approvato) ?? booleanValue(data.approved);
+            return { type: 'approval.resolved', requestId: String(data.requestId ?? ''), ...(approved !== undefined ? { approved } : {}), ...id };
+        }
+        case 'usage.updated': {
+            /* R5a lane R (S1): the last request's own usage and the run's declared cost ride inside the value (additive keys), so the
+               state keeps one usage object and `usageSnapshot` reads them there. */
+            const value = objectValue(data.value);
+            const lastRequest = objectValue(data.lastRequest);
+            const declared = countOrNull(data.declaredCostUsd) === null ? null : Number(data.declaredCostUsd);
+            if (!value || (!lastRequest && declared === null))
+                return { type: 'usage.updated', value: data.value, ...id };
+            return { type: 'usage.updated', value: { ...value, ...(lastRequest ? { lastRequest: { ...lastRequest } } : {}), ...(declared !== null ? { declaredCostUsd: declared } : {}) }, ...id };
+        }
+        case 'provider.attempt': {
+            const attempt = countOrNull(data.attempt), maxAttempts = countOrNull(data.maxAttempts);
+            if (attempt === null || maxAttempts === null)
+                return null;
+            return { type: 'provider.attempt', attempt, maxAttempts, status: countOrNull(data.status), retryAfterMs: countOrNull(data.retryAfterMs), waitMs: countOrNull(data.waitMs), ...id };
+        }
+        case 'context.summary.requested': return { type: 'context.summary.requested', ...id };
+        case 'context.compaction.paused': {
+            const code = typeof data.code === 'string' ? data.code : '', retryAfter = typeof data.retryAfter === 'string' ? data.retryAfter : '';
+            if (!code || !Number.isFinite(Date.parse(retryAfter)))
+                return null;
+            return { type: 'context.compaction.paused', noticeId: typeof data.noticeId === 'string' ? data.noticeId : null, code, attempts: countOrNull(data.attempts), waitSeconds: countOrNull(data.waitSeconds), retryAfter, ...id };
+        }
+        case 'context.compacted': {
+            const trigger = data.trigger === 'manual' || data.trigger === 'automatic' ? data.trigger : null;
+            return { type: 'context.compacted', engine: data.engine === 'context-engine' ? 'context-engine' : 'kernel', messagesSummarized: countOrNull(data.messagesSummarized),
+                tokensBefore: countOrNull(data.tokensBefore), tokensAfter: countOrNull(data.tokensAfter), ...(trigger ? { trigger } : {}), ...id };
+        }
+        case 'warning': {
+            /* R2 lane E (Q-R2-2): a kernel notice has no code (`onAvviso`, RuntimeFallback): Italian text is replaced by one English
+               sentence and kept as `raw` for the expanded view and the log; the CLI's own English notices pass unchanged. */
+            const message = String(data.message ?? 'warning');
+            return looksItalian(message) ? { type: 'warning', message: t('error.warning.untranslated'), raw: message, ...id } : { type: 'warning', message, ...id };
+        }
+        case 'session.snapshot':
+            return { type: 'session.snapshot', data: { ...data }, ...id };
+        case 'run.completed': {
+            const runId = stringValue(data.runId);
+            return { type: 'run.completed', ...(runId ? { runId } : {}), ...id };
+        }
+        case 'run.failed': {
+            const error = canonicalError(data);
+            const runId = stringValue(data.runId);
+            /* R2 lane E (gate E4, Q-R2-4): the message is the English three-part view of the CODE; the kernel's text rides along
+               only inside `error` (the transcript keeps it as the row's raw detail). */
+            const view = describeError(error ?? { message: String(data.message ?? 'run failed'), code: data.code });
+            return {
+                type: 'run.failed',
+                message: errorViewLines(view).join('\n'),
+                ...(error ? { error } : {}),
+                ...(runId ? { runId } : {}),
+                ...id
+            };
+        }
+        case 'run.cancelled': {
+            const runId = stringValue(data.runId);
+            const reason = stringValue(data.reason);
+            return { type: 'run.cancelled', ...(runId ? { runId } : {}), ...(reason ? { reason } : {}), ...id };
+        }
+        default:
+            return null;
+    }
+}
+/*
+ * R3 gate E3 (Q-R3-1/2): the facts of a finished tool, from structured fields only: the receipt's exit code, the kernel's
+ * measured `durataMs` (v2 `details.durationMs`, talosHarness.mjs:8661), and the isolation named by the glyph the CLI's own
+ * executor puts first in its annotation (`EXECUTION_TEXT.isolation`: ⛉ sandbox, ⛶ host). An absent fact stays absent: a
+ * zero would say "instant" or "exit 0" where the truth is unknown (agui-events.mjs OSS-1).
+ */
+const SANDBOX_GLYPH = '⛉', HOST_GLYPH = '⛶';
+export function isolationOf(enforcement) {
+    if (typeof enforcement !== 'string')
+        return null;
+    const head = enforcement.trimStart();
+    return head.startsWith(SANDBOX_GLYPH) ? 'sandbox' : head.startsWith(HOST_GLYPH) ? 'host' : null;
+}
+function toolFacts(result, noted = null) {
+    const exitCode = result.enforcement?.exitCode, durationMs = objectValue(result.details)?.durationMs, isolation = isolationOf(result.enforcement?.sandbox);
+    const denial = noted ?? kernelDenial(result);
+    const facts = {
+        ...(typeof exitCode === 'number' && Number.isInteger(exitCode) ? { exitCode } : {}),
+        ...(typeof durationMs === 'number' && Number.isFinite(durationMs) && durationMs >= 0 ? { durationMs: Math.round(durationMs) } : {}),
+        ...(isolation ? { isolation } : {}),
+        ...(denial ? { denial } : {}),
+    };
+    return Object.keys(facts).length ? facts : null;
+}
+/*
+ * R5a lane R (S10, gate finding 15). Why a refused tool did not run, from the receipt alone, only when the receipt can say
+ * it: the session's own level (read-only, research, workspace writes, a tool turned off) is `mode`; the kernel's floors (a
+ * command that cannot be undone, the checkpoint guard) are `policy`. An "asked" via is NOT decided here: the kernel writes
+ * the same via and the same sentence whether the person said no or the permission engine answered alone (finding 15), so
+ * only the session controller, which asked, can say which (`noteDenial`). A stop is not a denial.
+ */
+const MODE_VIAS = new Set(['toolOff', 'readOnly', 'research', 'workspaceWrite']);
+const POLICY_VIAS = new Set(['noRecovery', 'checkpoint']);
+function kernelDenial(result) {
+    if (result.receipt.allowed !== false && result.receipt.status !== 'denied')
+        return null;
+    const key = result.receipt.via ? REFUSAL_VIA[result.receipt.via] : undefined;
+    if (!key || (!MODE_VIAS.has(key) && !POLICY_VIAS.has(key)))
+        return null;
+    const english = result.receipt.reason ? describeKernelRefusalReason(result.receipt.reason, { toolLabel }) : null;
+    const reason = english ?? (result.receipt.reason && !looksItalian(result.receipt.reason) ? result.receipt.reason : null);
+    return { by: MODE_VIAS.has(key) ? 'mode' : 'policy', ...(reason ? { reason } : {}) };
+}
+/**
+ * R5a lane R (S10): the denial fact for a decision the permission engine made ALONE (`ApprovalDecision` deny,
+ * security/permission-engine.ts:36-44), in English. A matched deny rule is `rule` with its text (`explain.rule`, e.g. the
+ * rule `simulatePermission` names) and scope; a command the policy cannot split (`unsupported shell composition`,
+ * security/evaluate.ts:134-140) or a path outside the project is `policy`; plan mode, a mode that never asks and the automatic
+ * classifier are `mode`. The person's own "no" is `{by:'person'}`, and nothing else is.
+ */
+export function denialFromEngine(decision, explain = {}) {
+    const code = String(decision?.code ?? '');
+    const message = String(decision?.message ?? '');
+    const because = (id) => ({ by: code === 'PATH_NOT_ALLOWED' || id === 'error.denial.reason.unsupportedShell' || id === 'error.denial.reason.pathOutside' ? 'policy' : 'mode', reason: t(id) });
+    if (code === 'PLAN_MODE_READ_ONLY')
+        return because('error.denial.reason.planMode');
+    if (code === 'PERMISSION_REQUIRED')
+        return because('error.denial.reason.noAsking');
+    if (code === 'PERMISSION_AUTO_DENIED')
+        return because('error.denial.reason.autoDenied');
+    if (code === 'PATH_NOT_ALLOWED')
+        return because('error.denial.reason.pathOutside');
+    if (/(?:^|: )matched deny rule$/u.test(message)) {
+        let rule = null;
+        try {
+            rule = explain.rule?.() ?? null;
+        }
+        catch {
+            rule = null;
+        }
+        let scope = null;
+        try {
+            scope = rule ? explain.scope?.(rule) ?? null : null;
+        }
+        catch {
+            scope = null;
+        }
+        return { by: 'rule', ...(rule ? { rule } : {}), ...(scope ? { scope } : {}) };
+    }
+    if (/unsupported shell composition$/u.test(message))
+        return because('error.denial.reason.unsupportedShell');
+    if (/write path is outside the authorized project$/u.test(message))
+        return because('error.denial.reason.pathOutside');
+    return { by: 'policy', ...(message && !looksItalian(message) ? { reason: message } : {}) };
+}
+/*
+ * R3 gate E10 (Q-R3-4): a file the kernel wrote arrives as `StateDelta` rows `/file/<path>` with the text after and, for a
+ * file that existed, the text before (`prima`) (agui-events.mjs:427-436); the v2 bridge keeps only `/usage`, so the TUI
+ * reads the rows here, through the same redactor as every v2 string. A replaced file whose before is unknown is skipped
+ * (it must not look new); texts over MAX_FILE_CHANGE_CHARS are skipped (the diff of a huge file is not a screen). The change
+ * belongs to the open tool call whose arguments name the same path, or else to the only open call.
+ */
+const MAX_FILE_CHANGE_CHARS = 1_000_000, MAX_OPEN_ARGS_CHARS = 65_536;
+function samePath(value) { return value.replace(/\\/gu, '/').replace(/^\.\//u, ''); }
+function argsPath(args) {
+    try {
+        const parsed = objectValue(JSON.parse(args));
+        const value = parsed?.percorso ?? parsed?.path ?? parsed?.file_path;
+        return typeof value === 'string' && value ? samePath(value) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function createTuiEventAdapter(secretValues = []) {
+    let currentSessionId = null;
+    let bridge = null;
+    const redactor = createRedactor(secretValues);
+    const openTools = new Map();
+    /* R5a lane R (S10): the denial facts the session controller noted, by tool call, until the tool's result arrives. */
+    const noted = new Map();
+    /* R5a lane R (S3): the kernel compactions seen live in this run (the fetch observer's event). */
+    let liveKernelCompactions = 0;
+    function bindSession(sessionId) {
+        if (typeof sessionId !== 'string' || sessionId.length === 0)
+            throw new Error('SESSION_ID_REQUIRED');
+        if (sessionId === currentSessionId && bridge)
+            return;
+        currentSessionId = sessionId;
+        openTools.clear();
+        noted.clear();
+        liveKernelCompactions = 0;
+        bridge = createV2EventBridge(sessionId, undefined, secretValues);
+    }
+    function canonicalOf(raw) {
+        if (isCanonicalEvent(raw))
+            return raw;
+        if (!raw || typeof raw !== 'object' || !bridge)
+            return null;
+        return bridge.translate(raw);
+    }
+    function translate(raw) {
+        const canonical = canonicalOf(raw);
+        return canonical ? projectCanonical(canonical) : null;
+    }
+    /**
+     * R5a lane R (S10): the session controller tells the adapter who refused a tool BEFORE its result arrives — the person
+     * (`{by:'person'}`, only after asking) or the engine alone (`denialFromEngine`). The next `tool.facts` of that call carries it.
+     */
+    function noteDenial(toolCallId, denial) {
+        if (typeof toolCallId !== 'string' || !toolCallId || !denial)
+            return;
+        noted.set(toolCallId, denial);
+        if (noted.size > 256)
+            noted.delete(noted.keys().next().value);
+    }
+    function fileChanges(raw) {
+        if (raw.type !== 'StateDelta' || !Array.isArray(raw.delta))
+            return [];
+        const out = [];
+        for (const entry of raw.delta) {
+            const row = objectValue(entry);
+            const where = stringValue(row?.path);
+            if (!row || !where?.startsWith('/file/') || typeof row.value !== 'string' || (row.op !== 'add' && row.op !== 'replace'))
+                continue;
+            const before = row.op === 'add' ? null : typeof row.prima === 'string' ? row.prima : undefined;
+            if (before === undefined || row.value.length > MAX_FILE_CHANGE_CHARS || (before?.length ?? 0) > MAX_FILE_CHANGE_CHARS)
+                continue;
+            const path = where.slice('/file/'.length);
+            const owners = [...openTools].filter(([, args]) => argsPath(args) === samePath(path)).map(([id]) => id);
+            /* The call whose arguments name the path; failing that, the only open call (lane RD matches by path otherwise). */
+            const owner = owners.length === 1 ? owners[0] : owners.length === 0 && openTools.size === 1 ? [...openTools.keys()][0] : undefined;
+            const change = { path: redactor.text(path), before: before === null ? null : redactor.text(before), after: redactor.text(row.value), ...(owner ? { toolCallId: owner } : {}) };
+            out.push({ type: 'file.changed', change });
+        }
+        return out;
+    }
+    function translateAll(raw) {
+        const canonical = canonicalOf(raw);
+        const event = canonical ? projectCanonical(canonical) : null;
+        const out = event ? [event] : [];
+        if (event?.type === 'run.started')
+            liveKernelCompactions = 0;
+        else if (event?.type === 'context.compacted' && event.engine === 'kernel' && event.trigger !== 'manual')
+            liveKernelCompactions++;
+        if (event?.type === 'run.completed') {
+            /* R5a lane R (S3): the kernel counts its own compactions in the run's result (`compattazioni` → v2 `compactions`,
+               agent-service.mjs:182). A compaction the live observer did not report — every one, in a replay, where live events do
+               not exist — is named here, before the run ends, with what is known: nothing but that it happened. */
+            const total = countOrNull(objectValue(objectValue(canonical?.data)?.result)?.compactions) ?? 0;
+            const missing = Math.max(0, total - liveKernelCompactions);
+            for (let i = 0; i < missing; i++)
+                out.unshift({ type: 'context.compacted', engine: 'kernel', messagesSummarized: null, tokensBefore: null, tokensAfter: null, trigger: 'automatic' });
+            liveKernelCompactions = 0;
+        }
+        if (event?.type === 'tool.started')
+            openTools.set(event.toolCallId, '');
+        else if (event?.type === 'run.completed' || event?.type === 'run.failed' || event?.type === 'run.cancelled')
+            openTools.clear();
+        else if (event?.type === 'tool.args' && openTools.has(event.toolCallId))
+            openTools.set(event.toolCallId, (openTools.get(event.toolCallId) + event.delta).slice(0, MAX_OPEN_ARGS_CHARS));
+        else if (event?.type === 'tool.completed') {
+            openTools.delete(event.toolCallId);
+            const denial = noted.get(event.toolCallId) ?? null;
+            noted.delete(event.toolCallId);
+            const facts = event.result ? toolFacts(event.result, denial) : null;
+            if (facts)
+                out.push({ type: 'tool.facts', toolCallId: event.toolCallId, facts });
+            /* R5a lane R (Q-R5-10/11): the cut the model read, as facts the row states (the v2 result carries them). */
+            const saved = event.result?.outputSaved;
+            if (saved?.path)
+                out.push({ type: 'tool.output.saved', toolCallId: event.toolCallId, path: saved.path, keptChars: saved.keptChars, totalChars: saved.totalChars });
+            const cut = event.result?.readCut;
+            if (cut)
+                out.push({ type: 'tool.read.cut', toolCallId: event.toolCallId, shownLines: cut.shownLines, totalLines: cut.totalLines, limitChars: cut.limitChars });
+        }
+        const row = objectValue(raw);
+        if (row && !isCanonicalEvent(raw))
+            out.push(...fileChanges(row));
+        return out;
+    }
+    return { bindSession, translate, translateAll, noteDenial };
+}