talos-code 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -5,6 +5,59 @@ 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.2 — 2026-09-27
+
+`npm i -g talos-code@0.2.2`, or `talos update` to see it.
+
+### Changed
+- Faster turns again. The `/undo` snapshot looks at the files of a folder together instead of one by one: a turn in a
+  folder of 6,000 files went from 1.8 s to 1.25 s (1.4 s to 1.28 s in a git repository), on par with Pi.
+- Long sessions no longer slow down at every tool result: the context archive is written once per tool exchange instead
+  of after every result, and is no longer read back whole at every write. At 1,350 messages, a turn with six tools
+  spends 24 ms on it instead of 160 ms.
+
+### Fixed
+- A search asked in the same answer AFTER a file write could miss what that write had just changed (0.2.1: the searches
+  of one answer started together, before the write). Only the searches before any other tool start together now.
+- Stopping a turn also stops a search that is still walking the project when ripgrep is not available.
+
+### Known limits
+- Tested on Windows 11 x64 only; Node.js 24 (24.18 or later in the 24 line).
+- Shell commands run one at a time, each in its sandbox: the safety check of each command depends on what the
+  previous ones did.
+
+### Verification
+- Hermetic bench (`scripts/bench-harness.ts`, a git repository of 6,000 files, local fake provider): a turn with no
+  tool 1.13 s (Pi 1.23, OpenCode 2.69, Codex 0.50); six reads 1.10 s (Pi 1.23, Codex 1.98, OpenCode 3.34); four
+  searches 1.32 s (Pi 1.59, Codex 1.71, OpenCode 3.61).
+- CLI unit suite: 1879 tests, 1875 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.2.tgz`.
+
+## 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/context-archive.js

@@ -61,9 +61,28 @@ export function withArchivableCapture(hooks, { stalePatienceMs = STALE_PATIENCE_
     if (!hooks || typeof hooks.capture !== 'function')
         return hooks;
     const capture = hooks.capture, prepare = hooks.prepare;
+    /*
+     * P18 phase 1 (owner 2026-09-26). The kernel captures at 'start', 'before-request', 'response', after EVERY tool result
+     * and at 'finished'; with the rule above most of those carry the prefix already archived (a tool exchange is archived
+     * once, when its last result is in), and each still cost the service a full reread of the archive and a sha256 of
+     * every message (context-desktop-service.mjs syncOriginals): ~25 ms a capture at 1,351 messages, measured with
+     * scripts/bench-tools.ts. A prefix with the same length, first and last message as the last one archived is not sent
+     * again. Any other change (longer, shorter, a message replaced) still goes to the service, which decides.
+     */
+    let archived = null;
+    const sameAsArchived = (rows) => archived !== null && rows.length === archived.length && rows[0] === archived.first && rows[rows.length - 1] === archived.last;
     return {
         ...hooks,
-        capture: (input) => retryStale(() => capture({ ...input, messages: Array.isArray(input?.messages) ? archivableHistory(input.messages) : input?.messages }), stalePatienceMs),
+        capture: async (input) => {
+            if (!Array.isArray(input?.messages))
+                return retryStale(() => capture(input), stalePatienceMs);
+            const rows = archivableHistory(input.messages);
+            if (sameAsArchived(rows))
+                return undefined;
+            const result = await retryStale(() => capture({ ...input, messages: rows }), stalePatienceMs);
+            archived = { length: rows.length, first: rows[0], last: rows[rows.length - 1] };
+            return result;
+        },
         ...(typeof prepare === 'function' ? { prepare: (input) => retryStale(() => prepare(input), stalePatienceMs) } : {}),
     };
 }

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.2';
 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,17 @@ 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, CAPTURE_CONCURRENCY = 32;
+/* Runs `fn` over `items` with at most `limit` in flight and returns the results in the items' order. */
+async function inOrder(items, limit, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => { while (next < items.length) {
+        const i = next++;
+        out[i] = await fn(items[i]);
+    } }));
+    return out;
+}
 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 +70,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 +87,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 +210,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 };
 }
@@ -213,6 +248,9 @@ async function captureGit(workspace, blobRoot, budget) {
     }
     const entries = {};
     const seen = new Set();
+    /* The index is validated first, in order (unmerged, duplicate, gitlink: the first bad row decides), then the files are
+       looked at CAPTURE_CONCURRENCY at a time and their entries stored in index order. */
+    const jobs = [];
     for (const row of trackedRows) {
         const tab = row.indexOf('\t');
         if (tab < 0)
@@ -231,60 +269,50 @@ async function captureGit(workspace, blobRoot, budget) {
         if (!relGit)
             continue;
         const relative = safeRelative(relGit);
-        const absolute = absoluteFromRelative(workspace.canonicalRoot, relative);
+        jobs.push({ relative, absolute: absoluteFromRelative(workspace.canonicalRoot, relative), mode, oid, gitPath });
+    }
+    const tracked = await inOrder(jobs, CAPTURE_CONCURRENCY, async ({ relative, absolute, mode, oid, gitPath }) => {
         let stat;
         try {
             stat = await lstat(absolute);
         }
         catch (error) {
             if (error?.code === 'ENOENT')
-                continue;
+                return null;
             throw error;
         }
         const mustCapture = dirty.has(gitPath) || stat.isSymbolicLink() || !stat.isFile();
-        if (mustCapture) {
-            const actual = await captureActualFile(workspace, absolute, relative, blobRoot, budget, mode === '100755');
-            if (actual)
-                entries[relative] = actual;
-            continue;
-        }
+        if (mustCapture)
+            return captureActualFile(workspace, absolute, relative, blobRoot, budget, mode === '100755');
         consumeEntry(budget);
-        await assertExistingPathContained(workspace, absolute);
-        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)) {
-        const relGit = prefix ? (gitPath.startsWith(`${prefix}/`) ? gitPath.slice(prefix.length + 1) : null) : gitPath;
-        if (!relGit)
-            continue;
-        const relative = safeRelative(relGit);
-        if (entries[relative])
-            continue;
-        const actual = await captureActualFile(workspace, absoluteFromRelative(workspace.canonicalRoot, relative), relative, blobRoot, budget);
-        if (actual)
-            entries[relative] = actual;
-    }
+        await assertFileContained(workspace, absolute, budget);
+        return { kind: 'file', source: 'git', ref: oid, size: stat.size, mode: stat.mode & 0o777, executable: mode === '100755', gitPath };
+    });
+    jobs.forEach((job, i) => { const entry = tracked[i]; if (entry)
+        entries[job.relative] = entry; });
+    const untracked = [...new Set(nulList(untrackedRaw).map(gitPath => prefix ? (gitPath.startsWith(`${prefix}/`) ? gitPath.slice(prefix.length + 1) : null) : gitPath).filter((relGit) => Boolean(relGit)).map(safeRelative))].filter(relative => !entries[relative]);
+    const captured = await inOrder(untracked, CAPTURE_CONCURRENCY, relative => captureActualFile(workspace, absoluteFromRelative(workspace.canonicalRoot, relative), relative, blobRoot, budget));
+    untracked.forEach((relative, i) => { const entry = captured[i]; if (entry)
+        entries[relative] = entry; });
     return { capturedAt: new Date().toISOString(), workspace: { canonicalRoot: workspace.canonicalRoot, identityHash: workspace.identityHash, gitRoot }, entries, git: { root: gitRoot, head, indexHash, worktreeSemanticsHash }, coverage: { tracked: true, untrackedNonIgnored: true, ignoredUntracked: false, gitMetadataRestored: false }, exclusions: ['Untracked files ignored by Git are outside rollback coverage.', 'Empty-directory existence is outside rollback coverage.', 'Git refs, index and object database are observed for conflict evidence but are not restored.'] };
 }
 async function captureNonGit(workspace, blobRoot, budget) {
     const entries = {};
+    /* Folders one at a time and in order; the files of a folder CAPTURE_CONCURRENCY at a time. */
     async function preflight(dirname, relativeDir) {
         const rows = await readdir(dirname, { withFileTypes: true });
         rows.sort((a, b) => a.name.localeCompare(b.name));
-        for (const row of rows) {
+        const files = rows.filter(row => !row.isDirectory());
+        await inOrder(files, CAPTURE_CONCURRENCY, async (row) => {
             const relative = safeRelative(relativeDir ? `${relativeDir}/${row.name}` : row.name);
             const absolute = path.join(dirname, row.name);
-            if (row.isDirectory()) {
-                await assertExistingPathContained(workspace, absolute);
-                await preflight(absolute, relative);
-                continue;
-            }
             let stat;
             try {
                 stat = await lstat(absolute);
             }
             catch (error) {
                 if (error?.code === 'ENOENT')
-                    continue;
+                    return;
                 throw error;
             }
             consumeEntry(budget);
@@ -298,12 +326,17 @@ async function captureNonGit(workspace, blobRoot, budget) {
                 }
                 if (!inside(workspace.canonicalRoot, canonical))
                     throw coded('CHECKPOINT_SYMLINK_ESCAPE', `Checkpoint symlink escapes workspace: ${relative}`);
-                continue;
+                return;
             }
             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);
+        });
+        for (const row of rows.filter(row => row.isDirectory())) {
+            const absolute = path.join(dirname, row.name);
+            await assertExistingPathContained(workspace, absolute);
+            await preflight(absolute, safeRelative(relativeDir ? `${relativeDir}/${row.name}` : row.name));
         }
     }
     await preflight(workspace.canonicalRoot, '');
@@ -312,30 +345,30 @@ async function captureNonGit(workspace, blobRoot, budget) {
     async function walk(dirname, relativeDir) {
         const rows = await readdir(dirname, { withFileTypes: true });
         rows.sort((a, b) => a.name.localeCompare(b.name));
-        for (const row of rows) {
-            const relative = safeRelative(relativeDir ? `${relativeDir}/${row.name}` : row.name);
+        const files = rows.filter(row => !row.isDirectory()).map(row => safeRelative(relativeDir ? `${relativeDir}/${row.name}` : row.name));
+        const captured = await inOrder(files, CAPTURE_CONCURRENCY, relative => captureActualFile(workspace, path.join(dirname, path.basename(relative)), relative, blobRoot, budget));
+        files.forEach((relative, i) => { const entry = captured[i]; if (entry)
+            entries[relative] = entry; });
+        for (const row of rows.filter(row => row.isDirectory())) {
             const absolute = path.join(dirname, row.name);
-            if (row.isDirectory()) {
-                await assertExistingPathContained(workspace, absolute);
-                await walk(absolute, relative);
-                continue;
-            }
-            const actual = await captureActualFile(workspace, absolute, relative, blobRoot, budget);
-            if (actual)
-                entries[relative] = actual;
+            await assertExistingPathContained(workspace, absolute);
+            await walk(absolute, safeRelative(relativeDir ? `${relativeDir}/${row.name}` : row.name));
         }
     }
     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.2",
   "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/context-desktop-service.mjs

@@ -20,6 +20,8 @@ export function createDesktopContextService({ engine, store, loadLegacy, resolve
   /* 24/09 — F4: le sessioni per cui questo processo ha già cercato job orfani (basta una volta: in
      questo processo un job attivo è sempre nella mappa `running` del motore). */
   const recuperate = new Set();
+  /* P18: per sessione, le impronte dei record gia' verificati e la revisione dell'archivio che le ha prodotte. */
+  const impronteVerificate = new Map();
   let closed = false;
   function serial(sessionId, task) {
     const previous = queues.get(sessionId) ?? Promise.resolve();
@@ -194,15 +196,28 @@ export function createDesktopContextService({ engine, store, loadLegacy, resolve
       }
       fail('CTX_ROUTE_NOT_FOUND', 'Operazione del contesto non trovata.');
     },
+    /*
+     * P18 (26/09/2026, patch approvata dall'owner via la lane CLI): l'archivio non si RILEGGE a ogni capture. Le
+     * impronte dei record gia' verificati restano in memoria, legate alla revisione dell'archivio che le ha prodotte;
+     * se la revisione e' ancora quella (nessun altro ha scritto: una compattazione la cambia), si usano quelle invece
+     * di `allRecords` (misurato: ~25 ms a capture a 1.351 messaggi, cresce con la storia). Il confronto con OGNI
+     * messaggio resta: la divergenza si scopre come prima.
+     */
     syncOriginals({ sessionId, messages }) {
       return serial(sessionId, async () => {
         const snapshot = await ensure(sessionId);
         if (!Array.isArray(messages)) fail('CTX_INVALID_INPUT', 'Cronologia non valida.');
-        const saved = await allRecords(sessionId);
-        if (messages.length < saved.length || saved.some((record, index) => record.sha256 !== digest(messages[index]))) fail('CTX_HISTORY_DIVERGED', 'La cronologia attiva differisce dall’archivio. Gli originali sono conservati; occorre recuperare la versione completa.');
-        const records = messages.slice(saved.length).map((message, offset) => ({ id: `message-${saved.length + offset + 1}`, message, createdAt: clock(), origin: 'desktop-kernel' }));
+        const noto = impronteVerificate.get(sessionId);
+        const salvate = noto && Number.isInteger(snapshot?.revision) && noto.revision === snapshot.revision ? noto.impronte : (await allRecords(sessionId)).map((record) => record.sha256);
+        if (messages.length < salvate.length || salvate.some((impronta, index) => impronta !== digest(messages[index]))) {
+          impronteVerificate.delete(sessionId);
+          fail('CTX_HISTORY_DIVERGED', 'La cronologia attiva differisce dall’archivio. Gli originali sono conservati; occorre recuperare la versione completa.');
+        }
+        const records = messages.slice(salvate.length).map((message, offset) => ({ id: `message-${salvate.length + offset + 1}`, message, createdAt: clock(), origin: 'desktop-kernel' }));
         if (records.length) await store.appendOriginalBatch({ sessionId, records, expectedRevision: snapshot.revision });
-        return store.readContextSnapshot({ sessionId });
+        const dopo = await store.readContextSnapshot({ sessionId });
+        impronteVerificate.set(sessionId, { revision: dopo?.revision, impronte: [...salvate, ...records.map((record) => digest(record.message))] });
+        return dopo;
       });
     },
     /*

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

@@ -3662,6 +3662,125 @@ 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
+/* Gli attrezzi che non cambiano niente: una partenza anticipata puo' scavalcarli, mai scavalcare altro. */
+const LETTURE_PURE = new Set(['cerca', 'leggi', 'elenca'])
+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,18 +3804,28 @@ 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 })
+    /* P18 (vincolo desktop a, 26/09): lo Stop ferma anche la camminata JS, non solo rg — fino a 8 `cerca` possono
+       essere partite insieme, e nessuna deve finire in sottofondo dopo «Ferma». */
+    if (segnale?.aborted) return 'stopped: the search was interrupted.'
     const perNome = []
     const perTesto = []
     const conto = { letti: 0, binari: 0, troppoGrandi: 0, illeggibili: 0, tettoLetture: false, tettoRicerca: false }
 
     for (const p of percorsi) {
+        if (segnale?.aborted) return 'stopped: the search was interrupted.'
         const basso = p.toLowerCase()
         const combaciaNome = chiaveNome && basso.includes(chiaveNome)
         if (combaciaNome) { perNome.push(p); continue }
@@ -8136,6 +8265,35 @@ 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.
+         */
+        /* ⛔⛔ Solo il PREFISSO di sole letture della risposta (`cerca`, `leggi`, `elenca`): una `cerca` che viene DOPO
+           una scrittura o un comando deve vedere il loro effetto, e partita prima non lo vedrebbe (misurato: `scrivi`
+           poi `cerca` nella stessa risposta dava la ricerca SENZA il file appena scritto — p18-cerca-insieme). */
+        const ricercheAvviate = new Map()
+        const primaNonLettura = chiamate.findIndex((c) => !LETTURE_PURE.has(c.function?.name))
+        const prefissoDiLettura = primaNonLettura === -1 ? chiamate : chiamate.slice(0, primaNonLettura)
+        const daCercare = prefissoDiLettura.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 +8390,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/harness-ui/src/workspace-info.mjs

@@ -105,8 +105,13 @@ function git(argomenti, cwd) {
 export async function statoGit(percorso, { profondita = PROFONDITA_REPO_ANNIDATI, eseguiGit = git } = {}) {
   const dentro = await eseguiGit(['rev-parse', '--is-inside-work-tree'], percorso);
   if (!dentro || dentro.trim() !== 'true') return null;
-  const ramo = (await eseguiGit(['rev-parse', '--abbrev-ref', 'HEAD'], percorso) || '').trim() || null;
-  const stato = await eseguiGit(['status', '--porcelain'], percorso);
+  /* P18 (26/09/2026): ramo e stato sono indipendenti, si chiedono INSIEME (misurato all'avvio di un turno: ~55 ms
+     in meno, due processi git in fila diventano uno accanto all'altro). */
+  const [ramoGrezzo, stato] = await Promise.all([
+    eseguiGit(['rev-parse', '--abbrev-ref', 'HEAD'], percorso),
+    eseguiGit(['status', '--porcelain'], percorso),
+  ]);
+  const ramo = (ramoGrezzo || '').trim() || null;
   const nonSalvate = stato === null ? null : stato.split('\n').filter((r) => r.trim()).length;
   const annidati = await repoAnnidati(percorso, profondita);
   return { ramo, nonSalvate, repoAnnidati: annidati };

package/vendor/manifest.json

@@ -1,6 +1,6 @@
 {
  "schema": "talos.cli.vendor.v1",
- "sourceCommit": "f54beedcbd8fb3c6c735881e91dab21fbe13bc1b",
+ "sourceCommit": "e553a0cd2616df27b399505afc3fa0eeb8b504fa",
  "files": 163,
  "sha256": {
   "context-engine/package.json": "cd416c2ef02241365eca721ce1bed7a702cff34bb804d79e974f9f36731ced8a",
@@ -36,7 +36,7 @@
   "harness-ui/src/config.mjs": "ab482ac221f4b5ad3e1b46052d87549ebf89fd2ee30ce113ceda8132b028e1ef",
   "harness-ui/src/contesto-del-progetto.mjs": "5aec0670f0d81fc545112ae4f2a0a36a5359e76e76f39bf63d403a6cb615d030",
   "harness-ui/src/context-asset-adapter.mjs": "5a5feccad64c3b427031dcc8dfc47a2ffa5e0db4eec2959a8d3b70e3c87a55fc",
-  "harness-ui/src/context-desktop-service.mjs": "5415123aa96f5bdeeedcedbcd55cb0b3fe944c629232a92bb98eeda372c8d397",
+  "harness-ui/src/context-desktop-service.mjs": "0ac2625b63512909c689d81370047a7e54892fbf0c58622936b5c9a72aff9fc0",
   "harness-ui/src/context-embedding-runtime.mjs": "de494d5d1bf08e2a9b685dbf78f8e9a16631700e0c4e5d045c91f65a6a4c6ec2",
   "harness-ui/src/context-inference-scheduler.mjs": "26dcccde934993226d4adb0b239b465a45640701d377c5851fc58209552e7d39",
   "harness-ui/src/context-native-compaction.mjs": "55069d9a80283d10be924bd1309bb271a234608660424deb48aac82f8e273125",
@@ -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": "0ee781ebbb507389a0ac109eebb599d45760dedf9d368d6f921e02b2a8e97d1e",
   "harness-ui/src/library-policy-store.mjs": "b0295e20d7348cc13cb23a8ad2a0b577fe275b4778b94e102ceeb4fb1bb4c70b",
   "harness-ui/src/library-store.mjs": "b7a0333da5783361536509f9108e1293b1e8c22bddfb02fd5581a4e1ed4bcd4f",
   "harness-ui/src/llama-server-supervisor.mjs": "d59cc22a0e7875b4deeb4a4eac1daa55c3f524db7f5f9bd1f5e58f2c4be261e3",
@@ -162,7 +162,7 @@
   "harness-ui/src/workspace-context.mjs": "75bb99b0e5624b2257a73c76997bb8670206758cbabe4613683503c6c785930a",
   "harness-ui/src/workspace-disk.mjs": "b90a666880079a72bca7512bb936324f2abe3ed1075aec828cbcbeba3965ec7a",
   "harness-ui/src/workspace-files.mjs": "998f04da2959d8404da801d4cf981e1e42fcab221d2b96456acb19688980c4a4",
-  "harness-ui/src/workspace-info.mjs": "e685e98675cb432154cb20e076be310076e2f07c240de11bc4d0feab94293d05",
+  "harness-ui/src/workspace-info.mjs": "cd3cb40401139e06a5ddc23683822578913c180744bea233d3b5e2c29b417042",
   "harness-ui/src/workspace-launch-store.mjs": "06e14d1c740377d788609d6cd930575a1180dab32640a1692605a0225cadf9a9",
   "harness-ui/src/workspace-tree.mjs": "c5723383cdff663ea0537e384fef8593f574893e63b9645c395a076910ac1f8b",
   "harness-ui/src/workspace-watcher.mjs": "ab1e1a03ab61b98f2a7a5bd559b56e1e6dfc0b3ec201a41edc96d70512f8053f"