baro-ai 0.32.0 → 0.33.0

package/dist/cli.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // ../baro-orchestrator/scripts/cli.ts
-import { existsSync as existsSync2 } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve3 } from "path";
 
 // ../baro-orchestrator/src/orchestrate.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3 } from "path";
 
 // ../../node_modules/openai/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
@@ -247,7 +247,7 @@ var safeJSON = (text) => {
 };
 
 // ../../node_modules/openai/internal/utils/sleep.mjs
-var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
 
 // ../../node_modules/openai/version.mjs
 var VERSION = "6.35.0";
@@ -1326,8 +1326,8 @@ function addRequestID(value, response) {
 var _APIPromise_client;
 var APIPromise = class _APIPromise extends Promise {
   constructor(client, responsePromise, parseResponse2 = defaultParseResponse) {
-    super((resolve2) => {
-      resolve2(null);
+    super((resolve4) => {
+      resolve4(null);
     });
     this.responsePromise = responsePromise;
     this.parseResponse = parseResponse2;
@@ -1756,12 +1756,12 @@ function encodeURIPath(str2) {
   return str2.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
 }
 var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-var createPathTagFunction = (pathEncoder = encodeURIPath) => function path2(statics, ...params) {
+var createPathTagFunction = (pathEncoder = encodeURIPath) => function path4(statics, ...params) {
   if (statics.length === 1)
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path3 = statics.reduce((previousValue, currentValue, index) => {
+  const path5 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -1778,7 +1778,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path2(stat
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path3.split(/[?#]/, 1)[0];
+  const pathOnly = path5.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match;
   while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -1799,10 +1799,10 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path2(stat
     }, "");
     throw new OpenAIError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path3}
+${path5}
 ${underline}`);
   }
-  return path3;
+  return path5;
 };
 var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
 
@@ -1975,12 +1975,12 @@ var EventStream = class {
     _EventStream_errored.set(this, false);
     _EventStream_aborted.set(this, false);
     _EventStream_catchingPromiseCreated.set(this, false);
-    __classPrivateFieldSet(this, _EventStream_connectedPromise, new Promise((resolve2, reject) => {
-      __classPrivateFieldSet(this, _EventStream_resolveConnectedPromise, resolve2, "f");
+    __classPrivateFieldSet(this, _EventStream_connectedPromise, new Promise((resolve4, reject) => {
+      __classPrivateFieldSet(this, _EventStream_resolveConnectedPromise, resolve4, "f");
       __classPrivateFieldSet(this, _EventStream_rejectConnectedPromise, reject, "f");
     }), "f");
-    __classPrivateFieldSet(this, _EventStream_endPromise, new Promise((resolve2, reject) => {
-      __classPrivateFieldSet(this, _EventStream_resolveEndPromise, resolve2, "f");
+    __classPrivateFieldSet(this, _EventStream_endPromise, new Promise((resolve4, reject) => {
+      __classPrivateFieldSet(this, _EventStream_resolveEndPromise, resolve4, "f");
       __classPrivateFieldSet(this, _EventStream_rejectEndPromise, reject, "f");
     }), "f");
     __classPrivateFieldGet(this, _EventStream_connectedPromise, "f").catch(() => {
@@ -2064,11 +2064,11 @@ var EventStream = class {
    *   const message = await stream.emitted('message') // rejects if the stream errors
    */
   emitted(event) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       __classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f");
       if (event !== "error")
         this.once("error", reject);
-      this.once(event, resolve2);
+      this.once(event, resolve4);
     });
   }
   async done() {
@@ -3007,7 +3007,7 @@ var ChatCompletionStream = class _ChatCompletionStream extends AbstractChatCompl
           if (done) {
             return { value: void 0, done: true };
           }
-          return new Promise((resolve2, reject) => readQueue.push({ resolve: resolve2, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+          return new Promise((resolve4, reject) => readQueue.push({ resolve: resolve4, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
         }
         const chunk = pushQueue.shift();
         return { value: chunk, done: false };
@@ -3839,7 +3839,7 @@ var AssistantStream = class extends EventStream {
           if (done) {
             return { value: void 0, done: true };
           }
-          return new Promise((resolve2, reject) => readQueue.push({ resolve: resolve2, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+          return new Promise((resolve4, reject) => readQueue.push({ resolve: resolve4, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
         }
         const chunk = pushQueue.shift();
         return { value: chunk, done: false };
@@ -5788,7 +5788,7 @@ var ResponseStream = class _ResponseStream extends EventStream {
           if (done) {
             return { value: void 0, done: true };
           }
-          return new Promise((resolve2, reject) => readQueue.push({ resolve: resolve2, reject })).then((event2) => event2 ? { value: event2, done: false } : { value: void 0, done: true });
+          return new Promise((resolve4, reject) => readQueue.push({ resolve: resolve4, reject })).then((event2) => event2 ? { value: event2, done: false } : { value: void 0, done: true });
         }
         const event = pushQueue.shift();
         return { value: event, done: false };
@@ -6775,9 +6775,9 @@ var OpenAI = class {
     this.apiKey = token;
     return true;
   }
-  buildURL(path2, query, defaultBaseURL) {
+  buildURL(path4, query, defaultBaseURL) {
     const baseURL = !__classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-    const url = isAbsoluteURL(path2) ? new URL(path2) : new URL(baseURL + (baseURL.endsWith("/") && path2.startsWith("/") ? path2.slice(1) : path2));
+    const url = isAbsoluteURL(path4) ? new URL(path4) : new URL(baseURL + (baseURL.endsWith("/") && path4.startsWith("/") ? path4.slice(1) : path4));
     const defaultQuery = this.defaultQuery();
     const pathQuery = Object.fromEntries(url.searchParams);
     if (!isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) {
@@ -6802,24 +6802,24 @@ var OpenAI = class {
    */
   async prepareRequest(request, { url, options }) {
   }
-  get(path2, opts) {
-    return this.methodRequest("get", path2, opts);
+  get(path4, opts) {
+    return this.methodRequest("get", path4, opts);
   }
-  post(path2, opts) {
-    return this.methodRequest("post", path2, opts);
+  post(path4, opts) {
+    return this.methodRequest("post", path4, opts);
   }
-  patch(path2, opts) {
-    return this.methodRequest("patch", path2, opts);
+  patch(path4, opts) {
+    return this.methodRequest("patch", path4, opts);
   }
-  put(path2, opts) {
-    return this.methodRequest("put", path2, opts);
+  put(path4, opts) {
+    return this.methodRequest("put", path4, opts);
   }
-  delete(path2, opts) {
-    return this.methodRequest("delete", path2, opts);
+  delete(path4, opts) {
+    return this.methodRequest("delete", path4, opts);
   }
-  methodRequest(method, path2, opts) {
+  methodRequest(method, path4, opts) {
     return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path2, ...opts2 };
+      return { method, path: path4, ...opts2 };
     }));
   }
   request(options, remainingRetries = null) {
@@ -6937,8 +6937,8 @@ var OpenAI = class {
     }));
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
-  getAPIList(path2, Page2, opts) {
-    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path2, ...opts2 })) : { method: "get", path: path2, ...opts });
+  getAPIList(path4, Page2, opts) {
+    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path4, ...opts2 })) : { method: "get", path: path4, ...opts });
   }
   requestAPIList(Page2, options) {
     const request = this.makeRequest(options, null, void 0);
@@ -7029,8 +7029,8 @@ var OpenAI = class {
   }
   async buildRequest(inputOptions, { retryCount = 0 } = {}) {
     const options = { ...inputOptions };
-    const { method, path: path2, query, defaultBaseURL } = options;
-    const url = this.buildURL(path2, query, defaultBaseURL);
+    const { method, path: path4, query, defaultBaseURL } = options;
+    const url = this.buildURL(path4, query, defaultBaseURL);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -7665,7 +7665,7 @@ var AgenticEnvironment = class {
   async start() {
     this.isActive = true;
     while (this.isActive) {
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await new Promise((resolve4) => setTimeout(resolve4, 100));
     }
   }
   stop() {
@@ -7783,8 +7783,8 @@ var GitGate = class {
   chain = Promise.resolve();
   async acquire() {
     let release;
-    const next = new Promise((resolve2) => {
-      release = resolve2;
+    const next = new Promise((resolve4) => {
+      release = resolve4;
     });
     const wait = this.chain;
     this.chain = this.chain.then(() => next);
@@ -8491,13 +8491,13 @@ import { join } from "path";
 // ../baro-orchestrator/src/prd.ts
 import { readFileSync, writeFileSync } from "fs";
 var STORY_DEFAULTS = { retries: 2 };
-function loadPrd(path2) {
-  const raw = readFileSync(path2, "utf8");
+function loadPrd(path4) {
+  const raw = readFileSync(path4, "utf8");
   const json = JSON.parse(raw);
-  return normalizePrd(json, path2);
+  return normalizePrd(json, path4);
 }
-function savePrd(path2, prd) {
-  writeFileSync(path2, JSON.stringify(prd, null, 2) + "\n");
+function savePrd(path4, prd) {
+  writeFileSync(path4, JSON.stringify(prd, null, 2) + "\n");
 }
 function normalizePrd(input, source) {
   if (!input || typeof input !== "object") {
@@ -9306,8 +9306,8 @@ var Conductor = class extends BaroParticipant {
     if (this.opts.intraLevelDelaySecs == null) {
       this.opts.intraLevelDelaySecs = 10;
     }
-    this.done = new Promise((resolve2) => {
-      this.resolveDone = resolve2;
+    this.done = new Promise((resolve4) => {
+      this.resolveDone = resolve4;
     });
   }
   setEnvironment(env) {
@@ -9674,9 +9674,9 @@ function applyReplan(prd, replan) {
   }
   return { ...prd, userStories: stories };
 }
-function readFileSyncSafe(path2) {
+function readFileSyncSafe(path4) {
   try {
-    return readFileSync2(path2, "utf8");
+    return readFileSync2(path4, "utf8");
   } catch {
     return null;
   }
@@ -10626,19 +10626,19 @@ function describeCall(tool, args) {
   const tags = [tool.toLowerCase()];
   let summary = `${tool} call`;
   if (tool === "Read") {
-    const path2 = stringArg(args, "file_path") ?? stringArg(args, "path");
-    if (path2) {
-      summary = `Read ${path2}`;
-      tags.push(path2);
-      const base = path2.split("/").pop();
+    const path4 = stringArg(args, "file_path") ?? stringArg(args, "path");
+    if (path4) {
+      summary = `Read ${path4}`;
+      tags.push(path4);
+      const base = path4.split("/").pop();
       if (base) tags.push(base);
     }
   } else if (tool === "Grep") {
     const pattern = stringArg(args, "pattern");
-    const path2 = stringArg(args, "path");
-    summary = `Grep '${pattern ?? "?"}'${path2 ? ` in ${path2}` : ""}`;
+    const path4 = stringArg(args, "path");
+    summary = `Grep '${pattern ?? "?"}'${path4 ? ` in ${path4}` : ""}`;
     if (pattern) tags.push(pattern);
-    if (path2) tags.push(path2);
+    if (path4) tags.push(path4);
   } else if (tool === "Glob") {
     const pattern = stringArg(args, "pattern");
     summary = `Glob '${pattern ?? "?"}'`;
@@ -10752,27 +10752,27 @@ var Sentry = class extends BaroParticipant {
     if (!WRITE_TOOLS.has(item.name)) return;
     const agentId = source.agentId;
     if (typeof agentId !== "string") return;
-    const path2 = extractPath(item);
-    if (!path2) return;
+    const path4 = extractPath(item);
+    if (!path4) return;
     const touch = {
       agentId,
-      path: path2,
+      path: path4,
       tool: item.name,
       at: Date.now()
     };
     this.touches.push(touch);
-    const set = this.touchedBy.get(path2) ?? /* @__PURE__ */ new Set();
+    const set = this.touchedBy.get(path4) ?? /* @__PURE__ */ new Set();
     set.add(agentId);
-    this.touchedBy.set(path2, set);
+    this.touchedBy.set(path4, set);
     const otherAgents = [...set].filter((a) => a !== agentId);
     if (otherAgents.length === 0) return;
     this.opts.onOverlap?.({
-      path: path2,
+      path: path4,
       agents: [agentId, ...otherAgents]
     });
-    if (!this.opts.emitNotice || this.noticedPaths.has(path2)) return;
-    this.noticedPaths.add(path2);
-    const reason = `agents [${[agentId, ...otherAgents].join(", ")}] both touched ${path2}`;
+    if (!this.opts.emitNotice || this.noticedPaths.has(path4)) return;
+    this.noticedPaths.add(path4);
+    const reason = `agents [${[agentId, ...otherAgents].join(", ")}] both touched ${path4}`;
     for (const env of this.getEnvironments()) {
       ;
       env.deliverBusEvent(
@@ -10782,7 +10782,7 @@ var Sentry = class extends BaroParticipant {
           otherAgents[0],
           "notice",
           reason,
-          { path: path2, agents: [agentId, ...otherAgents] }
+          { path: path4, agents: [agentId, ...otherAgents] }
         )
       );
     }
@@ -10802,6 +10802,767 @@ function extractPath(item) {
   return null;
 }
 
+// ../baro-orchestrator/src/planning/story-tools.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+
+// ../baro-orchestrator/src/planning/codebase-tools.ts
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path2 from "path";
+var IGNORE = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".cache",
+  "__pycache__",
+  "target",
+  ".output",
+  ".vercel"
+]);
+var MAX_FILE_BYTES = 15e3;
+var MAX_GREP_LINES = 80;
+var MAX_BASH_OUTPUT_BYTES = 8e3;
+function createCodebaseTools(cwd) {
+  return [
+    readFileTool(cwd),
+    listFilesTool(cwd),
+    fileTreeTool(cwd),
+    grepTool(cwd),
+    globTool(cwd),
+    bashTool(cwd)
+  ];
+}
+function readFileTool(cwd) {
+  return {
+    type: "function",
+    name: "read_file",
+    description: "Read the full contents of a file by path relative to the project root. Returns up to 15000 characters (truncates past that). Use to inspect package.json, source files, config files, READMEs, etc.",
+    strict: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path relative to the project root (e.g. 'src/index.ts')."
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    async invoke(args) {
+      const target = safePath(cwd, args.path);
+      if (!target) return `Error: path '${args.path}' escapes the project root.`;
+      if (!fs.existsSync(target)) return `File not found: ${args.path}`;
+      const stat = fs.statSync(target);
+      if (stat.isDirectory()) {
+        return `${args.path} is a directory \u2014 use list_files or file_tree.`;
+      }
+      if (stat.size > 5e5) {
+        return `File too large (${(stat.size / 1024).toFixed(0)} KB) \u2014 skip or grep instead.`;
+      }
+      let content = fs.readFileSync(target, "utf-8");
+      if (content.length > MAX_FILE_BYTES) {
+        content = content.slice(0, MAX_FILE_BYTES) + "\n... (truncated)";
+      }
+      return content;
+    }
+  };
+}
+function listFilesTool(cwd) {
+  return {
+    type: "function",
+    name: "list_files",
+    description: "List files and directories at a path. Use path='' for the project root. Skips node_modules, .git, dist, build, target, and other dependency dirs.",
+    strict: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Directory path relative to the project root. Empty for root."
+        },
+        recursive: {
+          type: "boolean",
+          description: "Walk subdirectories up to 4 deep, capped at 200 entries."
+        }
+      },
+      required: ["path", "recursive"],
+      additionalProperties: false
+    },
+    async invoke(args) {
+      const target = safePath(cwd, args.path || ".");
+      if (!target) return `Error: path '${args.path}' escapes the project root.`;
+      if (!fs.existsSync(target)) return `Directory not found: ${args.path}`;
+      const stat = fs.statSync(target);
+      if (!stat.isDirectory()) return `${args.path} is not a directory \u2014 use read_file.`;
+      const results = [];
+      function walk(dir, prefix, depth) {
+        if (results.length >= 200 || depth > 4) return;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+          if (IGNORE.has(entry.name) || entry.name.startsWith(".")) continue;
+          const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) {
+            results.push(rel + "/");
+            if (args.recursive) walk(path2.join(dir, entry.name), rel, depth + 1);
+          } else {
+            results.push(rel);
+          }
+        }
+      }
+      walk(target, "", 0);
+      return results.join("\n") || "(empty directory)";
+    }
+  };
+}
+function fileTreeTool(cwd) {
+  return {
+    type: "function",
+    name: "file_tree",
+    description: "Show a condensed ASCII tree of the project structure up to 3 levels deep. Cheapest way to get a first overview before deciding which files to read.",
+    strict: true,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    },
+    async invoke() {
+      const lines = [path2.basename(cwd) + "/"];
+      function walk(dir, prefix, depth) {
+        if (lines.length >= 150 || depth > 3) return;
+        let entries;
+        try {
+          entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        entries.sort((a, b) => {
+          if (a.isDirectory() && !b.isDirectory()) return -1;
+          if (!a.isDirectory() && b.isDirectory()) return 1;
+          return a.name.localeCompare(b.name);
+        });
+        for (let i = 0; i < entries.length; i++) {
+          const entry = entries[i];
+          if (IGNORE.has(entry.name) || entry.name.startsWith(".")) continue;
+          const isLast = i === entries.length - 1;
+          const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+          const childPrefix = isLast ? "    " : "\u2502   ";
+          if (entry.isDirectory()) {
+            lines.push(`${prefix}${connector}${entry.name}/`);
+            walk(path2.join(dir, entry.name), prefix + childPrefix, depth + 1);
+          } else {
+            lines.push(`${prefix}${connector}${entry.name}`);
+          }
+        }
+      }
+      walk(cwd, "", 0);
+      return lines.join("\n");
+    }
+  };
+}
+function grepTool(cwd) {
+  return {
+    type: "function",
+    name: "grep",
+    description: "Search for a text pattern across project files. Returns matching lines with their file paths. Case-insensitive. Skips dependency directories. Caps results at 80 lines.",
+    strict: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Text or regex (POSIX) to search for."
+        },
+        path: {
+          type: "string",
+          description: "Directory to search in. Default: entire project."
+        },
+        file_pattern: {
+          type: "string",
+          description: "File glob filter (e.g. '*.ts', '*.tsx'). Default: all files."
+        }
+      },
+      required: ["pattern", "path", "file_pattern"],
+      additionalProperties: false
+    },
+    async invoke(args) {
+      const searchDir = safePath(cwd, args.path || ".");
+      if (!searchDir) return `Error: path '${args.path}' escapes the project root.`;
+      if (!fs.existsSync(searchDir)) return `Directory not found: ${args.path}`;
+      try {
+        const excludes = Array.from(IGNORE).map((d) => `--exclude-dir=${d}`).join(" ");
+        const include = args.file_pattern ? `--include='${args.file_pattern}'` : "";
+        const cmd = `grep -rn -i ${excludes} ${include} --max-count=50 -- ${JSON.stringify(
+          args.pattern
+        )} ${JSON.stringify(searchDir)} 2>/dev/null || true`;
+        const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 2 * 1024 * 1024 });
+        const lines = output.split("\n").filter(Boolean).map((line) => line.startsWith(cwd) ? line.slice(cwd.length + 1) : line);
+        return lines.slice(0, MAX_GREP_LINES).join("\n") || "No matches found.";
+      } catch {
+        return "No matches found.";
+      }
+    }
+  };
+}
+function globTool(cwd) {
+  return {
+    type: "function",
+    name: "glob",
+    description: "List files matching a glob pattern (e.g. 'src/**/*.ts'). Useful when you want every file of a type without scanning the whole tree.",
+    strict: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Glob pattern relative to the project root."
+        }
+      },
+      required: ["pattern"],
+      additionalProperties: false
+    },
+    async invoke(args) {
+      try {
+        const cmd = `cd ${JSON.stringify(cwd)} && find . -path './node_modules' -prune -o -path './.git' -prune -o -path './target' -prune -o -path './dist' -prune -o -path './build' -prune -o -type f -print | grep -E ${JSON.stringify(
+          globToRegex(args.pattern)
+        )} 2>/dev/null | head -200 || true`;
+        const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 1024 * 1024 });
+        const lines = output.split("\n").filter(Boolean).map((l) => l.replace(/^\.\//, ""));
+        return lines.join("\n") || "(no matches)";
+      } catch {
+        return "(glob failed)";
+      }
+    }
+  };
+}
+function bashTool(cwd) {
+  return {
+    type: "function",
+    name: "bash",
+    description: "Run a non-destructive read-only shell command in the project root. Use for inspections like 'cat package.json | head', 'git log --oneline | head', 'wc -l src/**/*.ts'. Caps output at 8 KB. Do NOT use for writes, edits, or installs.",
+    strict: true,
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The shell command to execute. Read-only operations only."
+        }
+      },
+      required: ["command"],
+      additionalProperties: false
+    },
+    async invoke(args) {
+      try {
+        const output = execSync(args.command, {
+          cwd,
+          encoding: "utf-8",
+          maxBuffer: 4 * 1024 * 1024,
+          timeout: 3e4,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        if (output.length > MAX_BASH_OUTPUT_BYTES) {
+          return output.slice(0, MAX_BASH_OUTPUT_BYTES) + `
+... (truncated, ${output.length - MAX_BASH_OUTPUT_BYTES} bytes elided)`;
+        }
+        return output || "(empty output)";
+      } catch (e) {
+        const err = e;
+        const stderr = err.stderr instanceof Buffer ? err.stderr.toString() : err.stderr ?? "";
+        return `bash exited with status ${err.status ?? "?"}: ${stderr || err.message || "unknown error"}`;
+      }
+    }
+  };
+}
+function safePath(cwd, filePath) {
+  const resolved = path2.resolve(cwd, filePath);
+  if (!resolved.startsWith(path2.resolve(cwd))) return null;
+  return resolved;
+}
+function globToRegex(glob) {
+  let regex = "^";
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        regex += ".*";
+        i += 2;
+        if (glob[i] === "/") i++;
+        continue;
+      }
+      regex += "[^/]*";
+      i++;
+      continue;
+    }
+    if (ch === "?") {
+      regex += "[^/]";
+      i++;
+      continue;
+    }
+    if (ch === ".") {
+      regex += "\\.";
+      i++;
+      continue;
+    }
+    if ("()[]{}+|^$\\".includes(ch)) {
+      regex += "\\" + ch;
+      i++;
+      continue;
+    }
+    regex += ch;
+    i++;
+  }
+  regex += "$";
+  return regex;
+}
+
+// ../baro-orchestrator/src/planning/story-tools.ts
+var MAX_WRITE_BYTES = 5e5;
+function createStoryTools(cwd) {
+  return [...createCodebaseTools(cwd), writeFileTool(cwd), editFileTool(cwd)];
+}
+function writeFileTool(cwd) {
+  return {
+    type: "function",
+    name: "write_file",
+    description: "Create a file or overwrite its full contents. Parent directories are created if needed. Use this for new files or when replacing the entire body of an existing file is simpler than a series of edits. Caps file size at 500 KB.",
+    strict: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path relative to the project root."
+        },
+        content: {
+          type: "string",
+          description: "Full file contents to write. UTF-8."
+        }
+      },
+      required: ["path", "content"],
+      additionalProperties: false
+    },
+    async invoke(args) {
+      const target = safePath2(cwd, args.path);
+      if (!target) return `Error: path '${args.path}' escapes the project root.`;
+      if (args.content.length > MAX_WRITE_BYTES) {
+        return `Error: write_file refused \u2014 content is ${args.content.length} bytes, max is ${MAX_WRITE_BYTES}. Split the file or use edit_file for partial updates.`;
+      }
+      try {
+        const dir = path3.dirname(target);
+        fs2.mkdirSync(dir, { recursive: true });
+        fs2.writeFileSync(target, args.content, "utf-8");
+        return `Wrote ${args.path} (${args.content.length} bytes).`;
+      } catch (e) {
+        return `Error writing ${args.path}: ${e?.message ?? String(e)}`;
+      }
+    }
+  };
+}
+function editFileTool(cwd) {
+  return {
+    type: "function",
+    name: "edit_file",
+    description: "Find-and-replace a single occurrence of a string in an existing file. `old` must appear in the file exactly once (case-sensitive, whitespace and newlines included); pass enough surrounding context to make it unique. Returns an error if `old` is not found or appears multiple times \u2014 at that point read_file again and pick a larger snippet.",
+    strict: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path relative to the project root."
+        },
+        old: {
+          type: "string",
+          description: "Exact text to find. Must be unique in the file. Include surrounding lines if needed to make it unique."
+        },
+        new: {
+          type: "string",
+          description: "Replacement text."
+        }
+      },
+      required: ["path", "old", "new"],
+      additionalProperties: false
+    },
+    async invoke(args) {
+      const target = safePath2(cwd, args.path);
+      if (!target) return `Error: path '${args.path}' escapes the project root.`;
+      if (!fs2.existsSync(target)) {
+        return `Error: ${args.path} does not exist. Use write_file to create it.`;
+      }
+      if (fs2.statSync(target).isDirectory()) {
+        return `Error: ${args.path} is a directory.`;
+      }
+      let original;
+      try {
+        original = fs2.readFileSync(target, "utf-8");
+      } catch (e) {
+        return `Error reading ${args.path}: ${e?.message ?? String(e)}`;
+      }
+      if (!args.old) return "Error: `old` is empty \u2014 refusing to edit.";
+      const firstIdx = original.indexOf(args.old);
+      if (firstIdx === -1) {
+        return `Error: \`old\` not found in ${args.path}. Re-read the file and pass an exact-matching snippet (including whitespace).`;
+      }
+      const secondIdx = original.indexOf(args.old, firstIdx + 1);
+      if (secondIdx !== -1) {
+        return `Error: \`old\` appears multiple times in ${args.path} (first at offset ${firstIdx}, again at ${secondIdx}). Include more surrounding context so the match is unique.`;
+      }
+      const updated = original.slice(0, firstIdx) + args.new + original.slice(firstIdx + args.old.length);
+      try {
+        fs2.writeFileSync(target, updated, "utf-8");
+        const delta = updated.length - original.length;
+        const sign = delta >= 0 ? "+" : "";
+        return `Edited ${args.path} (${sign}${delta} bytes).`;
+      } catch (e) {
+        return `Error writing ${args.path}: ${e?.message ?? String(e)}`;
+      }
+    }
+  };
+}
+function safePath2(cwd, filePath) {
+  const resolved = path3.resolve(cwd, filePath);
+  if (!resolved.startsWith(path3.resolve(cwd))) return null;
+  return resolved;
+}
+
+// ../baro-orchestrator/src/participants/openai-story-agent.ts
+var STORY_SYSTEM_PROMPT = `You are an autonomous coding agent. The user will hand you exactly one
+focused story: a goal plus acceptance criteria and (optionally) test
+commands. Your job is to read the relevant code, make the changes that
+satisfy every acceptance criterion, run the tests, and commit.
+
+Tools available (call them as function calls; arguments are JSON):
+  read_file, list_files, file_tree, grep, glob   \u2014 explore the repo
+  write_file                                       \u2014 create or overwrite
+  edit_file                                        \u2014 find-and-replace
+  bash                                             \u2014 run any shell cmd
+                                                     (build, test, git\u2026)
+
+Rules:
+- Stay tightly inside the story scope. Do NOT refactor unrelated code.
+  If you notice an unrelated issue, note it in your final commit body
+  under "Noted (out of scope)" \u2014 don't fix it inline.
+- Before you write code, READ the files you'll touch. Confirm exact
+  function names, exact paths.
+- When you edit, use edit_file with enough surrounding context to make
+  the match unique. write_file is for new files or full rewrites only.
+- After your edits, run the test commands the story specified. Use the
+  bash tool. Fix any failures and re-run.
+- When you're done, run \`git add -A && git commit -m "..."\` via bash
+  with a concise message. Then respond with a brief summary message
+  (no more tool calls) \u2014 that signals the turn is over.
+
+You may be sent corrective feedback after your turn. If you receive a
+follow-up user message, treat it as additional acceptance criteria
+and revise.`;
+var OpenAIStoryAgent = class extends BaroParticipant {
+  spec;
+  opts;
+  model;
+  runner = new OpenAIInferenceRunner();
+  tools;
+  envRef = null;
+  currentPhase = "idle";
+  startedAt = null;
+  resolveDone;
+  done;
+  /** Resolved by `onExternalBusEvent` when a targeted message arrives. */
+  notifyMessage = null;
+  /** Most recent pending message text (set alongside notifyMessage). */
+  pendingMessage = null;
+  constructor(spec, opts = {}) {
+    super();
+    this.spec = {
+      retries: 2,
+      timeoutSecs: 600,
+      retryDelayMs: 1500,
+      quietTimeoutMs: 2e3,
+      maxTurns: 4,
+      hardTimeoutSecs: 0,
+      ...spec
+    };
+    this.opts = {
+      model: opts.model ?? "gpt-5.5",
+      maxRoundsPerTurn: opts.maxRoundsPerTurn ?? 30,
+      perRoundTimeoutSecs: opts.perRoundTimeoutSecs ?? 180
+    };
+    this.model = pickModel2(this.opts.model);
+    this.tools = createStoryTools(spec.cwd);
+    setModelTools(this.model, this.tools);
+    this.done = new Promise((res) => {
+      this.resolveDone = res;
+    });
+  }
+  get id() {
+    return this.spec.id;
+  }
+  get agentId() {
+    return this.spec.id;
+  }
+  getPhase() {
+    return this.currentPhase;
+  }
+  run(env) {
+    if (this.startedAt != null) return this.done;
+    this.envRef = env;
+    this.startedAt = Date.now();
+    this.transition("starting", "story queued");
+    void this.executeAllAttempts();
+    return this.done;
+  }
+  abort() {
+    this.transition("aborted", "external abort");
+  }
+  async onExternalBusEvent(_source, event) {
+    if (event instanceof AgentTargetedMessageItem && event.recipientId === this.spec.id) {
+      this.pendingMessage = event.text;
+      this.notifyMessage?.();
+    }
+  }
+  // ─── Attempt orchestration ──────────────────────────────────────
+  async executeAllAttempts() {
+    const maxAttempts = this.spec.retries + 1;
+    let lastError = null;
+    let attempts = 0;
+    const hardTimer = this.spec.hardTimeoutSecs > 0 ? setTimeout(() => {
+      lastError = `hard timeout (${this.spec.hardTimeoutSecs}s) hit`;
+      this.transition("aborted", lastError);
+    }, this.spec.hardTimeoutSecs * 1e3) : null;
+    for (let i = 0; i < maxAttempts; i++) {
+      attempts = i + 1;
+      if (this.currentPhase === "aborted") break;
+      if (i > 0) {
+        this.transition("starting", `retry ${attempts}/${maxAttempts}`);
+        await sleep2(this.spec.retryDelayMs);
+      }
+      try {
+        await this.runOneAttempt();
+        if (this.currentPhase === "done") {
+          lastError = null;
+          break;
+        }
+        lastError = "attempt did not reach a terminal state";
+      } catch (e) {
+        lastError = e?.message ?? String(e);
+        this.transition("failed", lastError);
+      }
+    }
+    if (hardTimer) clearTimeout(hardTimer);
+    const durationSecs = this.startedAt ? Math.round((Date.now() - this.startedAt) / 1e3) : 0;
+    const success = this.currentPhase === "done";
+    this.envRef?.deliverBusEvent(
+      this,
+      new StoryResultItem(this.spec.id, success, attempts, durationSecs, lastError)
+    );
+    this.resolveDone({
+      storyId: this.spec.id,
+      success,
+      attempts,
+      durationSecs,
+      finalSummary: null,
+      error: lastError
+    });
+  }
+  async runOneAttempt() {
+    const userMessageText = this.spec.prompt;
+    this.envRef?.deliverBusEvent(
+      this,
+      new AgentUserMessageItem(this.spec.id, userMessageText)
+    );
+    let context = ModelContext.create(this.spec.id).addContextItem(SystemMessageItem.create(STORY_SYSTEM_PROMPT)).addContextItem(UserMessageItem.create(userMessageText));
+    this.transition("running", "first turn");
+    for (let turn = 1; turn <= this.spec.maxTurns; turn++) {
+      const turnResult = await this.runOneTurn(context);
+      context = turnResult.context;
+      this.envRef?.deliverBusEvent(
+        this,
+        new ClaudeResultItem(
+          this.spec.id,
+          turnResult.success ? "success" : "error",
+          null,
+          // session id — not applicable for OpenAI
+          !turnResult.success,
+          turnResult.assistantText,
+          null,
+          // usage info — not surfaced this phase
+          null,
+          null,
+          null,
+          {}
+        )
+      );
+      if (!turnResult.success) {
+        this.transition("failed", turnResult.error ?? "turn failed");
+        return;
+      }
+      const gotMessage = await this.waitForMessageOrQuiet();
+      if (!gotMessage) {
+        this.transition("done", `${turn} turn(s)`);
+        return;
+      }
+      context = context.addContextItem(
+        UserMessageItem.create(this.pendingMessage ?? "")
+      );
+      this.envRef?.deliverBusEvent(
+        this,
+        new AgentUserMessageItem(this.spec.id, this.pendingMessage ?? "")
+      );
+      this.pendingMessage = null;
+    }
+    this.transition("failed", `maxTurns (${this.spec.maxTurns}) exhausted`);
+  }
+  /**
+   * Drive a single TURN — repeated inference rounds with tool
+   * execution in between — until the model returns a final
+   * assistant message without tool calls. That terminal message
+   * IS the end of the turn.
+   */
+  async runOneTurn(initialContext) {
+    let context = initialContext;
+    let assistantText = null;
+    const perRoundMs = this.opts.perRoundTimeoutSecs * 1e3;
+    for (let round = 1; round <= this.opts.maxRoundsPerTurn; round++) {
+      const ac = new AbortController();
+      const timer = setTimeout(() => ac.abort(), perRoundMs);
+      const calls = [];
+      let sawMessage = false;
+      let lastMessageText = null;
+      try {
+        for await (const item of this.runner.run(context, this.model, ac.signal)) {
+          if (item.type === "function_call") {
+            await this.envRef?.deliverFunctionCall(this, item);
+            context = context.addContextItem(item);
+            calls.push(item);
+          } else if (item.type === "message" && item.role === "assistant") {
+            await this.envRef?.deliverModelMessage(this, item);
+            context = context.addContextItem(item);
+            const json = item.toJSON();
+            const text = json.content?.[0]?.text ?? "";
+            lastMessageText = text;
+            sawMessage = true;
+          } else if (item.type === "reasoning") {
+            context = context.addContextItem(item);
+          }
+        }
+      } catch (e) {
+        clearTimeout(timer);
+        return {
+          context,
+          success: false,
+          assistantText,
+          error: `inference round ${round} failed: ${e?.message ?? String(e)}`
+        };
+      } finally {
+        clearTimeout(timer);
+      }
+      for (const call of calls) {
+        const tool = this.tools.find((t) => t.name === call.name);
+        const output = tool ? await runToolSafely(tool, call.args) : `Error: tool '${call.name}' not registered`;
+        const outItem = FunctionCallOutputItem.create(call.callId, output);
+        await this.envRef?.deliverFunctionCallOutput(this, outItem);
+        context = context.addContextItem(outItem);
+      }
+      if (sawMessage && calls.length === 0) {
+        return {
+          context,
+          success: true,
+          assistantText: lastMessageText
+        };
+      }
+      if (!sawMessage && calls.length === 0) {
+        return {
+          context,
+          success: false,
+          assistantText,
+          error: `round ${round} returned no items`
+        };
+      }
+      assistantText = lastMessageText ?? assistantText;
+    }
+    return {
+      context,
+      success: false,
+      assistantText,
+      error: `exceeded maxRoundsPerTurn=${this.opts.maxRoundsPerTurn}`
+    };
+  }
+  /**
+   * Resolves `true` if an `AgentTargetedMessageItem` arrives within
+   * `quietTimeoutMs`, `false` if the timer fires first. Mirrors
+   * Claude side's quiet timer that closes stdin after silence.
+   */
+  async waitForMessageOrQuiet() {
+    return new Promise((resolve4) => {
+      const timer = setTimeout(() => {
+        this.notifyMessage = null;
+        resolve4(false);
+      }, this.spec.quietTimeoutMs);
+      this.notifyMessage = () => {
+        clearTimeout(timer);
+        this.notifyMessage = null;
+        resolve4(true);
+      };
+    });
+  }
+  transition(next, detail) {
+    if (next === this.currentPhase) return;
+    this.currentPhase = next;
+    this.envRef?.deliverBusEvent(
+      this,
+      new AgentStateItem(this.spec.id, next, detail)
+    );
+  }
+};
+function pickModel2(name) {
+  switch (name) {
+    case "gpt-5.5":
+      return new Gpt55();
+    case "gpt-5.4":
+      return new Gpt54();
+    case "gpt-5.4-mini":
+      return new Gpt54Mini();
+    case "gpt-5.4-nano":
+      return new Gpt54Nano();
+    default:
+      throw new Error(
+        `OpenAIStoryAgent: unknown model "${name}" \u2014 Mozaik 3.9 ships gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.4-nano`
+      );
+  }
+}
+function setModelTools(model, tools) {
+  const m = model;
+  if (typeof m.setTools !== "function") {
+    throw new Error(
+      `OpenAIStoryAgent: model ${model.specification.name} does not implement ToolCallingCapability`
+    );
+  }
+  m.setTools(tools);
+}
+async function runToolSafely(tool, argsJson) {
+  let parsed;
+  try {
+    parsed = JSON.parse(argsJson);
+  } catch (e) {
+    return `Error: tool args were not valid JSON: ${e?.message ?? String(e)}`;
+  }
+  try {
+    const result = await tool.invoke(parsed);
+    return typeof result === "string" ? result : JSON.stringify(result);
+  } catch (e) {
+    return `Error running ${tool.name}: ${e?.message ?? String(e)}`;
+  }
+}
+function sleep2(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}
+
 // ../baro-orchestrator/src/participants/story-factory.ts
 var StoryFactory = class extends BaroParticipant {
   constructor(opts) {
@@ -10829,7 +11590,18 @@ var StoryFactory = class extends BaroParticipant {
   async spawn(req) {
     if (!this.envRef) return;
     if (this.active.has(req.storyId)) return;
-    const agent = new StoryAgent({
+    const llm = this.opts.llm ?? "claude";
+    const agent = llm === "openai" ? new OpenAIStoryAgent(
+      {
+        id: req.storyId,
+        prompt: req.prompt,
+        cwd: this.opts.cwd,
+        model: req.model,
+        retries: req.retries,
+        timeoutSecs: req.timeoutSecs
+      },
+      { model: this.opts.openaiModel ?? "gpt-5.5" }
+    ) : new StoryAgent({
       id: req.storyId,
       prompt: req.prompt,
       cwd: this.opts.cwd,
@@ -11059,7 +11831,7 @@ function surgeonDeterministicReplan(failure) {
 }
 
 // ../baro-orchestrator/src/participants/surgeon-openai.ts
-function pickModel2(name) {
+function pickModel3(name) {
   switch (name) {
     case "gpt-5.5":
       return new Gpt55();
@@ -11088,7 +11860,7 @@ var SurgeonOpenAI = class extends BaroParticipant {
       model: opts.model ?? "gpt-5.4",
       snapshot: opts.snapshot
     };
-    this.model = pickModel2(this.opts.model);
+    this.model = pickModel3(this.opts.model);
   }
   async idle() {
     await Promise.allSettled([...this.pending]);
@@ -11178,7 +11950,7 @@ async function orchestrate(config) {
     );
   }
   if (config.auditLogPath) {
-    mkdirSync2(dirname2(config.auditLogPath), { recursive: true });
+    mkdirSync3(dirname3(config.auditLogPath), { recursive: true });
     new Auditor({ path: config.auditLogPath }).join(env);
   }
   if (config.extraParticipants) {
@@ -11307,7 +12079,11 @@ async function orchestrate(config) {
   });
   conductor.setEnvironment(env);
   conductor.join(env);
-  const storyFactory = new StoryFactory({ cwd: config.cwd });
+  const storyFactory = new StoryFactory({
+    cwd: config.cwd,
+    llm,
+    openaiModel: "gpt-5.5"
+  });
   storyFactory.setEnvironment(env);
   storyFactory.join(env);
   if (emitTui) {
@@ -11662,9 +12438,9 @@ async function main() {
     printHelp();
     return;
   }
-  const cwd = resolve(args.cwd);
-  const prdPath = resolve(cwd, args.prd);
-  if (!existsSync2(prdPath)) {
+  const cwd = resolve3(args.cwd);
+  const prdPath = resolve3(cwd, args.prd);
+  if (!existsSync4(prdPath)) {
     process.stderr.write(`[cli] PRD not found: ${prdPath}
 `);
     process.exit(2);