talos-code 0.1.0 → 0.2.1

package/dist/workspace/checkpoint.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { resolveWorkspaceIdentity } from "../security/workspace-identity.js";
 export const CHECKPOINT_LIMITS = { maxEntries: 50_000, maxStoredBytes: 256 * 1024 * 1024, maxStoredFileBytes: 64 * 1024 * 1024 };
+const RACY_MARGIN_MS = 2_000, BLOB_SYNC_BATCH = 16;
 function coded(code, message = code, details = {}) { return Object.assign(new Error(message === code ? code : `${code}: ${message}`), { code, details }); }
 function sha256(data) { return createHash('sha256').update(data).digest('hex'); }
 function slash(value) { return value.split(path.sep).join('/'); }
@@ -59,15 +60,15 @@ catch (error) {
     if (process.platform !== 'win32')
         throw error;
 } }
-async function storeBlob(blobRoot, data) {
+async function storeBlob(blobRoot, data, budget) {
     const hash = sha256(data), target = path.join(blobRoot, hash);
-    await ensurePrivateDir(blobRoot);
+    if (budget.blobs.has(hash))
+        return hash;
     const temp = path.join(blobRoot, `.${hash}.${process.pid}.tmp`);
     try {
         const handle = await open(temp, 'wx', 0o600);
         try {
             await handle.writeFile(data);
-            await handle.sync();
         }
         finally {
             await handle.close();
@@ -76,14 +77,35 @@ async function storeBlob(blobRoot, data) {
             await rm(temp, { force: true });
             return;
         } throw error; });
-        await durableDir(blobRoot);
     }
     catch (error) {
         if (error?.code !== 'EEXIST')
             throw error;
     }
+    budget.blobs.add(hash);
+    budget.pending.push(target);
     return hash;
 }
+/* Every blob written by this capture is durable before the capture returns (and so before its record is written); a sync
+   error is never swallowed (gate E8/E9). */
+async function syncNewBlobs(blobRoot, budget) {
+    if (budget.pending.length === 0)
+        return;
+    for (let i = 0; i < budget.pending.length; i += BLOB_SYNC_BATCH)
+        await Promise.all(budget.pending.slice(i, i + BLOB_SYNC_BATCH).map(durableFile));
+    budget.pending = [];
+    await durableDir(blobRoot);
+}
+async function assertFileContained(workspace, absolute, budget) {
+    const dir = path.dirname(absolute);
+    let canonical = budget.dirs.get(dir);
+    if (canonical === undefined) {
+        canonical = await realpath(dir);
+        budget.dirs.set(dir, canonical);
+    }
+    if (!inside(workspace.canonicalRoot, canonical))
+        throw coded('CHECKPOINT_PATH_ESCAPE', `Checkpoint path escapes workspace: ${absolute}`);
+}
 function consumeFileBudget(budget, size) {
     if (size > budget.limits.maxStoredFileBytes)
         throw coded('CHECKPOINT_FILE_TOO_LARGE');
@@ -178,10 +200,13 @@ async function captureActualFile(workspace, absolute, relative, blobRoot, budget
     }
     if (!stat.isFile())
         throw coded('CHECKPOINT_SPECIAL_FILE_UNSUPPORTED', `Unsupported workspace entry: ${relative}`);
-    await assertExistingPathContained(workspace, absolute);
+    await assertFileContained(workspace, absolute, budget);
     consumeFileBudget(budget, stat.size);
-    const data = await readFile(absolute);
-    const ref = await storeBlob(blobRoot, data);
+    const seen = budget.cache?.previous.get(relative);
+    const unchanged = Boolean(seen && seen.size === stat.size && seen.mtimeMs === stat.mtimeMs && seen.ctimeMs === stat.ctimeMs
+        && stat.mtimeMs < seen.verifiedAtMs - RACY_MARGIN_MS && stat.ctimeMs < seen.verifiedAtMs - RACY_MARGIN_MS && budget.blobs.has(seen.ref));
+    const ref = unchanged ? seen.ref : await storeBlob(blobRoot, await readFile(absolute), budget);
+    budget.cache?.next.set(relative, { size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, ref, verifiedAtMs: budget.startedAtMs });
     const executable = process.platform === 'win32' ? indexExecutable : Boolean(stat.mode & 0o111);
     return { kind: 'file', source: 'blob', ref, size: stat.size, mode: stat.mode & 0o777, executable };
 }
@@ -249,7 +274,7 @@ async function captureGit(workspace, blobRoot, budget) {
             continue;
         }
         consumeEntry(budget);
-        await assertExistingPathContained(workspace, absolute);
+        await assertFileContained(workspace, absolute, budget);
         entries[relative] = { kind: 'file', source: 'git', ref: oid, size: stat.size, mode: stat.mode & 0o777, executable: mode === '100755', gitPath };
     }
     for (const gitPath of nulList(untrackedRaw)) {
@@ -302,7 +327,7 @@ async function captureNonGit(workspace, blobRoot, budget) {
             }
             if (!stat.isFile())
                 throw coded('CHECKPOINT_SPECIAL_FILE_UNSUPPORTED', `Unsupported workspace entry: ${relative}`);
-            await assertExistingPathContained(workspace, absolute);
+            await assertFileContained(workspace, absolute, budget);
             consumeFileBudget(budget, stat.size);
         }
     }
@@ -328,14 +353,17 @@ async function captureNonGit(workspace, blobRoot, budget) {
     await walk(workspace.canonicalRoot, '');
     return { capturedAt: new Date().toISOString(), workspace: { canonicalRoot: workspace.canonicalRoot, identityHash: workspace.identityHash, gitRoot: null }, entries, git: null, coverage: { tracked: false, untrackedNonIgnored: true, ignoredUntracked: true, gitMetadataRestored: false }, exclusions: ['Filesystem metadata other than file content, executable bit and symlink target is outside rollback coverage.', 'Empty-directory existence is outside rollback coverage.'] };
 }
-export async function captureWorkspaceSnapshot({ projectRoot, blobRoot, limits = CHECKPOINT_LIMITS }) {
+export async function captureWorkspaceSnapshot({ projectRoot, blobRoot, limits = CHECKPOINT_LIMITS, statCache }) {
+    const startedAtMs = Date.now();
     const workspace = await resolveWorkspaceIdentity({ projectRoot });
     await ensurePrivateDir(blobRoot);
     const canonicalBlobRoot = await realpath(blobRoot);
     if (inside(workspace.canonicalRoot, canonicalBlobRoot))
         throw coded('CHECKPOINT_STORE_INSIDE_WORKSPACE');
-    const budget = { entries: 0, storedBytes: 0, limits };
-    return workspace.gitRoot ? captureGit(workspace, canonicalBlobRoot, budget) : captureNonGit(workspace, canonicalBlobRoot, budget);
+    const budget = { entries: 0, storedBytes: 0, limits, startedAtMs, blobs: new Set(await readdir(canonicalBlobRoot)), pending: [], dirs: new Map(), cache: statCache ?? null };
+    const snapshot = workspace.gitRoot ? await captureGit(workspace, canonicalBlobRoot, budget) : await captureNonGit(workspace, canonicalBlobRoot, budget);
+    await syncNewBlobs(canonicalBlobRoot, budget);
+    return snapshot;
 }
 export function checkpointMutationAllowed(mode) { return mode !== 'plan'; }
 export function extractWorkspaceWriteEvidence(raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talos-code",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "TALOS in the terminal: a coding agent with per-tool permissions, file checkpoints and resumable sessions, on the model you choose.",
   "keywords": [
     "coding-agent",
@@ -34,6 +34,7 @@
     "@microsoft/mxc-sdk": "0.8.0",
     "@modelcontextprotocol/client": "2.0.0",
     "@napi-rs/keyring": "1.3.0",
+    "@vscode/ripgrep": "1.18.0",
     "ai": "7.0.93",
     "diff": "9.0.0",
     "docx": "9.5.1",
@@ -61,6 +62,7 @@
     "dist/",
     "vendor/",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md"
   ]

package/vendor/harness-ui/src/kernel/talosHarness.mjs

@@ -3662,6 +3662,123 @@ async function tuttiIPercorsi(disco, { filtro = null } = {}) {
     return { percorsi, dimensioni, stato }
 }
 
+/**
+ * ⭐⭐⭐ P18 fase 3 (owner 26/09/2026: «TALOS più veloce di tutti»; decisioni: ripgrep DENTRO il pacchetto,
+ * righe trovate con un tetto) — `cerca` nel contenuto con ripgrep.
+ *
+ * Misurato sul banco ermetico (`cli/scripts/bench-harness.ts`, 26/09): quattro `cerca` su un albero di 6.000 file
+ * costavano **9,3 s** (una lettura JS alla volta, fino a `MAX_FILE_LETTI`), e su questo monorepo (6.405 file visibili)
+ * la ricerca si fermava a 5.000 letture: **incompleta**, e una parola assente risultava «non c'e'». Pi fa `rg --json`
+ * (`coding-agent/src/core/tools/grep.ts:119-168`), Claude Code ha ripgrep incluso (`USE_BUILTIN_RIPGREP`), Codex lo usa
+ * dalla shell. ⇒ Stessa semantica di prima (sottostringa, maiuscole indifferenti, `.gitignore` anche fuori da un repo,
+ * `.git`/`node_modules` sempre fuori, i binari saltati), ma ogni risultato porta **riga e testo** (`percorso:riga:testo`):
+ * il modello non deve riaprire il file per sapere dove.
+ *
+ * Il binario: `TALOS_RG_PATH` (la CLI lo mette da `@vscode/ripgrep`, che e' nel suo pacchetto, senza rete), altrimenti
+ * `@vscode/ripgrep` se risolvibile da qui. ⛔ Assente, rotto o in timeout ⇒ `null`, e `cercaNelProgetto` prosegue con la
+ * camminata JS di sempre: nessuna installazione perde la ricerca.
+ */
+const MAX_CERCA_INSIEME = 8
+const MAX_RIGHE_RG = 100
+const MAX_RIGHE_PER_FILE = 5
+const MAX_COLONNE_RG = 200
+const MAX_BYTE_RG = 4_000_000
+const TEMPO_MAX_RG_MS = 20_000
+let ripgrepRisolto = null
+function percorsoRipgrep() {
+    const daAmbiente = process.env.TALOS_RG_PATH
+    if (daAmbiente) return Promise.resolve(existsSync(daAmbiente) ? daAmbiente : null)
+    ripgrepRisolto ??= import('@vscode/ripgrep').then(
+        (m) => (typeof m?.rgPath === 'string' && existsSync(m.rgPath) ? m.rgPath : null),
+        () => null)
+    return ripgrepRisolto
+}
+function eseguiRipgrep(rg, argomenti, cartella, segnale) {
+    return new Promise((fine) => {
+        let figlio
+        try { figlio = spawn(rg, argomenti, { cwd: cartella, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }) }
+        catch { fine(null); return }
+        const pezzi = []
+        let byte = 0, tagliato = false
+        const orologio = setTimeout(() => { tagliato = true; figlio.kill() }, TEMPO_MAX_RG_MS)
+        /* Lo Stop ferma anche la ricerca IN VOLO (vincolo del desktop, 26/09): si uccide rg e si dice «fermata». */
+        let fermato = false
+        const alloStop = () => { fermato = true; figlio.kill() }
+        if (segnale?.aborted) alloStop(); else segnale?.addEventListener?.('abort', alloStop, { once: true })
+        figlio.stdout.on('data', (pezzo) => {
+            if (tagliato) return
+            byte += pezzo.length
+            pezzi.push(pezzo)
+            if (byte >= MAX_BYTE_RG) { tagliato = true; figlio.kill() }
+        })
+        figlio.on('error', () => { clearTimeout(orologio); fine(null) })
+        figlio.on('close', (codice) => {
+            clearTimeout(orologio)
+            segnale?.removeEventListener?.('abort', alloStop)
+            if (fermato) { fine({ testo: '', tagliato: false, scaduto: false, fermato: true }); return }
+            const testo = Buffer.concat(pezzi).toString('utf8')
+            /* 0 = trovato, 1 = niente; 2 = errori (un file illeggibile) con o senza risultati. Un 2 senza uscita,
+               o un processo ucciso senza niente, non e' «non c'e'»: e' un guasto, e decide il ripiego JS. */
+            if (codice === 0 || codice === 1 || testo) fine({ testo, tagliato: tagliato && byte >= MAX_BYTE_RG, scaduto: tagliato && byte < MAX_BYTE_RG })
+            else fine(null)
+        })
+    })
+}
+const percorsoDaRg = (p) => p.replace(/\\/gu, '/').replace(/^\.\//u, '')
+async function cercaConRipgrep(radice, testo, chiaveNome, segnale) {
+    const rg = await percorsoRipgrep()
+    if (!rg) return null
+    const comuni = ['--no-config', '--hidden', '--no-require-git', '--glob', '!.git', '--glob', '!node_modules']
+    /* Il ripiego delle cartelle potate vale, come prima, solo quando non c'e' un `.gitignore` da cui leggere. */
+    if (!existsSync(join(radice, '.gitignore'))) for (const c of POTATE_SENZA_GITIGNORE) comuni.push('--glob', `!${c}`)
+    const ricerca = await eseguiRipgrep(rg, [...comuni, '--line-number', '--with-filename', '--no-heading', '--color', 'never',
+        '--fixed-strings', '--ignore-case', '--max-count', String(MAX_RIGHE_PER_FILE), '--max-columns', String(MAX_COLONNE_RG),
+        '--max-columns-preview', '--max-filesize', String(MAX_BYTE_FILE), '-e', testo, '--', '.'], radice, segnale)
+    if (ricerca === null) return null
+    if (ricerca.fermato) return 'stopped: the search was interrupted.'
+    /* rg lavora in parallelo e non promette un ordine: si ordina qui, cosi' la stessa domanda da' la stessa risposta. */
+    const perFile = new Map()
+    for (const riga of ricerca.testo.split(/\r?\n/u)) {
+        const m = /^(.+?):(\d+):(.*)$/u.exec(riga)
+        if (!m) continue
+        const percorso = percorsoDaRg(m[1])
+        if (!perFile.has(percorso)) perFile.set(percorso, [])
+        perFile.get(percorso).push(`${percorso}:${m[2]}:${m[3].trim()}`)
+    }
+    let perNome = []
+    if (chiaveNome) {
+        const elenco = await eseguiRipgrep(rg, [...comuni, '--files', '.'], radice, segnale)
+        if (elenco === null) return null
+        if (elenco.fermato) return 'stopped: the search was interrupted.'
+        perNome = elenco.testo.split(/\r?\n/u).filter(Boolean).map(percorsoDaRg).filter((p) => p.toLowerCase().includes(chiaveNome)).sort()
+    }
+    const avvisi = []
+    if (ricerca.scaduto) avvisi.push(`⚠ incomplete scan: the search took longer than ${TEMPO_MAX_RG_MS / 1000} s and was stopped. Search inside a subfolder.`)
+    if (ricerca.tagliato) avvisi.push('⚠ incomplete scan: too much output — the matches below are a part of them. Narrow the search.')
+    const coda = avvisi.length > 0 ? `\n${avvisi.join('\n')}` : ''
+    const file = [...perFile.keys()].sort()
+    if (file.length === 0 && perNome.length === 0) {
+        return `no file matches "${testo}" (searched with ripgrep; .gitignore respected, binaries skipped). Try a shorter or different "testo".${coda}`
+    }
+    const righe = perNome.slice(0, MAX_RISULTATI)
+    let righeTesto = 0, fileMostrati = 0
+    for (const f of file) {
+        if (fileMostrati >= MAX_RISULTATI || righeTesto >= MAX_RIGHE_RG) break
+        const trovate = perFile.get(f).slice(0, MAX_RIGHE_RG - righeTesto)
+        righe.push(...trovate)
+        righeTesto += trovate.length
+        fileMostrati += 1
+    }
+    const fileTagliati = file.length - fileMostrati
+    const nomiTagliati = perNome.length - Math.min(perNome.length, MAX_RISULTATI)
+    return righe.join('\n')
+        + (nomiTagliati > 0 ? `\n… and ${nomiTagliati} more paths matching "${chiaveNome}" not shown — narrow the search.` : '')
+        // ⛔ Il taglio si DICHIARA, come nella camminata JS: «40 file» non deve leggersi come «sono 40».
+        + (fileTagliati > 0 ? `\n… and ${fileTagliati} more files with matches not shown — narrow the search.` : '')
+        + (file.some((f) => perFile.get(f).length >= MAX_RIGHE_PER_FILE) ? `\n(at most ${MAX_RIGHE_PER_FILE} matching lines per file are shown)` : '')
+        + coda
+}
+
 /**
  * ⭐⭐⭐ CERCA — l'attrezzo che toglie la cecita', senza comprare l'inventario.
  *
@@ -3685,10 +3802,16 @@ async function tuttiIPercorsi(disco, { filtro = null } = {}) {
  * @param {{radice?: string}} [opzioni] — la cartella VERA, per leggere il `.gitignore`.
  *   Assente (test, ponte del telefono) ⇒ si usa il ripiego `POTATE_SENZA_GITIGNORE`.
  */
-export async function cercaNelProgetto(disco, { testo, nome }, { radice } = {}) {
+export async function cercaNelProgetto(disco, { testo, nome }, { radice, segnale } = {}) {
     const chiaveTesto = String(testo ?? '').trim().toLowerCase()
     const chiaveNome = String(nome ?? '').trim().toLowerCase()
     if (!chiaveTesto && !chiaveNome) return 'give at least one of "testo" or "nome".'
+    /* P18 fase 3: con la cartella vera e un ripgrep disponibile, la ricerca nel contenuto la fa `rg`.
+       `null` = rg assente o fallito: si prosegue con la camminata JS qui sotto, invariata. */
+    if (chiaveTesto && radice) {
+        const conRg = await cercaConRipgrep(radice, String(testo).trim(), chiaveNome, segnale)
+        if (conRg !== null) return conRg
+    }
 
     const filtro = await filtroDelProgetto(radice)
     const { percorsi, dimensioni, stato } = await tuttiIPercorsi(disco, { filtro })
@@ -8136,6 +8259,30 @@ export async function talosLavora({
             break
         }
 
+        /*
+         * ⭐⭐ P18 fase 2 (owner 26/09/2026, patch approvata dalla lane desktop) — le `cerca` della STESSA risposta
+         * partono INSIEME, fino a `MAX_CERCA_INSIEME` (Hermes 8, `_MAX_TOOL_WORKERS`; Claude Code 10, i blocchi
+         * «concurrency-safe» dello `StreamingToolExecutor`). Il ciclo qui sotto resta quello di sempre: hook,
+         * approvazioni, eventi `tool-inizio`/`tool-esito` e risultati nella storia, tutto nell'ordine delle chiamate;
+         * il ramo `cerca` aspetta la SUA ricerca già partita invece di avviarla.
+         * ⛔ Solo `cerca`: e' pura (legge dentro la cartella, non chiede approvazioni) e un rifiuto del pre-hook su una
+         *   lettura e' gia' ignorato (vedi FASE A qui sotto). `leggi` no: un percorso fuori dal progetto chiede
+         *   l'approvazione, e quella va chiesta in ordine, prima di leggere.
+         * ⛔ Lo Stop ferma anche quelle in volo: il segnale arriva fino a rg, che viene ucciso.
+         * Misura (banco ermetico, 4 `cerca` su 6.000 file): 8.648 ms prima di P18, 377 con ripgrep in fila.
+         */
+        const ricercheAvviate = new Map()
+        const daCercare = chiamate.filter((c) => c.function?.name === 'cerca')
+        if (daCercare.length > 1 && !segnaleStop?.aborted) {
+            for (const c of daCercare.slice(0, MAX_CERCA_INSIEME)) {
+                let argomentiCerca = {}
+                try { argomentiCerca = JSON.parse(c.function?.arguments || '{}') } catch { /* vuoto: il ramo dira' cosa manca */ }
+                const avviata = cercaNelProgetto(disco, argomentiCerca, { radice: cartella, segnale: segnaleStop })
+                avviata.catch(() => {})
+                ricercheAvviate.set(c, avviata)
+            }
+        }
+
         let fermatoDentroIlGiro = false
         for (const c of chiamate) {
             /*
@@ -8232,7 +8379,7 @@ export async function talosLavora({
                      * potare. Senza, `cerca` ricade sulla lista fissa — che e' il ripiego per il ponte
                      * del telefono e per i test, non il caso normale.
                      */
-                    esito = await cercaNelProgetto(disco, argomenti, { radice: cartella })
+                    esito = await (ricercheAvviate.get(c) ?? cercaNelProgetto(disco, argomenti, { radice: cartella, segnale: segnaleStop }))
                 }
                 else if (nome === 'leggi') {
                     /*

package/vendor/manifest.json

@@ -1,6 +1,6 @@
 {
  "schema": "talos.cli.vendor.v1",
- "sourceCommit": "8b0aec01669422ea54791ff7356233cd53dc1767",
+ "sourceCommit": "9a10705c95b865e72c431f8d8ad7873bcdd430b5",
  "files": 163,
  "sha256": {
   "context-engine/package.json": "cd416c2ef02241365eca721ce1bed7a702cff34bb804d79e974f9f36731ced8a",
@@ -73,7 +73,7 @@
   "harness-ui/src/image-generator.mjs": "8762739d578f81d1b881d24338518480e59fcae5b8a3ff6a071947652bec8008",
   "harness-ui/src/istruzioni-di-progetto.mjs": "a0c2c9dec9d119799e3bc02b1aee99ffa996d2c141ba679345f7309495a29cff",
   "harness-ui/src/kernel/dist/kernelPerIlBanco.js": "ff75a3e93b6c6d6d838331016c5eb2d1e6acfea85ffc0609d2f531f07b202a54",
-  "harness-ui/src/kernel/talosHarness.mjs": "cd41c71a874ffaa25ba456ec98a664265704e71dcfd63eeb1a4216a5924ba613",
+  "harness-ui/src/kernel/talosHarness.mjs": "c03a8d1e155a8f4f31793e687f7b26e5ee625ff3a3dcfc737dde6f8cb0fca32a",
   "harness-ui/src/library-policy-store.mjs": "b0295e20d7348cc13cb23a8ad2a0b577fe275b4778b94e102ceeb4fb1bb4c70b",
   "harness-ui/src/library-store.mjs": "b7a0333da5783361536509f9108e1293b1e8c22bddfb02fd5581a4e1ed4bcd4f",
   "harness-ui/src/llama-server-supervisor.mjs": "d59cc22a0e7875b4deeb4a4eac1daa55c3f524db7f5f9bd1f5e58f2c4be261e3",