talos-code 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -5,6 +5,34 @@ 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.

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/version.js

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

package/dist/workspace/checkpoint.js

@@ -5,7 +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;
+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('/'); }
@@ -238,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)
@@ -256,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 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)) {
-        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;
-    }
+        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);
@@ -323,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 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, '');
@@ -337,17 +345,14 @@ 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, '');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talos-code",
-  "version": "0.2.1",
+  "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",

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

@@ -3679,6 +3679,8 @@ async function tuttiIPercorsi(disco, { filtro = null } = {}) {
  * 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
@@ -3815,11 +3817,15 @@ export async function cercaNelProgetto(disco, { testo, nome }, { radice, segnale
 
     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 }
@@ -8271,8 +8277,13 @@ export async function talosLavora({
          * ⛔ 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 daCercare = chiamate.filter((c) => c.function?.name === 'cerca')
+        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 = {}

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": "9a10705c95b865e72c431f8d8ad7873bcdd430b5",
+ "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": "c03a8d1e155a8f4f31793e687f7b26e5ee625ff3a3dcfc737dde6f8cb0fca32a",
+  "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"