talos-code 0.0.1 → 0.2.0

package/vendor/harness-ui/src/context-tool-output.mjs

@@ -0,0 +1,72 @@
+import { createHash } from 'node:crypto';
+import { dirname, isAbsolute } from 'node:path';
+
+// Qualified explicit filters from RTK 0.44.2 (700bdde); never use autodetection.
+const FILTERS = new Set(['cargo-test', 'pytest', 'go-test', 'go-build', 'tsc', 'vitest', 'grep', 'rg', 'find', 'fd', 'git-log', 'git-diff', 'git-status', 'log', 'mypy', 'ruff-check', 'ruff-format', 'prettier', 'phpunit', 'pest', 'paratest', 'php-test', 'ecs', 'phpstan', 'pint']);
+const MAX_BYTES = 10 * 1024 * 1024;
+const fail = (message, code) => { throw Object.assign(new Error(message), { code }); };
+const checkSignal = signal => { if (signal?.aborted) fail('Tool output compression cancelled', 'CTX_CANCELLED'); };
+const validId = value => typeof value === 'string' && value.trim() !== '' && value.length <= 256;
+
+export function createToolOutputCompressor({ binaryPath, processPolicy, store, timeoutMs = 10000 } = {}) {
+  if (typeof binaryPath !== 'string' || !isAbsolute(binaryPath) || !processPolicy || typeof processPolicy.spawn !== 'function'
+    || !store || typeof store.readOriginals !== 'function' || !Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 60000) fail('Compressor dependencies are invalid', 'CTX_OUTPUT_CONFIG');
+
+  async function filterStdin(text, filter, signal) {
+    return new Promise((resolve, reject) => {
+      let child; let timer; let done = false; let length = 0; let errorLength = 0; const output = [];
+      const stop = () => { try { child?.kill('SIGTERM'); } catch { /* process may already be gone */ } };
+      const finish = (value, error) => {
+        if (done) return;
+        done = true;
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', onAbort);
+        if (error) reject(error); else resolve(value);
+      };
+      const fallback = () => { finish(null); stop(); };
+      const onAbort = () => { finish(null, Object.assign(new Error('Tool output compression cancelled'), { code: 'CTX_CANCELLED' })); stop(); };
+      try {
+        // Authority remains in the caller-owned policy. `command` is never an argument.
+        child = processPolicy.spawn(binaryPath, ['pipe', '--filter', filter], { cwd: dirname(binaryPath), shell: false, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] });
+        if (!child?.stdin || typeof child.once !== 'function') return fallback();
+        child.on('error', fallback);
+        child.stdin.on('error', fallback);
+        child.stdout?.on('data', chunk => {
+          if (done) return;
+          const bytes = Buffer.from(chunk); length += bytes.length;
+          if (length > MAX_BYTES) return fallback();
+          output.push(bytes);
+        });
+        child.stderr?.on('data', chunk => { errorLength += Buffer.byteLength(chunk); if (errorLength > 65536) fallback(); });
+        child.once('close', code => {
+          if (code !== 0) return finish(null);
+          try { finish(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(output))); } catch { finish(null); }
+        });
+        timer = setTimeout(fallback, timeoutMs);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        if (signal?.aborted) return onAbort();
+        child.stdin.end(Buffer.from(text, 'utf8'));
+      } catch { fallback(); }
+    });
+  }
+
+  async function compressCapturedToolOutput({ sessionId, recordId, text, filter, command, exitCode, signal } = {}) {
+    checkSignal(signal);
+    if (!validId(sessionId) || !validId(recordId) || typeof text !== 'string' || !text.isWellFormed()
+      || (command !== undefined && typeof command !== 'string') || (exitCode !== undefined && exitCode !== null && !Number.isInteger(exitCode))) fail('Captured output is invalid', 'CTX_OUTPUT_INVALID');
+    const rows = await store.readOriginals({ sessionId, ids: [recordId], limit: 1 });
+    const record = Array.isArray(rows) && rows.length === 1 ? rows[0] : null;
+    if (!record || record.id !== recordId || record.sessionId !== sessionId || record.message?.role !== 'tool'
+      || record.message.content !== text || typeof record.sha256 !== 'string'
+      || createHash('sha256').update(JSON.stringify(record.message)).digest('hex') !== record.sha256) fail('Exact tool output must be archived before compression', 'CTX_ORIGINAL_MISMATCH');
+    checkSignal(signal);
+    const result = { text, originalRef: { sessionId, recordId, sha256: record.sha256 }, compressed: false, originalChars: text.length, outputChars: text.length, command, exitCode };
+    if (!FILTERS.has(filter) || Buffer.byteLength(text, 'utf8') > MAX_BYTES || text.length === 0) return result;
+    const output = await filterStdin(text, filter, signal);
+    checkSignal(signal);
+    if (typeof output !== 'string' || output.trim() === '' || output.length >= text.length) return result;
+    return { ...result, text: output, compressed: true, filter, outputChars: output.length };
+  }
+
+  return Object.freeze({ compressCapturedToolOutput });
+}

package/vendor/harness-ui/src/costo-elenco.mjs

@@ -0,0 +1,252 @@
+/*
+ * Quanto costa mettere un elenco di file in testa al prompt — DETTO CON IL METODO IN CHIARO.
+ *
+ * ⛔ Perché questo modulo esiste (09/09/2026, Context Manager): in `context-token-counters.mjs`
+ *    i BYTE erano contati come token e la misura sbagliava di 3,9 volte — un corpo di 39.513 byte,
+ *    che il fornitore ha misurato in 10.073 token, valeva 70.903. Effetto: overflow apparente a
+ *    ogni giro. La cura non è una costante migliore: è che il numero dica SEMPRE se è stato
+ *    contato o stimato, e come. Qui una stima non può travestirsi da misura: `metodo` è un campo
+ *    del risultato, non un commento.
+ *
+ * ⛔ Un solo contatore in tutto il repo. Questo modulo NON tokenizza: riceve `contatore` come
+ *    porta. L'adattatore `contatoreDaContextEngine()` in fondo prende il contatore che c'è già
+ *    (`createContextTokenCounter` in `src/context-token-counters.mjs`) e ne fa una porta sincrona.
+ *    Due contatori che danno due numeri diversi per la stessa cosa sono peggio di nessun contatore.
+ *
+ * RICERCA WEB (letta il 10/09/2026, prima di scrivere una riga):
+ *  1. «1 token ≈ 4 caratteri» è la REGOLA D'ORO di OpenAI per l'INGLESE, e sta entro ~10% solo lì;
+ *     il rapporto cambia molto con lingua, dominio e tokenizer.
+ *     — OpenAI Developer Community, "Rules of Thumb for number of source code characters to tokens"
+ *       <https://community.openai.com/t/rules-of-thumb-for-number-of-source-code-characters-to-tokens/622947>
+ *  2. Il BPE a livello di byte parte da un alfabeto Σ={0..255} e fonde BYTE UTF-8, non caratteri
+ *     Unicode: «penalizza le lingue con grafemi multibyte (tamil, hindi, cinese), fino a 3 volte
+ *     più token dell'inglese» (parità tamil 4,54 con GPT-2). ⇒ per il testo non latino la stima si
+ *     fa sui BYTE, mai sui caratteri.
+ *     — EmergentMind, "Byte-level BPE Tokenizers" <https://www.emergentmind.com/topics/byte-level-bpe-tokenizers>
+ *  3. Misura citabile: 8 caratteri cinesi costano 11 token in cl100k_base, contro 5 token per 16
+ *     caratteri inglesi. La regola dei 4 caratteri predirebbe 2 token per quegli 8 ideogrammi:
+ *     sbaglia di 5,5 volte. (Vedi la prova COSTO-ELENCO-08.)
+ *     — Token Optimization Guide, "Language Comparison"
+ *       <https://olivomarco.github.io/github-copilot-token-optimization/03-language-comparison/>
+ *  4. Anche un conteggio del fornitore è dichiarato dal fornitore stesso come STIMA a meno di uno
+ *     scarto piccolo, e un tokenizer nuovo cambia i numeri (Claude 4.7+: ~30% token in più sullo
+ *     stesso testo). ⇒ `'contato'` qui vuol dire «un tokenizer ha guardato QUESTO testo», non
+ *     «verità eterna»; la confidenza lo dice.
+ *     — Claude Platform Docs, "Token counting" <https://platform.claude.com/docs/en/build-with-claude/token-counting>
+ *
+ * ⛔ Nessuna dipendenza nuova: in `node_modules` non c'è nessun tokenizer BPE (verificato il
+ *    10/09/2026, cercando tiktoken/cl100k/o200k/vocab). Un conteggio VERO offline oggi non è
+ *    possibile in questo repo — e questo modulo lo dice invece di fingerlo.
+ */
+
+const fallisci = (codice, messaggio) => { throw Object.assign(new Error(messaggio), { code: codice }); };
+
+/**
+ * Taratura della stima. ⛔ È la STESSA di `src/context-token-counters.mjs:70` — di proposito: due
+ * stime diverse per lo stesso testo rifarebbero il difetto del 09/09 in forma nuova.
+ * Misurata quel giorno su z-ai/glm-5.3-flash (italiano + JSON di strumenti): 3,92 byte/token e
+ * 3,64 caratteri/token reali; dividere per 3,5 tiene la stima ~12% SOPRA il vero, cioè prudente
+ * nel verso giusto, con il margine dichiarato a parte invece che nascosto nel numero.
+ */
+export const TARATURA_STIMA = Object.freeze({
+  bytePerToken: 3.5,
+  margine: 0.15,
+  margineMinimoToken: 8,
+  misurata: '09/09/2026 su z-ai/glm-5.3-flash (3,92 byte/token, 3,64 caratteri/token)',
+});
+
+/**
+ * Listino e comportamento della cache — MISURATI il 22/08/2026, non stimati qui.
+ * Tre chiamate ravvicinate sullo stesso prefisso da 16.811 token: la TERZA ne legge 16.768 dalla
+ * cache e costa $0,000172 contro $0,001011, cioè 5,9 volte meno. Il fattore di listino è 6,0
+ * esatto ($0,06/M contro $0,01/M); il 5,9 misurato è più basso perché 43 token dei 16.811 non
+ * erano in cache — i conti tornano: 16.768×$0,01/M + 43×$0,06/M = $0,00017026.
+ * ⛔ La cache PRENDE DALLA TERZA CHIAMATA: le prime due si pagano piene. Chi prova due volte sole
+ *    conclude «non funziona», ed è l'unico esito sbagliato possibile.
+ * Z.AI cacheggia da sé, senza configurazione.
+ */
+export const LISTINO_22_08 = Object.freeze({
+  promptDollariPerMilione: 0.06,
+  cacheReadDollariPerMilione: 0.01,
+  giriPagatiPieni: 2,
+  misurato: '22/08/2026 — 16.811 token, terza chiamata $0,000172 contro $0,001011',
+});
+
+const METODI = ['auto', 'contato', 'stimato'];
+const arrotonda = (valore, cifre) => Number(valore.toFixed(cifre));
+const dollari = (token, perMilione) => arrotonda(token * perMilione / 1_000_000, 10);
+// ⛔ Non ASCII = il BPE a livello di byte spezza il carattere in 2-4 byte: la confidenza deve dirlo.
+const haNonLatino = testo => [...testo].some(carattere => carattere.codePointAt(0) > 127);
+
+/* ⛔ Un elenco di percorsi NON è prosa: `src/context-token-counters.mjs` è pieno di `/ - .`, e il BPE
+   spezza a ogni separatore («nomi, codice o caratteri non inglesi vengono tagliati in più pezzi» —
+   OpenAI Developer Community, letto 10/09/2026). Qui NON correggiamo il numero con un coefficiente
+   inventato: alziamo una BANDIERA, perché su testo così la stima è un pavimento e non un tetto.
+   La soglia 0,10 è una soglia di SEGNALAZIONE, non una taratura: la prosa italiana sta molto sotto,
+   un elenco di percorsi molto sopra. */
+const SOGLIA_PUNTEGGIATURA_DENSA = 0.10;
+const quotaPunteggiatura = testo => {
+  const caratteri = [...testo];
+  if (!caratteri.length) return 0;
+  return caratteri.filter(carattere => !/[\p{L}\p{N}\s]/u.test(carattere)).length / caratteri.length;
+};
+
+/**
+ * La regola d'oro «1 token ogni 4 caratteri». ⛔ NON è una misura, e non è usata da nessun
+ * risultato di questo modulo: esiste solo perché le prove possano mostrare DI QUANTO sbaglia.
+ * Vedi ricerca (1) e (3) in testa al file.
+ */
+export function stimaRegolaQuattroCaratteri(testo) {
+  if (typeof testo !== 'string') fallisci('COSTO_TESTO_INVALIDO', 'Il testo da stimare deve essere una stringa.');
+  return Math.ceil([...testo].length / 4);
+}
+
+/** Quanto costa questo testo, con il metodo dichiarato. */
+export function costoDelTesto(testo, { metodo = 'auto', contatore } = {}) {
+  if (typeof testo !== 'string') fallisci('COSTO_TESTO_INVALIDO', 'Il testo da misurare deve essere una stringa.');
+  if (!METODI.includes(metodo)) fallisci('COSTO_METODO_IGNOTO', `Metodo sconosciuto: ${metodo}. Ammessi: ${METODI.join(', ')}.`);
+  if (contatore !== undefined && typeof contatore !== 'function') fallisci('COSTO_CONTATORE_INVALIDO', 'Il contatore deve essere una funzione (testo) => numero di token.');
+  // ⛔ Chiedere `'contato'` senza avere un contatore non produce una stima battezzata misura: si ferma.
+  if (metodo === 'contato' && !contatore) fallisci('COSTO_CONTATORE_ASSENTE', 'Il metodo "contato" richiede un contatore vero: senza, il numero sarebbe una stima travestita da misura.');
+
+  const byte = Buffer.byteLength(testo, 'utf8');
+  const caratteri = [...testo].length;
+  const nonLatino = haNonLatino(testo);
+  const quotaSeparatori = quotaPunteggiatura(testo);
+  const punteggiaturaDensa = quotaSeparatori > SOGLIA_PUNTEGGIATURA_DENSA;
+  const base = { byte, caratteri, unitaDiCodice: testo.length, nonLatino, punteggiaturaDensa, quotaSeparatori: Number(quotaSeparatori.toFixed(4)) };
+
+  if (contatore && metodo !== 'stimato') {
+    const conteggio = contatore(testo);
+    if (typeof conteggio?.then === 'function') fallisci('COSTO_CONTATORE_ASINCRONO', 'Il contatore deve essere sincrono: usa contatoreDaContextEngine() per pre-misurare i testi e ottenere una porta sincrona.');
+    if (!Number.isSafeInteger(conteggio) || conteggio < 0) fallisci('COSTO_CONTEGGIO_INVALIDO', 'Il contatore non ha restituito un numero di token valido; nessun ripiego silenzioso su una stima.');
+    // ⛔ Un contatore che dichiara di aver stimato NON diventa «contato» passando di qui.
+    const suoMetodo = contatore.metodo === 'stimato' ? 'stimato' : 'contato';
+    const fonte = contatore.fonte ?? 'contatore iniettato (fonte non dichiarata)';
+    return {
+      ...base,
+      token: conteggio,
+      metodo: suoMetodo,
+      fonte,
+      margineToken: suoMetodo === 'contato' ? 0 : Math.max(TARATURA_STIMA.margineMinimoToken, Math.ceil(conteggio * TARATURA_STIMA.margine)),
+      confidenza: suoMetodo === 'contato'
+        ? `contato: ${fonte} ha tokenizzato questo testo. ⛔ Il fornitore dichiara la propria misura come stima a meno di uno scarto piccolo, e un tokenizer nuovo cambia i numeri (Claude 4.7+: ~30% token in più sullo stesso testo — Claude Platform Docs, token-counting, letto 10/09/2026).`
+        : `stimato dal contatore iniettato (${fonte}): ha dichiarato metodo "stimato", e passare di qui non lo trasforma in una misura.`,
+    };
+  }
+
+  /* Stima sui BYTE UTF-8, non sui caratteri: il BPE a livello di byte fonde byte, quindi un
+     carattere accentato (2 byte), un ideogramma (3) o un'emoji (4) costano di più di una lettera
+     ASCII, e la regola dei 4 caratteri li conta uguali. Vedi ricerca (2) e (3). */
+  const token = Math.ceil(byte / TARATURA_STIMA.bytePerToken);
+  const margineToken = token === 0 ? 0 : Math.max(TARATURA_STIMA.margineMinimoToken, Math.ceil(token * TARATURA_STIMA.margine));
+  const avvisoNonLatino = nonLatino
+    ? ' ⛔ Il testo contiene caratteri non ASCII: per gli script non latini il BPE a livello di byte arriva fino a 3 volte l\'inglese e questa stima è un PAVIMENTO, non un tetto (8 ideogrammi = 11 token misurati in cl100k_base, dove byte/3,5 ne predice 7 e caratteri/4 solo 2).'
+    : '';
+  const avvisoDenso = punteggiaturaDensa
+    ? ` ⛔ Testo fitto di separatori (${Math.round(quotaSeparatori * 100)}% di caratteri non alfanumerici: è la forma di un elenco di percorsi, non di prosa): il BPE spezza a ogni "/", "-" e ".", quindi anche qui la stima è un PAVIMENTO.`
+    : '';
+  return {
+    ...base,
+    token,
+    metodo: 'stimato',
+    fonte: 'nessun contatore iniettato',
+    margineToken,
+    confidenza: `stimato: byte UTF-8 (${byte}) ÷ ${TARATURA_STIMA.bytePerToken}, taratura ${TARATURA_STIMA.misurata}; margine dichiarato ±${Math.round(TARATURA_STIMA.margine * 100)}% (${margineToken} token). ⛔ Non è un conteggio: nessun tokenizer ha guardato questo testo.${avvisoNonLatino}${avvisoDenso}`,
+  };
+}
+
+/** Il costo di un elenco, e quanto ne resta nella finestra. */
+export function costoElenco(testoElenco, { finestra, giri = 1, contatore, metodo = 'auto', listino = LISTINO_22_08 } = {}) {
+  if (!Number.isSafeInteger(giri) || giri < 1) fallisci('COSTO_GIRI_INVALIDI', 'I giri devono essere un intero maggiore o uguale a 1.');
+  const misura = costoDelTesto(testoElenco, { metodo, contatore });
+  const token = misura.token;
+
+  /* ⛔ Finestra assente, zero o non intera: nessuna percentuale inventata. Non «100%», non «0%»:
+     ASSENTE. Un 0% su finestra ignota è la bugia più comoda che ci sia. */
+  const finestraNota = Number.isSafeInteger(finestra) && finestra > 0;
+  const percentualeFinestra = finestraNota ? arrotonda(token / finestra * 100, 2) : null;
+
+  const costoSuNGiri = token * giri;
+  const giriPieni = Math.min(giri, listino.giriPagatiPieni);
+  const giriScontati = Math.max(0, giri - listino.giriPagatiPieni);
+  const tokenPieni = token * giriPieni;
+  const tokenInCache = token * giriScontati;
+  const dollariSenzaCache = dollari(costoSuNGiri, listino.promptDollariPerMilione);
+  const dollariConCache = arrotonda(dollari(tokenPieni, listino.promptDollariPerMilione) + dollari(tokenInCache, listino.cacheReadDollariPerMilione), 10);
+  const cacheAttiva = giriScontati > 0 && token > 0;
+
+  return {
+    token,
+    metodo: misura.metodo,
+    confidenza: misura.confidenza,
+    fonte: misura.fonte,
+    margineToken: misura.margineToken,
+    byte: misura.byte,
+    caratteri: misura.caratteri,
+    nonLatino: misura.nonLatino,
+    finestraNota,
+    percentualeFinestra,
+    tokenLiberiNellaFinestra: finestraNota ? finestra - token : null,
+    oltreLaFinestra: finestraNota ? token > finestra : null,
+    costoSuNGiri,
+    conCache: {
+      attiva: cacheAttiva,
+      giri,
+      giriPieni,
+      giriScontati,
+      tokenPieni,
+      tokenInCache,
+      dollari: dollariConCache,
+      dollariSenzaCache,
+      risparmioDollari: arrotonda(dollariSenzaCache - dollariConCache, 10),
+      fattoreRisparmio: dollariConCache > 0 ? arrotonda(dollariSenzaCache / dollariConCache, 3) : null,
+      listino: `prompt $${listino.promptDollariPerMilione}/M, input_cache_read $${listino.cacheReadDollariPerMilione}/M (${listino.misurato})`,
+      avvertenza: cacheAttiva
+        ? `⛔ I primi ${listino.giriPagatiPieni} giri si pagano PIENI (${tokenPieni} token a $${listino.promptDollariPerMilione}/M): la cache prende dalla TERZA chiamata. Il risparmio qui vale solo perché i giri sono ${giri}.`
+        : `⛔ Con ${giri} gir${giri === 1 ? 'o' : 'i'} la cache non ha ancora preso: si paga tutto pieno, esattamente come senza cache. Chi prova due volte sole conclude «non funziona» — è l'unico esito sbagliato possibile, non un difetto della cache.`,
+    },
+  };
+}
+
+/**
+ * Adattatore: prende il contatore che c'è GIÀ (`createContextTokenCounter`, `src/context-token-counters.mjs:40`)
+ * e ne ricava una porta sincrona per `costoDelTesto`/`costoElenco`.
+ *
+ * ⛔ Pre-misura i testi che gli passi e basta: sui testi che non ha visto la porta SI FERMA invece
+ *    di ripiegare su una stima — un ripiego silenzioso è esattamente il modo in cui una stima
+ *    diventa una misura per sbaglio.
+ * ⛔ `sottraiInvolucro`: `countPreparedContext` conta l'INTERA richiesta (nome del modello, ruoli,
+ *    scaffolding JSON), non il testo nudo. Misurando anche la richiesta vuota e sottraendo si
+ *    ottiene il costo MARGINALE dell'elenco — che è la domanda vera: «quanto costa AGGIUNGERLO».
+ * ⛔ Se il contatore risponde con il suo ripiego euristico (`method === 'heuristic'`), la porta si
+ *    dichiara `metodo: 'stimato'` e il risultato lo eredita: nessun travestimento.
+ */
+export async function contatoreDaContextEngine({ counter, model, testi, signal, sottraiInvolucro = true } = {}) {
+  if (typeof counter?.countPreparedContext !== 'function') fallisci('COSTO_CONTATORE_ASSENTE', 'Serve un contatore con countPreparedContext (createContextTokenCounter).');
+  if (!Array.isArray(testi) || testi.some(testo => typeof testo !== 'string')) fallisci('COSTO_TESTI_INVALIDI', 'I testi da pre-misurare devono essere un elenco di stringhe.');
+  const conta = async testo => {
+    const esito = await counter.countPreparedContext({ messages: [{ role: 'user', content: testo }], tools: [], model, signal });
+    if (!Number.isSafeInteger(esito?.inputTokens) || esito.inputTokens < 0) fallisci('COSTO_CONTEGGIO_INVALIDO', 'Il contatore del Context Engine non ha restituito un conteggio valido.');
+    return esito;
+  };
+  const involucro = sottraiInvolucro ? (await conta('')).inputTokens : 0;
+  const misurati = new Map();
+  let stimato = false;
+  const metodiVisti = new Set();
+  for (const testo of testi) {
+    const esito = await conta(testo);
+    if (esito.method === 'heuristic') stimato = true;
+    metodiVisti.add(esito.method);
+    misurati.set(testo, Math.max(0, esito.inputTokens - involucro));
+  }
+  const fonte = `context-token-counters (${model?.provider ?? 'provider ignoto'}/${model?.model ?? 'modello ignoto'}, method=${[...metodiVisti].join('+') || 'nessuno'}${sottraiInvolucro ? `, involucro ${involucro} token sottratto` : ''})`;
+  const porta = testo => {
+    if (!misurati.has(testo)) fallisci('COSTO_TESTO_NON_MISURATO', 'Questo testo non è stato pre-misurato: la porta non stima di nascosto. Passalo a contatoreDaContextEngine().');
+    return misurati.get(testo);
+  };
+  porta.fonte = fonte;
+  porta.metodo = stimato ? 'stimato' : 'contato';
+  porta.involucroToken = involucro;
+  return porta;
+}

package/vendor/harness-ui/src/custom-task.mjs

@@ -0,0 +1,171 @@
+/**
+ * custom-task.mjs — un compito LIBERO su una cartella dell'allowlist
+ * (`TALOS_HARNESS_UI_PROJECT_DIRS`, vedi `config.mjs`), non uno dei task
+ * fissi del corpus benchmark. Owner, 27/8: "per adesso un allowlist per
+ * testare... come se fosse un vero coding agent di produzione".
+ *
+ * ⛔⛔ Diverso da `task-catalog.mjs` apposta: quello fa SEMPRE una copia
+ * usa-e-getta (`preparaCopia`), perché il suo scopo è misurare un harness
+ * senza mai toccare l'originale del corpus. Qui l'obiettivo dichiarato è
+ * l'opposto — vedere l'effetto REALE su un progetto vero, esattamente
+ * come un coding agent di produzione — quindi si lavora DIRETTAMENTE
+ * sulla cartella scelta. Il confine di sicurezza non è "una copia": è
+ * l'allowlist stessa, verificata all'AVVIO del server (vedi config.mjs),
+ * mai un percorso a piacere accettato a runtime.
+ *
+ * ⭐⭐⭐ 28/8 — ECCEZIONE dichiarata al paragrafo sopra: col permesso "Full
+ * access" (piano elegant-spinning-dongarra.md, owner) un percorso A
+ * PIACERE È ammesso — `cartellaLibera` sotto. Questo file NON scrive una
+ * denylist di percorsi sensibili come CONFINE di sicurezza, e il motivo è
+ * questo, non quello scritto qui fino al 16/09:
+ * ⛔ 16/09 — CITAZIONE CORRETTA. La versione precedente attribuiva a un
+ * inesistente «Docker/Developers Digest, agosto 2026» la tesi che le
+ * denylist fossero «una strategia fallita». Verificato aprendo le fonti
+ * (segnalazione della lane CLI, controllata qui): NON esiste una
+ * pubblicazione congiunta; Developers Digest, «AI Coding Agent Security
+ * Models Compared 2026» (28 LUGLIO 2026,
+ * developersdigest.tech/blog/ai-coding-agent-security-models-compared-2026)
+ * RACCOMANDA «credential masking or deny rules for SSH keys and .env
+ * files»; Docker, «AI Coding Agent Horror Stories» (18 MAGGIO 2026,
+ * docker.com/blog/ai-coding-agent-horror-stories-security-risks) SPEDISCE
+ * una blocklist («~/.aws, ~/.ssh, ~/.docker, ~/.gnupg, ~/.netrc, ~/.npm and
+ * ~/.cargo are all on the blocklist»); la frase sugli escape «nella
+ * categoria denylist» è di un TERZO editore, Pillar Security, «The Week of
+ * Sandbox Escapes» (20 LUGLIO 2026, pillar.security/blog/the-week-of-sandbox-escapes),
+ * e parla di profili di CONFINAMENTO del sistema operativo (Seatbelt su
+ * macOS): «a list of things somebody remembered to block that's always
+ * one entry short». ⇒ La distinzione che conta, e che nessuna fonte fa al
+ * posto nostro: una lista usata come CONFINE («questa lista ferma un
+ * attaccante») è debole perché un percorso si calcola a runtime — su
+ * questo Pillar ha ragione; una lista usata come INNESCO («questa lista
+ * decide quando CHIEDERE») non promette contenimento: se manca un
+ * percorso, il caso peggiore è lo stato di oggi. Il commento vecchio
+ * applicava una critica della prima classe a un meccanismo della
+ * seconda. NVIDIA («Practical Security Guidance for Sandboxing Agentic
+ * Workflows», developer.nvidia.com) raccomanda un piccolo elenco di
+ * percorsi protetti anche a Full access — e copre l'ACCESSO, lettura
+ * compresa, non le sole scritture come riassumeva il dossier del 03/09.
+ * ⇒ Qui resta «nessuna denylist come confine»; l'innesco «la shell chiede
+ * davanti a un percorso segreto» è la fase P0-bis (owner 16/09, «Sì»).
+ * La sicurezza vera sta altrove: (1) il permesso "Full access" è una SCELTA ESPLICITA
+ * dell'owner per QUELLA sessione, mai un default; (2) il percorso deve
+ * ESISTERE ed essere leggibile/scrivibile DAVVERO (stessa validazione
+ * già in uso per l'allowlist fissa, solo a runtime invece che all'avvio
+ * — l'owner sceglie un percorso che gestisce già col suo stesso OS); (3)
+ * da quel momento la cartella scelta diventa la RADICE della sessione
+ * esattamente come una voce dell'allowlist — lo stesso `isPathInside`
+ * la contiene, solo più in alto nell'albero. Non è "nessun confine": è
+ * "il confine è dove l'owner ha detto esplicitamente", il pattern che
+ * VS Code chiama Workspace Trust.
+ */
+import { accessSync, constants, realpathSync, statSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+
+export class CustomTaskError extends Error {
+  constructor(message, code = 'PROJECT_NOT_ALLOWED') {
+    super(message);
+    this.name = 'CustomTaskError';
+    this.code = code;
+  }
+}
+
+const COMANDO_PROVA_DEFAULT = 'npm test';
+const CONSEGNA_MASSIMA_BYTE = 8192;
+
+/** Proiezione leggera per il menu — mai il percorso assoluto verso il browser: solo id e nome, stesso principio di `listaTaskDisponibili`. */
+export function elencaCartelleProgetto(cartelleProgetto) {
+  return cartelleProgetto.map(({ id, nome }) => ({ id, nome }));
+}
+
+/**
+ * ⭐⭐⭐ 28/8 — la validazione di un percorso "Full access", a RUNTIME (non
+ * all'avvio: qui il percorso non è noto in anticipo). Stessa forma
+ * dell'errore già dichiarata sopra, stessi controlli di
+ * `config.mjs#parseCartelleProgetto` — deliberatamente duplicati invece
+ * di importati: quella funzione valida un ARRAY all'avvio e fallisce
+ * l'intero processo (`fail()`, mai recuperabile), questa valida UN
+ * percorso per richiesta e deve tornare un errore HTTP onesto, non far
+ * cadere il server.
+ */
+function validaCartellaLibera(percorsoInput, { realpathSyncFn = realpathSync, statSyncFn = statSync, accessSyncFn = accessSync } = {}) {
+  if (typeof percorsoInput !== 'string' || percorsoInput.trim().length === 0) {
+    throw new CustomTaskError('cartellaLibera mancante', 'QUERY_INVALID');
+  }
+  if (!isAbsolute(percorsoInput)) {
+    throw new CustomTaskError('cartellaLibera deve essere un percorso assoluto', 'QUERY_INVALID');
+  }
+  let reale;
+  try {
+    reale = realpathSyncFn(percorsoInput);
+  } catch {
+    throw new CustomTaskError(`Il percorso non esiste o non è raggiungibile: ${percorsoInput}`, 'PROJECT_NOT_ALLOWED');
+  }
+  let stat;
+  try {
+    stat = statSyncFn(reale);
+  } catch {
+    throw new CustomTaskError(`Il percorso non è leggibile: ${percorsoInput}`, 'PROJECT_NOT_ALLOWED');
+  }
+  if (!stat.isDirectory()) {
+    throw new CustomTaskError(`Il percorso non è una cartella: ${percorsoInput}`, 'PROJECT_NOT_ALLOWED');
+  }
+  try {
+    accessSyncFn(reale, constants.R_OK | constants.W_OK);
+  } catch {
+    throw new CustomTaskError(`La cartella non è leggibile/scrivibile: ${percorsoInput}`, 'PROJECT_NOT_ALLOWED');
+  }
+  return reale;
+}
+
+/**
+ * @returns {{cartella:string, comandoProva:string, task:object}} — mai un
+ * `pulisci()`: non c'è una copia usa-e-getta da buttare, la cartella È
+ * il progetto vero.
+ *
+ * ⭐ `cartellaLibera` (assoluta, validata da `validaCartellaLibera`) e
+ * `cartellaId` (dall'allowlist) sono MUTUAMENTE ESCLUSIVI — chi chiama
+ * decide quale dei due passare in base al permesso della sessione (vedi
+ * session-registry.mjs), questa funzione si limita a rifiutare se
+ * arrivano ENTRAMBI o NESSUNO dei due, mai a scegliere lei stessa.
+ */
+export function preparaEsecuzioneLibera(cartelleProgetto, { cartellaId, cartellaLibera, consegna, comandoProva }, deps = {}) {
+  if ((cartellaId && cartellaLibera) || (!cartellaId && !cartellaLibera)) {
+    throw new CustomTaskError('serve ESATTAMENTE uno fra cartellaId e cartellaLibera', 'QUERY_INVALID');
+  }
+
+  let cartella;
+  let nomeProgetto;
+  if (cartellaLibera) {
+    cartella = validaCartellaLibera(cartellaLibera, deps);
+    nomeProgetto = cartella.split(/[\\/]/).pop() || cartella;
+  } else {
+    if (typeof cartellaId !== 'string' || cartellaId.length === 0) {
+      throw new CustomTaskError('cartellaId mancante', 'QUERY_INVALID');
+    }
+    const voce = cartelleProgetto.find((candidata) => candidata.id === cartellaId);
+    if (!voce) throw new CustomTaskError(`Cartella non ammessa: ${cartellaId}`);
+    cartella = voce.percorso;
+    nomeProgetto = voce.nome;
+  }
+
+  if (typeof consegna !== 'string' || consegna.trim().length === 0) {
+    throw new CustomTaskError('consegna mancante', 'QUERY_INVALID');
+  }
+  if (Buffer.byteLength(consegna, 'utf8') > CONSEGNA_MASSIMA_BYTE) {
+    throw new CustomTaskError(`consegna oltre ${CONSEGNA_MASSIMA_BYTE} byte`, 'QUERY_INVALID');
+  }
+
+  let comando = COMANDO_PROVA_DEFAULT;
+  if (comandoProva !== undefined && comandoProva !== null) {
+    if (typeof comandoProva !== 'string' || comandoProva.trim().length === 0) {
+      throw new CustomTaskError('comandoProva non valido', 'QUERY_INVALID');
+    }
+    comando = comandoProva;
+  }
+
+  return {
+    cartella,
+    comandoProva: comando,
+    task: { consegna, consegnaCorta: consegna.length > 80 ? `${consegna.slice(0, 77)}...` : consegna, progetto: nomeProgetto },
+  };
+}

package/vendor/harness-ui/src/doctor.mjs

@@ -0,0 +1,142 @@
+/**
+ * doctor.mjs — 4 controlli VERI, non un "Doctor: Healthy" scritto a mano.
+ * Blocco Settings, sotto-carta "Control plane". Owner, 27/8: "analizza
+ * bene... eliminare tutti i mockup" — trovato che il pulsante Doctor
+ * mostrava sempre lo stesso testo hardcoded, indipendentemente da
+ * qualunque stato reale del sistema.
+ *
+ * ⛔ Stesso principio già in uso in tutto il progetto (`enforcement`
+ * dichiarato, mai un bluff): ogni riga dice cosa ha VERIFICATO, non cosa
+ * ci si aspetta. `shell` riusa `eseguiComandoSandboxato` — la stessa
+ * funzione che l'attrezzo `shell` chiama davvero, non una seconda
+ * verifica scritta a mano che potrebbe disallinearsi.
+ */
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { createProcessPolicy } from './process-policy.mjs';
+
+const DOCTOR_PROCESS_POLICY = createProcessPolicy({ allowedExecutables: ['git', 'echo'], capabilities: { doctor: tmpdir() } });
+
+async function eseguiComandoSandboxatoLocale(comando, cartella) {
+  // Doctor esegue soltanto il controllo fisso `echo ok`; non accetta testo
+  // composto dal chiamante. Il resto del sistema usa il runtime owner.
+  if (comando !== 'echo ok') return { codice: 1, testo: 'Controllo non previsto', enforcement: 'none' };
+  const risultato = await DOCTOR_PROCESS_POLICY.runApprovedProcess({
+    executable: 'echo',
+    args: ['ok'],
+    cwd: cartella,
+    capability: 'doctor',
+    envKeys: ['PATH', 'SystemRoot', 'WINDIR'],
+  });
+  return { codice: risultato.code ?? 1, testo: risultato.stdout.trim(), enforcement: 'desktop' };
+}
+
+function controllaGit(spawnSyncFn) {
+  try {
+    if (spawnSyncFn) return spawnSyncFn('git', ['--version']).status === 0;
+    DOCTOR_PROCESS_POLICY.execFileSync('git', ['--version'], { cwd: process.cwd() });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {boolean} chiaveConfigurata — config.chiaveApi presente sul server.
+ * @param {Array<{id:string,nome:string,percorso?:string}>|undefined} cartelleProgetto —
+ *   elenco già validato da config.mjs. Quando fornito, il Doctor aggiunge un
+ *   controllo reale per la scelta della cartella nella modale Nuova sessione.
+ * @param {Array<object>|undefined} providerRows — stato pubblico dei provider, mai segreti
+ * @param {boolean|undefined} providerStoreAvailable — portachiavi di sistema disponibile
+ * @param {{configurato:boolean,pronto:boolean,dettaglio:string}|undefined} ownerRuntime — stato reale del runtime agente
+ * @param {{disponibile:boolean,dettaglio:string}|undefined} catalogoTask — disponibilità del catalogo task preset
+ * @param {{corrotte:string[],ultimaLettura:{ripristinate:number,totali:number}}|undefined} sessioniPersistenza — stato di lettura dei registri persistiti
+ * @returns {{chiaveApi:boolean, shell:'wsl2'|'none'|'desktop', git:boolean, naviga:boolean, cartelleProgetto?:{disponibili:boolean,conteggio:number,dettaglio:string}, providers?:{storeAvailable:boolean,items:Array<object>}, ownerRuntime?:{configurato:boolean,pronto:boolean,dettaglio:string}, catalogoTask?:{disponibile:boolean,dettaglio:string}, sessioniPersistenza?:{corrotte:string[],ultimaLettura:{ripristinate:number,totali:number}}}}
+ */
+export async function diagnosi({
+  chiaveConfigurata, cartelleProgetto, providerRows, providerStoreAvailable, ownerRuntime, catalogoTask, sessioniPersistenza,
+  // ⭐ 04/9, R-03 — stato pubblico della fonte di ricerca web (search-source-store.listPublic()): fonte, prontezza; mai una chiave.
+  ricercaWeb,
+  // ⭐ 04/9, W0-04 — i lab accesi (config.labs): informativo, mai un problema.
+  labsAccesi,
+  eseguiComandoSandboxatoFn = eseguiComandoSandboxatoLocale, spawnSyncFn,
+} = {}) {
+  // ⛔ Una cartella usa-e-getta SOLO per il comando diagnostico, mai una
+  // cartella del progetto vero — il Doctor non deve toccare niente.
+  const cartellaProva = mkdtempSync(join(tmpdir(), 'talos-doctor-'));
+  let shell;
+  try {
+    const esito = await eseguiComandoSandboxatoFn('echo ok', cartellaProva);
+    shell = esito.enforcement;
+  } finally {
+    rmSync(cartellaProva, { recursive: true, force: true });
+  }
+  const risultato = {
+    chiaveApi: Boolean(chiaveConfigurata),
+    shell,
+    git: controllaGit(spawnSyncFn),
+    naviga: true, // built-in, nessuna dipendenza esterna da verificare
+  };
+  if (Array.isArray(labsAccesi)) {
+    risultato.labs = { accesi: [...labsAccesi], dettaglio: labsAccesi.length ? `Labs accesi: ${labsAccesi.join(', ')} (NOT_LIVE_VALIDATED finché non provati).` : 'Labs accesi: nessuno.' };
+  }
+  if (ricercaWeb && typeof ricercaWeb === 'object') {
+    const fonte = Array.isArray(ricercaWeb.fonti) ? ricercaWeb.fonti.find((f) => f.id === ricercaWeb.source) : null;
+    risultato.ricercaWeb = {
+      fonte: ricercaWeb.source,
+      etichetta: fonte?.label ?? (ricercaWeb.source === 'off' ? 'Spenta' : ricercaWeb.source),
+      pronta: ricercaWeb.readiness === 'pronta',
+      dettaglio: ricercaWeb.readiness === 'pronta' ? (fonte?.keyless ? 'Pronta, senza chiave: DuckDuckGo (pagina pubblica, può bloccare sotto uso intenso).' : `Pronta: ${fonte?.label ?? ricercaWeb.source}.`)
+        : ricercaWeb.readiness === 'spenta' ? 'Spenta da te: il modello non cercherà sul web.'
+          : ricercaWeb.readiness === 'chiave-mancante' ? `Serve ancora la chiave di ${fonte?.label ?? ricercaWeb.source}.`
+            : `Serve ancora l'indirizzo dell'istanza ${fonte?.label ?? ricercaWeb.source}.`,
+    };
+  }
+  if (Array.isArray(cartelleProgetto)) {
+    risultato.cartelleProgetto = {
+      disponibili: cartelleProgetto.length > 0,
+      conteggio: cartelleProgetto.length,
+      dettaglio: cartelleProgetto.length > 0
+        ? `${cartelleProgetto.length} cartell${cartelleProgetto.length === 1 ? 'a' : 'e'} di progetto disponibili.`
+        : 'Nessuna cartella di progetto è stata configurata nell’elenco consentito.',
+    };
+  }
+  if (Array.isArray(providerRows)) {
+    risultato.providers = { storeAvailable: providerStoreAvailable === true, items: providerRows };
+  }
+  if (ownerRuntime && typeof ownerRuntime === 'object') {
+    risultato.ownerRuntime = {
+      configurato: ownerRuntime.configurato === true,
+      pronto: ownerRuntime.pronto === true,
+      dettaglio: typeof ownerRuntime.dettaglio === 'string' ? ownerRuntime.dettaglio : 'Stato runtime non osservato.',
+    };
+  }
+  if (catalogoTask && typeof catalogoTask === 'object') {
+    risultato.catalogoTask = {
+      disponibile: catalogoTask.disponibile === true,
+      dettaglio: typeof catalogoTask.dettaglio === 'string' ? catalogoTask.dettaglio : 'Elenco attività predefinite non osservato.',
+    };
+  }
+  if (sessioniPersistenza && typeof sessioniPersistenza === 'object') {
+    // ⭐ 04/9, W0-01 — ogni file scartato porta il suo motivo: il Doctor dice DOVE è finita la differenza fra totali e ripristinate.
+    const scartate = Array.isArray(sessioniPersistenza.scartate)
+      ? sessioniPersistenza.scartate.filter((s) => s && typeof s.sessionId === 'string').map((s) => ({ sessionId: s.sessionId, motivo: String(s.motivo || 'ignoto'), ...(s.dettaglio ? { dettaglio: String(s.dettaglio).slice(0, 200) } : {}) }))
+      : [];
+    const ripristinate = Number(sessioniPersistenza.ultimaLettura?.ripristinate) || 0;
+    const totali = Number(sessioniPersistenza.ultimaLettura?.totali) || 0;
+    const perMotivo = {};
+    for (const s of scartate) perMotivo[s.motivo] = (perMotivo[s.motivo] || 0) + 1;
+    risultato.sessioniPersistenza = {
+      corrotte: Array.isArray(sessioniPersistenza.corrotte) ? [...sessioniPersistenza.corrotte] : [],
+      scartate,
+      perMotivo,
+      ultimaLettura: { ripristinate, totali },
+      dettaglio: scartate.length === 0
+        ? `${ripristinate} sessioni ripristinate su ${totali}: nessuna scartata.`
+        : `${ripristinate} ripristinate, ${scartate.length} scartate su ${totali}: ${Object.entries(perMotivo).map(([m, n]) => `${n} ${m}`).join(', ')}.`,
+    };
+  }
+  return risultato;
+}