talos-code 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -5,6 +5,31 @@ Format: [Keep a Changelog 1.1.0](https://keepachangelog.com/en/1.1.0/). Versions
 `src/version.ts`, and in the `talos-cli-vX.Y.Z` tag. The package is published on npm as
 [`talos-code`](https://www.npmjs.com/package/talos-code); the command is `talos`.
 
+## talos-cli-v0.2.1 — 2026-09-26
+
+`npm i -g talos-code@0.2.1`, or `talos update` to see it.
+
+### Changed
+- Faster turns in large folders. The workspace snapshot that makes `/undo` possible no longer reads, rewrites and syncs
+  every file at every turn: a file that has not changed since the last turn reuses what was stored. A turn in a plain
+  folder of 6,000 files went from 39 s to 1.8 s, and from 2.6 s to 1.4 s in a git repository of the same size. What
+  `/undo` covers is unchanged.
+- Faster and complete project search. `cerca` runs ripgrep, shipped inside the package for your platform (no download),
+  and each match now comes with its line: `path:line:text`. Four searches over 6,000 files took 9.3 s; now about 0.2 s.
+  Before, a search stopped after reading 5,000 files and could miss matches in a bigger project. Several searches asked
+  in the same answer run together. Without ripgrep, the previous search still works.
+
+### Known limits
+- Tested on Windows 11 x64 only; Node.js 24 (24.18 or later in the 24 line).
+- Shell commands still run one at a time, each in its sandbox; a start of about one second remains.
+
+### Verification
+- Measured on a hermetic bench (`scripts/bench-harness.ts`): a local fake provider, no network, TALOS against Pi, Codex
+  and OpenCode on the same turns.
+- CLI unit suite: 1876 tests, 1872 pass, 4 skip, 0 fail. Acceptance on the built CLI in a synthetic terminal: 263/263.
+- The package proof (`scripts/prove-standalone.ts`), 16/16 on `talos-code-0.2.1.tgz` (1.76 MB); the installed package
+  resolves its own ripgrep.
+
 ## talos-cli-v0.2.0 — 2026-09-26
 
 `npm i -g talos-code@0.2.0`, or `talos update` to see it from 0.1.0.

package/dist/runtime/repo.js

@@ -89,7 +89,18 @@ export function findTalosRepoRoot(start = process.cwd(), deps = {}) {
         return cwd;
     throw new Error('TALOS_RUNTIME_NOT_FOUND');
 }
+/* P18 phase 3 (owner 2026-09-26: ripgrep inside the npm package, no network): the kernel's `cerca` runs ripgrep from
+   TALOS_RG_PATH. `@vscode/ripgrep` ships the binary for this platform as an optional dependency of the package (no
+   install script, no download); a path already set, or a package without it, is left alone and `cerca` keeps its JS walk. */
+let bundledRipgrep = null;
+export function provideBundledRipgrep(env = process.env) {
+    if (env.TALOS_RG_PATH)
+        return Promise.resolve();
+    return bundledRipgrep ??= import('@vscode/ripgrep').then((m) => { if (typeof m?.rgPath === 'string' && existsSync(m.rgPath))
+        env.TALOS_RG_PATH = m.rgPath; }, () => { });
+}
 export async function importTalosModule(repoRoot, relativeFromHarnessSrc) {
+    await provideBundledRipgrep();
     const file = join(repoRoot, 'harness-ui', 'src', relativeFromHarnessSrc);
     return import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
 }

package/dist/runtime/talos-composition.js

@@ -12,6 +12,7 @@ import { secretValuesFromEnvironment } from "../diagnostics/redact.js";
 import { isTestProfile } from "../provider/store.js";
 import { compactionEvent, createCliEventHub, createRunObserver, RETRY_AFTER_MAX_MS, summaryRequestedEvent } from "./provider-attempts.js";
 import { createToolOutputStore, pruneToolOutput } from "./output-store.js";
+import { provideBundledRipgrep } from "./repo.js";
 import { withArchivableCapture } from "./context-archive.js";
 import { CONTEXT_ENGINE_MIN_WINDOW, configureModelProfiles, createModelsDevLoader, modelProfile, modelProfileEvidence, ollamaWindow, rememberOllamaWindow, setModelOverrides } from "./model-profile.js";
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -246,7 +247,7 @@ export function createCliContextBridge({ repoRoot, paths, registry, providerRegi
 export function scopeCliKeyring(raw) { if (!raw)
     return null; return { get: (s, a) => raw.get(remapService(s), a), set: (s, a, v) => raw.set(remapService(s), a, v), remove: (s, a) => raw.remove(remapService(s), a) }; }
 /** The kernel modules the product composes with. Exported so a test can observe one of them while every other stays the production one. */
-export async function loadModules(repoRoot) { const src = join(repoRoot, 'harness-ui', 'src'); const [cred, owner, agent, sessions, plugins, search, duck, providerRegistry, probe, destination, readiness, chatImages] = await Promise.all([import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'provider-credential-store.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'runtime-owner-adapter.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'agent-service.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'session-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'plugin-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'search-source-store.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'duckduckgo-search.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'provider-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'provider-probe.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'model-destination.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'sessione-pronta.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'chat-image-attachments.mjs')).href))]); return { createProviderCredentialStore: cred.createProviderCredentialStore, createOwnerRuntimeAdapter: owner.createOwnerRuntimeAdapter, creaFetchMultiProvider: owner.creaFetchMultiProvider, compattaSessione: agent.compattaSessione, chiediAlModelloUnaVolta: agent.chiediAlModelloUnaVolta, avviaSessione: agent.avviaSessione, eseguiComandoDiretto: agent.eseguiComandoDiretto, createSessionRegistry: sessions.createSessionRegistry, verificaTrustPlugin: plugins.verificaTrustPlugin, createSearchSourceStore: search.createSearchSourceStore, creaTrasportoSenzaChiave: duck.creaTrasportoSenzaChiave, ENDPOINT_SENTINELLA_DUCKDUCKGO: duck.ENDPOINT_SENTINELLA_DUCKDUCKGO, REGISTRO_FORNITORI: providerRegistry.REGISTRO_FORNITORI, createProviderProbe: probe.createProviderProbe, separaFonteModello: destination.separaFonteModello, creaProntoFn: readiness.creaProntoFn, createChatImageStore: chatImages.createChatImageStore }; }
+export async function loadModules(repoRoot) { await provideBundledRipgrep(); const src = join(repoRoot, 'harness-ui', 'src'); const [cred, owner, agent, sessions, plugins, search, duck, providerRegistry, probe, destination, readiness, chatImages] = await Promise.all([import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'provider-credential-store.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'runtime-owner-adapter.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'agent-service.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'session-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'plugin-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'search-source-store.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'duckduckgo-search.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'provider-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'provider-probe.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'model-destination.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'sessione-pronta.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'chat-image-attachments.mjs')).href))]); return { createProviderCredentialStore: cred.createProviderCredentialStore, createOwnerRuntimeAdapter: owner.createOwnerRuntimeAdapter, creaFetchMultiProvider: owner.creaFetchMultiProvider, compattaSessione: agent.compattaSessione, chiediAlModelloUnaVolta: agent.chiediAlModelloUnaVolta, avviaSessione: agent.avviaSessione, eseguiComandoDiretto: agent.eseguiComandoDiretto, createSessionRegistry: sessions.createSessionRegistry, verificaTrustPlugin: plugins.verificaTrustPlugin, createSearchSourceStore: search.createSearchSourceStore, creaTrasportoSenzaChiave: duck.creaTrasportoSenzaChiave, ENDPOINT_SENTINELLA_DUCKDUCKGO: duck.ENDPOINT_SENTINELLA_DUCKDUCKGO, REGISTRO_FORNITORI: providerRegistry.REGISTRO_FORNITORI, createProviderProbe: probe.createProviderProbe, separaFonteModello: destination.separaFonteModello, creaProntoFn: readiness.creaProntoFn, createChatImageStore: chatImages.createChatImageStore }; }
 async function loadTrustSupport(repoRoot) {
     const src = join(repoRoot, 'harness-ui', 'src');
     const [plugins, hooks, mcp, mcpSession, pluginSession] = await Promise.all([import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'plugin-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'hook-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'mcp-registry.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'mcp-session.mjs')).href)), import(__rewriteRelativeImportExtension(pathToFileURL(join(src, 'plugin-session.mjs')).href))]);

package/dist/version.js

@@ -1,2 +1,2 @@
-export const CLI_VERSION = '0.2.0';
+export const CLI_VERSION = '0.2.1';
 export const TALOS_BASE_COMMIT = '0c432153a288f64237e98403869d02d20d8fabc7';

package/dist/workspace/checkpoint-store.js

@@ -60,6 +60,24 @@ function parseRecord(text, expectedRoot) {
         throw coded('CHECKPOINT_STORE_INVALID');
     return value;
 }
+const STAT_INDEX_SCHEMA = 'talos.cli.checkpoint-stat-index.v1';
+async function loadStatIndex(indexPath) {
+    const rows = new Map();
+    try {
+        const value = JSON.parse(await readFile(indexPath, 'utf8'));
+        if (value?.schema !== STAT_INDEX_SCHEMA || !Array.isArray(value.rows))
+            return rows;
+        for (const row of value.rows) {
+            if (!Array.isArray(row) || row.length !== 6)
+                continue;
+            const [p, size, mtimeMs, ctimeMs, ref, verifiedAtMs] = row;
+            if (typeof p === 'string' && typeof ref === 'string' && /^[0-9a-f]{64}$/u.test(ref) && [size, mtimeMs, ctimeMs, verifiedAtMs].every(n => typeof n === 'number' && Number.isFinite(n)))
+                rows.set(p, { size, mtimeMs, ctimeMs, ref, verifiedAtMs });
+        }
+    }
+    catch { /* missing or torn: an empty index, every file is read again */ }
+    return rows;
+}
 function dedupeEvidence(rows) { const byKey = new Map(); for (const row of rows)
     byKey.set(`${row.path}\0${row.beforeHash ?? ''}\0${row.afterHash ?? ''}`, row); return [...byKey.values()]; }
 export function createCheckpointStore({ rootDir, projectRoot, limits = CHECKPOINT_LIMITS }) {
@@ -85,7 +103,20 @@ export function createCheckpointStore({ rootDir, projectRoot, limits = CHECKPOIN
     } }
     async function replace(record) { const x = await init(); if (record.canonicalRoot !== x.canonicalRoot)
         throw coded('CHECKPOINT_WORKSPACE_MISMATCH'); await atomicWrite(await recordPath(record.id), `${JSON.stringify(record)}\n`); }
-    async function capture() { const x = await init(); return captureWorkspaceSnapshot({ projectRoot: x.canonicalRoot, blobRoot, limits }); }
+    /* P18: the stat index of the last capture (checkpoint.ts StatCache), kept in memory and in the workspace's folder so a new
+       `talos -p` process starts from it too. It is only a cache: unreadable means empty (every file read again), and a
+       failed save costs speed on the next turn, never a checkpoint. */
+    let statRows = null;
+    async function capture() {
+        const x = await init();
+        const indexPath = path.join(x.workspaceDir, 'stat-index.json');
+        statRows ??= await loadStatIndex(indexPath);
+        const next = new Map();
+        const snapshot = await captureWorkspaceSnapshot({ projectRoot: x.canonicalRoot, blobRoot, limits, statCache: { previous: statRows, next } });
+        statRows = next;
+        await atomicWrite(indexPath, `${JSON.stringify({ schema: STAT_INDEX_SCHEMA, rows: [...next].map(([p, r]) => [p, r.size, r.mtimeMs, r.ctimeMs, r.ref, r.verifiedAtMs]) })}\n`).catch(() => { });
+        return snapshot;
+    }
     async function list() { const x = await init(); let names = []; try {
         names = await readdir(x.recordsDir);
     }

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.2.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",

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": "f54beedcbd8fb3c6c735881e91dab21fbe13bc1b",
+ "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",