@odla-ai/harness 0.7.0 → 0.8.0

package/dist/code-runtime-cli.cjs

@@ -317,7 +317,7 @@ function validateCodePatch(rawPatch, maxBytes) {
   if (FORBIDDEN.test(patch2) || /(?:old|new)(?: file)? mode 120000/.test(patch2)) {
     throw new TypeError("patch uses a forbidden binary, link, mode, rename, or copy operation");
   }
-  const paths = [];
+  const paths2 = [];
   const lines = patch2.split("\n");
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index];
@@ -333,10 +333,10 @@ function validateCodePatch(rawPatch, maxBytes) {
     if (!validHeaderPath(oldPath, path, "a") || !validHeaderPath(newPath, path, "b")) {
       throw new TypeError("patch file headers do not match the declared path");
     }
-    paths.push(path);
+    paths2.push(path);
   }
-  if (!paths.length || new Set(paths).size !== paths.length) throw new TypeError("patch has no diffs or repeats a path");
-  return paths;
+  if (!paths2.length || new Set(paths2).size !== paths2.length) throw new TypeError("patch has no diffs or repeats a path");
+  return paths2;
 }
 function validHeaderPath(value, path, prefix) {
   return value === "/dev/null" || value === `${prefix}/${path}`;
@@ -361,11 +361,11 @@ function describePatchFailure(patch2, detail) {
   const hint = hunks.length > 0 && contextless ? " A hunk has no context lines; include at least one unchanged line above or below each change." : "";
   return `patch did not apply: ${detail}${hint}`;
 }
-async function applyCodePatch(workspaceDir, rawPatch, paths) {
+async function applyCodePatch(workspaceDir, rawPatch, paths2) {
   const patch2 = stripPatchEnvelope(rawPatch);
   await gitApply(workspaceDir, patch2, true);
   await gitApply(workspaceDir, patch2, false);
-  for (const path of paths) {
+  for (const path of paths2) {
     try {
       const info = await (0, import_promises.lstat)(resolveCodePath(workspaceDir, path));
       if (info.isSymbolicLink() || !info.isFile() && !info.isDirectory()) {
@@ -387,8 +387,8 @@ function gitApply(cwd, patch2, check) {
     });
     let stderr = "";
     child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (text) => {
-      if (stderr.length < 4e3) stderr += text.slice(0, 4e3);
+    child.stderr.on("data", (text2) => {
+      if (stderr.length < 4e3) stderr += text2.slice(0, 4e3);
     });
     child.once("error", reject);
     child.once("exit", (code) => code === 0 ? accept() : reject(new TypeError(describePatchFailure(patch2, stderr.trim().slice(0, 500)))));
@@ -471,12 +471,12 @@ async function gitSourceFiles(sourceDir, maxFiles, maxBytes) {
   });
   if (outputBytes > 8 * 1024 * 1024) throw new Error("git file inventory exceeds 8 MiB");
   if (code !== 0) throw new Error(`git file inventory failed: ${Buffer.concat(stderr).toString("utf8").slice(0, 1e3)}`);
-  const paths = Buffer.concat(stdout).toString("utf8").split("\0").filter(Boolean).sort();
-  if (paths.length > maxFiles) throw new Error(`workspace exceeds ${maxFiles} files`);
+  const paths2 = Buffer.concat(stdout).toString("utf8").split("\0").filter(Boolean).sort();
+  if (paths2.length > maxFiles) throw new Error(`workspace exceeds ${maxFiles} files`);
   const root = (0, import_node_path3.resolve)(sourceDir);
   const files = [];
   let bytes = 0;
-  for (const relativePath of paths) {
+  for (const relativePath of paths2) {
     if (!allowedWorkspacePath(relativePath)) continue;
     const source = (0, import_node_path3.resolve)(root, relativePath);
     if (!source.startsWith(`${root}${import_node_path3.sep}`)) throw new TypeError("git file path escapes workspace");
@@ -610,8 +610,8 @@ async function restoreCodeWorkspaceCheckpoint(input) {
   const workspace = await stageWorkspace(input.trustedBaseDir, input.stage);
   try {
     if (checkpoint.patch) {
-      const paths = validateCodePatch(checkpoint.patch, 256 * 1024);
-      await applyCodePatch(workspace.workspaceDir, checkpoint.patch, paths);
+      const paths2 = validateCodePatch(checkpoint.patch, 256 * 1024);
+      await applyCodePatch(workspace.workspaceDir, checkpoint.patch, paths2);
     }
     return { workspace, checkpoint };
   } catch (error) {
@@ -889,8 +889,8 @@ async function verifyCodeCandidate(input) {
   try {
     const baseDigest = await digestStagedWorkspace(staged.workspaceDir, limits);
     if (baseDigest !== input.trustedBaseDigest) throw new TypeError("trusted base does not match its registered digest");
-    const paths = validateCodePatch(input.candidatePatch, policy.maximumPatchBytes);
-    await applyCodePatch(staged.workspaceDir, input.candidatePatch, paths);
+    const paths2 = validateCodePatch(input.candidatePatch, policy.maximumPatchBytes);
+    await applyCodePatch(staged.workspaceDir, input.candidatePatch, paths2);
     const sourceDigest = await digestStagedWorkspace(staged.workspaceDir, limits);
     const policyDigest = digestPolicy(policy);
     const patchDigest = digestBytes(input.candidatePatch);
@@ -899,7 +899,7 @@ async function verifyCodeCandidate(input) {
       trustedBaseDigest: input.trustedBaseDigest,
       patchDigest
     });
-    const changedTests = changedTestPaths(paths, policy);
+    const changedTests = changedTestPaths(paths2, policy);
     if (changedTests.length > policy.maximumChangedTests) throw new TypeError("candidate changes too many test files");
     const recipes = [];
     const logs = [];
@@ -966,8 +966,8 @@ function validate(input) {
   }
   return result;
 }
-function changedTestPaths(paths, policy) {
-  return paths.filter((path) => policy.testPathSuffixes.some((suffix) => path.endsWith(suffix)) || policy.testPathPrefixes.some((prefix) => path.startsWith(prefix) || path.includes(`/${prefix}`))).sort();
+function changedTestPaths(paths2, policy) {
+  return paths2.filter((path) => policy.testPathSuffixes.some((suffix) => path.endsWith(suffix)) || policy.testPathPrefixes.some((prefix) => path.startsWith(prefix) || path.includes(`/${prefix}`))).sort();
 }
 function recipeReceipt(recipe2, result, artifacts) {
   const status = result.timedOut ? "timed_out" : result.outputLimitExceeded ? "output_limited" : result.exitCode === 0 && artifacts.every((item) => item.status === "verified") ? "passed" : "failed";
@@ -1401,7 +1401,10 @@ Never claim a build or test passed unless odla_run_recipe returned that result.`
 var V2_SYSTEM_PROMPT = `You are the coding agent inside an odla Code harness.
 Start by orienting: odla_list shows the files in the workspace and odla_search
 finds a literal string across them. Prefer those over guessing a path.
-Then odla_read a bounded range, and odla_apply_git_diff to mutate.
+Then odla_read a bounded range, and odla_apply_git_diff to mutate. When you
+need several independent searches or file ranges, issue those read-only calls
+together in one turn; their results stay ordered and the harness overlaps them.
+Never issue odla_apply_git_diff or odla_run_recipe alongside another tool call.
 For mutations, call odla_apply_git_diff with raw git diff text. It must start
 with "diff --git a/<path> b/<path>", include matching "---" and "+++" file
 headers and numbered "@@" hunks, and never use "*** Begin Patch" wrappers.
@@ -1432,18 +1435,26 @@ var SYSTEM_PROMPT_FOR = {
 };
 function codeSkill(opts) {
   let seq = 0;
+  let nextCompletion = 1;
+  const completed = /* @__PURE__ */ new Map();
   const call = async (tool, input, signal) => {
+    const sequence = ++seq;
     const startedAt = Date.now();
     const response2 = await opts.broker.execute(
       { lease: opts.lease, workspaceDir: opts.workspaceDir, signal },
-      { requestId: `bench-${tool}-${++seq}`, tool, input }
+      { requestId: `bench-${tool}-${sequence}`, tool, input }
     );
-    opts.onToolCall?.({
+    completed.set(sequence, {
       tool,
       ok: response2.ok,
       durationMs: Date.now() - startedAt,
       ...response2.ok ? {} : { error: String(response2.content).slice(0, 300) }
     });
+    while (completed.has(nextCompletion)) {
+      const completion = completed.get(nextCompletion);
+      completed.delete(nextCompletion++);
+      opts.onToolCall?.(completion);
+    }
     return { content: response2.content, isError: !response2.ok };
   };
   const read2 = {
@@ -1459,6 +1470,7 @@ function codeSkill(opts) {
       },
       additionalProperties: false
     },
+    concurrency: "parallel",
     handler: (input, ctx) => call("sandbox.read", input, ctx.signal)
   };
   const applyPatch = {
@@ -1500,6 +1512,7 @@ function codeSkill(opts) {
       },
       additionalProperties: false
     },
+    concurrency: "parallel",
     handler: (input, ctx) => call("sandbox.list", input, ctx.signal)
   };
   const searchFiles = {
@@ -1516,11 +1529,13 @@ function codeSkill(opts) {
       },
       additionalProperties: false
     },
+    concurrency: "parallel",
     handler: (input, ctx) => call("sandbox.search", input, ctx.signal)
   };
   const graphTool = (name, tool, description, required) => ({
     name,
     description,
+    concurrency: "parallel",
     inputSchema: {
       type: "object",
       ...required ? { required: ["query"] } : {},
@@ -1823,16 +1838,16 @@ function createCodePolicyGate(options) {
     }
   };
 }
-function directoryPrefixes(paths) {
+function directoryPrefixes(paths2) {
   const prefixes = /* @__PURE__ */ new Set(["."]);
-  for (const path of paths) {
+  for (const path of paths2) {
     const parts = path.split("/");
     for (let index = 1; index < parts.length; index += 1) prefixes.add(parts.slice(0, index).join("/"));
   }
   return [...prefixes].sort();
 }
-async function safePrefix(base, paths, prefix) {
-  const prefixes = directoryPrefixes(paths);
+async function safePrefix(base, paths2, prefix) {
+  const prefixes = directoryPrefixes(paths2);
   const conversions = await conversionRegistry(
     [await registeredPolicy("code.prefix.v1", "code.prefixes.v1", prefixes)],
     { "code.prefixes.v1": prefixes }
@@ -1950,13 +1965,32 @@ function response(request, ok, content, details) {
 var import_promises9 = require("fs/promises");
 
 // src/code-tool-discovery.ts
+var import_node_child_process5 = require("child_process");
 var import_promises7 = require("fs/promises");
 var import_node_path8 = require("path");
 var DEFAULT_MAX_FILES = 2e4;
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_FILE_BYTES = 512 * 1024;
+function createWorkspaceFileRegistry(limit = DEFAULT_MAX_FILES, enumerate = registeredFiles) {
+  const cache2 = /* @__PURE__ */ new Map();
+  return {
+    files(root) {
+      const existing = cache2.get(root);
+      if (existing) return existing;
+      const pending = enumerate(root, limit).then((paths2) => Object.freeze(paths2));
+      cache2.set(root, pending);
+      void pending.catch(() => {
+        if (cache2.get(root) === pending) cache2.delete(root);
+      });
+      return pending;
+    },
+    invalidate(root) {
+      cache2.delete(root);
+    }
+  };
+}
 async function registeredFiles(root, limit = DEFAULT_MAX_FILES) {
-  const paths = [];
+  const paths2 = [];
   const walk = async (directory) => {
     for (const entry of await (0, import_promises7.readdir)(directory, { withFileTypes: true })) {
       if (SKIP_WORKSPACE_DIRS.has(entry.name)) continue;
@@ -1970,43 +2004,137 @@ async function registeredFiles(root, limit = DEFAULT_MAX_FILES) {
         } catch {
           continue;
         }
-        paths.push(path);
-        if (paths.length > limit) throw new TypeError("workspace file registry exceeds its bound");
+        paths2.push(path);
+        if (paths2.length > limit) throw new TypeError("workspace file registry exceeds its bound");
       }
     }
   };
   await walk((0, import_node_path8.resolve)(root));
-  return paths.sort();
+  return paths2.sort();
 }
-function listWorkspace(paths, options = {}) {
+function listWorkspace(paths2, options = {}) {
   const max = options.maxEntries ?? 1e3;
   const prefix = options.prefix?.replace(/\/+$/, "");
-  const scoped = prefix ? paths.filter((path) => path === prefix || path.startsWith(`${prefix}/`)) : [...paths];
+  const scoped = prefix ? paths2.filter((path) => path === prefix || path.startsWith(`${prefix}/`)) : [...paths2];
   return scoped.slice(0, max);
 }
-async function searchWorkspace(root, paths, options) {
-  const query = options.caseSensitive === false ? options.query.toLowerCase() : options.query;
-  if (!query) throw new TypeError("search query must be a non-empty string");
+async function searchWorkspace(root, paths2, options) {
+  options.signal?.throwIfAborted();
+  if (!options.query) throw new TypeError("search query must be a non-empty string");
   const maxResults = options.maxResults ?? DEFAULT_MAX_RESULTS;
   const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
-  const scoped = listWorkspace(paths, { ...options.prefix ? { prefix: options.prefix } : {}, maxEntries: paths.length });
+  const scoped = listWorkspace(paths2, { ...options.prefix ? { prefix: options.prefix } : {}, maxEntries: paths2.length });
+  if (scoped.length === 0) return [];
+  try {
+    return await nativeSearch(root, scoped, { ...options, maxResults, maxFileBytes });
+  } catch (error) {
+    options.signal?.throwIfAborted();
+    return fallbackSearch(root, scoped, { ...options, maxResults, maxFileBytes });
+  }
+}
+var MAX_NATIVE_ARG_BYTES = 96 * 1024;
+async function nativeSearch(root, paths2, options) {
+  const batches = [];
+  let batch = [];
+  let bytes = 0;
+  for (const path of paths2) {
+    const size = Buffer.byteLength(path) + 1;
+    if (batch.length > 0 && bytes + size > MAX_NATIVE_ARG_BYTES) {
+      batches.push(batch);
+      batch = [];
+      bytes = 0;
+    }
+    batch.push(path);
+    bytes += size;
+  }
+  if (batch.length > 0) batches.push(batch);
+  const matches = [];
+  for (const files of batches) {
+    const remaining = options.maxResults - matches.length;
+    if (remaining <= 0) break;
+    matches.push(...await nativeSearchBatch(root, files, options, remaining));
+  }
+  return matches;
+}
+function nativeSearchBatch(root, paths2, options, remaining) {
+  return new Promise((resolveMatches, reject) => {
+    const args = [
+      "--fixed-strings",
+      "--json",
+      "--no-messages",
+      "--sort=path",
+      `--max-filesize=${options.maxFileBytes}`,
+      "--max-columns=4096",
+      "--max-columns-preview",
+      options.caseSensitive === false ? "--ignore-case" : "--case-sensitive",
+      "--",
+      options.query,
+      ...paths2
+    ];
+    const child = (0, import_node_child_process5.spawn)("rg", args, {
+      cwd: root,
+      stdio: ["ignore", "pipe", "ignore"],
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    const matches = [];
+    let carry = "";
+    let stopped = false;
+    const consume = (line) => {
+      if (matches.length >= remaining) return;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        return;
+      }
+      const path = event.data?.path?.text;
+      const lineNumber = event.data?.line_number;
+      const source = event.data?.lines?.text;
+      if (event.type !== "match" || path === void 0 || lineNumber === void 0 || source === void 0) return;
+      matches.push({ path, line: lineNumber, text: source.trim().slice(0, 240) });
+      if (matches.length >= remaining) {
+        stopped = true;
+        child.kill();
+      }
+    };
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      carry += chunk;
+      let newline = carry.indexOf("\n");
+      while (newline >= 0) {
+        consume(carry.slice(0, newline));
+        carry = carry.slice(newline + 1);
+        newline = carry.indexOf("\n");
+      }
+    });
+    child.once("error", reject);
+    child.once("close", (code) => {
+      if (carry) consume(carry);
+      if (stopped || code === 0 || code === 1) resolveMatches(matches);
+      else reject(new Error(`native search exited with status ${code ?? "unknown"}`));
+    });
+  });
+}
+async function fallbackSearch(root, scoped, options) {
+  const query = options.caseSensitive === false ? options.query.toLowerCase() : options.query;
   const matches = [];
   for (const path of scoped) {
-    if (matches.length >= maxResults) break;
+    options.signal?.throwIfAborted();
+    if (matches.length >= options.maxResults) break;
     let source;
     try {
       source = await (0, import_promises7.readFile)((0, import_node_path8.resolve)(root, path));
     } catch {
       continue;
     }
-    if (source.byteLength > maxFileBytes || source.includes(0)) continue;
+    if (source.byteLength > options.maxFileBytes || source.includes(0)) continue;
     const lines = source.toString("utf8").split("\n");
     for (let index = 0; index < lines.length; index += 1) {
       const raw = lines[index];
       const haystack = options.caseSensitive === false ? raw.toLowerCase() : raw;
       if (!haystack.includes(query)) continue;
       matches.push({ path, line: index + 1, text: raw.trim().slice(0, 240) });
-      if (matches.length >= maxResults) break;
+      if (matches.length >= options.maxResults) break;
     }
   }
   return matches;
@@ -2018,7 +2146,7 @@ var import_node_path9 = require("path");
 var import_graph = require("@odla-ai/graph");
 var import_code4 = require("@odla-ai/graph/code");
 var cache = /* @__PURE__ */ new Map();
-function workspaceGraphs(workspaceDir, paths) {
+function workspaceGraphs(workspaceDir, paths2) {
   const existing = cache.get(workspaceDir);
   if (existing) return existing;
   const read2 = (path) => (0, import_promises8.readFile)((0, import_node_path9.join)(workspaceDir, path), "utf8");
@@ -2026,11 +2154,14 @@ function workspaceGraphs(workspaceDir, paths) {
     // No knownTables: a staged workspace may not carry migrations, and a filter
     // that silently drops every table is worse than an unfiltered one. Callers
     // with ground truth should build the graph themselves.
-    graph: await (0, import_code4.buildCodeGraph)({ paths, read: read2, data: { ignore: (path) => path.includes(".generated.") } })
+    graph: await (0, import_code4.buildCodeGraph)({ paths: paths2, read: read2, data: { ignore: (path) => path.includes(".generated.") } })
   }))();
   cache.set(workspaceDir, built);
   return built;
 }
+function forgetWorkspaceGraphs(workspaceDir) {
+  cache.delete(workspaceDir);
+}
 var shortId = (id) => id.slice(id.indexOf(":") + 1);
 function renderOverview(graphs, prefix) {
   const rows = (0, import_graph.rollup)(graphs.graph, import_code4.FILE, prefix === void 0 ? {} : { prefix });
@@ -2077,7 +2208,7 @@ var GRAPH_TOOLS = /* @__PURE__ */ new Set([
   "sandbox.who_imports",
   "sandbox.who_touches"
 ]);
-async function read(context, request, options, policy) {
+async function read(context, request, options, policy, registry) {
   exactKeys(request.input, ["path", "startLine", "endLine"]);
   const path = stringField(request.input, "path");
   const startLine = optionalInteger(request.input.startLine) ?? 1;
@@ -2085,11 +2216,11 @@ async function read(context, request, options, policy) {
   if (endLine < startLine || endLine - startLine + 1 > (options.maxReadLines ?? 2e3)) {
     throw new TypeError("requested line range exceeds its bound");
   }
-  const paths = await registeredFiles(context.workspaceDir, 2e4);
-  if (!paths.includes(path)) {
+  const paths2 = await registry.files(context.workspaceDir);
+  if (!paths2.includes(path)) {
     throw new TypeError(`no such file in the staged workspace: "${path}". Use sandbox.overview, sandbox.where_is or sandbox.search to find the correct path.`);
   }
-  const allowed = await policy.read(policyContext(context, request, options, { paths, path, startLine, endLine }));
+  const allowed = await policy.read(policyContext(context, request, options, { paths: paths2, path, startLine, endLine }));
   if (!allowed) return response(request, false, "tool denied by CaMeL policy");
   const target = resolveCodePath(context.workspaceDir, path);
   const info = await (0, import_promises9.stat)(target);
@@ -2105,22 +2236,22 @@ async function read(context, request, options, policy) {
   }
   return response(request, true, content, { path, startLine, endLine: Math.min(endLine, lines.length) });
 }
-async function list(context, request, options, policy) {
+async function list(context, request, options, policy, registry) {
   exactKeys(request.input, ["prefix", "maxEntries"]);
   const raw = request.input.prefix;
   const prefix = typeof raw === "string" && raw.length > 0 ? raw : void 0;
   const maxEntries = optionalInteger(request.input.maxEntries) ?? 1e3;
   if (maxEntries > 5e3) throw new TypeError("maxEntries exceeds its bound");
-  const paths = await registeredFiles(context.workspaceDir, 2e4);
-  const allowed = await policy.list(policyContext(context, request, options, { paths, ...prefix ? { prefix } : {} }));
+  const paths2 = await registry.files(context.workspaceDir);
+  const allowed = await policy.list(policyContext(context, request, options, { paths: paths2, ...prefix ? { prefix } : {} }));
   if (!allowed) return response(request, false, "tool denied by CaMeL policy");
-  const entries = listWorkspace(paths, { ...prefix ? { prefix } : {}, maxEntries });
+  const entries = listWorkspace(paths2, { ...prefix ? { prefix } : {}, maxEntries });
   if (!entries.length) {
     return response(request, true, prefix ? `No files under "${prefix}".` : "Workspace is empty.", { count: 0 });
   }
-  const truncated = entries.length < paths.length && entries.length === maxEntries;
-  const hint = !prefix && paths.length > 500 ? `
-\u2026 ${paths.length} files total. sandbox.overview is far cheaper for orientation; use a prefix here once you know the area.` : "";
+  const truncated = entries.length < paths2.length && entries.length === maxEntries;
+  const hint = !prefix && paths2.length > 500 ? `
+\u2026 ${paths2.length} files total. sandbox.overview is far cheaper for orientation; use a prefix here once you know the area.` : "";
   return response(
     request,
     true,
@@ -2129,7 +2260,7 @@ async function list(context, request, options, policy) {
     { count: entries.length, truncated }
   );
 }
-async function search(context, request, options, policy) {
+async function search(context, request, options, policy, registry) {
   exactKeys(request.input, ["query", "prefix", "maxResults", "caseSensitive"]);
   const query = stringField(request.input, "query");
   if (query.length > 512) throw new TypeError("search query exceeds its bound");
@@ -2138,21 +2269,22 @@ async function search(context, request, options, policy) {
   const maxResults = optionalInteger(request.input.maxResults) ?? 100;
   if (maxResults > 500) throw new TypeError("maxResults exceeds its bound");
   const caseSensitive = request.input.caseSensitive === void 0 ? true : request.input.caseSensitive === true;
-  const paths = await registeredFiles(context.workspaceDir, 2e4);
-  const allowed = await policy.search(policyContext(context, request, options, { paths, query, ...prefix ? { prefix } : {} }));
+  const paths2 = await registry.files(context.workspaceDir);
+  const allowed = await policy.search(policyContext(context, request, options, { paths: paths2, query, ...prefix ? { prefix } : {} }));
   if (!allowed) return response(request, false, "tool denied by CaMeL policy");
-  const matches = await searchWorkspace(context.workspaceDir, paths, {
+  const matches = await searchWorkspace(context.workspaceDir, paths2, {
     query,
     maxResults,
     caseSensitive,
-    ...prefix ? { prefix } : {}
+    ...prefix ? { prefix } : {},
+    ...context.signal ? { signal: context.signal } : {}
   });
   if (!matches.length) return response(request, true, `No match for "${query}".`, { count: 0 });
   return response(request, true, matches.map((match) => `${match.path}:${match.line}: ${match.text}`).join("\n"), {
     count: matches.length
   });
 }
-async function graphQuery(context, request, options, policy) {
+async function graphQuery(context, request, options, policy, registry) {
   exactKeys(request.input, ["query"]);
   const raw = request.input.query;
   const query = typeof raw === "string" ? raw : "";
@@ -2162,8 +2294,8 @@ async function graphQuery(context, request, options, policy) {
     selector: query
   }));
   if (!allowed) return response(request, false, "tool denied by CaMeL policy");
-  const paths = await registeredFiles(context.workspaceDir, 2e4);
-  const graphs = await workspaceGraphs(context.workspaceDir, paths);
+  const paths2 = await registry.files(context.workspaceDir);
+  const graphs = await workspaceGraphs(context.workspaceDir, paths2);
   if (request.tool === "sandbox.overview") {
     return response(request, true, renderOverview(graphs, query || void 0));
   }
@@ -2178,23 +2310,38 @@ function createCodeToolBroker(options) {
   validateOptions(options);
   const recipes = new Map(options.recipes.map((recipe2) => [recipe2.id, recipe2]));
   const policy = createCodePolicyGate(options);
-  let tail = Promise.resolve();
+  const registry = createWorkspaceFileRegistry();
+  let barrier = Promise.resolve();
+  const activeReads = /* @__PURE__ */ new Set();
   return {
     execute(context, request) {
-      const result = tail.then(() => route(context, request, options, recipes, policy));
-      tail = result.then(() => void 0, () => void 0);
+      if (isReadTool(request.tool)) {
+        const result2 = barrier.then(() => route(context, request, options, recipes, policy, registry));
+        const settled = result2.then(() => void 0, () => void 0);
+        activeReads.add(settled);
+        void settled.then(() => {
+          activeReads.delete(settled);
+        });
+        return result2;
+      }
+      const earlierReads = [...activeReads];
+      const result = barrier.then(() => Promise.all(earlierReads)).then(() => route(context, request, options, recipes, policy, registry));
+      barrier = result.then(() => void 0, () => void 0);
       return result;
     }
   };
 }
-async function route(context, request, options, recipes, policy) {
+function isReadTool(tool) {
+  return tool === "sandbox.read" || tool === "sandbox.list" || tool === "sandbox.search" || GRAPH_TOOLS.has(tool);
+}
+async function route(context, request, options, recipes, policy, registry) {
   try {
     if (context.signal?.aborted) throw new TypeError("tool request was cancelled");
-    if (request.tool === "sandbox.read") return await read(context, request, options, policy);
-    if (request.tool === "sandbox.list") return await list(context, request, options, policy);
-    if (request.tool === "sandbox.search") return await search(context, request, options, policy);
-    if (GRAPH_TOOLS.has(request.tool)) return await graphQuery(context, request, options, policy);
-    if (request.tool === "sandbox.apply_patch") return await patch(context, request, options, policy);
+    if (request.tool === "sandbox.read") return await read(context, request, options, policy, registry);
+    if (request.tool === "sandbox.list") return await list(context, request, options, policy, registry);
+    if (request.tool === "sandbox.search") return await search(context, request, options, policy, registry);
+    if (GRAPH_TOOLS.has(request.tool)) return await graphQuery(context, request, options, policy, registry);
+    if (request.tool === "sandbox.apply_patch") return await patch(context, request, options, policy, registry);
     return await recipe(context, request, options, recipes, policy);
   } catch (reason) {
     return response(request, false, toolFailureMessage(reason));
@@ -2209,17 +2356,19 @@ function toolFailureMessage(reason) {
   if (code === "EACCES" || code === "EPERM") return "that path is not readable through this tool";
   return "tool failed closed";
 }
-async function patch(context, request, options, policy) {
+async function patch(context, request, options, policy, registry) {
   exactKeys(request.input, ["patch"]);
   const value = stringField(request.input, "patch");
-  const paths = validateCodePatch(value, options.maxPatchBytes ?? 256 * 1024);
-  if (paths.some((path) => options.readOnlyPrefixes?.some((prefix) => path === prefix || path.startsWith(`${prefix}/`)))) {
+  const paths2 = validateCodePatch(value, options.maxPatchBytes ?? 256 * 1024);
+  if (paths2.some((path) => options.readOnlyPrefixes?.some((prefix) => path === prefix || path.startsWith(`${prefix}/`)))) {
     throw new TypeError("patch targets a read-only reference source");
   }
   const allowed = await policy.patch(policyContext(context, request, options, { patch: value }));
   if (!allowed) return response(request, false, "tool denied by CaMeL policy");
-  await applyCodePatch(context.workspaceDir, value, paths);
-  return response(request, true, `Applied patch to ${paths.length} file(s).`, { paths });
+  await applyCodePatch(context.workspaceDir, value, paths2);
+  registry.invalidate(context.workspaceDir);
+  forgetWorkspaceGraphs(context.workspaceDir);
+  return response(request, true, `Applied patch to ${paths2.length} file(s).`, { paths: paths2 });
 }
 async function recipe(context, request, options, recipes, policy) {
   exactKeys(request.input, ["recipeId"]);
@@ -2580,12 +2729,129 @@ var import_node_crypto4 = require("crypto");
 async function appendCodeRuntimeEvent(control, command, event, refs) {
   const eventId = `${command.commandId.slice(0, 45)}:${refs.length + 1}`;
   refs.push(eventId);
-  const bounded = event.type === "message" ? { ...event, body: event.body.trim().slice(0, 2e4) || `${event.actor} event` } : event;
+  const attributed = { ...event, interactionId: command.commandId };
+  const bounded = attributed.type === "message" ? { ...attributed, body: attributed.body.trim().slice(0, 2e4) || `${attributed.actor} event` } : attributed;
   await control.appendSessionEvent(command.sessionId, eventId, bounded);
 }
 var digestRuntimeValue = (value) => `sha256:${(0, import_node_crypto4.createHash)("sha256").update(value).digest("hex")}`;
 var runtimeErrorMessage = (value) => value instanceof Error ? value.message : String(value);
 
+// src/code-tool-presentation.ts
+var text = (value, maximum) => {
+  if (typeof value !== "string") return void 0;
+  const bounded = value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ").trim();
+  return bounded ? bounded.slice(0, maximum) : void 0;
+};
+var integer2 = (value) => Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : void 0;
+var record3 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var excerpt = (value, tail = false) => {
+  if (typeof value !== "string") return void 0;
+  const safe = value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ");
+  const source = (tail ? safe.slice(-1e4) : safe.slice(0, 1e4)).trim();
+  if (!source) return void 0;
+  const lines = source.split("\n").filter((line) => line.trim()).map((line) => line.slice(0, 240));
+  const selected = tail ? lines.slice(-10) : lines.slice(0, 10);
+  return text(selected.join("\n"), 2400);
+};
+var paths = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.flatMap((item) => {
+    const path = text(item, 1024);
+    return path ? [path] : [];
+  }).slice(0, 12);
+  return items.length ? items : void 0;
+};
+function patchStats(value) {
+  if (typeof value !== "string") return {};
+  let additions = 0;
+  let deletions = 0;
+  for (const line of value.slice(0, 262144).split("\n")) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) additions += 1;
+    else if (line.startsWith("-")) deletions += 1;
+  }
+  return { ...additions ? { additions } : {}, ...deletions ? { deletions } : {} };
+}
+function searchResults(value) {
+  if (typeof value !== "string") return void 0;
+  const results = value.split("\n").flatMap((line) => {
+    const match = /^([^:\n]{1,1024}):(\d+):\s?(.*)$/.exec(line);
+    if (!match) return [];
+    const lineNumber = Number(match[2]);
+    const itemText = text(match[3], 240);
+    if (!Number.isSafeInteger(lineNumber) || lineNumber < 1) return [];
+    return [{ path: match[1], line: lineNumber, ...itemText ? { text: itemText } : {} }];
+  }).slice(0, 5);
+  return results.length ? results : void 0;
+}
+function codeToolRequestPresentation(request) {
+  const input = request.input;
+  if (request.tool === "sandbox.read") {
+    const path = text(input.path, 1024);
+    if (!path) return void 0;
+    const startLine = integer2(input.startLine);
+    const endLine = integer2(input.endLine);
+    return { kind: "read", path, ...startLine ? { startLine } : {}, ...endLine ? { endLine } : {} };
+  }
+  if (request.tool === "sandbox.list") {
+    const scope = text(input.prefix, 1024);
+    return { kind: "list", ...scope ? { scope } : {} };
+  }
+  if (request.tool === "sandbox.search" || request.tool === "sandbox.overview" || request.tool === "sandbox.where_is" || request.tool === "sandbox.who_imports" || request.tool === "sandbox.who_touches") {
+    const query = text(input.query, 512);
+    const scope = request.tool === "sandbox.search" ? text(input.prefix, 1024) : void 0;
+    if (request.tool === "sandbox.search" && !query) return void 0;
+    return { kind: "query", ...query ? { query } : {}, ...scope ? { scope } : {} };
+  }
+  if (request.tool === "sandbox.apply_patch") {
+    return { kind: "patch", ...patchStats(input.patch) };
+  }
+  const recipeId = text(input.recipeId, 120);
+  return recipeId ? { kind: "recipe", recipeId } : void 0;
+}
+function codeToolResultPresentation(request, response2) {
+  const started = codeToolRequestPresentation(request);
+  if (!started || !response2.ok) return started;
+  const details = record3(response2.details);
+  if (started.kind === "read") {
+    return {
+      ...started,
+      ...integer2(details?.startLine) ? { startLine: integer2(details?.startLine) } : {},
+      ...integer2(details?.endLine) ? { endLine: integer2(details?.endLine) } : {},
+      ...excerpt(response2.content) ? { excerpt: excerpt(response2.content) } : {}
+    };
+  }
+  if (started.kind === "list") {
+    const listed = response2.content.split("\n").filter((line) => line && !line.startsWith("\u2026") && !line.startsWith("Workspace ")).map((line) => text(line, 1024)).filter((line) => Boolean(line)).slice(0, 8);
+    return {
+      ...started,
+      ...integer2(details?.count) !== void 0 ? { count: integer2(details?.count) } : {},
+      ...listed.length ? { paths: listed } : {}
+    };
+  }
+  if (started.kind === "query") {
+    const results = request.tool === "sandbox.search" ? searchResults(response2.content) : void 0;
+    const resultExcerpt = request.tool === "sandbox.search" ? void 0 : excerpt(response2.content);
+    return {
+      ...started,
+      ...integer2(details?.count) !== void 0 ? { count: integer2(details?.count) } : {},
+      ...results ? { results } : {},
+      ...resultExcerpt ? { excerpt: resultExcerpt } : {}
+    };
+  }
+  if (started.kind === "patch") {
+    return { ...started, ...paths(details?.paths) ? { paths: paths(details?.paths) } : {} };
+  }
+  const output = response2.content.replace(/^Recipe [^\n]*\.?\s*/u, "");
+  return {
+    ...started,
+    ...integer2(details?.exitCode) !== void 0 ? { exitCode: integer2(details?.exitCode) } : {},
+    ...typeof details?.timedOut === "boolean" ? { timedOut: details.timedOut } : {},
+    ...typeof details?.outputLimitExceeded === "boolean" ? { outputLimitExceeded: details.outputLimitExceeded } : {},
+    ...excerpt(output, true) ? { excerpt: excerpt(output, true) } : {}
+  };
+}
+
 // src/code-runtime-engine.ts
 var TheseusRuntimeEngine = class {
   constructor(options) {
@@ -2820,18 +3086,29 @@ var TheseusRuntimeEngine = class {
     return {
       execute: async (context, request) => {
         const startedAt = Date.now();
+        const operationId = digestRuntimeValue(`${command.commandId}:${request.requestId}`);
+        const startedPresentation = codeToolRequestPresentation(request);
         await this.#event(
           command,
-          { type: "tool", phase: "started", tool: request.tool },
+          {
+            type: "tool",
+            phase: "started",
+            tool: request.tool,
+            operationId,
+            ...startedPresentation ? { presentation: startedPresentation } : {}
+          },
           active.conversationRefs
         ).catch(() => void 0);
         const response2 = await broker.execute(context, request);
+        const completedPresentation = codeToolResultPresentation(request, response2);
         await this.#event(command, {
           type: "tool",
           phase: "completed",
           tool: request.tool,
           ok: response2.ok,
-          durationMs: Date.now() - startedAt
+          durationMs: Date.now() - startedAt,
+          operationId,
+          ...completedPresentation ? { presentation: completedPresentation } : {}
         }, active.conversationRefs).catch(() => void 0);
         return response2;
       }