talos-code 0.0.1 → 0.2.0

package/dist/runtime/brokered-executor.js

@@ -0,0 +1,395 @@
+import { t } from "../i18n/index.js";
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { TalosError } from "../errors.js";
+import { TOOL_OUTPUT_LIMIT, cutToolOutput, hasKernelCutMarker, replaceKernelCutMarker } from "./output-store.js";
+/*
+ * ⭐⭐⭐ B1 slice 8 — IL COMANDO SCRITTO DALLA PERSONA PASSA DAL BROKER, e lo DICE.
+ *
+ * Questa e' l'unica implementazione nuova della corsia: un adattatore che si infila nel seam che il
+ * kernel espone GIA' — `eseguiComandoDiretto({eseguiComandoSandboxatoFn})` in
+ * `harness-ui/src/agent-service.mjs` (L1975) — e che quindi eredita, senza riscriverli, il
+ * vocabolario di eventi, l'accorpamento dei pezzi e la cucitura nella cronologia. (Il tracciamento
+ * della cartella di lavoro NO: dal round 5 della fetta 12 il ramo brokerato non appende la coda della
+ * cartella — vedi sotto.)
+ *
+ * ⛔ La firma e' quella POSIZIONALE del kernel (`eseguiComandoSandboxato(comando, cartella, opzioni)`),
+ *   non una nuova: il CLI si conforma al kernel, mai il contrario.
+ * ⛔ `harness-ui/` si LEGGE e non si scrive: la regola di troncamento (`uscitaUtile`) e l'esecutore di
+ *   ripiego arrivano dal kernel per iniezione. `staccaCartellaFinale` e `codaCheStampaLaCartella`
+ *   restano nel contratto degli aiutanti perche' il kernel li espone, ma il ramo brokerato non li usa.
+ */
+/** ⛔ I due codici di uscita documentati dal kernel: 124 = tempo scaduto, 130 = 128 + SIGINT. */
+export const KERNEL_EXIT = { timeout: 124, stoppedOnRequest: 130 };
+/*
+ * ⭐⭐⭐ B1 slice 12, round 5 — SUL RAMO BROKERATO NON SI APPENDE NIENTE AL COMANDO.
+ *
+ * Tre round di fila hanno ricostruito il codice d'uscita dopo la coda della cartella, e ognuno ha
+ * aperto un buco nel codice d'uscita:
+ *  · round 2, marcatore stampato: un'ultima riga senza a-capo lo incollava e la persona leggeva
+ *    «exit 0» col token; un comando poteva stamparne uno e falsificare il codice nei due versi;
+ *  · round 4, stato del processo via `call set` / `call exit`: DENTRO la sandbox MXC quei due nomi si
+ *    risolvono in un `set.bat`/`set.cmd`/`exit.bat`/`exit.cmd` della cartella di lavoro. Misurato
+ *    il 17/09/2026 con `findstr /c:zzz talos_absent.txt` (vero: 1): cmd dell'host 1, sandbox semplice
+ *    1, ramo brokerato **0** con quei file presenti. E per `type mancante & echo ok` il ramo brokerato
+ *    dava 1 mentre `cmd /c` semplice e il ripiego del kernel davano 0.
+ * La coda esisteva solo perche' quella della cartella sovrascrive il codice d'uscita, e la coda della
+ * cartella sul ramo cmd NON FUNZIONA comunque (`cartella: null` su cmd, misurato al round 2, sia qui
+ * sia nel kernel). Costava onesta' e non comprava niente che funzioni oggi.
+ *
+ * ⇒ Si esegue `%ComSpec% /d /s /c <comando>` e basta. Il codice che la persona vede e' lo stato
+ *   d'uscita del processo nella sandbox, riportato da `mxcSandboxedSpawn`; niente viene stampato,
+ *   letto o tolto che il comando non abbia prodotto da se'.
+ * ⛔ COSTO DICHIARATO, NON UNA REGRESSIONE: sul ramo brokerato un `cd` non persiste fra un comando e
+ *   l'altro (`cartellaFinale` e' sempre null, e il registro tiene la cartella di prima). E' identico a
+ *   oggi sul ramo cmd, dove la persistenza e' gia' rotta dal parser della cartella del kernel.
+ */
+/*
+ * ⭐ B1 slice 12, round 2 — UN BROKER CHE NON SI E' POTUTO COSTRUIRE NON E' «NON CONFIGURATO».
+ * Chi compone ripiega sull'esecuzione (fail-open) ma deve poterlo DIRE: questo sostituto rifiuta
+ * ogni esecuzione con un codice che il ramo di ripiego riconosce, e porta il codice dell'errore
+ * vero. Un difetto di contratto (un TypeError) arriva a schermo con il suo nome invece di sparire.
+ */
+export const BROKER_CONSTRUCTION_FAILED = 'EXECUTION_BROKER_CONSTRUCTION_FAILED';
+export function createUnbuildableExecutionBroker(cause) {
+    const code = typeof cause?.code === 'string' ? String(cause.code) : cause instanceof Error ? cause.name : 'UNKNOWN_ERROR';
+    const message = (cause instanceof Error ? cause.message : String(cause)).split(/\r?\n/u)[0].slice(0, 300);
+    const detail = `${code}: ${message}`;
+    return { async execute(request) { throw new TalosError({ code: BROKER_CONSTRUCTION_FAILED, component: 'execution-broker', retryable: false, hint: detail, traceId: request.id }, cause); } };
+}
+/*
+ * The words of the execution row. R2 (gate E1, Q-R2-1): they live in the one dictionary, `src/i18n/en/screen.ts`
+ * (`screen.exec.*`); this object keeps the shape its callers use. The `marker` block is NOT screen text: it is a
+ * byte-identical copy of kernel constants (gate E2) and never enters the dictionary.
+ *
+ * ⛔⛔⛔ E la riga `enforcement` NON si accorcia. Misurato il 16/09/2026: una ricerca nel binario di
+ *   Claude Code per una resa a schermo del suo flag «senza sandbox» torna ZERO, e il suo comando
+ *   digitato dall'utente gira sempre fuori dall'isolamento senza dirlo; la barra di stato di Hermes,
+ *   documentata campo per campo, non ha un campo isolamento. Entrambi approvano i comandi in
+ *   allowlist in silenzio. Questa stringa e' l'unico posto in cui una persona scopre che il suo
+ *   comando NON era isolato e PERCHE': toglierle la ragione la rende inutile.
+ */
+export const EXECUTION_TEXT = {
+    isolation: {
+        /** Un backend ha eseguito e ha portato le prove: si nomina il backend. */
+        sandbox: (backend) => t('screen.exec.isolation.sandbox', { backend }),
+        /** Il giro isolato e' finito prima di dire come: non si promette un isolamento che non e' provato. */
+        sandboxWithoutEvidence: t('screen.exec.isolation.sandboxWithoutEvidence'),
+        host: t('screen.exec.isolation.host'),
+        /**
+         * R0 lane S, owner decision 1 (review §J.1): the row of a command the PRODUCT wanted in the sandbox and ran on the
+         * host. ⛔ Never "secure" or "safe" anywhere on this path (gate E6): MXC itself is "contained", not a boundary.
+         */
+        hostNotIsolated: t('screen.exec.isolation.hostNotIsolated'),
+        wsl2: t('screen.exec.isolation.wsl2'),
+        device: t('screen.exec.isolation.device'),
+        other: (name) => t('screen.exec.isolation.named', { name }),
+    },
+    reason: {
+        verified: (evidence) => t('screen.exec.reason.verified', { appContainer: t(evidence.appContainer ? 'screen.exec.on' : 'screen.exec.off'), filesystem: evidence.filesystem, network: evidence.network, processTree: evidence.processTree }),
+        backendUnavailable: (why) => t('screen.exec.reason.backendUnavailable', { why }),
+        brokerNotConfigured: t('screen.exec.reason.brokerNotConfigured'),
+        /** The broker exists in this build but could not be BUILT: never the same sentence as «not configured». */
+        brokerConstructionFailed: (detail) => t('screen.exec.reason.brokerConstructionFailed', { detail }),
+        destinationMobile: t('screen.exec.reason.destinationMobile'),
+        destinationWsl2: t('screen.exec.reason.destinationWsl2'),
+        platformNotWindows: (platform) => t('screen.exec.reason.platformNotWindows', { platform }),
+        timedOut: (ms) => t('screen.exec.reason.timedOut', { seconds: Math.round(ms / 1_000) }),
+        stoppedOnRequest: t('screen.exec.reason.stoppedOnRequest'),
+        /*
+         * ⛔ R0 lane S — the declared host fallback. These rows are shared by the person's `!` commands AND the model's
+         *   shell tool (M1-E: one executor), so they do not say who typed the command; the approval that precedes the
+         *   run is the permission engine's, not this executor's.
+         */
+        sandboxUnverified: (why) => t('screen.exec.reason.sandboxUnverified', { why }),
+        brokerUnbuildable: (detail) => t('screen.exec.reason.brokerUnbuildable', { detail }),
+        hostPlatform: (platform) => t('screen.exec.reason.hostPlatform', { platform }),
+        hostNoBroker: t('screen.exec.reason.hostNoBroker'),
+    },
+    /*
+     * ⛔ Le tre marche del kernel, riprodotte LETTERA PER LETTERA perche' il kernel non le esporta
+     *   (`MARCA_FERMATO_MENTRE_GIRAVA` e `USCITA_FERMATO_SU_RICHIESTA` sono `const` di modulo, non
+     *   `export`). Una prova legge il sorgente del kernel e verifica che siano ancora identiche: e'
+     *   l'unico modo per accorgersi di una deriva, visto che la copia e' inevitabile.
+     */
+    marker: {
+        stoppedOnRequest: '⛔ Fermato su richiesta:',
+        stoppedOnRequestSentence: 'il comando e stato interrotto mentre girava.',
+        timedOut: (ms) => `⛔ Fermato allo scadere dei ${Math.round(ms / 1_000)} secondi: non ha finito da solo.`,
+    },
+    /** ⛔ Un comando senza sessione si RIFIUTA a voce alta: farlo sparire e' peggio che negarlo. */
+    shellSessionRequired: t('screen.exec.shellSessionRequired'),
+};
+/** The most of a fallback command's streamed output kept for its file (the kernel itself holds 160,000 characters). */
+const CAPTURE_MAX = 8_000_000;
+function isolationForKernelEnforcement(value) {
+    if (value === 'wsl2')
+        return EXECUTION_TEXT.isolation.wsl2;
+    if (value === 'adb-shell-on-device')
+        return EXECUTION_TEXT.isolation.device;
+    if (value === 'none' || !value)
+        return EXECUTION_TEXT.isolation.host;
+    return EXECUTION_TEXT.isolation.other(value);
+}
+function annotate(isolation, reason) { return `${isolation} — ${reason}`; }
+export function createBrokeredKernelExecutor(options) {
+    const platform = options.platform ?? process.platform;
+    /*
+     * ⛔ LA RETE SEGUE IL MOTORE DEI PERMESSI, non una costante inventata qui. Il motore di oggi
+     *   (`cli/src/security/permission-engine.ts`) non ha ancora una regola che parli della rete di un
+     *   sottoprocesso: `WebFetch` riguarda le richieste del MODELLO, non quelle che un comando apre
+     *   per conto suo. ⇒ Il default e' il valore che CONSERVA il comportamento di oggi (il kernel
+     *   esegue senza alcun confine di rete), e il buco e' dichiarato nel rapporto invece di essere
+     *   colmato inventando un motore nuovo. Chi compone puo' gia' passare `network` quando il motore
+     *   imparera' a decidere deny/ask/allow.
+     */
+    const network = options.network ?? 'internet-client';
+    /*
+     * ⛔ `restricted-process` e non `windows-sandbox`: con `windows-sandbox` il broker LANCIA
+     *   `SANDBOX_REQUIRED_UNAVAILABLE` (execution-broker.ts L85) invece di declinare, e un backend
+     *   assente diventerebbe un errore duro invece del ripiego che lo scenario 2 pretende. Con
+     *   `restricted-process` il broker prende comunque `windows-sandbox` se ce l'ha (L82-84) e
+     *   declina con `EXECUTION_BACKEND_UNAVAILABLE` quando non ha niente (L87).
+     */
+    const requiredEnforcement = options.requiredEnforcement ?? 'restricted-process';
+    const requireVerifiedIsolation = options.requireVerifiedIsolation ?? false;
+    /*
+     * ⭐⭐⭐ R0 lane S — THE DECLARED HOST FALLBACK (owner decision 1, 2026-09-23; review D-01/E-01).
+     * F16 (`dd9620d9b`) made the product refuse every command whose isolation could not be proven, and on a host where
+     * the probe itself was broken that meant NO command ran at all. The product still ASKS for the Windows sandbox
+     * (`requiredEnforcement:'windows-sandbox'`, network denied), still never accepts a weaker sandbox in its place, and
+     * still lets a sandbox that exists and fails propagate (below). What changes: when no verified sandbox exists, the
+     * command runs through the kernel's own executor on the host, and the row says so — `⛶ host · not isolated` and
+     * the backend's own reason. Claude Code does the same by default ("shows a warning and runs commands without
+     * sandboxing", code.claude.com/docs/en/sandboxing, v2.1.271, 2026-09-14); the approval before it is the permission
+     * engine's (gate §0.2 rule 2).
+     */
+    const declaredHost = !requireVerifiedIsolation && requiredEnforcement === 'windows-sandbox';
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const newId = options.newId ?? (() => randomUUID());
+    let loading = null;
+    const loadKernel = () => (loading ??= options.kernel());
+    /*
+     * ⛔ CHI NON PUO' ANDARE NEL BROKER, E PERCHE'. Un AppContainer non puo' ospitare una `adb shell`
+     *   ne' una distribuzione WSL2: mandarceli sarebbe la cura di una malattia che non esiste, e
+     *   cambierebbe in silenzio DOVE gira il comando — esattamente il difetto che D-10F ha chiuso.
+     */
+    function declineReason(opts) {
+        if (opts.mobile === true)
+            return EXECUTION_TEXT.reason.destinationMobile;
+        if (opts.dove === 'wsl2')
+            return EXECUTION_TEXT.reason.destinationWsl2;
+        if (platform !== 'win32')
+            return declaredHost ? EXECUTION_TEXT.reason.hostPlatform(String(platform)) : EXECUTION_TEXT.reason.platformNotWindows(String(platform));
+        if (!options.broker)
+            return declaredHost ? EXECUTION_TEXT.reason.hostNoBroker : EXECUTION_TEXT.reason.brokerNotConfigured;
+        return null;
+    }
+    async function fallback(helpers, comando, cartella, opts, reason) {
+        /*
+         * R5a lane R, S6: the kernel's executor cuts its output itself (`uscitaUtile`) and returns only the cut; every piece it
+         * reads is also handed to `onPezzo` as it arrives (talosHarness.mjs `eseguiComandoSandboxato`, D-10B). The pieces are
+         * kept here, in arrival order, so a cut output can still be saved whole; the caller's listener still gets every piece.
+         */
+        const keep = options.keepFullOutput;
+        let captured = '';
+        let capturedAll = true;
+        const listener = opts.onPezzo;
+        const withCapture = keep ? { ...opts, onPezzo: (piece) => {
+                if (captured.length < CAPTURE_MAX)
+                    captured += piece.testo;
+                else
+                    capturedAll = false;
+                listener?.(piece);
+            } } : opts;
+        const kernelResult = await helpers.eseguiComandoSandboxato(comando, cartella, withCapture);
+        let result = kernelResult;
+        if (keep && hasKernelCutMarker(String(kernelResult.testo ?? ''))) {
+            const full = capturedAll ? captured : captured.slice(0, CAPTURE_MAX);
+            let saved = null;
+            try {
+                saved = full ? await keep(full) : null;
+            }
+            catch {
+                saved = null;
+            }
+            result = { ...kernelResult, testo: replaceKernelCutMarker(String(kernelResult.testo), saved) };
+        }
+        const kernelEnforcement = String(result.enforcement ?? '');
+        /* ⛔ Only a plain host run takes the declared label: WSL2 and the device keep naming where they ran. */
+        const isolation = declaredHost && (kernelEnforcement === 'none' || !kernelEnforcement) ? EXECUTION_TEXT.isolation.hostNotIsolated : isolationForKernelEnforcement(kernelEnforcement);
+        return { ...result, enforcement: annotate(isolation, reason) };
+    }
+    /* R5a lane R, S6: the same head and tail as the kernel's cut, and with `keepFullOutput` the English marker naming the file. */
+    async function cutOutput(helpers, full) {
+        const keep = options.keepFullOutput;
+        if (!keep)
+            return helpers.uscitaUtile(full, 4_000, 0.25);
+        if (full.length <= TOOL_OUTPUT_LIMIT)
+            return full;
+        let saved = null;
+        try {
+            saved = await keep(full);
+        }
+        catch {
+            saved = null;
+        }
+        return cutToolOutput(full, saved);
+    }
+    return async function brokeredKernelExecutor(comando, cartella, opts = {}) {
+        const helpers = await loadKernel();
+        const declined = declineReason(opts);
+        if (declined !== null) {
+            if (requireVerifiedIsolation) {
+                let why = t('screen.exec.why.unverified');
+                if (opts.mobile === true)
+                    why = t('screen.exec.why.mobile');
+                else if (opts.dove === 'wsl2')
+                    why = t('screen.exec.why.wsl2');
+                else if (platform !== 'win32')
+                    why = t('screen.exec.why.platform', { platform: String(platform) });
+                else if (!options.broker)
+                    why = t('screen.exec.why.noBroker');
+                throw new TalosError({
+                    code: 'SANDBOX_REQUIRED_UNAVAILABLE',
+                    component: 'execution-broker',
+                    retryable: false,
+                    hint: t('screen.exec.why.notRun', { why }),
+                    traceId: newId(),
+                });
+            }
+            return fallback(helpers, comando, cartella, opts, declined);
+        }
+        const broker = options.broker;
+        /*
+         * ⛔ Round 5: nessuna coda, nemmeno con `tracciaCartella`. Vedi il blocco in testa al file.
+         *
+         * ⛔ Invocazione NON INTERATTIVA, identica a quella che Node stesso costruisce per
+         *   `spawn(comando,{shell:true})` su Windows: `%ComSpec% /d /s /c <comando>`. `/d` spegne gli
+         *   AutoRun del registro, che dentro un isolamento sarebbero un ingresso non dichiarato.
+         * ⛔ La RADICE DEL VOLUME in sola lettura e' OBBLIGATORIA, non una comodita': upstream
+         *   microsoft/mxc#1109 (SDK 0.8.0) dimostra che una concessione in scrittura su una cartella di
+         *   profilo utente e' inutilizzabile se la radice del volume non sta anche fra le sole letture.
+         */
+        const request = {
+            id: newId(),
+            executable: options.shellExecutable ?? process.env['ComSpec'] ?? 'cmd.exe',
+            args: ['/d', '/s', '/c', comando],
+            cwd: cartella,
+            readWritePaths: [cartella],
+            readOnlyPaths: [path.parse(path.resolve(cartella)).root],
+            network,
+            requiredEnforcement,
+            timeoutMs,
+            ...(opts.segnaleStop ? { signal: opts.segnaleStop } : {}),
+        };
+        /*
+         * ⛔⛔ I DUE FERMI DEL KERNEL NON SONO RIPRODUCIBILI ATTRAVERSO LA FORMA DEL BROKER: il contratto
+         *   di risultato di un backend porta `exitCode/stdout/stderr/applied` e nient'altro, quindi
+         *   «ucciso dal tempo» e «fermato da te» non tornano indietro. Si ricostruiscono QUI, con gli
+         *   stessi codici (124 / 130) e le stesse marche del kernel. Dichiarato, non nascosto.
+         */
+        const work = broker.execute(request).then((value) => ({ kind: 'ok', value }), (error) => ({ kind: 'error', error }));
+        let timer;
+        const expired = new Promise((resolve) => { timer = setTimeout(() => resolve({ kind: 'timeout' }), timeoutMs); });
+        const stopped = new Promise((resolve) => {
+            const signal = opts.segnaleStop;
+            if (!signal)
+                return;
+            if (signal.aborted) {
+                resolve({ kind: 'stopped' });
+                return;
+            }
+            signal.addEventListener('abort', () => resolve({ kind: 'stopped' }), { once: true });
+        });
+        let outcome;
+        try {
+            outcome = await Promise.race([work, expired, stopped]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+        if (outcome.kind === 'timeout')
+            return {
+                codice: KERNEL_EXIT.timeout,
+                fermatoDalTempo: true,
+                testo: `\n\n${EXECUTION_TEXT.marker.timedOut(timeoutMs)}`.trim(),
+                enforcement: annotate(EXECUTION_TEXT.isolation.sandboxWithoutEvidence, EXECUTION_TEXT.reason.timedOut(timeoutMs)),
+                cartellaFinale: null,
+            };
+        if (outcome.kind === 'stopped')
+            return {
+                codice: KERNEL_EXIT.stoppedOnRequest,
+                fermatoSuRichiesta: true,
+                testo: `\n\n${EXECUTION_TEXT.marker.stoppedOnRequest} ${EXECUTION_TEXT.marker.stoppedOnRequestSentence}`.trim(),
+                enforcement: annotate(EXECUTION_TEXT.isolation.sandboxWithoutEvidence, EXECUTION_TEXT.reason.stoppedOnRequest),
+                cartellaFinale: null,
+            };
+        if (outcome.kind === 'error') {
+            const failure = outcome.error;
+            /*
+             * ⛔⛔⛔ UN SOLO ERRORE E' CONDIZIONE DI RIPIEGO: «non esiste nessun backend». Tutto il resto —
+             *   e in particolare `SANDBOX_EVIDENCE_MISMATCH` — RISALE. Una sandbox che esiste e ha
+             *   RIFIUTATO non si aggira in silenzio: sarebbe la peggiore delle bugie, perche' il comando
+             *   girerebbe fuori dall'isolamento proprio nel caso in cui l'isolamento aveva qualcosa da dire.
+             */
+            /* ⛔ Il broker non si e' potuto COSTRUIRE: nessun isolamento esiste, quindi si esegue fuori, e
+               la riga dice perche' con il codice dell'errore — mai «non configurato in questa build». */
+            if (failure?.code === BROKER_CONSTRUCTION_FAILED) {
+                if (requireVerifiedIsolation)
+                    throw outcome.error;
+                const detail = failure.hint ?? t('screen.exec.why.noDetail');
+                return fallback(helpers, comando, cartella, opts, declaredHost ? EXECUTION_TEXT.reason.brokerUnbuildable(detail) : EXECUTION_TEXT.reason.brokerConstructionFailed(detail));
+            }
+            /*
+             * ⛔ R0 lane S: `SANDBOX_REQUIRED_UNAVAILABLE` from the BROKER is the same fact as EXECUTION_BACKEND_UNAVAILABLE —
+             *   no verified backend exists — for a request that required the Windows sandbox (execution-broker.ts). Its
+             *   cause carries the backend's own reason (for example the probe's). Everything else still propagates:
+             *   EXECUTION_BACKEND_FAILED, SANDBOX_EVIDENCE_MISMATCH, SANDBOX_PATH_INVALID, SANDBOX_CWD_NOT_GRANTED.
+             */
+            if (declaredHost && failure?.code === 'SANDBOX_REQUIRED_UNAVAILABLE') {
+                const cause = outcome.error?.cause;
+                const why = cause instanceof Error && cause.message ? cause.message : failure.hint ?? t('screen.exec.why.noBackend');
+                return fallback(helpers, comando, cartella, opts, EXECUTION_TEXT.reason.sandboxUnverified(why));
+            }
+            if (failure?.code !== 'EXECUTION_BACKEND_UNAVAILABLE')
+                throw outcome.error;
+            if (requireVerifiedIsolation)
+                throw outcome.error;
+            const why = failure.hint ?? failure.message ?? t('screen.exec.why.noEnforcement');
+            return fallback(helpers, comando, cartella, opts, declaredHost ? EXECUTION_TEXT.reason.sandboxUnverified(why) : EXECUTION_TEXT.reason.backendUnavailable(why));
+        }
+        const { exitCode, stdout, stderr, evidence } = outcome.value;
+        /*
+         * ⛔ Round 5: nessuna coda, quindi niente da staccare. Stdout e stderr arrivano come il comando li ha
+         *   scritti — anche se contengono qualcosa che somiglia a un marcatore: e' uscita del comando.
+         * ⛔ Round 2, ancora vero: stderr non si perde mai, e non si unisce a stdout prima di un taglio.
+         */
+        const out = String(stdout ?? '').replace(/[\r\n]+$/u, '');
+        const err = String(stderr ?? '').replace(/[\r\n]+$/u, '');
+        /*
+         * ⛔ DEBITO B1.10, DICHIARATO: sul ramo brokerato l'uscita dal vivo NON esiste — il contratto di
+         *   risultato del backend non ha un canale di streaming. Si emette il testo intero UNA volta
+         *   prima di tornare, cosi' chi ascolta vede qualcosa; il ramo di ripiego continua a trasmettere
+         *   a pezzi come sempre.
+         * ⛔ E per la stessa ragione l'ORDINE fra i due flussi non esiste qui: prima stdout, poi stderr.
+         *   Il ripiego del kernel li intreccia nell'ordine d'arrivo; questo contratto non lo permette.
+         */
+        if (out)
+            opts.onPezzo?.({ flusso: 'fuori', testo: out });
+        if (err)
+            opts.onPezzo?.({ flusso: 'errori', testo: out ? `\n${err}` : err });
+        return {
+            /* ⛔ Lo stato d'uscita del PROCESSO `cmd /d /s /c <comando>`, lo stesso di `cmd /c` semplice. Mai un
+               numero letto dal testo. */
+            codice: exitCode,
+            /* ⛔ Il taglio e' quello del KERNEL, non una seconda regola: persona e modello devono leggere
+               lo stesso testo sotto lo stesso nome. */
+            testo: await cutOutput(helpers, `${out}\n${err}`.trim()),
+            enforcement: annotate(EXECUTION_TEXT.isolation.sandbox(evidence.backend), EXECUTION_TEXT.reason.verified(evidence)),
+            /* ⛔ Nessuna coda, nessuna cartella finale: il registro tiene quella di prima. */
+            cartellaFinale: null,
+        };
+    };
+}

package/dist/runtime/context-archive.js

@@ -0,0 +1,69 @@
+/*
+ * P12 (owner, 2026-09-25, "quando riprendo sessione mi dà CTX_HISTORY_DIVERGED"). Measured on a copy of the owner's
+ * session and Context Engine archive: the archive held 10 messages, the last an assistant message with a tool call and NO
+ * result (12:16:45, the turn interrupted there); the session's own history had dropped that unanswered call, as it must (a
+ * call without its result is not sent back to a model), and gone on with the next person's messages. From then on the
+ * archive was no longer a prefix of the history, `syncOriginals` (harness-ui/src/context-desktop-service.mjs:202) refused
+ * every turn, and the session could not be resumed.
+ * Where the unanswered call came from: the kernel archives the whole history at several points of a turn, among them
+ * right after the model's answer, BEFORE the tools run (talosHarness.mjs `capture` reason 'response'). The cure, on the
+ * CLI's side of the bridge (the kernel and the service are not edited): `capture` never archives an assistant message
+ * whose tool calls do not all have a result yet, nor the partial results after it. The next capture, once the results
+ * are in, archives the exchange whole; if the turn stops first, nothing unanswered was archived. The archive stays a
+ * prefix of the history in both cases.
+ */
+/** The longest prefix of `messages` that does not end inside an unanswered tool exchange. */
+export function archivableHistory(messages) {
+    const rows = messages;
+    for (let index = rows.length - 1; index >= 0; index--) {
+        const message = rows[index];
+        if (message?.role !== 'assistant' || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0)
+            continue;
+        const wanted = new Set(message.tool_calls.map((call) => call?.id).filter((id) => typeof id === 'string' && id));
+        for (let later = index + 1; later < rows.length && rows[later]?.role === 'tool'; later++)
+            wanted.delete(rows[later].tool_call_id);
+        /* The last tool exchange decides: complete, the whole history is archivable; unanswered, it and what follows wait. */
+        return wanted.size === 0 ? [...messages] : messages.slice(0, index);
+    }
+    return [...messages];
+}
+/*
+ * The same measurement found a race: `syncOriginals` reads the session revision, then appends with it
+ * (context-desktop-service.mjs:199-204), while a Context Engine compaction running in the background can commit a version
+ * in between (outside that session's queue). The append is then refused with CTX_STALE_REVISION and the TURN failed
+ * (r5a-coord-ce-compaction: 3 of 8 runs once capture waited for whole tool exchanges, 0 of 11 before; the race existed
+ * before too, only rarer). A retry is safe: `syncOriginals` rereads the revision and appends only what is missing, and
+ * `prepare` recomputes from the archive. So `capture` and `prepare` retry a stale revision, briefly.
+ * The shape follows Hermes' SQLite write retry (hermes_state.py:467-489, read 2026-09-26): patience is TIME-based, since
+ * "attempt-counted budgets destroyed turns on a healthy store", and each wait is RANDOM (20-150 ms), so two writers that
+ * lost the same race do not collide again in step (the "full jitter" of AWS's "Exponential Backoff and Jitter"). The
+ * budget is short, like Hermes' wait on a live compression lock: a compaction's commit is one write, and the revision reread
+ * after it succeeds; a revision that keeps moving for two seconds is a real conflict, and the error goes on.
+ */
+const STALE_PATIENCE_MS = 2_000, STALE_WAIT_MIN_MS = 20, STALE_WAIT_MAX_MS = 150;
+async function retryStale(operation, patienceMs) {
+    const deadline = Date.now() + patienceMs;
+    for (;;) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const remaining = deadline - Date.now();
+            if (error?.code !== 'CTX_STALE_REVISION' || remaining <= 0)
+                throw error;
+            const wait = STALE_WAIT_MIN_MS + Math.random() * (STALE_WAIT_MAX_MS - STALE_WAIT_MIN_MS);
+            await new Promise(resolve => setTimeout(resolve, Math.min(wait, remaining)));
+        }
+    }
+}
+/** The service's kernel hooks: `capture` archives only whole tool exchanges; `capture` and `prepare` retry a stale revision. */
+export function withArchivableCapture(hooks, { stalePatienceMs = STALE_PATIENCE_MS } = {}) {
+    if (!hooks || typeof hooks.capture !== 'function')
+        return hooks;
+    const capture = hooks.capture, prepare = hooks.prepare;
+    return {
+        ...hooks,
+        capture: (input) => retryStale(() => capture({ ...input, messages: Array.isArray(input?.messages) ? archivableHistory(input.messages) : input?.messages }), stalePatienceMs),
+        ...(typeof prepare === 'function' ? { prepare: (input) => retryStale(() => prepare(input), stalePatienceMs) } : {}),
+    };
+}

package/dist/runtime/context-status.js

@@ -0,0 +1,76 @@
+const DEFAULT_TRIGGER_RATIO = 0.5;
+function finite(value) { return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null; }
+function positive(value) { const n = finite(value); return n !== null && n > 0 ? n : null; }
+function ratio(value, fallback = null) { const n = finite(value); return n !== null && n > 0 && n < 1 ? n : fallback; }
+function percent(numerator, denominator) { return Math.round((numerator / denominator) * 1000) / 10; }
+function integer(value) { return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : null; }
+function text(value) { return typeof value === 'string' && value.trim() ? value.trim() : null; }
+export function unavailableContextStatus(sessionId, reason) {
+    return {
+        schema: 'talos.cli.context-status.v1', sessionId, available: false, reason,
+        measurement: null, budget: null,
+        autoCompaction: { enabled: true, triggerRatio: DEFAULT_TRIGGER_RATIO, triggerPercent: 50, targetRatio: null, provenance: 'CLI owner policy; active only when Context Engine measurement is available' },
+        cache: { promptTokens: null, cachedTokens: null, percent: null, provenance: 'not measured' },
+        cost: { usd: null, provenance: 'not reported by runtime' },
+        sources: { activeVersionId: null, activeSourceCount: null, summaryCitationCount: null, provenance: 'no measured Context Engine snapshot' },
+    };
+}
+export function buildContextStatus({ sessionId, snapshot, sessionUsage }) {
+    if (!snapshot || typeof snapshot !== 'object')
+        return unavailableContextStatus(sessionId, 'not-measured');
+    const revision = integer(snapshot.revision);
+    const measured = snapshot.measurement && typeof snapshot.measurement === 'object' ? snapshot.measurement : null;
+    const tokens = measured?.tokens && typeof measured.tokens === 'object' ? measured.tokens : null;
+    const inputTokens = integer(tokens?.inputTokens), windowTokens = positive(tokens?.windowTokens), responseReserve = integer(tokens?.responseReserve);
+    const method = ['runtime', 'provider', 'heuristic'].includes(tokens?.method) ? tokens.method : null;
+    const measurement = inputTokens !== null && windowTokens !== null && responseReserve !== null && method ? {
+        inputTokens, windowTokens, responseReserve,
+        percentOfWindow: percent(inputTokens, windowTokens),
+        method, exact: tokens?.exact === true,
+        measuredAt: text(measured?.measuredAt),
+        revision: integer(measured?.revision),
+        stale: revision !== null && integer(measured?.revision) !== revision,
+        estimatedMarginTokens: integer(tokens?.estimatedMarginTokens),
+    } : null;
+    const settings = snapshot.settings && typeof snapshot.settings === 'object' ? snapshot.settings : {};
+    const triggerRatio = ratio(settings.triggerRatio, DEFAULT_TRIGGER_RATIO) ?? DEFAULT_TRIGGER_RATIO;
+    const targetRatio = ratio(settings.targetRatio, null);
+    const promptTokens = integer(sessionUsage?.promptTokens);
+    const cachedTokens = integer(sessionUsage?.cachedTokens);
+    const cacheMeasured = promptTokens !== null && promptTokens > 0 && cachedTokens !== null && cachedTokens <= promptTokens;
+    const active = snapshot.activeVersion && typeof snapshot.activeVersion === 'object' ? snapshot.activeVersion : null;
+    const sourceIds = Array.isArray(active?.sourceIds) ? active.sourceIds : null;
+    const citations = Array.isArray(active?.summary?.sources) ? active.summary.sources : null;
+    const profile = snapshot.cliProfileEvidence && typeof snapshot.cliProfileEvidence === 'object' ? snapshot.cliProfileEvidence : null;
+    const profileSource = text(profile?.source);
+    const profileDate = text(profile?.date);
+    const safetyMarginTokens = measurement ? Math.max(measurement.method === 'heuristic' ? 1024 : 256, Math.ceil(measurement.windowTokens * (measurement.method === 'heuristic' ? 0.15 : 0.05))) : null;
+    const inputLimitTokens = measurement && safetyMarginTokens !== null ? Math.max(0, measurement.windowTokens - measurement.responseReserve - safetyMarginTokens) : null;
+    const budget = measurement && safetyMarginTokens !== null && inputLimitTokens !== null ? {
+        windowTokens: measurement.windowTokens, responseReserve: measurement.responseReserve,
+        safetyMarginTokens, inputLimitTokens, triggerTokens: Math.floor(inputLimitTokens * triggerRatio),
+        estimatedMarginTokens: measurement.estimatedMarginTokens,
+        provenance: (profileSource ? 'model profile: ' + profileSource + (profileDate ? ' (' + profileDate + ')' : '') : measurement.method + ' prepared-request measurement') + '; Context Engine effective-input safety budget',
+    } : null;
+    return {
+        schema: 'talos.cli.context-status.v1', sessionId, available: true, reason: measurement ? null : 'not-measured',
+        measurement, budget,
+        autoCompaction: {
+            enabled: settings.auto === true,
+            triggerRatio, triggerPercent: Math.round(triggerRatio * 1000) / 10, targetRatio,
+            provenance: 'Context Engine session settings; CLI owner trigger policy is 0.50',
+        },
+        cache: {
+            promptTokens, cachedTokens,
+            percent: cacheMeasured ? percent(cachedTokens, promptTokens) : null,
+            provenance: cacheMeasured ? 'whole-session measured usage' : 'not measured',
+        },
+        cost: { usd: null, provenance: 'not reported by runtime' },
+        sources: {
+            activeVersionId: text(active?.id),
+            activeSourceCount: sourceIds ? sourceIds.length : null,
+            summaryCitationCount: citations ? citations.length : null,
+            provenance: active ? 'Context Engine active version' : 'no active compacted version',
+        },
+    };
+}