@odla-ai/cli 0.42.0 → 0.42.2

package/dist/{cli-EGZGMIKB.js → cli-4FCRBWED.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "./chunk-74DXL2MT.js";
+} from "./chunk-K6ATAKGR.js";
 import {
   exitCodeFor
 } from "./chunk-UKLSRQ5J.js";
@@ -9,4 +9,4 @@ export {
   exitCodeFor,
   runCli
 };
-//# sourceMappingURL=cli-EGZGMIKB.js.map
+//# sourceMappingURL=cli-4FCRBWED.js.map

package/dist/index.cjs

@@ -6275,7 +6275,7 @@ async function stageWorkspacePair(baselineSource, workspaceSource, options = {})
   }
 }
 
-// ../harness/dist/chunk-QZXCQSPZ.js
+// ../harness/dist/chunk-GYWQM76X.js
 var import_crypto = require("crypto");
 var import_promises5 = require("fs/promises");
 var import_path5 = require("path");
@@ -6612,7 +6612,7 @@ function validateSnapshot(snapshot, limits) {
   }
 }
 
-// ../harness/dist/chunk-QZXCQSPZ.js
+// ../harness/dist/chunk-GYWQM76X.js
 var import_child_process4 = require("child_process");
 var import_promises6 = require("fs/promises");
 var import_path6 = require("path");
@@ -6628,6 +6628,7 @@ var import_os3 = require("os");
 var import_path8 = require("path");
 var import_ai4 = require("@odla-ai/ai");
 var import_ai5 = require("@odla-ai/ai");
+var import_child_process6 = require("child_process");
 var import_promises9 = require("fs/promises");
 var import_path9 = require("path");
 
@@ -6915,7 +6916,7 @@ function looksLikeDestination(value2) {
   return /^(?:[a-z][a-z0-9+.-]*:\/\/|\/|\\\\)/i.test(text3) || /^[\w.-]+\.[a-z]{2,}(?:[/:]|$)/i.test(text3);
 }
 
-// ../harness/dist/chunk-QZXCQSPZ.js
+// ../harness/dist/chunk-GYWQM76X.js
 var import_promises10 = require("fs/promises");
 var import_promises11 = require("fs/promises");
 var import_path10 = require("path");
@@ -7183,7 +7184,7 @@ async function buildCodeGraph(input) {
   return builder.build();
 }
 
-// ../harness/dist/chunk-QZXCQSPZ.js
+// ../harness/dist/chunk-GYWQM76X.js
 var import_crypto4 = require("crypto");
 async function digestStagedWorkspace(root, limits) {
   const files = [];
@@ -8247,7 +8248,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.
@@ -8278,18 +8282,26 @@ var SYSTEM_PROMPT_FOR = {
 };
 function codeSkill(opts) {
   let seq = 0;
+  let nextCompletion = 1;
+  const completed = /* @__PURE__ */ new Map();
   const call4 = 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 read22 = {
@@ -8305,6 +8317,7 @@ function codeSkill(opts) {
       },
       additionalProperties: false
     },
+    concurrency: "parallel",
     handler: (input, ctx) => call4("sandbox.read", input, ctx.signal)
   };
   const applyPatch = {
@@ -8346,6 +8359,7 @@ function codeSkill(opts) {
       },
       additionalProperties: false
     },
+    concurrency: "parallel",
     handler: (input, ctx) => call4("sandbox.list", input, ctx.signal)
   };
   const searchFiles = {
@@ -8362,11 +8376,13 @@ function codeSkill(opts) {
       },
       additionalProperties: false
     },
+    concurrency: "parallel",
     handler: (input, ctx) => call4("sandbox.search", input, ctx.signal)
   };
   const graphTool = (name, tool, description, required) => ({
     name,
     description,
+    concurrency: "parallel",
     inputSchema: {
       type: "object",
       ...required ? { required: ["query"] } : {},
@@ -8544,6 +8560,24 @@ function createCodeRuntimeInference(options) {
 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((paths) => Object.freeze(paths));
+      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 walk = async (directory) => {
@@ -8574,28 +8608,122 @@ function listWorkspace(paths, options = {}) {
   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");
+  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 });
+  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, paths, options) {
+  const batches = [];
+  let batch = [];
+  let bytes = 0;
+  for (const path of paths) {
+    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, paths, 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,
+      ...paths
+    ];
+    const child = (0, import_child_process6.spawn)("rg", args, {
+      cwd: root,
+      stdio: ["ignore", "pipe", "ignore"],
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    const matches = [];
+    let carry = "";
+    let stopped = false;
+    const consume = (line2) => {
+      if (matches.length >= remaining) return;
+      let event;
+      try {
+        event = JSON.parse(line2);
+      } 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_promises9.readFile)((0, import_path9.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;
@@ -8850,6 +8978,9 @@ function workspaceGraphs(workspaceDir, paths) {
   cache.set(workspaceDir, built);
   return built;
 }
+function forgetWorkspaceGraphs(workspaceDir) {
+  cache.delete(workspaceDir);
+}
 var shortId = (id2) => id2.slice(id2.indexOf(":") + 1);
 function renderOverview(graphs, prefix) {
   const rows = rollup(graphs.graph, FILE, prefix === void 0 ? {} : { prefix });
@@ -8894,7 +9025,7 @@ var GRAPH_TOOLS = /* @__PURE__ */ new Set([
   "sandbox.who_imports",
   "sandbox.who_touches"
 ]);
-async function read(context, request3, options, policy) {
+async function read(context, request3, options, policy, registry) {
   exactKeys(request3.input, ["path", "startLine", "endLine"]);
   const path = stringField(request3.input, "path");
   const startLine = optionalInteger(request3.input.startLine) ?? 1;
@@ -8902,7 +9033,7 @@ async function read(context, request3, 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);
+  const paths = await registry.files(context.workspaceDir);
   if (!paths.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.`);
   }
@@ -8922,13 +9053,13 @@ async function read(context, request3, options, policy) {
   }
   return response(request3, true, content2, { path, startLine, endLine: Math.min(endLine, lines.length) });
 }
-async function list(context, request3, options, policy) {
+async function list(context, request3, options, policy, registry) {
   exactKeys(request3.input, ["prefix", "maxEntries"]);
   const raw = request3.input.prefix;
   const prefix = typeof raw === "string" && raw.length > 0 ? raw : void 0;
   const maxEntries = optionalInteger(request3.input.maxEntries) ?? 1e3;
   if (maxEntries > 5e3) throw new TypeError("maxEntries exceeds its bound");
-  const paths = await registeredFiles(context.workspaceDir, 2e4);
+  const paths = await registry.files(context.workspaceDir);
   const allowed = await policy.list(policyContext(context, request3, options, { paths, ...prefix ? { prefix } : {} }));
   if (!allowed) return response(request3, false, "tool denied by CaMeL policy");
   const entries = listWorkspace(paths, { ...prefix ? { prefix } : {}, maxEntries });
@@ -8946,7 +9077,7 @@ async function list(context, request3, options, policy) {
     { count: entries.length, truncated }
   );
 }
-async function search(context, request3, options, policy) {
+async function search(context, request3, options, policy, registry) {
   exactKeys(request3.input, ["query", "prefix", "maxResults", "caseSensitive"]);
   const query = stringField(request3.input, "query");
   if (query.length > 512) throw new TypeError("search query exceeds its bound");
@@ -8955,21 +9086,22 @@ async function search(context, request3, options, policy) {
   const maxResults = optionalInteger(request3.input.maxResults) ?? 100;
   if (maxResults > 500) throw new TypeError("maxResults exceeds its bound");
   const caseSensitive = request3.input.caseSensitive === void 0 ? true : request3.input.caseSensitive === true;
-  const paths = await registeredFiles(context.workspaceDir, 2e4);
+  const paths = await registry.files(context.workspaceDir);
   const allowed = await policy.search(policyContext(context, request3, options, { paths, query, ...prefix ? { prefix } : {} }));
   if (!allowed) return response(request3, false, "tool denied by CaMeL policy");
   const matches = await searchWorkspace(context.workspaceDir, paths, {
     query,
     maxResults,
     caseSensitive,
-    ...prefix ? { prefix } : {}
+    ...prefix ? { prefix } : {},
+    ...context.signal ? { signal: context.signal } : {}
   });
   if (!matches.length) return response(request3, true, `No match for "${query}".`, { count: 0 });
   return response(request3, true, matches.map((match) => `${match.path}:${match.line}: ${match.text}`).join("\n"), {
     count: matches.length
   });
 }
-async function graphQuery(context, request3, options, policy) {
+async function graphQuery(context, request3, options, policy, registry) {
   exactKeys(request3.input, ["query"]);
   const raw = request3.input.query;
   const query = typeof raw === "string" ? raw : "";
@@ -8979,7 +9111,7 @@ async function graphQuery(context, request3, options, policy) {
     selector: query
   }));
   if (!allowed) return response(request3, false, "tool denied by CaMeL policy");
-  const paths = await registeredFiles(context.workspaceDir, 2e4);
+  const paths = await registry.files(context.workspaceDir);
   const graphs = await workspaceGraphs(context.workspaceDir, paths);
   if (request3.tool === "sandbox.overview") {
     return response(request3, true, renderOverview(graphs, query || void 0));
@@ -8993,23 +9125,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, request3) {
-      const result = tail.then(() => route2(context, request3, options, recipes, policy));
-      tail = result.then(() => void 0, () => void 0);
+      if (isReadTool(request3.tool)) {
+        const result2 = barrier.then(() => route2(context, request3, 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(() => route2(context, request3, options, recipes, policy, registry));
+      barrier = result.then(() => void 0, () => void 0);
       return result;
     }
   };
 }
-async function route2(context, request3, options, recipes, policy) {
+function isReadTool(tool) {
+  return tool === "sandbox.read" || tool === "sandbox.list" || tool === "sandbox.search" || GRAPH_TOOLS.has(tool);
+}
+async function route2(context, request3, options, recipes, policy, registry) {
   try {
     if (context.signal?.aborted) throw new TypeError("tool request was cancelled");
-    if (request3.tool === "sandbox.read") return await read(context, request3, options, policy);
-    if (request3.tool === "sandbox.list") return await list(context, request3, options, policy);
-    if (request3.tool === "sandbox.search") return await search(context, request3, options, policy);
-    if (GRAPH_TOOLS.has(request3.tool)) return await graphQuery(context, request3, options, policy);
-    if (request3.tool === "sandbox.apply_patch") return await patch(context, request3, options, policy);
+    if (request3.tool === "sandbox.read") return await read(context, request3, options, policy, registry);
+    if (request3.tool === "sandbox.list") return await list(context, request3, options, policy, registry);
+    if (request3.tool === "sandbox.search") return await search(context, request3, options, policy, registry);
+    if (GRAPH_TOOLS.has(request3.tool)) return await graphQuery(context, request3, options, policy, registry);
+    if (request3.tool === "sandbox.apply_patch") return await patch(context, request3, options, policy, registry);
     return await recipe(context, request3, options, recipes, policy);
   } catch (reason) {
     return response(request3, false, toolFailureMessage(reason));
@@ -9024,7 +9171,7 @@ 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, request3, options, policy) {
+async function patch(context, request3, options, policy, registry) {
   exactKeys(request3.input, ["patch"]);
   const value2 = stringField(request3.input, "patch");
   const paths = validateCodePatch(value2, options.maxPatchBytes ?? 256 * 1024);
@@ -9034,6 +9181,8 @@ async function patch(context, request3, options, policy) {
   const allowed = await policy.patch(policyContext(context, request3, options, { patch: value2 }));
   if (!allowed) return response(request3, false, "tool denied by CaMeL policy");
   await applyCodePatch(context.workspaceDir, value2, paths);
+  registry.invalidate(context.workspaceDir);
+  forgetWorkspaceGraphs(context.workspaceDir);
   return response(request3, true, `Applied patch to ${paths.length} file(s).`, { paths });
 }
 async function recipe(context, request3, options, recipes, policy) {
@@ -10857,12 +11006,10 @@ Commands:
                explicitly. Same device-grant auth as "app".
                Status changes and comments post to each item's @odla-ai/chat
                discussion thread.
-               NOTE: "--column ready" is OWNER-ONLY. Creating a task in Ready
-               approves its complete execution contract, so it needs pm.plan,
-               which no device enrollment or handshake approval can grant. An
-               agent proposes in Backlog (the default); a human owner or a
-               pm.plan agent promotes. This is deliberate, not a permission
-               gap \u2014 it was reported as one.
+               Creating or promoting a task in Ready requires a complete
+               execution contract and a reviewed revision. Any caller with PM
+               mutation access to that app/project may do it; claims coordinate
+               execution but never own or lock the PM record.
   bug          Intent-first alias for PM bugs. "bug report" writes to
                odla PM; odla product defects do not belong in GitHub Issues.
   discuss      Group discussions (via @odla-ai/chat) for the apps you co-own: