talos-code 0.0.1 → 0.2.0

package/dist/i18n/en/tools.js

@@ -0,0 +1,127 @@
+/*
+ * R2 lane T: tool labels and argument labels shown on screen (gate E3, Q-R2-3). Ids are keyed by the KERNEL name
+ * (`tool.<kernel>.label`), because the kernel name is the key the table is zipped on; the values are the only words the
+ * screen shows. The model keeps the kernel names and argument keys (gate E2): nothing here is sent to it.
+ */
+export const tools = {
+    'tool.unknown.label': 'Tool',
+    'tool.mcp.label': '{tool} ({server} MCP)',
+    'tool.plugin.label': '{tool} ({plugin} plugin)',
+    'tool.forge.label': '{tool} (forged tool)',
+    'tool.unknown.verb': 'Running {tool}',
+    'tool.elenca.label': 'List folder', 'tool.elenca.verb': 'Listing',
+    'tool.cerca.label': 'Search files', 'tool.cerca.verb': 'Searching',
+    'tool.leggi.label': 'Read file', 'tool.leggi.verb': 'Reading',
+    'tool.scrivi.label': 'Write file', 'tool.scrivi.verb': 'Writing',
+    'tool.prova.label': 'Run tests', 'tool.prova.verb': 'Running tests',
+    'tool.shell.label': 'Shell', 'tool.shell.verb': 'Running',
+    'tool.naviga.label': 'Fetch web page', 'tool.naviga.verb': 'Fetching',
+    'tool.web_search.label': 'Web search', 'tool.web_search.verb': 'Searching the web',
+    'tool.artifact_create.label': 'Create artifact', 'tool.artifact_create.verb': 'Creating artifact',
+    'tool.document_create.label': 'Create document', 'tool.document_create.verb': 'Creating document',
+    'tool.time_now.label': 'Current time', 'tool.time_now.verb': 'Checking the time',
+    'tool.delega_sottotask.label': 'Delegate subtask', 'tool.delega_sottotask.verb': 'Delegating',
+    'tool.generate_image.label': 'Generate image', 'tool.generate_image.verb': 'Generating image',
+    'tool.library_list.label': 'List library', 'tool.library_list.verb': 'Listing library',
+    'tool.library_search.label': 'Search library', 'tool.library_search.verb': 'Searching library',
+    'tool.library_read.label': 'Read library file', 'tool.library_read.verb': 'Reading library file',
+    'tool.library_file_origin.label': 'Library file origin', 'tool.library_file_origin.verb': 'Checking file origin',
+    'tool.library_rename.label': 'Rename library file', 'tool.library_rename.verb': 'Renaming library file',
+    'tool.library_delete.label': 'Delete library file', 'tool.library_delete.verb': 'Deleting library file',
+    'tool.library_export.label': 'Export library file', 'tool.library_export.verb': 'Exporting library file',
+    'tool.library_context_policy_update.label': 'Update library policy', 'tool.library_context_policy_update.verb': 'Updating library policy',
+    'tool.notes_list.label': 'List notes', 'tool.notes_list.verb': 'Listing notes',
+    'tool.notes_create.label': 'Create note', 'tool.notes_create.verb': 'Creating note',
+    'tool.notes_update.label': 'Update note', 'tool.notes_update.verb': 'Updating note',
+    'tool.notes_delete.label': 'Delete note', 'tool.notes_delete.verb': 'Deleting note',
+    'tool.tasks_list.label': 'List tasks', 'tool.tasks_list.verb': 'Listing tasks',
+    'tool.tasks_create.label': 'Create task', 'tool.tasks_create.verb': 'Creating task',
+    'tool.tasks_complete.label': 'Set task status', 'tool.tasks_complete.verb': 'Setting task status',
+    'tool.tasks_update.label': 'Update task', 'tool.tasks_update.verb': 'Updating task',
+    'tool.tasks_delete.label': 'Delete task', 'tool.tasks_delete.verb': 'Deleting task',
+    'tool.memory_search.label': 'Search memory', 'tool.memory_search.verb': 'Searching memory',
+    'tool.memory_write.label': 'Save memory', 'tool.memory_write.verb': 'Saving memory',
+    'tool.memory_update.label': 'Update memory', 'tool.memory_update.verb': 'Updating memory',
+    'tool.memory_delete.label': 'Delete memory', 'tool.memory_delete.verb': 'Deleting memory',
+    'tool.research_list.label': 'List research', 'tool.research_list.verb': 'Listing research',
+    'tool.research_start.label': 'Start research', 'tool.research_start.verb': 'Starting research',
+    'tool.research_read.label': 'Read research', 'tool.research_read.verb': 'Reading research',
+    'tool.research_rename.label': 'Rename research', 'tool.research_rename.verb': 'Renaming research',
+    'tool.research_pause.label': 'Pause research', 'tool.research_pause.verb': 'Pausing research',
+    'tool.research_resume.label': 'Resume research', 'tool.research_resume.verb': 'Resuming research',
+    'tool.research_cancel.label': 'Cancel research', 'tool.research_cancel.verb': 'Cancelling research',
+    'tool.research_delete.label': 'Delete research', 'tool.research_delete.verb': 'Deleting research',
+    'tool.research_deposit.label': 'Submit research report', 'tool.research_deposit.verb': 'Submitting research report',
+    'tool.tool_create.label': 'Create tool', 'tool.tool_create.verb': 'Creating tool',
+    'tool.file_edit.label': 'Edit file', 'tool.file_edit.verb': 'Editing',
+    'tool.carica_skill.label': 'Load skill', 'tool.carica_skill.verb': 'Loading skill',
+    /* The 11 Italian argument keys of gate §1.3, and the English keys whose code spelling is not a word. Any other key
+       is shown humanised (snake_case and camelCase → words). */
+    'tool.arg.percorso': 'path', 'tool.arg.contenuto': 'content', 'tool.arg.comando': 'command', 'tool.arg.descrizione': 'description',
+    'tool.arg.testo': 'text', 'tool.arg.nome': 'name', 'tool.arg.titolo': 'title', 'tool.arg.cartella': 'folder', 'tool.arg.parte': 'part',
+    'tool.arg.affermazioni': 'claims', 'tool.arg.fonti': 'sources',
+    'tool.arg.old_string': 'old text', 'tool.arg.new_string': 'new text', 'tool.arg.replace_all': 'replace all',
+    'tool.arg.maxResults': 'max results', 'tool.arg.html': 'HTML', 'tool.arg.url': 'URL', 'tool.arg.id': 'ID', 'tool.arg.ids': 'IDs',
+    'tool.arg.file_ids': 'file IDs', 'tool.arg.receipt_id': 'receipt ID', 'tool.arg.input_schema': 'input fields',
+    /* Summaries of values: a value is data and is shown as it is, except that a structure is counted, never printed. */
+    'tool.value.fields.one': '{count} field', 'tool.value.fields.other': '{count} fields',
+    'tool.value.bytes': '{bytes} bytes · {lines} lines',
+    'tool.value.empty': '(empty)',
+    'tool.detail.raw': 'tool id {name}',
+    'tool.read.lines': 'lines {from}–{to}', 'tool.read.from': 'from line {from}',
+    'tool.write.append': '{bytes} bytes · {lines} lines · appended',
+    'tool.search.results.one': '{count} result', 'tool.search.results.other': '{count} results',
+    /* R3 (owner Q-R3-1/2/3/4/10, gate E2/E6): the words of the ONE tool row `<Label> <target> · <isolation> · <why it ran> ·
+       <result> · <duration>`. A state other than done replaces the result and the duration with its word; the enum value
+       (`queued`, `streaming`, `cancelled`…) is never printed. */
+    'tool.state.running': 'running', 'tool.state.runningFor': 'running {duration}',
+    'tool.state.waiting': 'waiting for you',
+    'tool.state.done': 'done',
+    'tool.state.failed': 'failed',
+    'tool.state.denied': 'denied',
+    'tool.state.interrupted': 'interrupted', 'tool.state.interruptedAfter': 'interrupted after {duration}',
+    'tool.state.unknown': 'result unknown',
+    /* Why it ran (Q-R3-3), from the decision kinds of tool-facts.ts. */
+    'tool.why.typed': 'typed by you', 'tool.why.once': 'you allowed once', 'tool.why.session': 'you allowed for this session',
+    'tool.why.always': 'always allowed', 'tool.why.rule': 'allow: {rule}', 'tool.why.auto': 'auto', 'tool.why.accept-edits': 'accept edits',
+    'tool.why.full-access': 'Full access',
+    /* Isolation (E6): the CLI's own annotation words (screen.exec.isolation.*), without the backend; the glyph alone is what
+       a narrow row keeps (never dropped, Q-R3-1). */
+    'tool.isolation.sandbox': '⛉ sandbox', 'tool.isolation.sandbox.glyph': '⛉',
+    'tool.isolation.host': '⛶ host · not isolated', 'tool.isolation.host.glyph': '⛶',
+    /* A command the person typed at `!` is labelled by what they typed (gate §2.3). */
+    'tool.person.label': '!',
+    'tool.exit': 'exit {code}',
+    'tool.duration.seconds': '{seconds} s', 'tool.duration.minutes': '{minutes} min {seconds} s',
+    'tool.result.lines.one': '{count} line', 'tool.result.lines.other': '{count} lines',
+    'tool.result.entries.one': '{count} entry', 'tool.result.entries.other': '{count} entries',
+    'tool.result.newFile': 'new file', 'tool.result.appended': 'appended',
+    'tool.result.changes': '+{added} −{removed}',
+    /* Output of a command (Q-R3-10): the last lines are shown, the ones above them are counted. */
+    'tool.output.more.one': '+{count} line', 'tool.output.more.other': '+{count} lines',
+    'tool.diff.more.one': '… {count} more diff line', 'tool.diff.more.other': '… {count} more diff lines',
+    'tool.diff.tooLarge': 'This change is too large to compare line by line ({before} lines before, {after} lines after).',
+    'tool.transcript.truncated': '…[truncated in TUI]',
+    /* After a turn that did not end normally (Q-R3-8/9): one neutral line; the Run rows are gone. */
+    'tool.turn.interrupted': 'Interrupted', 'tool.turn.interruptedWhile': 'Interrupted · {while}',
+    'tool.turn.closed': 'Interrupted · TALOS was closed before this run finished',
+    /* R5a S6/S7 (Q-R5-10, Q-R5-11; gate E6): every cut says how much was kept and how to reopen the rest. */
+    'tool.output.saved': 'kept {kept} of {total} characters · full output: {path}',
+    'tool.read.cutLines': '{shown} of {total} lines',
+    'tool.read.cutAt': 'cut at {limit} characters',
+    /* R5a S10 (Q-R5-17; gate finding 15): why a tool did not run names what decided; "you did not approve it" only when the
+       person was asked and said no. */
+    'tool.denied.person': 'Not run: you did not approve it.',
+    'tool.denied.rule': 'Not run: denied by rule {rule}.',
+    'tool.denied.ruleScoped': 'Not run: denied by rule {rule} ({scope}).',
+    'tool.denied.policy': 'Not run: denied by policy: {reason}.',
+    'tool.denied.policyNoReason': 'Not run: denied by policy.',
+    'tool.denied.mode': 'Not run: denied by the permission mode: {reason}.',
+    'tool.denied.modeNoReason': 'Not run: denied by the permission mode.',
+    /* The approval dialog (Q-R2-3): the title uses the on-screen label; rule text keeps its `Bash(…)` grammar. When the
+       payload names no kernel tool, the label is the permission tool's own, from this closed set. */
+    'tool.approval.title': 'Permission: {label}',
+    'tool.permission.Read': 'Read file', 'tool.permission.Write': 'Write file', 'tool.permission.Edit': 'Edit file',
+    'tool.permission.Bash': 'Shell', 'tool.permission.WebFetch': 'Web access', 'tool.permission.Mcp': 'MCP tool',
+    'tool.permission.Hook': 'Hook', 'tool.permission.Plugin': 'Plugin tool', 'tool.permission.TalosService': 'TALOS service',
+};

package/dist/i18n/en.js

@@ -0,0 +1,14 @@
+/*
+ * R2: the English dictionary, split by area so that parallel lanes each own one file (ledger R2 lane plan). Ids must be
+ * unique across areas: `i18n.test.ts` fails on a duplicate. Add ids to the area that owns the words, never here.
+ */
+import { approval } from "./en/approval.js";
+import { common } from "./en/common.js";
+import { credentials } from "./en/credentials.js";
+import { errors } from "./en/errors.js";
+import { firstrun } from "./en/firstrun.js";
+import { providers } from "./en/providers.js";
+import { screen } from "./en/screen.js";
+import { tools } from "./en/tools.js";
+export const AREAS = { approval, common, credentials, errors, firstrun, providers, screen, tools };
+export const en = { ...approval, ...common, ...credentials, ...errors, ...firstrun, ...providers, ...screen, ...tools };

package/dist/i18n/error-view.js

@@ -0,0 +1,307 @@
+/*
+ * R2 CONTRACT (owner: lane E). Every error the screen shows goes through `describeError`: what happened · what to do ·
+ * where to look, the code once and secondary (Q-R2-4, gate E6). Lanes other than E only CALL these functions.
+ *
+ * - Mapping is by CODE (gate E4): `envelope.code`; `PROVIDER_REQUEST_ERROR` × kernel `classe` × HTTP `stato`; the RunError
+ *   outcome codes; the credential-store codes. The only text comparisons are the pinned kernel constants of kernel-map.ts.
+ * - `detail` is English only and is what the third line shows; `raw` is the original text, in whatever language the kernel
+ *   wrote it, for the expanded view and the log only (Q-R2-2). An unmapped code gets its family's sentence (E5).
+ * - `describeError` never throws: it runs on failure paths, where a second failure would hide the first.
+ */
+import { codeForError } from "../errors.js";
+import { missingKeyText } from "../provider/missing-key.js";
+import { en, t } from "./index.js";
+import { DISPLAY_CODES, KERNEL_CLASSES, KERNEL_NOTICES, KERNEL_PROVIDER_MESSAGES, KERNEL_REFUSAL_REASONS, KERNEL_RUN_TEXT, REFUSAL_VIA, RUN_OUTCOMES, TRANSPORT_CODES, looksItalian } from "./kernel-map.js";
+import { RETRY_AFTER_MAX_MS } from "../runtime/provider-attempts.js";
+function field(value, key) { try {
+    return value && typeof value === 'object' ? value[key] : undefined;
+}
+catch {
+    return undefined;
+} }
+function text(value) { return typeof value === 'string' && value.trim().length > 0 ? value : null; }
+function finite(value) { const n = typeof value === 'string' && /^\d+$/u.test(value) ? Number(value) : value; return typeof n === 'number' && Number.isFinite(n) ? n : null; }
+function facts(error) {
+    const envelope = field(error, 'envelope');
+    const source = error;
+    let code = '';
+    try {
+        code = text(field(envelope, 'code')) ?? codeForError(error);
+    }
+    catch {
+        code = 'INTERNAL_ERROR';
+    }
+    /* A v2 error (owner 2026-09-24) carries the English headline in `message` and the original, redacted text in `raw`:
+       the kernel's own words are what identify its provider class, so `raw` wins whenever it is there. */
+    const raw = typeof error === 'string' ? error : text(field(source, 'raw')) ?? text(field(source, 'message')) ?? text(field(field(envelope, 'cause'), 'message'));
+    return {
+        code: code || 'INTERNAL_ERROR', raw,
+        hint: text(field(envelope, 'hint')) ?? text(field(source, 'hint')),
+        classe: text(field(source, 'classe')),
+        stato: finite(field(source, 'stato')) ?? finite(field(source, 'status')),
+        provider: text(field(source, 'provider')),
+        retryAfterMs: finite(field(source, 'retryAfterMs')),
+    };
+}
+/** The code once: a message that repeats its own code as a `CODE:` prefix loses it (s02 D-06 printed it twice). */
+function withoutCodePrefix(raw, code) { return raw.startsWith(code) ? raw.slice(code.length).replace(/^\s*:\s*/u, '').trim() : raw.trim(); }
+function englishDetail(raw, code, what) {
+    if (!raw)
+        return null;
+    const rest = withoutCodePrefix(raw, code);
+    return rest && rest !== code && rest !== what && !looksItalian(rest) ? rest : null;
+}
+/* The words' family. Not the exit-code taxonomy (`exitCodeForEnvelope`), whose `/KEY/` also catches CONFIG_UNKNOWN_KEY:
+   the order here puts configuration before keys, so a bad setting is never worded as a rejected API key. */
+const FAMILIES = [
+    [/^(?:INTERRUPTED|CANCELLED|ABORT_ERR)$/u, 'interrupted'],
+    [/CONFIG|USAGE|ERR_PARSE_ARGS|STDIN|QUERY|UNKNOWN_OPTION|SECRET_FIELD/u, 'usage'],
+    [/PERMISSION|APPROVAL|DENIED|SANDBOX|PATH_NOT_ALLOWED|PLAN_MODE|TRUST/u, 'permission'],
+    [/PROVIDER_KEY|API_KEY|AUTH|CREDENTIAL|KEYRING|PROVIDER_STORE/u, 'key'],
+    [/PROVIDER|MODEL|OPENROUTER|OLLAMA|GEMINI|ANTHROPIC|OPENAI|CATALOG/u, 'provider'],
+    [/MCP|HOOK|PLUGIN|EXTENSION|TOOL|FORGE|ACP_/u, 'extension'],
+    [/TIMEOUT/u, 'timeout'],
+    [/SESSION|RESEARCH_NOT_FOUND|AUTOMATION_NOT_FOUND/u, 'session'],
+    [/UPDATE/u, 'update'],
+    [/REQUIRED|INVALID|UNKNOWN|TALOS_RUNTIME_NOT_FOUND/u, 'usage'],
+];
+function family(code) { for (const [pattern, name] of FAMILIES)
+    if (pattern.test(code))
+        return name; return 'internal'; }
+const FAMILY_WHERE = {
+    internal: 'error.generic.where', permission: 'error.family.permission.where', key: 'error.family.key.where', provider: 'error.where.providerList',
+    extension: 'error.where.doctor', timeout: 'error.where.doctor', session: 'error.family.session.where', update: 'error.where.doctor', usage: 'error.family.usage.where', interrupted: null,
+};
+function providerWhere(provider) { return provider ? t('error.where.providerTest', { id: provider }) : t('error.where.providerList'); }
+function providerClass(f) {
+    if (TRANSPORT_CODES[f.code])
+        return TRANSPORT_CODES[f.code];
+    if (f.code !== 'PROVIDER_REQUEST_ERROR' && !f.code.startsWith('PROVIDER_HTTP'))
+        return null;
+    if (f.stato === 429)
+        return 'rate-limited';
+    if (f.stato !== null && f.stato >= 500)
+        return 'server-error';
+    if (f.classe && KERNEL_CLASSES[f.classe])
+        return KERNEL_CLASSES[f.classe];
+    if (f.raw && KERNEL_PROVIDER_MESSAGES[f.raw.trim()])
+        return KERNEL_PROVIDER_MESSAGES[f.raw.trim()];
+    return 'not-accepted';
+}
+function describeProvider(cls, f) {
+    const id = f.provider ?? '<id>';
+    if (cls === 'credential' || cls === 'not-accepted') {
+        // The status, when the error still carries it, splits the kernel's lumped classes (E7: 403 is never "the key is wrong").
+        if (f.stato === 401)
+            return { what: t('error.provider.unauthorized.what'), todo: t('error.provider.unauthorized.todo', { id }) };
+        if (f.stato === 403)
+            return { what: t('error.provider.forbidden.what'), todo: t('error.provider.forbidden.todo') };
+        if (f.stato === 404)
+            return { what: t('error.provider.notFound.what'), todo: t('error.provider.notFound.todo') };
+    }
+    switch (cls) {
+        case 'rate-limited': {
+            // A wait is given only when it is known (E7); a keyless provider's Retry-After never reaches the CLI (E15).
+            const seconds = f.retryAfterMs !== null && f.retryAfterMs > 0 ? Math.ceil(f.retryAfterMs / 1000) : null;
+            /* R5a lane R (Q-R5-6): a requested wait above the 60 s TALOS takes by itself ended the retries at once (the kernel
+               amendment), so "TALOS retried" would be false. */
+            const what = seconds !== null && f.retryAfterMs > RETRY_AFTER_MAX_MS ? t('error.provider.rateLimited.whatLongWait', { seconds }) : t('error.provider.rateLimited.what');
+            return { what, todo: seconds ? t('error.provider.rateLimited.todoKnown', { seconds }) : t('error.provider.rateLimited.todo') };
+        }
+        case 'credential': return { what: t('error.provider.credential.what'), todo: t('error.provider.credential.todo') };
+        case 'credit': return { what: t('error.provider.credit.what'), todo: t('error.provider.credit.todo') };
+        case 'network': return { what: t('error.provider.network.what'), todo: t('error.provider.network.todo') };
+        case 'timeout': return { what: t('error.provider.timeout.what'), todo: t('error.provider.timeout.todo') };
+        case 'server-error': return { what: t('error.provider.serverError.what'), todo: t('error.provider.serverError.todo') };
+        case 'stream-cut': return { what: t('error.provider.streamCut.what'), todo: t('error.provider.streamCut.todo') };
+        case 'context': return { what: t('error.provider.context.what'), todo: t('error.provider.context.todo') };
+        default: return { what: t('error.provider.notAccepted.what'), todo: t('error.provider.notAccepted.todo') };
+    }
+}
+function stopPhrase(point) {
+    if (!point)
+        return null;
+    if (point.kind === 'answering')
+        return t('error.run.while.answering');
+    if (point.kind === 'approval')
+        return t('error.run.while.approval', { tool: point.tool });
+    return t('error.run.while.tool', { tool: point.tool });
+}
+function describeOutcome(code, f, options) {
+    const outcome = RUN_OUTCOMES[code];
+    if (outcome === 'stopped') {
+        if (f.raw?.trim() === KERNEL_RUN_TEXT.stoppedWithoutAnswer)
+            return { what: t('error.run.noAnswer.what'), todo: t('error.run.noAnswer.todo'), where: null };
+        const phrase = stopPhrase(options.stopPoint);
+        return { what: phrase ? t('error.run.interruptedWhile.what', { while: phrase }) : t('error.run.interrupted.what'), todo: null, where: null };
+    }
+    if (outcome === 'turns-exhausted')
+        return { what: t('error.run.turnsExhausted.what'), todo: t('error.run.turnsExhausted.todo'), where: null };
+    if (outcome === 'repetition')
+        return { what: t('error.run.repetition.what'), todo: t('error.run.repetition.todo'), where: null };
+    return { what: t('error.run.premiseDenied.what'), todo: t('error.run.premiseDenied.todo'), where: null };
+}
+/** Codes with their own words: `error.code.<CODE>.what` / `.todo`, and where to look. */
+const CODE_WHERE = {
+    PROJECT_TRUST_REQUIRED: 'error.code.PROJECT_TRUST.where', PROJECT_TRUST_INVALIDATED: 'error.code.PROJECT_TRUST.where',
+    CREDENTIAL_STORE_INVALID: 'error.where.doctor', CREDENTIAL_STORE_REAL_IN_TEST: 'error.where.doctor', CONFIG_INVALID_CREDENTIAL_STORE: 'error.code.config.where', CONFIG_INVALID_CREDENTIALS: 'error.code.config.where',
+    SANDBOX_REQUIRED_UNAVAILABLE: 'error.where.doctor', MXC_BACKEND_UNAVAILABLE: 'error.where.doctor', PROVIDER_STORE_UNAVAILABLE: 'error.where.doctor',
+    RULE_COMMAND_UNSUPPORTED: 'error.family.permission.where', RULE_COMPOUND_COMMAND: 'error.family.permission.where', RULE_UNREADABLE: 'error.family.permission.where',
+    RULE_MATCHES_NOTHING: 'error.family.permission.where', RULE_STORE_INVALID: 'error.code.config.where', KEYMAP_INVALID: 'error.code.config.where',
+    FORGE_PACKAGE_SCHEMA_INVALID: 'error.generic.where', PROVIDER_KEY_REQUIRED: 'error.where.providerList', PROVIDER_KEY_INVALID: 'error.where.providerList',
+    PROVIDER_KEY_NOT_FOUND: 'error.where.providerList', PROVIDER_POOL_FULL: 'error.where.providerList', PROVIDER_RUNTIME_INVALID: 'error.where.providerList',
+    PROVIDER_RUNTIME_UNAVAILABLE: 'error.where.doctor', PROVIDER_KEY_MISSING: 'error.where.providerList', MODEL_IMAGE_NOT_SUPPORTED: 'error.where.providerList',
+    LOCAL_RUNTIME_NOT_READY: 'error.where.doctor', PATH_NOT_ALLOWED: 'error.family.permission.where', PLAN_MODE_READ_ONLY: 'error.family.permission.where',
+    SESSION_NOT_FOUND: 'error.family.session.where', EXECUTION_BACKEND_UNAVAILABLE: 'error.where.doctor', RUN_TIMEOUT: 'error.generic.where', RUNTIME_NOT_AVAILABLE: 'error.where.providerList', NOT_FOUND: 'error.family.session.where',
+    TALOS_RUNTIME_NOT_FOUND: 'error.where.doctor', PERMISSION_RULE_INVALID: 'error.family.permission.where', CLI_USAGE_ERROR: 'error.family.usage.where', PROVIDER_FALLBACK_BUSY: 'error.generic.where',
+    /* R5a lane R: the R5 configuration keys. */
+    CONFIG_INVALID_MODELS: 'error.code.config.where', CONFIG_INVALID_MODEL_WINDOW: 'error.code.config.where', CONFIG_INVALID_BUSY_INPUT: 'error.code.config.where',
+    CONFIG_INVALID_REASONING_DISPLAY: 'error.code.config.where',
+    /* R5b (R5a open 4): the Context Engine's failures point at /context. */
+    CTX_CONTEXT_OVERFLOW: 'error.where.context', CTX_TRUNCATED_SUMMARY: 'error.where.context', CTX_SUMMARY_RESPONSE_INVALID: 'error.where.context', CTX_SEGMENT_TOO_LARGE: 'error.where.context',
+    CTX_INVALID_SUMMARY: 'error.where.context', CTX_EMPTY_SUMMARY: 'error.where.context', CTX_NO_REDUCTION: 'error.where.context', CTX_NOTHING_TO_COMPACT: 'error.where.context',
+    CTX_CONTEXT_TOO_SMALL: 'error.where.context', CTX_COMPACTION_FAILED: 'error.where.context', CTX_JOB_INTERRUPTED: 'error.where.context', CTX_HISTORY_DIVERGED: 'error.where.context',
+};
+function familyTodo(fam) { return fam === 'interrupted' ? null : `error.family.${fam}.todo`; }
+const RULE_CODES = new Set(['RULE_COMMAND_UNSUPPORTED', 'RULE_COMPOUND_COMMAND', 'RULE_UNREADABLE', 'RULE_MATCHES_NOTHING']);
+function mapped(id) { return Object.hasOwn(en, id) ? id : null; }
+export function hasEnglishFor(code) {
+    if (DISPLAY_CODES[code] && !(code in RUN_OUTCOMES))
+        return hasEnglishFor(DISPLAY_CODES[code]);
+    return Boolean(mapped(`error.code.${code}.what`)) || code in RUN_OUTCOMES || Boolean(TRANSPORT_CODES[code]) || code === 'PROVIDER_REQUEST_ERROR';
+}
+/** The code the screen prints for a kernel code (an Italian-spelled one gets its English name, D-05). */
+export function displayCode(code) { return DISPLAY_CODES[code] ?? code; }
+function describe(error, options) {
+    const f = facts(error);
+    const code = f.code;
+    const base = (parts) => {
+        const view = { ...parts, code, detail: englishDetail(f.raw, code, parts.what), raw: f.raw };
+        // The envelope's hint is the thrower's own advice for THIS failure: more specific than any table, so it wins when it is
+        // English (a kernel hint in Italian stays off the screen, Q-R2-2).
+        if (f.hint && !looksItalian(f.hint))
+            view.todo = f.hint;
+        return view;
+    };
+    if (code in RUN_OUTCOMES) {
+        const view = base(describeOutcome(code, f, options));
+        const noAnswer = code === 'fermato' && f.raw?.trim() === KERNEL_RUN_TEXT.stoppedWithoutAnswer;
+        // The person's own stop is not an error: no code and no "Details" line (the kernel code stays in the JSON envelope).
+        if (code === 'fermato' && !noAnswer)
+            return { ...view, code: null, detail: null };
+        return { ...view, code: noAnswer ? 'NO_ANSWER' : DISPLAY_CODES[code] ?? null, detail: null };
+    }
+    // A lowercase kernel code (`internal-error`) is shown as its English code; the facts travel, the envelope does not.
+    if (DISPLAY_CODES[code])
+        return describe({ message: f.raw ?? undefined, code: DISPLAY_CODES[code], hint: f.hint ?? undefined, provider: f.provider ?? undefined }, options);
+    if (code === 'PROVIDER_KEY_MISSING' && f.provider)
+        return { ...base({ what: missingKeyText(f.provider), todo: null, where: t('error.where.providerList') }), detail: null };
+    const cls = providerClass(f);
+    if (cls) {
+        const parts = describeProvider(cls, f);
+        return { ...base({ ...parts, where: providerWhere(f.provider) }), detail: f.stato ? `HTTP ${f.stato}` : null };
+    }
+    const own = mapped(`error.code.${code}.what`);
+    if (own) {
+        const todoId = mapped(`error.code.${code}.todo`) ?? (RULE_CODES.has(code) ? 'error.code.RULE.todo' : null) ?? familyTodo(family(code));
+        const where = CODE_WHERE[code] ? t(CODE_WHERE[code]) : family(code) === 'provider' ? providerWhere(f.provider) : t('error.generic.where');
+        return base({ what: t(own), todo: todoId ? t(todoId) : null, where });
+    }
+    const fam = family(code);
+    if (fam === 'interrupted')
+        return base({ what: t('error.family.interrupted.what'), todo: null, where: null });
+    const whereId = fam === 'provider' ? null : FAMILY_WHERE[fam];
+    return base({ what: t(`error.family.${fam}.what`), todo: t(`error.family.${fam}.todo`), where: whereId ? t(whereId) : providerWhere(f.provider) });
+}
+export function describeError(error, options = {}) {
+    try {
+        return describe(error, options);
+    }
+    catch {
+        return { what: t('error.generic.what'), todo: t('error.family.internal.todo'), where: t('error.generic.where'), code: 'INTERNAL_ERROR', detail: null, raw: null };
+    }
+}
+/** The three screen lines for a view (headline · what to do · dim "Details: … (CODE) · where"), without colour codes.
+ *  `raw` is never printed here (Q-R2-2). */
+export function errorViewLines(view) {
+    const details = [view.detail, view.code ? `(${view.code})` : null, view.where].filter(Boolean).join(' · ');
+    return [view.what, ...(view.todo ? [view.todo] : []), ...(details ? [`${t('common.details')}: ${details}`] : [])];
+}
+/** A kernel notice sent as a whole chat message, in English; `null` when the text is not one of the kernel's templates. */
+export function describeKernelNotice(text) {
+    for (const notice of KERNEL_NOTICES) {
+        const m = notice.pattern.exec(text);
+        if (m)
+            return t(notice.id, { ...m.groups });
+    }
+    return null;
+}
+/*
+ * R3 Q-R3-8 (R3-INT). The kernel ends a tool result it stopped with one of these sentences, as a whole paragraph
+ * (talosHarness.mjs:4040, 4806-4808, 4947; `annullaAnnunciate` :684). The model reads them unchanged (R2 E2); the screen
+ * shows the English of the EXACT sentence, compared as a whole line, so a command's own output is never rewritten.
+ * Pinned against the kernel source by test/tui/r3-sp-tool-stop-markers.test.ts.
+ */
+export const KERNEL_TOOL_STOP = Object.freeze({
+    commandWhileRunning: '⛔ Fermato su richiesta: il comando e stato interrotto mentre girava.',
+    testWhileRunning: '⛔ Fermato su richiesta: la prova e stata interrotta mentre girava.',
+    notRun: '⛔ Fermato su richiesta: non riesco a eseguirlo, la sessione e stata interrotta prima. Questo attrezzo non e stato eseguito.',
+    timedOut: /^⛔ Fermato allo scadere dei (?<seconds>\d+) secondi: non ha finito da solo\.$/u,
+});
+/** A tool result's display text with the kernel's stop sentences in English; `stopped` = the person stopped it. */
+export function describeKernelToolText(text) {
+    if (!text.includes('⛔ Fermato'))
+        return { text, stopped: false };
+    let stopped = false;
+    const lines = text.split('\n').map(line => {
+        if (line === KERNEL_TOOL_STOP.commandWhileRunning || line === KERNEL_TOOL_STOP.testWhileRunning) {
+            stopped = true;
+            return t('error.toolStop.whileRunning');
+        }
+        if (line === KERNEL_TOOL_STOP.notRun) {
+            stopped = true;
+            return t('error.toolStop.notRun');
+        }
+        const timeout = KERNEL_TOOL_STOP.timedOut.exec(line);
+        return timeout ? t('error.toolStop.timedOut', { seconds: timeout.groups.seconds }) : line;
+    });
+    return { text: lines.join('\n'), stopped };
+}
+/**
+ * A refused tool, worded from the receipt's permission `via` (the kernel's `motivo` is Italian; it stays in the receipt).
+ * R5a lane R (S10, gate finding 15): with the tool's `denial` fact, the words name who decided — the person only when the
+ * person was asked and said no; a rule by its text, the policy or the mode by their reason — instead of the via, which says
+ * "you did not approve it" for every "asked" via, even when the engine answered alone.
+ */
+export function describeRefusal(receipt, denial) {
+    if (denial)
+        return describeDenial(denial);
+    const key = receipt.via ? REFUSAL_VIA[receipt.via] : undefined;
+    return t(key ? `error.refused.${key}` : 'error.refused.generic');
+}
+/** The one sentence of a denial fact (`ToolDenial`, tui/tool-facts.ts). */
+export function describeDenial(denial) {
+    if (denial.by === 'person')
+        return t('error.denial.person');
+    if (denial.by === 'rule')
+        return denial.rule ? (denial.scope ? t('error.denial.ruleScoped', { rule: denial.rule, scope: denial.scope }) : t('error.denial.rule', { rule: denial.rule })) : t('error.denial.ruleUnnamed');
+    return denial.reason ? t('error.denial.because', { reason: denial.reason }) : t('error.refused.generic');
+}
+/**
+ * R5a lane R (S10): the kernel's refusal sentence (a receipt's `motivo`) in English, matched whole against the kernel's
+ * constants (kernel-map.ts `KERNEL_REFUSAL_REASONS`); `null` when it is not one of them. `toolLabel` names a kernel tool id in
+ * the screen's words. Display only: the receipt and the model keep the kernel's text.
+ */
+export function describeKernelRefusalReason(text, { toolLabel = (id) => id } = {}) {
+    const value = String(text ?? '').trim();
+    for (const row of KERNEL_REFUSAL_REASONS) {
+        const match = row.pattern.exec(value);
+        if (!match)
+            continue;
+        const groups = match.groups ?? {};
+        /* The kernel writes `(nessun percorso)` when the action named no path (talosHarness.mjs, research branch). */
+        const path = groups.path === undefined ? undefined : !groups.path || groups.path === '(nessun percorso)' ? t('error.refusalReason.noPath') : groups.path;
+        return t(row.id, { ...(groups.tool ? { tool: toolLabel(groups.tool) } : {}), ...(path !== undefined ? { path } : {}) });
+    }
+    return null;
+}

package/dist/i18n/index.js

@@ -0,0 +1,19 @@
+/*
+ * R2 (Q-R2-1, gate E1/E9): the ONE place the screen's words come from. `en` is a flat, typed object keyed by dotted ids;
+ * values are data strings with `{name}` placeholders; plurals are `<id>.one` / `<id>.other` chosen by Intl.PluralRules.
+ * A later locale is `{...en,...overrides}` and needs no code change (Hermes desktop / OpenCode pattern). What the MODEL
+ * receives (kernel tool names, argument keys, contract markers) never comes from here (gate E2).
+ */
+import { en } from "./en.js";
+const pluralRules = new Intl.PluralRules('en');
+function fill(template, params = {}) {
+    return template.replace(/\{(\w+)\}/gu, (whole, name) => Object.hasOwn(params, name) ? String(params[name]) : whole);
+}
+/** The English text for `id`, with `{name}` placeholders filled from `params` (a missing param stays visible as `{name}`). */
+export function t(id, params) { return fill(en[id], params); }
+/** The plural form of `base` for `count` (`{count}` is available to the template). */
+export function tn(base, count, params = {}) {
+    const form = pluralRules.select(count) === 'one' ? 'one' : 'other';
+    return fill(en[`${base}.${form}`], { count, ...params });
+}
+export { en };