talos-code 0.0.1 → 0.1.0

package/dist/runtime/create-runtime.js

@@ -0,0 +1,111 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { findTalosRepoRoot } from "./repo.js";
+import { ensureCliPaths, resolveCliPaths } from "../paths.js";
+import { composeTalosRuntime } from "./talos-composition.js";
+import { assertProjectTrusted } from "../security/project-trust-gate.js";
+import { createCliExecutionBroker } from "../security/execution-backends.js";
+import { createUnbuildableExecutionBroker } from "./brokered-executor.js";
+import { environmentKeyModeForEntry } from "../provider/environment-keys.js";
+import { createRuntimeSupervisor } from "./supervisor.js";
+import { developmentLog, developmentLogError } from "../diagnostics/development-log.js";
+/**
+ * ⛔ Il default e' il broker VERO, per identita' e non per somiglianza.
+ * `composeTalosRuntime` ha sempre accettato `brokerFactory`, e fino a questa fetta NESSUNO gliela
+ * passava: i due ingressi qui sotto omettevano il campo, quindi ogni comando digitato finiva nel
+ * ripiego e dichiarava «nessun broker configurato». Il collegamento sta QUI e non nella
+ * composizione, perche' la composizione e' gia' parametrica: e' l'ingresso che non sceglieva.
+ */
+export const DEFAULT_EXECUTION_BROKER_FACTORY = createCliExecutionBroker;
+/**
+ * Consegna alla composizione una fabbrica che costruisce il broker la PRIMA volta che la
+ * composizione la chiama, e poi restituisce sempre la stessa istanza.
+ *
+ * ⛔ Perche' si costruisce DENTRO la chiamata della composizione e non qui: una revisione ha
+ *   provato a costruire il broker e poi buttarlo via (mutazione M10), e le prove restavano verdi,
+ *   perche' contavano le costruzioni e non chi le chiedeva. Adesso l'unico modo di costruirlo e'
+ *   che la composizione lo chieda: costruito e raggiunto sono la stessa cosa.
+ * ⛔ Perche' l'istanza e' una sola: il backend misura l'albero di processi al primo `available()`
+ *   e memoizza quella misura per la sua vita. Una costruzione per comando rifarebbe la sonda ogni
+ *   volta, e sarebbe un difetto di prestazioni invisibile, perche' il comando funzionerebbe lo stesso.
+ *
+ * ⛔⛔ E perche' il `try` esiste: la disponibilita' e' a prova di guasto in due versi OPPOSTI.
+ *   Per l'ISOLAMENTO si chiude (un backend che non prova il suo confinamento non esegue niente:
+ *   lo decide `execution-broker.ts`). Per l'ESECUZIONE si apre: se il broker non si riesce
+ *   nemmeno a COSTRUIRE, il comando della persona gira lo stesso attraverso il kernel.
+ * ⛔⛔ Ma NON in silenzio (revisione, round 2): prima questo `catch` restituiva «nessun broker» e la
+ *   riga diceva «non configurato in questa build», anche per un TypeError di contratto. Ora il
+ *   broker sostituto rifiuta ogni esecuzione portando il codice dell'errore vero, e la riga dice
+ *   «the isolation broker could not be built (<codice>: <messaggio>)».
+ */
+export function resolveExecutionBrokerFactory(input) {
+    const factory = input.brokerFactory ?? DEFAULT_EXECUTION_BROKER_FACTORY;
+    let broker;
+    return { brokerFactory: (options) => {
+            if (broker)
+                return broker;
+            try {
+                const built = factory(options);
+                broker = built ?? createUnbuildableExecutionBroker(Object.assign(new TypeError('the broker factory returned no broker'), { code: 'EXECUTION_BROKER_FACTORY_RETURNED_NOTHING' }));
+            }
+            catch (cause) {
+                developmentLogError('runtime.broker.construct_failure', cause, { platform: options.platform }, 'runtime-create');
+                broker = createUnbuildableExecutionBroker(cause);
+            }
+            return broker;
+        } };
+}
+/**
+ * ⛔ `prepared` restituisce l'INTERO argomento di `composeTalosRuntime`, non dei pezzi da
+ *   riassemblare due volte. Cosi' i due ingressi non possono divergere: una differenza fra loro e'
+ *   il modo in cui una funzione finisce per esistere in un comando e non nell'altro, ed e' gia'
+ *   successo in questo programma. Qui non c'e' un secondo posto dove sbagliarla.
+ * ⛔ Il broker si costruisce DOPO il cancello della fiducia: un progetto non fidato non arriva
+ *   nemmeno a toccare la cache delle prove.
+ */
+async function prepared(input) {
+    const root = input.repoRoot ?? findTalosRepoRoot(process.cwd());
+    const paths = input.paths ?? resolveCliPaths(process.env, process.platform, homedir());
+    await ensureCliPaths(paths);
+    if (!input.trustVerified)
+        await assertProjectTrusted({ projectRoot: input.projectRoot, trustRoot: paths.trust.projects });
+    return { repoRoot: root, projectRoot: input.projectRoot, paths, model: input.model ?? 'openai:gpt-5-mini', ...(input.keyring !== undefined ? { keyring: input.keyring } : {}), ...resolveExecutionBrokerFactory(input) };
+}
+/**
+ * ⭐ B1 slice 18 — WHO USES AN ENVIRONMENT KEY WITHOUT ASKING.
+ * The ENTRY decides, and says so explicitly (fix round, condition 3): `main.ts` passes `consent` for the interactive screen and
+ * `use` for `talos -p`; the one-shot commands that run a model pass `use` and state the key's origin; `talos provider` passes
+ * `consent`. Measured by the coordinator before this round: with the subcommands left on this factory's default,
+ * `talos research start` in CI with `OPENROUTER_API_KEY` set exited 2 and sent nothing.
+ * ⛔ A caller that forgets to choose gets `consent` from both factories: the closed behaviour.
+ * ⛔ `TALOS_ENVIRONMENT_KEYS=consent`, which the screen sets on every child it spawns, closes whatever the entry asked for; no
+ *   value of that variable opens anything (`environmentKeyModeForEntry`).
+ */
+function entryMode(input) { return environmentKeyModeForEntry(input.environmentKeys ?? 'consent', process.env); }
+async function composeRuntimeContext(input) {
+    developmentLog('runtime.compose.begin', { projectRoot: input.projectRoot, model: input.model ?? null, environmentKeys: input.environmentKeys ?? 'consent' }, 'debug', 'runtime-create');
+    const context = await composeTalosRuntime({ ...await prepared(input), environmentKeys: entryMode(input) });
+    developmentLog('runtime.compose.ready', { projectRoot: input.projectRoot, model: input.model ?? null }, 'info', 'runtime-create');
+    return context;
+}
+function supervisorRoot(input) {
+    const paths = input.paths ?? resolveCliPaths(process.env, process.platform, homedir());
+    return join(paths.dataRoot, 'runtime-supervisor');
+}
+export async function createCliRuntime(input) {
+    const initial = await composeRuntimeContext(input);
+    return createRuntimeSupervisor({
+        initialRuntime: initial.runtime,
+        runtimeFactory: async () => (await composeRuntimeContext(input)).runtime,
+        journalRoot: supervisorRoot(input),
+    });
+}
+export async function createCliRuntimeContext(input) {
+    const initial = await composeRuntimeContext(input);
+    const runtime = createRuntimeSupervisor({
+        initialRuntime: initial.runtime,
+        runtimeFactory: async () => (await composeRuntimeContext(input)).runtime,
+        journalRoot: supervisorRoot(input),
+    });
+    return { ...initial, runtime };
+}

package/dist/runtime/model-profile.js

@@ -0,0 +1,361 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/*
+ * R5 CONTRACT (owner: lane R; stub written by the coordinator so both lanes compile). Owner decision Q-R5-3: a model's
+ * context window comes from the registry rows, the provider's live list when it carries the fields, Ollama's /api/show, a
+ * person's override (config `models.<provider:model>.contextWindow`) and the models.dev catalogue (one outbound request, no
+ * key, 4 h cache). `null` means nobody knows it: the screen then says `ctx ?` and never invents a number (gate E1). Lane S
+ * only CALLS modelProfile; lane R owns the body and may add loaders, never change this signature.
+ *
+ * R5a lane R — the body. `modelProfile` is synchronous (the screen calls it while drawing): it reads layers that the
+ * composition fills and keeps fresh, highest first:
+ *   1. `override`    the person's `models.<provider:model>.contextWindow` (and, optional, `.maxOutputTokens`), config/load.ts;
+ *   2. `ollama-show` a local Ollama's own answer for the model (see `ollamaWindow`);
+ *   3. `provider`    rows the provider's store keeps (`provider-runtime.json` `modelli`) and live catalogue rows that carry a
+ *                    window (catalog-service.ts, e.g. OpenRouter's `context_length`);
+ *   4. `registry`    the kernel registry's documented rows (`modelliNoti`, `modelliDiRiserva`: dated sources);
+ *   5. `models.dev`  the kernel's catalogue adapter (model-catalog-models-dev.mjs), under gate E7 (see `createModelsDevLoader`).
+ * The window comes from the highest layer that has one; the reserve (the model's maximum output, which the kernel sends as
+ * `max_tokens` once the Context Engine prepares the request, talosHarness.mjs `preparedContext.measurement.responseReserve`)
+ * from the highest layer that knows it. When no layer knows the output limit the reserve is Pi's default for a model without
+ * one, 16,384 (pi-mono packages/coding-agent/src/core/provider-composer.ts:225 `maxTokens: definition.maxTokens ?? 16384`,
+ * 2026-09-24), never more than a quarter of the window.
+ */
+import { pathToFileURL } from 'node:url';
+import { join } from 'node:path';
+const DEFAULT_RESERVE = 16_384;
+/*
+ * R5a (owner decision 2026-09-24, from the s22 acceptance run): the Context Engine runs only for a window of 64k tokens or
+ * more. TALOS's own instructions and tools are about 11.1k tokens; the engine's input limit is the window minus the reserve
+ * (a quarter of a small window) minus a 15 % heuristic margin (context-engine profiles.mjs:6), about 0.6 x the window: a 16k
+ * window failed every turn (CTX_CONTEXT_OVERFLOW) and anything under ~40k compacts at once. Below this TALOS keeps its simple
+ * mode (the kernel's path) and the screen says so once (tui/usage-view.ts smallWindowNotice).
+ */
+export const CONTEXT_ENGINE_MIN_WINDOW = 64_000;
+const state = {
+    rowsFor: (() => ({ runtime: [], registry: [] })),
+    registry: {},
+    overrides: new Map(),
+    ollama: new Map(),
+    live: new Map(),
+    modelsDev: new Map(),
+};
+function positiveInteger(value) { return Number.isSafeInteger(value) && Number(value) > 0 ? Number(value) : null; }
+function positiveNumber(value) { const n = typeof value === 'string' && value.trim() !== '' ? Number(value) : value; return typeof n === 'number' && Number.isFinite(n) && n >= 0 ? n : null; }
+function keyOf(provider, model) { const prefix = `${provider}:`; return `${provider}:${model.startsWith(prefix) ? model.slice(prefix.length) : model}`; }
+function day(value) { if (typeof value !== 'string' || !value)
+    return null; const match = /^\d{4}-\d{2}-\d{2}/u.exec(value); return match ? match[0] : null; }
+function today(now = Date.now()) { return new Date(now).toISOString().slice(0, 10); }
+/** The composition's sources: the provider store's rows and the registry's, read live on every call (they are small). A new
+ *  composition is a new runtime: what an earlier one learnt from the network (live lists, Ollama, models.dev) is dropped and
+ *  learnt again (models.dev from its disk cache). */
+export function configureModelProfiles({ rowsFor, registry }) {
+    state.rowsFor = rowsFor;
+    state.registry = registry ?? {};
+    state.overrides.clear();
+    state.ollama.clear();
+    state.live.clear();
+    state.modelsDev.clear();
+}
+/** Test and restart hygiene: every layer back to empty. */
+export function resetModelProfiles() {
+    state.rowsFor = () => ({ runtime: [], registry: [] });
+    state.registry = {};
+    state.overrides.clear();
+    state.ollama.clear();
+    state.live.clear();
+    state.modelsDev.clear();
+}
+/** `config.models` (validated by config/load.ts): `{"provider:model":{contextWindow,maxOutputTokens?}}`. */
+export function setModelOverrides(models) {
+    state.overrides.clear();
+    if (!models || typeof models !== 'object' || Array.isArray(models))
+        return;
+    for (const [id, row] of Object.entries(models)) {
+        const windowTokens = positiveInteger(row?.contextWindow), outputTokens = positiveInteger(row?.maxOutputTokens);
+        if (windowTokens === null && outputTokens === null)
+            continue;
+        const split = splitModelId(id);
+        if (!split)
+            continue;
+        state.overrides.set(keyOf(split.provider, split.model), { windowTokens, outputTokens });
+    }
+}
+/** The provider part of a TALOS model id: a known registry prefix, else OpenRouter (model-destination.mjs:65-75). */
+export function splitModelId(id) {
+    if (typeof id !== 'string' || !id.trim())
+        return null;
+    const cut = id.indexOf(':');
+    if (cut > 0) {
+        const provider = id.slice(0, cut);
+        if (Object.hasOwn(state.registry, provider) || provider === 'openrouter' || provider === 'ollama' || provider === 'local')
+            return { provider, model: id.slice(cut + 1) };
+    }
+    return { provider: 'openrouter', model: id };
+}
+/** A local engine (the registry's `catalogo.fonte: 'runtime-locale'`: Ollama, LM Studio, the embedded runtime). */
+export function isLocalProvider(provider) {
+    if (!provider)
+        return false;
+    if (provider === 'local')
+        return true;
+    return state.registry[provider]?.catalogo?.fonte === 'runtime-locale';
+}
+/** Rows from a provider's live catalogue (OpenRouter `/models`, a kernel probe list): those that carry a window. */
+export function rememberProviderModelRows(provider, rows, now = Date.now()) {
+    for (const row of rows ?? []) {
+        const raw = String(row?.id ?? row?.modelId ?? '').trim();
+        if (!raw)
+            continue;
+        const windowTokens = positiveInteger(row?.context_length ?? row?.contextLength ?? row?.contextWindow);
+        const outputTokens = positiveInteger(row?.top_provider?.max_completion_tokens ?? row?.maxOutputTokens ?? row?.max_output_tokens);
+        const prompt = positiveNumber(row?.pricing?.prompt), completion = positiveNumber(row?.pricing?.completion), cacheRead = positiveNumber(row?.pricing?.input_cache_read);
+        const price = prompt !== null && completion !== null ? { inputPerMTok: prompt * 1_000_000, outputPerMTok: completion * 1_000_000, cacheReadPerMTok: cacheRead === null ? null : cacheRead * 1_000_000, source: `${provider} model list`, date: today(now) } : null;
+        if (windowTokens === null && outputTokens === null && !price)
+            continue;
+        state.live.set(keyOf(provider, raw), { windowTokens, outputTokens, date: today(now), price });
+    }
+}
+/** Ollama's own window for a model (see `ollamaWindow`). */
+export function rememberOllamaWindow(provider, model, windowTokens, now = Date.now()) {
+    const key = keyOf(provider, model);
+    if (windowTokens === null) {
+        state.ollama.delete(key);
+        return;
+    }
+    state.ollama.set(key, { windowTokens, outputTokens: null, date: today(now) });
+}
+function registryLayers(provider, model) {
+    let rows = { runtime: [], registry: [] };
+    try {
+        rows = state.rowsFor(provider) ?? rows;
+    }
+    catch { /* a source that cannot be read is no source */ }
+    const same = (row) => { const raw = String(row?.id ?? row?.modelId ?? ''); return raw === model || raw === `${provider}:${model}`; };
+    const layer = (row) => row ? { windowTokens: positiveInteger(row.contextLength ?? row.contextWindow ?? row.max_context_length ?? row.maxInputTokens), outputTokens: positiveInteger(row.maxOutputTokens ?? row.max_output_tokens ?? row.outputTokenLimit), date: day(row.dataMetadati ?? row.data) } : null;
+    const runtimeRow = (rows.runtime ?? []).find(same), registryRow = (rows.registry ?? []).find(same);
+    const record = state.registry[provider];
+    const own = registryRow?.prezzi;
+    const price = own && positiveNumber(own.ingresso) !== null && positiveNumber(own.uscita) !== null
+        ? { inputPerMTok: positiveNumber(own.ingresso), outputPerMTok: positiveNumber(own.uscita), cacheReadPerMTok: positiveNumber(own.cache), source: typeof record?.prezzi?.fonte === 'string' ? record.prezzi.fonte : 'TALOS provider registry', date: day(record?.prezzi?.data) ?? day(registryRow?.data) }
+        : null;
+    return { provider: layer(runtimeRow), registry: layer(registryRow), price };
+}
+export function modelProfile(input) {
+    const provider = typeof input?.provider === 'string' ? input.provider : '';
+    const model = typeof input?.model === 'string' ? input.model : '';
+    if (!provider || !model)
+        return null;
+    const key = keyOf(provider, model);
+    const bare = key.slice(provider.length + 1);
+    const fixed = registryLayers(provider, bare);
+    const override = state.overrides.get(key);
+    const layers = [
+        ['override', override ? { windowTokens: override.windowTokens, outputTokens: override.outputTokens, date: null } : null],
+        ['ollama-show', state.ollama.get(key)],
+        ['provider', fixed.provider],
+        ['provider', state.live.get(key)],
+        ['registry', fixed.registry],
+        ['models.dev', state.modelsDev.get(key)],
+    ];
+    const windowLayer = layers.find(([, layer]) => layer?.windowTokens);
+    if (!windowLayer)
+        return null;
+    const [source, chosen] = windowLayer;
+    const windowTokens = chosen.windowTokens;
+    const output = layers.find(([, layer]) => layer?.outputTokens)?.[1]?.outputTokens ?? null;
+    const responseReserve = output !== null && output < windowTokens ? output : Math.max(1, Math.min(DEFAULT_RESERVE, Math.floor(windowTokens / 4)));
+    if (responseReserve >= windowTokens)
+        return null;
+    return { windowTokens, responseReserve, source, date: chosen.date };
+}
+/** Where the window of `modelProfile` comes from, for the context status's provenance: a row's own dated source URL when the
+ *  registry or the provider's store names one, else the layer's name. */
+export function modelProfileEvidence(input) {
+    const profile = modelProfile(input);
+    if (!profile)
+        return null;
+    if (profile.source === 'registry' || profile.source === 'provider') {
+        let rows = { runtime: [], registry: [] };
+        try {
+            rows = state.rowsFor(input.provider) ?? rows;
+        }
+        catch { /* no rows */ }
+        const bare = keyOf(input.provider, input.model).slice(input.provider.length + 1);
+        const row = [...(rows.runtime ?? []), ...(rows.registry ?? [])].find((candidate) => { const raw = String(candidate?.id ?? candidate?.modelId ?? ''); return raw === bare || raw === `${input.provider}:${bare}`; });
+        const url = typeof row?.fonteMetadati === 'string' ? row.fonteMetadati : typeof row?.fonte === 'string' ? row.fonte : null;
+        if (url)
+            return { source: url, date: profile.date };
+    }
+    return { source: profile.source, date: profile.date };
+}
+/** The list price of a model from a NAMED source (registry, live list, models.dev), or null. Never invented. */
+export function modelPrice(input) {
+    const provider = typeof input?.provider === 'string' ? input.provider : '';
+    const model = typeof input?.model === 'string' ? input.model : '';
+    if (!provider || !model || isLocalProvider(provider))
+        return null;
+    const key = keyOf(provider, model);
+    const bare = key.slice(provider.length + 1);
+    return registryLayers(provider, bare).price ?? state.live.get(key)?.price ?? state.modelsDev.get(key)?.price ?? null;
+}
+/*
+ * OLLAMA. The window Ollama runs a model with is NOT the model's trained maximum (`model_info.<arch>.context_length`, which
+ * /api/show and /api/tags report): it is the Modelfile's `num_ctx`, else the server's default — "Context length to use unless
+ * otherwise specified (default: 4k/32k/256k based on VRAM)" (ollama/ollama envconfig/config.go, 98acec40, 2026-09-15). A
+ * loaded model reports the window it really has in /api/ps `context_length` (api/types.go `ProcessModelResponse`, d0c8cdb7,
+ * 2026-09-18). So: `num_ctx` from /api/show `parameters` when set; else /api/ps for a loaded model; else unknown. The trained
+ * maximum only caps the first. Same rules as the R4 local list (catalog-service.ts): no key, no redirect, capped, 3 s.
+ */
+const OLLAMA_TIMEOUT_MS = 3_000, OLLAMA_MAX_BYTES = 4 * 1024 * 1024;
+async function readJsonCapped(response) {
+    if (!response.ok || !response.body) {
+        try {
+            await response.body?.cancel();
+        }
+        catch { /* not read */ }
+        return null;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > OLLAMA_MAX_BYTES)
+                return null;
+            chunks.push(value);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+    }
+    try {
+        return JSON.parse(new TextDecoder().decode(Buffer.concat(chunks)));
+    }
+    catch {
+        return null;
+    }
+}
+export async function ollamaWindow({ root, model, fetchImpl, signal }) {
+    const base = String(root ?? '').trim().replace(/\/+$/u, '').replace(/\/v1$/u, '');
+    if (!/^https?:\/\//iu.test(base))
+        return null;
+    const timeout = () => signal ? AbortSignal.any([signal, AbortSignal.timeout(OLLAMA_TIMEOUT_MS)]) : AbortSignal.timeout(OLLAMA_TIMEOUT_MS);
+    let trained = null;
+    try {
+        const show = await readJsonCapped(await fetchImpl(`${base}/api/show`, { method: 'POST', headers: { 'content-type': 'application/json', accept: 'application/json' }, body: JSON.stringify({ model }), redirect: 'error', signal: timeout() }));
+        const info = show?.model_info && typeof show.model_info === 'object' ? show.model_info : {};
+        trained = positiveInteger(Object.entries(info).find(([name]) => name.endsWith('.context_length'))?.[1]);
+        const numCtx = /(?:^|\n)\s*num_ctx\s+(\d+)\s*(?:\n|$)/u.exec(String(show?.parameters ?? ''));
+        if (numCtx) {
+            const value = positiveInteger(Number(numCtx[1]));
+            if (value !== null)
+                return trained !== null ? Math.min(value, trained) : value;
+        }
+    }
+    catch { /* not reachable: unknown */ }
+    try {
+        const ps = await readJsonCapped(await fetchImpl(`${base}/api/ps`, { method: 'GET', headers: { accept: 'application/json' }, redirect: 'error', signal: timeout() }));
+        const row = (Array.isArray(ps?.models) ? ps.models : []).find((entry) => entry?.name === model || entry?.model === model);
+        const loaded = positiveInteger(row?.context_length);
+        if (loaded !== null)
+            return loaded;
+    }
+    catch { /* not reachable: unknown */ }
+    return null;
+}
+/*
+ * MODELS.DEV, under gate E7: one outbound GET of https://models.dev/api.json, no key, no personal data; cached 4 h under the
+ * data root by the kernel adapter itself (model-catalog-models-dev.mjs: `<dataRoot>/cache/models-dev-<hash>.json`, TTL 4 h,
+ * ETag revalidation, schema-checked); this wrapper adds what E7 asks and the adapter does not do: `redirect:'error'`, a body
+ * capped at 32 MiB, 15 s (the adapter's own timeout). OFF in test profiles (`provider/store.ts` `isTestProfile`:
+ * TALOS_TEST_PROFILE=1 or NODE_TEST_CONTEXT) and when `TALOS_MODELS_DEV=off`: then nothing is imported and nothing is sent.
+ */
+export const MODELS_DEV_URL = 'https://models.dev/api.json';
+export const MODELS_DEV_MAX_BYTES = 32 * 1024 * 1024;
+export function modelsDevFetch(fetchImpl, maxBytes = MODELS_DEV_MAX_BYTES) {
+    return async (url, init = {}) => {
+        const response = await fetchImpl(url, { ...init, redirect: 'error' });
+        const declared = Number(response.headers?.get?.('content-length'));
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            try {
+                await response.body?.cancel();
+            }
+            catch { /* refused */ }
+            throw Object.assign(new Error('MODELS_DEV_TOO_LARGE'), { code: 'MODELS_DEV_TOO_LARGE' });
+        }
+        if (!response.body)
+            return response;
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > maxBytes)
+                    throw Object.assign(new Error('MODELS_DEV_TOO_LARGE'), { code: 'MODELS_DEV_TOO_LARGE' });
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => { });
+        }
+        return new Response(Buffer.concat(chunks), { status: response.status, statusText: response.statusText, headers: response.headers });
+    };
+}
+export const MODELS_DEV_CACHE_HOURS = 4;
+export function modelsDevSwitch({ env, config, testProfile }) {
+    if (testProfile)
+        return { enabled: false, reason: 'test' };
+    if (String(env.TALOS_MODELS_DEV ?? '').trim().toLowerCase() === 'off')
+        return { enabled: false, reason: 'environment' };
+    if (config?.catalog?.modelsDev === false)
+        return { enabled: false, reason: 'config' };
+    return { enabled: true, reason: 'on' };
+}
+export function createModelsDevLoader({ repoRoot, dataRoot, env, config, fetchImpl, testProfile }) {
+    if (!modelsDevSwitch({ env, config, testProfile }).enabled)
+        return { enabled: false, load: async () => { } };
+    let catalog = null;
+    const done = new Map();
+    const open = () => catalog ??= import(__rewriteRelativeImportExtension(pathToFileURL(join(repoRoot, 'harness-ui', 'src', 'model-catalog-models-dev.mjs')).href))
+        .then((m) => m.createModelsDevCatalog({ cartellaStore: dataRoot, url: MODELS_DEV_URL, fetchFn: modelsDevFetch(fetchImpl) }));
+    return {
+        enabled: true,
+        load(provider) {
+            const known = done.get(provider);
+            if (known)
+                return known;
+            const work = (async () => {
+                const result = await (await open()).ottieni(provider);
+                if (!result?.disponibile)
+                    return;
+                const date = day(result.aggiornatoAlle);
+                for (const row of result.modelli ?? []) {
+                    const model = String(row?.modelId ?? '');
+                    if (!model)
+                        continue;
+                    const prices = row?.prezziPerMilione;
+                    const input = positiveNumber(prices?.input), output = positiveNumber(prices?.output);
+                    state.modelsDev.set(keyOf(provider, model), { windowTokens: positiveInteger(row.contextLength), outputTokens: positiveInteger(row.maxOutputTokens), date,
+                        price: input !== null && output !== null ? { inputPerMTok: input, outputPerMTok: output, cacheReadPerMTok: positiveNumber(prices?.cache_read), source: 'models.dev', date } : null });
+                }
+            })().catch(() => { done.delete(provider); });
+            done.set(provider, work);
+            return work;
+        },
+    };
+}

package/dist/runtime/output-store.js

@@ -0,0 +1,137 @@
+/*
+ * R5a lane R, S6 — owner decision Q-R5-10 (2026-09-24), gate E6: a long command output is never cut in silence.
+ *
+ * The CLI holds the whole output before it is cut (brokered-executor.ts), so it keeps it: a private file under the data root
+ * (`<dataRoot>/tool-output/<sessionId>/<time>-<id>.txt`), never under the project; folder 0o700 and file 0o600 (on Windows the
+ * data root is inside the person's profile, whose ACL already admits only its owner; the mode bits are what POSIX reads),
+ * written once (`wx`), redacted with the existing secret patterns (`diagnostics/redact.ts`: the environment's secret values,
+ * `KEY=value` assignments, vendor-prefixed tokens, Bearer credentials), and deleted with its session: `deleteSessionToolOutput`
+ * for `talos session delete`, `pruneToolOutput` at start for a session whose record is gone.
+ *
+ * What the model reads is the same cut as before (a quarter kept from the head, three quarters from the tail, 4,000
+ * characters: the kernel's `uscitaUtile`, talosHarness.mjs:1489-1506) with an ENGLISH marker in place of the kernel's Italian
+ * `… [tolti N caratteri dal mezzo] …`: how much was cut, how much is shown, and the file that holds the rest (Pi, Claude
+ * Code, Gemini and OpenCode name the full-output file; gate §8). The marker is model-facing text, not a screen word: it stays
+ * English whatever the screen language, and the screen reads its numbers through `parseToolOutputMarker`.
+ */
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, readdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createRedactor } from "../diagnostics/redact.js";
+/** The kernel's own cut for a command's output: 4,000 characters, a quarter from the head (talosHarness.mjs:1489). */
+export const TOOL_OUTPUT_LIMIT = 4_000;
+export const TOOL_OUTPUT_HEAD_SHARE = 0.25;
+/** A file keeps at most this many characters; beyond it the file says where it stopped. */
+export const TOOL_OUTPUT_FILE_MAX = 8_000_000;
+const FOLDER = 'tool-output';
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+/** The kernel's Italian cut marker, whole (talosHarness.mjs:1505); pinned against the kernel source by r5a-r-output-store.test.ts. */
+export const KERNEL_CUT_MARKER = /\n\n… \[tolti (?<removed>\d+) caratteri dal mezzo\] …\n\n/u;
+const MARKER = /… \[TALOS cut (?<removed>\d+) characters from the middle of this output; (?<kept>\d+) of (?<total>\d+) characters are shown\.(?: The full output is saved in "(?<path>[^"\r\n]+)"; read that file for the rest\.| The full output could not be saved\.)\] …/u;
+function validSessionId(sessionId) { return typeof sessionId === 'string' && SESSION_ID.test(sessionId) && !sessionId.includes('..'); }
+export function toolOutputRoot(dataRoot) { return join(dataRoot, FOLDER); }
+export function createToolOutputStore({ dataRoot, secretValues = [], now = () => Date.now(), newId = () => randomUUID() }) {
+    const redactor = createRedactor(secretValues);
+    return {
+        async save({ sessionId, text }) {
+            if (!validSessionId(sessionId))
+                return null;
+            try {
+                const folder = join(toolOutputRoot(dataRoot), sessionId);
+                await mkdir(folder, { recursive: true, mode: 0o700 });
+                const body = text.length > TOOL_OUTPUT_FILE_MAX ? `${text.slice(0, TOOL_OUTPUT_FILE_MAX)}\n[TALOS stopped keeping this output after ${TOOL_OUTPUT_FILE_MAX} characters.]\n` : text;
+                const file = join(folder, `${now()}-${newId().replace(/[^A-Za-z0-9-]/gu, '').slice(0, 12)}.txt`);
+                await writeFile(file, redactor.text(body), { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+                try {
+                    await chmod(file, 0o600);
+                }
+                catch { /* Windows: the profile's ACL is the boundary */ }
+                return { path: file };
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+/** Removes the one folder of one session's kept outputs (named, validated; never a pattern). */
+export async function deleteSessionToolOutput(dataRoot, sessionId) {
+    if (!validSessionId(sessionId))
+        return false;
+    const folder = join(toolOutputRoot(dataRoot), sessionId);
+    if (!existsSync(folder))
+        return false;
+    await rm(folder, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    return true;
+}
+/**
+ * At start: the folders of sessions whose record no longer exists (`<sessionsRoot>/<id>.jsonl`, session-store.mjs:53-56) are
+ * removed, one named folder at a time after that check. Returns the ids removed. Never throws.
+ */
+export async function pruneToolOutput({ dataRoot, sessionsRoot }) {
+    const removed = [];
+    let entries = [];
+    try {
+        entries = await readdir(toolOutputRoot(dataRoot), { withFileTypes: true });
+    }
+    catch {
+        return removed;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !validSessionId(entry.name))
+            continue;
+        if (existsSync(join(sessionsRoot, `${entry.name}.jsonl`)))
+            continue;
+        try {
+            if (await deleteSessionToolOutput(dataRoot, entry.name))
+                removed.push(entry.name);
+        }
+        catch { /* the next start tries again */ }
+    }
+    return removed;
+}
+function markerText(removed, kept, total, saved) {
+    const where = saved ? ` The full output is saved in "${saved.path}"; read that file for the rest.` : ' The full output could not be saved.';
+    return `… [TALOS cut ${removed} characters from the middle of this output; ${kept} of ${total} characters are shown.${where}] …`;
+}
+/** The kernel's head/tail cut with the English marker. The text is returned unchanged when it fits. */
+export function cutToolOutput(full, saved, { limit = TOOL_OUTPUT_LIMIT, headShare = TOOL_OUTPUT_HEAD_SHARE } = {}) {
+    if (full.length <= limit)
+        return full;
+    const head = Math.max(0, Math.round(limit * headShare));
+    const tail = limit - head;
+    return `${full.slice(0, head)}\n\n${markerText(full.length - limit, limit, full.length, saved)}\n\n${full.slice(full.length - tail)}`;
+}
+/** The kernel's own cut (fallback executor): its Italian marker replaced by the English one, the kept text untouched. */
+export function replaceKernelCutMarker(text, saved, { limit = TOOL_OUTPUT_LIMIT } = {}) {
+    const match = KERNEL_CUT_MARKER.exec(text);
+    if (!match)
+        return text;
+    const removed = Number(match.groups.removed);
+    return text.replace(KERNEL_CUT_MARKER, () => `\n\n${markerText(removed, limit, limit + removed, saved)}\n\n`);
+}
+export function hasKernelCutMarker(text) { return KERNEL_CUT_MARKER.test(text); }
+/**
+ * The kernel's ENGLISH marker on a tool result it cut at 8,000 characters (the owner's amendment Q-R5-11, talosHarness.mjs
+ * `esitoAttrezzoPerIlModello`, asked for with `toolResultCutMarker`), always the last paragraph of the result. Pinned against
+ * the kernel by r5a-r-kernel-amendment.test.ts.
+ */
+export const KERNEL_TOOL_RESULT_CUT = /\n\n\[TALOS cut this tool result at (?<limit>\d+) characters: (?<shown>\d+) of (?<total>\d+) characters and (?<shownLines>\d+) of (?<totalLines>\d+) lines are shown\. Ask for a smaller part \(a line range or a search\) to read the rest\.\]$/u;
+export function parseToolResultCut(text) {
+    const match = KERNEL_TOOL_RESULT_CUT.exec(String(text ?? ''));
+    if (!match)
+        return null;
+    const g = match.groups;
+    return { limitChars: Number(g.limit), shownChars: Number(g.shown), totalChars: Number(g.total), shownLines: Number(g.shownLines), totalLines: Number(g.totalLines) };
+}
+/** The result without the kernel's cut marker, for a screen that states the cut in its own words. */
+export function withoutToolResultCut(text) { return String(text ?? '').replace(KERNEL_TOOL_RESULT_CUT, ''); }
+/** The marker's facts, for the screen (`tool.output.saved`); `path` is null when the output could not be saved. */
+export function parseToolOutputMarker(text) {
+    const match = MARKER.exec(String(text ?? ''));
+    if (!match)
+        return null;
+    const g = match.groups;
+    return { removedChars: Number(g.removed), keptChars: Number(g.kept), totalChars: Number(g.total), path: g.path ?? null };
+}