talos-code 0.0.1 → 0.2.0

package/dist/tui/status-bar.js

@@ -0,0 +1,125 @@
+/*
+ * R5a lane S — S1, the ONE status row (owner decisions Q-R5-2 and Q-R5-5; gate E1, E2; R3 Q-R3-13):
+ *
+ *   Full access · No sandbox · model X · ↑1.2k ↓340 · cached 800 · ctx 3.1k/131k 2% · ~$0.004 · cmp 1 · 3 new
+ *
+ * It is the Hermes form (`☤ model │ 12.4K/200K │ [bar] 6% │ $0.06`, hermes `website/docs/user-guide/cli.md:149-180`,
+ * 2026-09-23; TUI `ui-tui/src/components/appChrome.tsx:197-215, 525-547`, 2026-09-19) plus the two R3 safety labels, which
+ * lead the row as they led the old footer. Pure: the facts come from lane R's `usageSnapshot` (runtime/usage-snapshot.ts).
+ *
+ * E1, no invented number: a window nobody knows is `ctx ?` (never a percentage); an estimate carries `~`; a cost is shown
+ * only from a named price source (`~$`, list price), `local` for a local engine, `cost ?` otherwise; token counts nobody
+ * reported leave their segment out, one side unknown is `?`.
+ * E2, one row: when the row is too wide the segments go in a fixed order — cost, cache, ↑↓, the compaction count, the
+ * "N new" count, then the window figure (`ctx 3.1k/131k 2%` → `ctx 2%`), then the model is cut in the middle and last
+ * dropped. The context figure (`ctx N%` or `ctx ?`), `Full access` and `No sandbox` are never dropped (Q-R3-13).
+ * The percentage is toned as Hermes colours it (50 / 80 / 95, appChrome.tsx:319-334); the number is always there, so a
+ * monochrome screen loses nothing.
+ */
+import { t } from "../i18n/index.js";
+import { shellSafeText } from "./components/terminal-shell.js";
+import { displayWidth, truncateDisplay, truncateMiddle } from "./text-width.js";
+const SEPARATOR = ' · ';
+/* A model id cut shorter than this says nothing; it is dropped instead. */
+const MODEL_MIN = 8;
+/* The drop order of E2 (first dropped first). `context-window` shortens the context segment; `model` cuts, then drops. */
+const DROP_ORDER = ['cost', 'cached', 'tokens', 'compactions', 'unseen', 'context-window', 'model'];
+const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+/** 340 → `340`, 1,200 → `1.2k`, 131,072 → `131k`, 1,500,000 → `1.5m`. */
+export function compactTokens(value) {
+    const n = Math.max(0, Math.round(value));
+    if (n < 1000)
+        return String(n);
+    if (n < 99_950)
+        return `${(n / 1000).toFixed(1).replace(/\.0$/u, '')}k`;
+    if (n < 999_500)
+        return `${Math.round(n / 1000)}k`;
+    return `${(n / 1_000_000).toFixed(1).replace(/\.0$/u, '')}m`;
+}
+/** A whole percentage; a used window under one percent reads `<1`, never `0` (that would say "empty"). */
+export function percentText(percent) {
+    if (percent > 0 && percent < 1)
+        return '<1';
+    return String(Math.min(999, Math.round(percent)));
+}
+/** US dollars at list price: three decimals under a dollar (`0.004`), two above (`1.25`), `<0.001` for dust. */
+export function costText(usd) {
+    if (usd > 0 && usd < 0.001)
+        return '<0.001';
+    return usd < 1 ? usd.toFixed(3) : usd.toFixed(2);
+}
+/** Hermes's thresholds for the context percentage (50 / 80 / 95). */
+export function contextTone(percent) {
+    if (percent === null)
+        return 'normal';
+    return percent >= 95 ? 'critical' : percent >= 80 ? 'high' : percent >= 50 ? 'warn' : 'normal';
+}
+function contextSegment(snapshot) {
+    /* R5a wiring: `inputTokens` is the run's total; the context in use is lane R's `contextTokens` (the last request). */
+    const window = count(snapshot?.windowTokens), used = count(snapshot?.contextTokens), percent = count(snapshot?.percent);
+    if (window === null || window === 0 || percent === null)
+        return { id: 'context', text: t('screen.statusbar.contextUnknown'), tone: 'normal' };
+    const tilde = snapshot?.estimated ? '~' : '';
+    const short = t('screen.statusbar.contextShort', { percent: `${tilde}${percentText(percent)}` });
+    const text = used === null ? short : t('screen.statusbar.context', { used: `${tilde}${compactTokens(used)}`, window: compactTokens(window), percent: percentText(percent) });
+    return { id: 'context', text, short, tone: contextTone(percent) };
+}
+function tokensSegment(snapshot) {
+    const input = count(snapshot?.inputTokens), output = count(snapshot?.outputTokens);
+    if (input === null && output === null)
+        return null;
+    const tilde = snapshot?.estimated ? '~' : '', unknown = t('screen.statusbar.unknown');
+    return { id: 'tokens', text: t('screen.statusbar.tokens', { input: input === null ? unknown : `${tilde}${compactTokens(input)}`, output: output === null ? unknown : `${tilde}${compactTokens(output)}` }), tone: 'normal' };
+}
+function costSegment(snapshot) {
+    if (snapshot?.local)
+        return { id: 'cost', text: t('screen.statusbar.local'), tone: 'normal' };
+    const usd = count(snapshot?.costUsd), source = typeof snapshot?.costSource === 'string' && snapshot.costSource.trim() ? snapshot.costSource : null;
+    if (usd === null || source === null)
+        return { id: 'cost', text: t('screen.statusbar.costUnknown'), tone: 'normal' };
+    /* R5a wiring (Q-R5-5, E1): a cost the provider declared is reported, not estimated: no `~`. */
+    return { id: 'cost', text: t(source === 'provider-reported' ? 'screen.statusbar.costReported' : 'screen.statusbar.cost', { cost: costText(usd) }), tone: 'normal' };
+}
+function segmentsOf(input) {
+    const { snapshot } = input, model = shellSafeText(input.model);
+    const cached = count(snapshot?.cachedTokens), compactions = count(snapshot?.compactions), unseen = count(input.unseen);
+    const tokens = tokensSegment(snapshot);
+    return [
+        ...(input.safety.fullAccess ? [{ id: 'fullAccess', text: t('screen.footer.fullAccess'), tone: 'normal' }] : []),
+        ...(input.safety.noSandbox ? [{ id: 'noSandbox', text: t('screen.footer.noSandbox'), tone: 'normal' }] : []),
+        ...(model ? [{ id: 'model', text: t('screen.statusbar.model', { model }), tone: 'normal', model }] : []),
+        ...(tokens ? [tokens] : []),
+        ...(cached ? [{ id: 'cached', text: t('screen.statusbar.cached', { count: compactTokens(cached) }), tone: 'normal' }] : []),
+        contextSegment(snapshot),
+        costSegment(snapshot),
+        ...(compactions ? [{ id: 'compactions', text: t('screen.statusbar.compactions', { count: compactions }), tone: 'normal' }] : []),
+        ...(unseen ? [{ id: 'unseen', text: t('screen.footer.unseen', { count: unseen }), tone: 'normal' }] : []),
+    ];
+}
+const joined = (segments) => segments.map(segment => segment.text).join(SEPARATOR);
+/** The status row at `width` columns: never wider, never more than one row, the protected segments always present. */
+export function statusBar(input) {
+    const width = Math.max(0, Math.floor(Number(input.width) || 0));
+    let current = segmentsOf(input);
+    const fits = () => displayWidth(joined(current)) <= width;
+    for (const step of DROP_ORDER) {
+        if (fits())
+            break;
+        if (step === 'context-window') {
+            current = current.map(segment => segment.id === 'context' && segment.short ? { ...segment, text: segment.short } : segment);
+            continue;
+        }
+        if (step === 'model') {
+            const model = current.find(segment => segment.id === 'model');
+            if (!model?.model)
+                continue;
+            const others = current.filter(segment => segment !== model);
+            const room = width - displayWidth(joined(others)) - (others.length ? SEPARATOR.length : 0) - displayWidth(t('screen.statusbar.model', { model: '' }));
+            current = room >= MODEL_MIN ? current.map(segment => segment === model ? { ...segment, text: t('screen.statusbar.model', { model: truncateMiddle(model.model, room) }) } : segment) : others;
+            continue;
+        }
+        current = current.filter(segment => segment.id !== step);
+    }
+    const segments = current.map(({ id, text, tone }) => ({ id, text, tone }));
+    return { text: truncateDisplay(joined(segments), width), segments };
+}

package/dist/tui/status-view.js

@@ -0,0 +1,40 @@
+/*
+ * R5b D7 (owner decision Q-R5-17): what `/status` adds to its R4 block — the sandbox verdict, the permission rules counted
+ * in each scope's own file, the open tasks and the notes, and the session's usage in the status bar's own words. A fact
+ * that could not be read says so; nothing is shown as zero because it was not measured.
+ */
+import { t } from "../i18n/index.js";
+import { readConfigScope } from "../config/load.js";
+import { statusBar } from "./status-bar.js";
+const size = (value) => Array.isArray(value) ? value.length : 0;
+export async function permissionRuleCounts({ paths, projectRoot }) {
+    try {
+        const count = async (scope) => { const rules = (await readConfigScope({ paths, projectRoot, scope })).permissions; return { allow: size(rules?.allow), ask: size(rules?.ask), deny: size(rules?.deny) }; };
+        const [user, project, projectUser] = await Promise.all([count('user'), count('project'), count('project-user')]);
+        return { user, project, projectUser };
+    }
+    catch {
+        return null;
+    }
+}
+/** The usage segments of the status bar (tokens, cache, context, cost, compactions), unshortened, in one line. */
+export function usageLine(snapshot, model) {
+    if (!snapshot)
+        return null;
+    const parts = statusBar({ snapshot, model, width: 10_000, safety: { fullAccess: false, noSandbox: false } }).segments.filter(row => ['tokens', 'cached', 'context', 'cost', 'compactions'].includes(row.id)).map(row => row.text);
+    return parts.length ? parts.join(' · ') : null;
+}
+export function statusFactLines(facts) {
+    const lines = [t(facts.sandbox === true ? 'screen.status.sandboxVerified' : facts.sandbox === false ? 'screen.status.sandboxNone' : 'screen.status.sandboxUnknown')];
+    if (!facts.rules)
+        lines.push(t('screen.status.rulesUnknown'));
+    else {
+        const total = (row) => row.allow + row.ask + row.deny;
+        const { user, project, projectUser } = facts.rules;
+        const all = { allow: user.allow + project.allow + projectUser.allow, ask: user.ask + project.ask + projectUser.ask, deny: user.deny + project.deny + projectUser.deny };
+        lines.push(total(all) === 0 ? t('screen.status.rulesNone') : t('screen.status.rules', { ...all, user: total(user), project: total(project), projectUser: total(projectUser) }));
+    }
+    lines.push(facts.work ? t('screen.status.work', facts.work) : t('screen.status.workUnknown'));
+    lines.push(facts.usage ? t('screen.status.usage', { usage: facts.usage }) : t('screen.status.usageNone'));
+    return lines;
+}

package/dist/tui/terminal-capabilities.js

@@ -0,0 +1,9 @@
+export function detectTerminalCapabilities({ stdinIsTTY, stdoutIsTTY, color, env }) {
+    const interactive = stdinIsTTY && stdoutIsTTY;
+    const dumb = env.TERM === 'dumb';
+    const noColor = typeof env.NO_COLOR === 'string' && env.NO_COLOR.length > 0;
+    const reduced = env.TALOS_REDUCED_MOTION === '1' || env.TALOS_REDUCED_MOTION === 'true';
+    const unicode = interactive && !dumb;
+    const effectiveColor = interactive && !dumb && color && !noColor;
+    return { interactive, color: effectiveColor, motion: effectiveColor && !reduced, unicode };
+}

package/dist/tui/terminal-session.js

@@ -0,0 +1,11 @@
+export function createTerminalSessionPlan({ capabilities, env, supportsAlternateScreen = true, }) {
+    if (!capabilities.interactive)
+        return { mode: 'plain', alternateScreen: false, paintBackground: false, fallbackReason: 'non-interactive' };
+    if (env.TERM === 'dumb')
+        return { mode: 'plain', alternateScreen: false, paintBackground: false, fallbackReason: 'term-dumb' };
+    if (!supportsAlternateScreen)
+        return { mode: 'plain', alternateScreen: false, paintBackground: false, fallbackReason: 'alternate-screen-unavailable' };
+    if (!capabilities.color)
+        return { mode: 'mono', alternateScreen: true, paintBackground: false, fallbackReason: null };
+    return { mode: 'full', alternateScreen: true, paintBackground: true, fallbackReason: null };
+}

package/dist/tui/text-width.js

@@ -0,0 +1,66 @@
+/* R1 gate E4/E16: TALOS measures text with the SAME function Ink 7.1.1 uses to lay it out (`string-width` 8.2.2, the
+   one copy in the lockfile, hoisted beside Ink). The hand-rolled table this replaces disagreed with Ink on 17 of 63
+   fixtures (SGR, tabs, ZWSP, flags, text-presentation symbols ☺ ⚠ © ™ ✔ ▶, combining marks, controls), and a row
+   count computed with one width and rendered with another is how a frame overflows (review D-02/D-04).
+   It is imported here, not declared in package.json, per the lane rule "no new dependency"; see the lane hand-back. */
+import stringWidth from 'string-width';
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+export function splitGraphemes(text) { return [...segmenter.segment(text)].map(x => x.segment); }
+export function displayWidth(text) { return stringWidth(String(text)); }
+export function truncateDisplay(text, width) { if (displayWidth(text) <= width)
+    return text; if (width <= 1)
+    return '…'; let out = '', used = 0; for (const g of splitGraphemes(text)) {
+    const w = displayWidth(g);
+    if (used + w + 1 > width)
+        break;
+    out += g;
+    used += w;
+} return `${out}…`; }
+/* Keeps both ends of a long value (a workspace path): the tail says which folder, the head says which drive/root. */
+export function truncateMiddle(text, width) {
+    if (displayWidth(text) <= width)
+        return text;
+    if (width <= 1)
+        return '…';
+    const graphemes = splitGraphemes(text);
+    const budget = width - 1;
+    let head = '', tail = '', used = 0, left = 0, right = graphemes.length - 1;
+    while (left <= right) {
+        const takeTail = displayWidth(tail) <= displayWidth(head);
+        const g = takeTail ? graphemes[right] : graphemes[left];
+        const w = displayWidth(g);
+        if (used + w > budget)
+            break;
+        used += w;
+        if (takeTail) {
+            tail = g + tail;
+            right--;
+        }
+        else {
+            head += g;
+            left++;
+        }
+    }
+    return `${head}…${tail}`;
+}
+/* Hard-wraps text into rows of at most `width` columns by grapheme, the way a terminal fills cells. Used where TALOS
+   owns the line breaks itself (the composer, chrome), so the row count is exact before render (E4). */
+export function wrapDisplay(text, width) {
+    const limit = Math.max(1, Math.floor(width));
+    const rows = [];
+    for (const line of String(text).split('\n')) {
+        let row = '', used = 0;
+        for (const g of splitGraphemes(line)) {
+            const w = displayWidth(g);
+            if (used + w > limit && row !== '') {
+                rows.push(row);
+                row = '';
+                used = 0;
+            }
+            row += g;
+            used += w;
+        }
+        rows.push(row);
+    }
+    return rows;
+}

package/dist/tui/theme-catalog.js

@@ -0,0 +1,27 @@
+/** `color-mix(in srgb, a amount%, b)` for #rrggbb. */
+export function mixHex(a, amount, b) {
+    const parse = (hex) => [1, 3, 5].map(i => parseInt(hex.slice(i, i + 2), 16));
+    const [x, y] = [parse(a), parse(b)];
+    const t = Math.max(0, Math.min(100, amount)) / 100;
+    return `#${x.map((v, i) => Math.round(v * t + y[i] * (1 - t)).toString(16).padStart(2, '0')).join('')}`;
+}
+const theme = (id, label, accent, background) => ({ id, label, accent, background, muted: mixHex(accent, 62, background) });
+/* P15 (owner, 2026-09-25, "vorrei mettere forge come tema principale di default"): Forge is the default from 0.2.0. A theme
+   the person chose stays theirs (it is in their configuration); the legacy migrations keep mapping to what they mapped to. */
+export const DEFAULT_THEME_ACCENT = 'forge';
+export const TALOS_THEME_ACCENTS = Object.freeze([
+    theme('calm', 'Calm', '#c08b3c', '#1e1f22'),
+    theme('forge', 'Forge', '#c98b32', '#080b11'),
+    theme('terminal', 'Terminal', '#63f08e', '#020403'),
+    theme('aurora', 'Aurora', '#42e7c7', '#071113'),
+    theme('ember', 'Ember', '#ff5c62', '#10090a'),
+    theme('atlas', 'Atlas', '#d49a52', '#07101f'),
+    theme('noir', 'Noir', '#f2f2f2', '#050505'),
+    theme('signal', 'Signal', '#ff6f61', '#091011'),
+    theme('violet', 'Violet', '#b794f6', '#0d0a19'),
+    theme('telemetry', 'Telemetry', '#6ad4d4', '#0b0f11'),
+]);
+export function isThemeAccentId(id) { return TALOS_THEME_ACCENTS.some(row => row.id === id); }
+export function themeAccent(id) {
+    return TALOS_THEME_ACCENTS.find(row => row.id === id) ?? TALOS_THEME_ACCENTS.find(row => row.id === DEFAULT_THEME_ACCENT);
+}

package/dist/tui/theme-store.js

@@ -0,0 +1,23 @@
+import { createTuiTheme } from "./theme.js";
+import { DEFAULT_THEME_ACCENT, TALOS_THEME_ACCENTS, isThemeAccentId } from "./theme-catalog.js";
+/** What /theme offers, in the product's order, mono last. */
+export const THEME_CHOICES = Object.freeze([...TALOS_THEME_ACCENTS.map(row => row.id), 'mono']);
+export function parseThemeChoice(value) {
+    const id = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return THEME_CHOICES.includes(id) ? id : null;
+}
+export function liveTheme(base, id) {
+    const capabilities = id === 'mono' ? { ...base, color: false, motion: false } : base;
+    return { id, capabilities, theme: createTuiTheme(capabilities, isThemeAccentId(id) ? id : DEFAULT_THEME_ACCENT) };
+}
+export function createThemeStore(base, id = DEFAULT_THEME_ACCENT) {
+    let snapshot = liveTheme(base, id);
+    const listeners = new Set();
+    return {
+        getSnapshot: () => snapshot,
+        subscribe(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
+        set(next) { if (next === snapshot.id)
+            return; snapshot = liveTheme(base, next); for (const listener of [...listeners])
+            listener(); },
+    };
+}

package/dist/tui/theme.js

@@ -0,0 +1,23 @@
+import { DEFAULT_THEME_ACCENT, themeAccent } from "./theme-catalog.js";
+export function createTuiTheme(c, accentId = DEFAULT_THEME_ACCENT) {
+    const accent = themeAccent(accentId);
+    return {
+        id: accent.id,
+        colors: c.color ? {
+            background: accent.background,
+            foreground: '#F5F5F4',
+            accent: accent.accent,
+            muted: accent.muted,
+            success: '#34D399',
+            warning: '#FBBF24',
+            danger: '#FB7185',
+        } : {},
+        glyphs: c.unicode
+            ? { spinner: ['⠋', '⠙', '⠹', '⠸'], success: '✓', error: '!', branch: '├', bullet: '•' }
+            : { spinner: ['-', '\\', '|', '/'], success: 'OK', error: '!', branch: '+', bullet: '*' },
+    };
+}
+const SURFACE_COLOR = {
+    boot: 'accent', transcript: 'accent', picker: 'accent', approval: 'warning', tool: 'success', footer: 'muted',
+};
+export function themeColor(theme, surface) { return theme.colors[SURFACE_COLOR[surface]]; }

package/dist/tui/tool-display.js

@@ -0,0 +1,135 @@
+/*
+ * R2 CONTRACT (owner: lane T). The ONE table that turns a kernel tool name into what the screen shows (Q-R2-3, gate
+ * E3), zipped once on the kernel name as Qwen zips `ToolNames` with `ToolDisplayNames` (`cli/src/ui/utils/
+ * tool-display-map.ts:12-24`, 2026-09-06). Every surface reads it: transcript rows and renderer lookup (tools/registry.ts),
+ * approval title and summary (overlays/approval-dialog.ts), permission mapping (security/from-approval.ts). The model
+ * keeps the kernel names and argument keys (gate E2): this file maps for display and never renames what it receives.
+ *
+ * The 46 rows are the kernel's own tools, measured, not remembered: `ATTREZZI` (talosHarness.mjs:1571-1741, 7 tools),
+ * `ATTREZZI_ESTESI` (:1829-2806, 38 tools) and `carica_skill` (:7603-7612), 53 distinct argument keys — the gate's §1.3
+ * count. test/i18n/tools-labels.test.ts imports those schemas and fails on a tool or key without a row here.
+ */
+import { en } from "../i18n/en.js";
+import { t } from "../i18n/index.js";
+const row = (permission, renderer, ...primary) => ({ permission, renderer, primary });
+/*
+ * `permission` is the tool the permission engine judges the call as (security/types.ts). The kernel asks for approval on
+ * 30 of them (`verificaPermessoConBarriera`, talosHarness.mjs:8166-9714): reads are Read, the two file writers Write (a
+ * write judged as Read was ALLOWED inside the project without asking, evaluate.ts:130 — review E-07), the targeted edit
+ * Edit, the two command runners Bash, the web tools WebFetch; TALOS's own services are TalosService with the kernel
+ * name as operation. `primary` lists the argument keys whose value stands beside the label, first present wins.
+ */
+const TABLE = {
+    elenca: row('Read', 'list', 'percorso'),
+    cerca: row('Read', 'search', 'testo', 'nome'),
+    leggi: row('Read', 'read', 'percorso'),
+    scrivi: row('Write', 'write', 'percorso'),
+    prova: row('Bash', 'bash'),
+    shell: row('Bash', 'bash', 'comando'),
+    naviga: row('WebFetch', 'generic', 'url'),
+    web_search: row('WebFetch', 'generic', 'query'),
+    artifact_create: row('TalosService', 'generic', 'titolo'),
+    document_create: row('TalosService', 'generic', 'title'),
+    time_now: row('TalosService', 'generic'),
+    delega_sottotask: row('TalosService', 'generic', 'task'),
+    generate_image: row('TalosService', 'generic', 'prompt'),
+    library_list: row('TalosService', 'generic'),
+    library_search: row('TalosService', 'generic', 'query'),
+    library_read: row('TalosService', 'generic', 'id'),
+    library_file_origin: row('TalosService', 'generic', 'id'),
+    library_rename: row('TalosService', 'generic', 'name', 'id'),
+    library_delete: row('TalosService', 'generic', 'id'),
+    library_export: row('TalosService', 'generic', 'reference'),
+    library_context_policy_update: row('TalosService', 'generic', 'action'),
+    notes_list: row('TalosService', 'generic'),
+    notes_create: row('TalosService', 'generic', 'title'),
+    notes_update: row('TalosService', 'generic', 'title', 'id'),
+    notes_delete: row('TalosService', 'generic', 'id'),
+    tasks_list: row('TalosService', 'generic', 'status'),
+    tasks_create: row('TalosService', 'generic', 'title'),
+    tasks_complete: row('TalosService', 'generic', 'id'),
+    tasks_update: row('TalosService', 'generic', 'title', 'id'),
+    tasks_delete: row('TalosService', 'generic', 'id'),
+    memory_search: row('TalosService', 'generic', 'query'),
+    memory_write: row('TalosService', 'generic', 'title'),
+    memory_update: row('TalosService', 'generic', 'title', 'id'),
+    memory_delete: row('TalosService', 'generic', 'id'),
+    research_list: row('TalosService', 'generic', 'status'),
+    research_start: row('TalosService', 'generic', 'question'),
+    research_read: row('TalosService', 'generic', 'id'),
+    research_rename: row('TalosService', 'generic', 'title', 'id'),
+    research_pause: row('TalosService', 'generic', 'id'),
+    research_resume: row('TalosService', 'generic', 'id'),
+    research_cancel: row('TalosService', 'generic', 'id'),
+    research_delete: row('TalosService', 'generic', 'id'),
+    research_deposit: row('Write', 'generic'),
+    tool_create: row('TalosService', 'generic', 'title'),
+    file_edit: row('Edit', 'edit', 'percorso'),
+    carica_skill: row('TalosService', 'generic', 'nome'),
+};
+export const KERNEL_TOOL_NAMES = Object.freeze(Object.keys(TABLE));
+const WORDS_COMPLETE = true;
+void WORDS_COMPLETE;
+export function isKernelTool(name) { return typeof name === 'string' && Object.hasOwn(TABLE, name); }
+export function rendererKindFor(name) { return isKernelTool(name) ? TABLE[name].renderer : 'generic'; }
+/* A tool the kernel did not declare is named by whoever wrote it: an MCP server (`mcp__<server>__<tool>`,
+   harness-ui/src/mcp-session.mjs:47), a plugin (`plugin__<plugin>__<tool>`, plugin-session.mjs:52), the Tool Forge
+   (`forge_<id>`, forge-contract.mjs:127), or anything else. Their parts are split by these exact prefixes. */
+export function externalToolParts(name) {
+    for (const kind of ['mcp', 'plugin']) {
+        const prefix = `${kind}__`;
+        if (!name.startsWith(prefix))
+            continue;
+        const rest = name.slice(prefix.length), split = rest.indexOf('__');
+        if (split > 0 && split < rest.length - 2)
+            return { kind, owner: rest.slice(0, split), tool: rest.slice(split + 2) };
+    }
+    if (name.startsWith('forge_') && name.length > 6)
+        return { kind: 'forge', owner: null, tool: name.slice(6) };
+    return null;
+}
+/** snake_case, kebab-case and camelCase → lower-case words. */
+function words(name) { return name.replace(/([a-z0-9])([A-Z])/gu, '$1 $2').replace(/[_\-.\s]+/gu, ' ').trim().toLowerCase(); }
+function capitalised(text) { return text ? text[0].toUpperCase() + text.slice(1) : text; }
+function permissionOfExternal(name) { const parts = externalToolParts(name); return parts?.kind === 'mcp' ? 'Mcp' : parts?.kind === 'plugin' ? 'Plugin' : 'TalosService'; }
+/** The permission tool the engine judges this tool as: from the table, or from the external prefix. */
+export function permissionToolFor(name) { return isKernelTool(name) ? TABLE[name].permission : permissionOfExternal(name); }
+/** The English label of an argument key: the dictionary's when it has one, otherwise the key in words. */
+export function argumentLabel(key) { const id = `tool.arg.${key}`; return Object.hasOwn(en, id) ? t(id) : words(key); }
+/* Keys an unknown tool's primary argument is looked for under (Hermes `_PRIMARY_ARGS`, agent/display.py:353-361, 2026-09-22). */
+const EXTERNAL_PRIMARY = ['path', 'file_path', 'file', 'url', 'query', 'command', 'pattern', 'name', 'title', 'id'];
+function primaryValue(keys, args) {
+    if (!args)
+        return null;
+    for (const key of keys) {
+        const value = args[key];
+        if ((typeof value === 'string' && value.trim() !== '') || typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+    }
+    return null;
+}
+function externalLabel(name) {
+    const parts = externalToolParts(name);
+    if (parts?.kind === 'mcp')
+        return t('tool.mcp.label', { tool: capitalised(words(parts.tool)), server: parts.owner });
+    if (parts?.kind === 'plugin')
+        return t('tool.plugin.label', { tool: capitalised(words(parts.tool)), plugin: parts.owner });
+    if (parts?.kind === 'forge')
+        return t('tool.forge.label', { tool: capitalised(words(parts.tool)) });
+    return capitalised(words(name)) || t('tool.unknown.label');
+}
+/**
+ * What the screen shows for a tool call: the English label and verb, the VALUE of its primary argument when `args` is
+ * given (null when absent or not a plain value), the permission tool it is judged as, and the raw kernel name, which
+ * only an expanded detail shows (Q-R2-3).
+ */
+export function toolDisplay(kernelName, args) {
+    if (isKernelTool(kernelName)) {
+        const entry = TABLE[kernelName];
+        return { label: t(`tool.${kernelName}.label`), verb: t(`tool.${kernelName}.verb`), primaryArg: primaryValue(entry.primary, args), permissionTool: entry.permission, raw: kernelName };
+    }
+    const label = externalLabel(kernelName);
+    return { label, verb: t('tool.unknown.verb', { tool: label }), primaryArg: primaryValue(EXTERNAL_PRIMARY, args), permissionTool: permissionOfExternal(kernelName), raw: kernelName };
+}
+/** The argument keys a tool's primary value is read from, in order (the table's `primary`; R3 renderers read it too). */
+export function primaryArgumentKeys(kernelName) { return isKernelTool(kernelName) ? TABLE[kernelName].primary : EXTERNAL_PRIMARY; }

package/dist/tui/tool-facts.js

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

package/dist/tui/tools/bash-renderer.js

@@ -0,0 +1,32 @@
+import { boundedLines, detailWidth, formatDuration, moreLines, outputTail, outputText, parseArgs, sanitizeDisplayText, withoutKernelExitLine } from "./shared.js";
+import { truncateDisplay } from "../text-width.js";
+import { t } from "../../i18n/index.js";
+/* R2 lane T: the kernel's `shell` sends `comando` and the model's own `descrizione` ("shown to the person watching",
+   talosHarness.mjs:1702-1720), which leads the detail; `prova` sends no argument at all.
+   R3 (Q-R3-10): the output is a TAIL — the last 5 lines (errors are at the end), 40 in the expanded view — with the lines
+   above it counted. While the command runs, the live tail ends with `+N lines · T s`; a sandboxed command streams
+   nothing today (brokered-executor.ts:343-352), so its row says `running T s` and the output arrives at the end.
+   The kernel's `exit N [sandbox: …]` first line is hidden (shared.ts, gate E3); a person's `!` command is labelled `!`. */
+const TAIL = 5, TAIL_EXPANDED = 40;
+export const renderBash = (row, context) => {
+    const a = parseArgs(row);
+    const command = String(a.comando ?? a.command ?? a.cmd ?? a.raw ?? '').trim();
+    const description = typeof a.descrizione === 'string' ? a.descrizione.trim() : typeof a.description === 'string' ? a.description.trim() : '';
+    const detail = description ? boundedLines(description, context.width, context.expanded ? 4 : 1) : [];
+    const live = row.status === 'queued' || row.status === 'running' || row.status === 'streaming';
+    let liveTail = false;
+    if (row.status !== 'denied') {
+        const tail = outputTail(live ? row.liveOutput : withoutKernelExitLine(outputText(row)), context.expanded ? TAIL_EXPANDED : TAIL);
+        detail.push(...tail.lines.map(line => truncateDisplay(sanitizeDisplayText(line), detailWidth(context.width)) || ' '));
+        const summary = tail.hidden > 0 ? [moreLines(tail.hidden, tail.atLeast)] : [];
+        if (live && tail.lines.length) {
+            liveTail = true;
+            const elapsed = row.startedAt === null ? 0 : Math.max(0, context.now - row.startedAt);
+            if (elapsed >= 1000)
+                summary.push(formatDuration(elapsed));
+        }
+        if (summary.length)
+            detail.push(summary.join(' · '));
+    }
+    return { ...(row.origin === 'person' ? { label: t('tool.person.label') } : {}), target: command, result: [], detail, command: true, showsOutput: true, liveTail };
+};

package/dist/tui/tools/change.js

@@ -0,0 +1,61 @@
+/*
+ * R3 lane RD (Q-R3-4, gate E10): a write or edit row reads its change through the ONE line diff (line-diff.ts). A row is
+ * drawn many times (every frame, every height estimate), so a file change is diffed once per change object and a pair
+ * of edit fragments once per text (bounded cache); the expanded view renders the model with components/diff.ts.
+ */
+import { t, tn } from "../../i18n/index.js";
+import { renderDiffModel } from "../components/diff.js";
+import { lineDiff } from "../line-diff.js";
+import { lineCount } from "./shared.js";
+const DIFFS = new WeakMap();
+export function changeDiff(change) {
+    let diff = DIFFS.get(change);
+    if (!diff) {
+        diff = lineDiff(change.before, change.after, { path: change.path });
+        DIFFS.set(change, diff);
+    }
+    return diff;
+}
+export function summarizeChange(change) {
+    const diff = changeDiff(change);
+    return { newFile: change.before === null, lines: lineCount(change.after), added: diff.approximate ? null : diff.added, removed: diff.approximate ? null : diff.removed };
+}
+export function changeSummaryOf(row) { return row.changeSummary ?? (row.change ? summarizeChange(row.change) : null); }
+/** The result facts of a change: `new file · N lines`, `+a −r`, or `N lines` when it was too large to compare. */
+export function resultOfChange(summary) {
+    if (summary.newFile)
+        return [t('tool.result.newFile'), tn('tool.result.lines', summary.lines)];
+    if (summary.added === null || summary.removed === null)
+        return [tn('tool.result.lines', summary.lines)];
+    return [t('tool.result.changes', { added: summary.added, removed: summary.removed })];
+}
+/* Edit fragments are small; the cache keeps the last few pairs so a redraw does not diff again. */
+const FRAGMENTS = new Map();
+const FRAGMENT_CACHE = 64, FRAGMENT_KEY_MAX = 64 * 1024;
+/** The diff of an edit's two fragments: their line numbers are not the file's, so none is claimed (no numbers, no `@@`).
+ *  A fragment is a piece of a line-ended file, so both get a final line break before diffing: `line` and `line\n` are the
+ *  same line here (for a whole file jsdiff, like git, rightly tells them apart). */
+const lineEnded = (text) => text === '' || text.endsWith('\n') ? text : text + '\n';
+export function fragmentDiff(oldText, newText, path) {
+    const key = oldText.length + newText.length <= FRAGMENT_KEY_MAX ? `${path}\u0000${oldText}\u0000${newText}` : null;
+    const cached = key === null ? undefined : FRAGMENTS.get(key);
+    if (cached)
+        return cached;
+    const diff = lineDiff(lineEnded(oldText), lineEnded(newText), { path });
+    const model = { ...diff.model, files: diff.model.files.map(file => ({ ...file, rows: file.rows.filter(row => row.kind !== 'hunk').map(row => ({ ...row, oldLine: null, newLine: null })) })) };
+    const result = { ...diff, model };
+    if (key !== null) {
+        FRAGMENTS.set(key, result);
+        if (FRAGMENTS.size > FRAGMENT_CACHE)
+            FRAGMENTS.delete(FRAGMENTS.keys().next().value);
+    }
+    return result;
+}
+/* The expanded view of a change is bounded like every other detail: the first lines of the diff, then how many more. */
+const MAX_DIFF_LINES = 400;
+export function diffDetail(diff, width) {
+    const lines = renderDiffModel(diff.model, width).lines.filter(line => line.kind !== 'file').map(line => line.text);
+    if (lines.length <= MAX_DIFF_LINES)
+        return lines;
+    return [...lines.slice(0, MAX_DIFF_LINES), tn('tool.diff.more', lines.length - MAX_DIFF_LINES)];
+}

package/dist/tui/tools/edit-renderer.js

@@ -0,0 +1,17 @@
+import { parseArgs } from "./shared.js";
+import { changeDiff, changeSummaryOf, diffDetail, fragmentDiff, resultOfChange } from "./change.js";
+import { t } from "../../i18n/index.js";
+/* R2 lane T: the kernel's `file_edit` sends `percorso`, `old_string`, `new_string` (talosHarness.mjs:2786-2806).
+   R3 (Q-R3-4, gate E10): `+a −r` from the ONE line diff (line-diff.ts, jsdiff) — of the whole file when the kernel reported
+   the change (`file.changed`), of the two fragments before that. The multiset count that stood here is gone: it saw a
+   moved line as no change and an edit of one of two identical lines as nothing (gate §3.1). */
+export const renderEdit = (row, context) => {
+    const a = parseArgs(row);
+    const path = String(a.percorso ?? a.path ?? a.file ?? '').trim();
+    const oldText = String(a.oldText ?? a.old_string ?? a.before ?? ''), newText = String(a.newText ?? a.new_string ?? a.after ?? '');
+    const summary = changeSummaryOf(row);
+    const fragment = summary && summary.added !== null ? null : fragmentDiff(oldText, newText, path);
+    const result = fragment ? [t('tool.result.changes', { added: fragment.added, removed: fragment.removed })] : resultOfChange(summary);
+    const detail = !context.expanded ? [] : diffDetail(row.change ? changeDiff(row.change) : fragment ?? fragmentDiff(oldText, newText, path), context.width);
+    return { target: path, result, detail };
+};

package/dist/tui/tools/generic-renderer.js

@@ -0,0 +1,13 @@
+import { argumentLine, boundedLines, outputText, parseArgs } from "./shared.js";
+import { primaryArgumentKeys, toolDisplay } from "../tool-display.js";
+/* R2 lane T (review D-07, Q-R2-3): the title is the English label and the primary argument's value; every other argument
+   is one `label: value` line, a structure counted and never printed as JSON. R3: a refused call shows its reason, not
+   its output (row-format.ts). */
+export const renderGeneric = (row, context) => {
+    const a = parseArgs(row);
+    const view = toolDisplay(row.name, a);
+    const primaryKey = view.primaryArg === null ? null : primaryArgumentKeys(row.name).find(key => a[key] !== undefined && String(a[key]) === view.primaryArg) ?? null;
+    const argLines = Object.entries(a).filter(([key]) => key !== primaryKey).map(([key, value]) => argumentLine(key, value));
+    const details = [...boundedLines(argLines.join('\n'), context.width, context.expanded ? 12 : 2), ...(row.status === 'denied' ? [] : boundedLines(outputText(row), context.width, context.expanded ? 12 : 3))];
+    return { target: view.primaryArg ?? '', result: [], detail: details, showsOutput: true };
+};

package/dist/tui/tools/list-renderer.js

@@ -0,0 +1,14 @@
+import { boundedLines, outputText, parseArgs } from "./shared.js";
+import { tn } from "../../i18n/index.js";
+/* R3 (Q-R3-1, gate §2.3): `List folder <path> · N entries`. The kernel's `elenca` (elencaDaCartella,
+   talosHarness.mjs:3487) answers one path per line, `no files and no folders. …` for an empty folder, and a sentence for a
+   folder it cannot read or a refusal; those exact shapes are pinned by r3-rd-tool-rows.test.ts, anything else gets no count. */
+const EMPTY = /^no files and no folders\. /u;
+const NOT_COUNTED = /^REFUSED\. | is not a readable folder of this workspace\. /u;
+export const renderList = (row, context) => {
+    const a = parseArgs(row);
+    const path = String(a.percorso ?? a.path ?? a.folder ?? a.raw ?? '').trim();
+    const text = outputText(row).trim();
+    const count = EMPTY.test(text) ? 0 : NOT_COUNTED.test(text) ? null : text.split(/\r?\n/u).filter(line => line.trim()).length;
+    return { target: path, result: count === null ? [] : [tn('tool.result.entries', count)], detail: row.status === 'denied' || count === 0 ? [] : boundedLines(text, context.width, context.expanded ? 12 : 3), showsOutput: true };
+};

package/dist/tui/tools/read-renderer.js

@@ -0,0 +1,13 @@
+import { lineCount, parseArgs } from "./shared.js";
+import { t, tn } from "../../i18n/index.js";
+/* R2 lane T: the kernel's `leggi` sends `percorso` (talosHarness.mjs:1601-1608); the English spellings stay accepted.
+   R3 (Q-R3-1): the row says what was read — `N lines` of the content returned, or the range the call asked for. */
+export const renderRead = row => {
+    const a = parseArgs(row);
+    const path = String(a.percorso ?? a.path ?? a.file ?? a.filename ?? a.raw ?? '').trim();
+    const offset = Number.isFinite(a.offset) ? Number(a.offset) : Number.isFinite(a.start) ? Number(a.start) : 1;
+    const limit = Number.isFinite(a.limit) ? Number(a.limit) : Number.isFinite(a.lines) ? Number(a.lines) : null;
+    const count = tn('tool.result.lines', lineCount(row.finalOutput));
+    const result = limit !== null ? [t('tool.read.lines', { from: offset, to: offset + Math.max(0, limit - 1) })] : offset > 1 ? [t('tool.read.from', { from: offset }), count] : [count];
+    return { target: path, result, detail: [] };
+};