baro-ai 0.41.0 → 0.42.1

package/dist/cli.mjs

@@ -9904,6 +9904,10 @@ var ClaudeSystem = defineSemanticEvent("claude_system");
 var AgentResult = defineSemanticEvent("claude_result");
 var ClaudeStreamChunk = defineSemanticEvent("claude_stream_chunk");
 var ClaudeRateLimit = defineSemanticEvent("claude_rate_limit");
+var CodexSystem = defineSemanticEvent("codex_system");
+var CodexTurnEvent = defineSemanticEvent("codex_turn_event");
+var CodexItemEvent = defineSemanticEvent("codex_item_event");
+var CodexUnknownEvent = defineSemanticEvent("codex_unknown_event");
 var Critique = defineSemanticEvent("critique");
 var ClaudeUnknownEvent = defineSemanticEvent("claude_unknown_event");
 var RunStartRequest = defineSemanticEvent("run_start_request");
@@ -11761,6 +11765,584 @@ function extractPath(item) {
   return null;
 }
 
+// ../baro-orchestrator/src/participants/codex-story-agent.ts
+import { setTimeout as setTimeoutPromise } from "timers/promises";
+
+// ../baro-orchestrator/src/participants/codex-cli-participant.ts
+import { spawn } from "child_process";
+
+// ../baro-orchestrator/src/codex-stream-mapper.ts
+function mapCodexEvent(agentId, event) {
+  const threadId = typeof event.thread_id === "string" ? event.thread_id : null;
+  const items = [];
+  const type = typeof event.type === "string" ? event.type : "";
+  if (type === "thread.started" || type === "thread.completed") {
+    items.push(
+      CodexSystem.create({
+        agentId,
+        subtype: type,
+        raw: event
+      })
+    );
+    return { items, threadId };
+  }
+  if (type === "turn.started" || type === "turn.completed" || type === "turn.failed") {
+    items.push(
+      CodexTurnEvent.create({
+        agentId,
+        phase: type.slice("turn.".length),
+        raw: event
+      })
+    );
+    return { items, threadId };
+  }
+  if (type === "error") {
+    items.push(
+      CodexSystem.create({
+        agentId,
+        subtype: "error",
+        raw: event
+      })
+    );
+    return { items, threadId };
+  }
+  if (type === "item.started" || type === "item.updated") {
+    const inner = event.item && typeof event.item === "object" ? event.item : {};
+    const innerType = typeof inner.type === "string" ? inner.type : "unknown";
+    items.push(
+      CodexItemEvent.create({
+        agentId,
+        itemType: `${type.slice("item.".length)}:${innerType}`,
+        raw: event
+      })
+    );
+    return { items, threadId };
+  }
+  if (type === "item.completed") {
+    const inner = event.item && typeof event.item === "object" ? event.item : {};
+    const innerType = typeof inner.type === "string" ? inner.type : "unknown";
+    if (innerType === "agent_message" || innerType === "message") {
+      const text = typeof inner.text === "string" ? inner.text : "";
+      if (text) {
+        items.push(ModelMessageItem.rehydrate({ text }));
+      }
+      items.push(
+        CodexItemEvent.create({
+          agentId,
+          itemType: innerType,
+          raw: event
+        })
+      );
+      return { items, threadId };
+    }
+    if (innerType === "reasoning") {
+      items.push(
+        CodexItemEvent.create({
+          agentId,
+          itemType: innerType,
+          raw: event
+        })
+      );
+      return { items, threadId };
+    }
+    if (innerType === "command_execution" || innerType === "file_change" || innerType === "mcp_tool_call" || innerType === "web_search") {
+      const callId = stringifyId(inner);
+      const name = inferToolName(innerType, inner);
+      const args = inferToolArgs(inner);
+      items.push(FunctionCallItem.rehydrate({ callId, name, args }));
+      const output = inferToolOutput(innerType, inner);
+      if (output !== null) {
+        items.push(FunctionCallOutputItem.create(callId, output));
+      }
+      items.push(
+        CodexItemEvent.create({
+          agentId,
+          itemType: innerType,
+          raw: event
+        })
+      );
+      return { items, threadId };
+    }
+    items.push(
+      CodexItemEvent.create({
+        agentId,
+        itemType: innerType,
+        raw: event
+      })
+    );
+    return { items, threadId };
+  }
+  items.push(
+    CodexUnknownEvent.create({
+      agentId,
+      codexType: type || "unspecified",
+      raw: event
+    })
+  );
+  return { items, threadId };
+}
+function stringifyId(event) {
+  if (typeof event.id === "string") return event.id;
+  if (typeof event.call_id === "string") return event.call_id;
+  if (typeof event.item_id === "string") return event.item_id;
+  const hint = typeof event.command === "string" ? event.command.slice(0, 32) : typeof event.path === "string" ? event.path : typeof event.tool_name === "string" ? event.tool_name : "anon";
+  return `codex:${event.type ?? "item"}:${hint}`;
+}
+function inferToolName(itemType, event) {
+  if (typeof event.tool_name === "string") return event.tool_name;
+  switch (itemType) {
+    case "command_execution":
+      return "shell";
+    case "file_change":
+      return "edit";
+    case "web_search":
+      return "web_search";
+    default:
+      return itemType;
+  }
+}
+function inferToolArgs(event) {
+  if (event.arguments !== void 0) {
+    return typeof event.arguments === "string" ? event.arguments : JSON.stringify(event.arguments);
+  }
+  const candidate = {};
+  for (const key of ["command", "path", "diff", "query"]) {
+    if (event[key] !== void 0) candidate[key] = event[key];
+  }
+  if (Object.keys(candidate).length > 0) return JSON.stringify(candidate);
+  const { type: _t, ...rest } = event;
+  return JSON.stringify(rest);
+}
+function inferToolOutput(itemType, event) {
+  if (typeof event.output === "string") return event.output;
+  if (typeof event.aggregated_output === "string") {
+    return event.aggregated_output;
+  }
+  if (typeof event.result === "string") return event.result;
+  if (itemType === "command_execution" && typeof event.exit_code === "number") {
+    return `exit_code=${event.exit_code}`;
+  }
+  return null;
+}
+
+// ../baro-orchestrator/src/participants/codex-cli-participant.ts
+var CodexCliParticipant = class _CodexCliParticipant extends BaseObserver {
+  constructor(agentId, opts) {
+    super();
+    this.agentId = agentId;
+    this.options = {
+      codexBin: "codex",
+      fullAuto: false,
+      skipGitRepoCheck: false,
+      ...opts
+    };
+    this.ready = new Promise((res, rej) => {
+      this.resolveReady = res;
+      this.rejectReady = rej;
+    });
+    this.done = new Promise((res) => {
+      this.resolveDone = res;
+    });
+  }
+  /**
+   * Process-wide registry of every Codex child currently running. Used
+   * by the orchestrator's SIGINT/SIGTERM handlers to nuke orphans so a
+   * killed baro doesn't leave a swarm of background agents burning
+   * quota.
+   */
+  static active = /* @__PURE__ */ new Set();
+  /** Send a signal to every active Codex child. Idempotent. */
+  static killAll(signal = "SIGTERM") {
+    for (const p of _CodexCliParticipant.active) {
+      try {
+        p.proc?.kill(signal);
+      } catch {
+      }
+    }
+  }
+  options;
+  proc = null;
+  buffer = "";
+  envRef = null;
+  currentPhase = "idle";
+  threadId = null;
+  exitCode = null;
+  spawnError = null;
+  resolveDone;
+  resolveReady;
+  rejectReady;
+  /** Resolves once Codex emits its first `thread.started` event. */
+  ready;
+  /** Resolves once the Codex process exits (regardless of success). */
+  done;
+  getThreadId() {
+    return this.threadId;
+  }
+  getPhase() {
+    return this.currentPhase;
+  }
+  /**
+   * Spawn the Codex process and start streaming its events into the
+   * environment. Idempotent: subsequent calls are a no-op.
+   */
+  start(environment) {
+    if (this.proc) return;
+    this.envRef = environment;
+    const args = this.buildArgs();
+    let proc;
+    try {
+      proc = spawn(this.options.codexBin, args, {
+        cwd: this.options.cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (e) {
+      this.spawnError = e instanceof Error ? e : new Error(String(e));
+      this.transition("failed", this.spawnError.message);
+      this.rejectReady(this.spawnError);
+      this.resolveDone({
+        threadId: null,
+        exitCode: null,
+        error: this.spawnError
+      });
+      return;
+    }
+    this.proc = proc;
+    _CodexCliParticipant.active.add(this);
+    this.transition("starting");
+    proc.stdout.setEncoding("utf8");
+    proc.stderr.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => this.handleStdout(chunk));
+    proc.stderr.on("data", (chunk) => this.handleStderr(chunk));
+    proc.on("error", (err) => {
+      this.spawnError = err;
+      this.rejectReady(err);
+    });
+    proc.on("exit", (code) => {
+      _CodexCliParticipant.active.delete(this);
+      this.exitCode = code;
+      const finalPhase = this.spawnError != null || code != null && code !== 0 ? "failed" : "done";
+      this.transition(
+        finalPhase,
+        code != null ? `exit code ${code}` : "no exit code"
+      );
+      this.resolveDone({
+        threadId: this.threadId,
+        exitCode: code,
+        error: this.spawnError
+      });
+    });
+  }
+  /** Kill the Codex process. Resolves once exit fires. */
+  abort(signal = "SIGTERM") {
+    this.transition("aborted");
+    this.proc?.kill(signal);
+  }
+  async onExternalEvent(_source, event) {
+    if (AgentTargetedMessage.is(event) && event.data.recipientId === this.agentId) {
+      process.stderr.write(
+        `[codex:${this.agentId}] received AgentTargetedMessage but Codex exec is one-shot \u2014 dropped
+`
+      );
+    }
+  }
+  buildArgs() {
+    const args = ["exec", "--json"];
+    if (this.options.skipGitRepoCheck) args.push("--skip-git-repo-check");
+    if (this.options.fullAuto) args.push("--full-auto");
+    if (this.options.model) args.push("--model", this.options.model);
+    if (this.options.extraArgs?.length) args.push(...this.options.extraArgs);
+    args.push(this.options.prompt);
+    return args;
+  }
+  handleStdout(chunk) {
+    this.buffer += chunk;
+    let nl;
+    while ((nl = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, nl).trim();
+      this.buffer = this.buffer.slice(nl + 1);
+      if (!line) continue;
+      this.processLine(line);
+    }
+  }
+  handleStderr(chunk) {
+    const trimmed = chunk.trimEnd();
+    if (!trimmed) return;
+    process.stderr.write(`[codex:${this.agentId}/stderr] ${trimmed}
+`);
+  }
+  processLine(line) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      process.stderr.write(
+        `[codex:${this.agentId}] non-JSON stdout: ${line.slice(0, 200)}
+`
+      );
+      return;
+    }
+    const { items, threadId } = mapCodexEvent(this.agentId, parsed);
+    if (threadId && !this.threadId) {
+      this.threadId = threadId;
+    }
+    for (const item of items) {
+      if (item instanceof SemanticEvent) {
+        if (CodexSystem.is(item) && item.data.subtype === "thread.started") {
+          this.transition("running", "codex thread started");
+          this.resolveReady();
+        }
+        if (CodexTurnEvent.is(item)) {
+          const phase = item.data.phase;
+          if (phase === "failed") {
+            this.transition("failed", "codex turn failed");
+          }
+        }
+      }
+      this.dispatch(item);
+    }
+  }
+  /**
+   * Route a mapped event to the right Mozaik delivery channel.
+   * Mirror of ClaudeCliParticipant.dispatch — assistant-side LLM items
+   * use Mozaik's typed channels; everything else goes through
+   * deliverSemanticEvent.
+   */
+  dispatch(item) {
+    if (!this.envRef) return;
+    if (item instanceof ModelMessageItem) {
+      this.envRef.deliverModelMessage(this, item);
+      return;
+    }
+    if (item instanceof FunctionCallItem) {
+      this.envRef.deliverFunctionCall(this, item);
+      return;
+    }
+    if (item instanceof FunctionCallOutputItem) {
+      this.envRef.deliverFunctionCallOutput(this, item);
+      return;
+    }
+    this.envRef.deliverSemanticEvent(this, item);
+  }
+  transition(next, detail) {
+    if (next === this.currentPhase) return;
+    this.currentPhase = next;
+    this.envRef?.deliverSemanticEvent(
+      this,
+      AgentState.create({
+        agentId: this.agentId,
+        phase: next,
+        detail
+      })
+    );
+  }
+};
+
+// ../baro-orchestrator/src/participants/codex-story-agent.ts
+var CodexStoryAgent = class extends BaseObserver {
+  spec;
+  envRef = null;
+  currentCodex = null;
+  currentPhase = "idle";
+  startedAt = null;
+  resolveDone;
+  done;
+  constructor(spec) {
+    super();
+    this.spec = {
+      retries: 2,
+      timeoutSecs: 600,
+      retryDelayMs: 1500,
+      hardTimeoutSecs: 0,
+      fullAuto: true,
+      skipGitRepoCheck: false,
+      ...spec
+    };
+    this.done = new Promise((res) => {
+      this.resolveDone = res;
+    });
+  }
+  get id() {
+    return this.spec.id;
+  }
+  get agentId() {
+    return this.spec.id;
+  }
+  getPhase() {
+    return this.currentPhase;
+  }
+  getCurrentCodex() {
+    return this.currentCodex;
+  }
+  /**
+   * Begin executing the story. Idempotent. Returns the `done` promise
+   * for the caller's convenience.
+   */
+  run(environment) {
+    if (this.startedAt != null) {
+      return this.done;
+    }
+    this.envRef = environment;
+    this.startedAt = Date.now();
+    this.transition("starting", "story queued");
+    void this.executeAllAttempts();
+    return this.done;
+  }
+  /**
+   * No-op: Codex exec is one-shot, there's no stdin channel to forward
+   * mid-flight messages to. Logged at the participant level if we ever
+   * see an AgentTargetedMessage addressed here.
+   */
+  async onExternalEvent(_source, _event) {
+  }
+  /** Abort the story, killing the running Codex (if any). */
+  abort() {
+    this.currentCodex?.abort();
+    this.transition("aborted", "external abort");
+  }
+  async executeAllAttempts() {
+    const maxAttempts = this.spec.retries + 1;
+    let lastSummary = null;
+    let lastError = null;
+    let hardTimedOut = false;
+    const hardTimer = this.spec.hardTimeoutSecs > 0 ? setTimeout(() => {
+      hardTimedOut = true;
+      this.currentCodex?.abort();
+    }, this.spec.hardTimeoutSecs * 1e3) : null;
+    try {
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        if (hardTimedOut) {
+          lastError = `hard timeout after ${this.spec.hardTimeoutSecs}s`;
+          break;
+        }
+        if (attempt > 1) {
+          this.transition(
+            "waiting",
+            `retrying (attempt ${attempt}/${maxAttempts})`
+          );
+          await setTimeoutPromise(this.spec.retryDelayMs);
+          if (hardTimedOut) {
+            lastError = `hard timeout after ${this.spec.hardTimeoutSecs}s`;
+            break;
+          }
+        }
+        const result = await this.runOneAttempt(attempt);
+        lastSummary = result.summary;
+        lastError = result.error;
+        if (result.success) {
+          const durationSecs2 = Math.round(
+            (Date.now() - (this.startedAt ?? Date.now())) / 1e3
+          );
+          this.transition("done", `success on attempt ${attempt}`);
+          this.emitStoryResult(true, attempt, durationSecs2, null);
+          this.resolveDone({
+            storyId: this.spec.id,
+            success: true,
+            attempts: attempt,
+            durationSecs: durationSecs2,
+            finalSummary: result.summary,
+            error: null
+          });
+          return;
+        }
+        if (hardTimedOut) {
+          lastError = `hard timeout after ${this.spec.hardTimeoutSecs}s`;
+          break;
+        }
+      }
+    } finally {
+      if (hardTimer !== null) clearTimeout(hardTimer);
+    }
+    const durationSecs = Math.round(
+      (Date.now() - (this.startedAt ?? Date.now())) / 1e3
+    );
+    this.transition("failed", `exhausted ${maxAttempts} attempts`);
+    this.emitStoryResult(false, maxAttempts, durationSecs, lastError);
+    this.resolveDone({
+      storyId: this.spec.id,
+      success: false,
+      attempts: maxAttempts,
+      durationSecs,
+      finalSummary: lastSummary,
+      error: lastError
+    });
+  }
+  async runOneAttempt(attempt) {
+    if (!this.envRef) {
+      return { success: false, summary: null, error: "no environment" };
+    }
+    this.transition("running", `attempt ${attempt}`);
+    const codex = new CodexCliParticipant(this.spec.id, {
+      cwd: this.spec.cwd,
+      prompt: this.spec.prompt,
+      model: this.spec.model,
+      fullAuto: this.spec.fullAuto,
+      skipGitRepoCheck: this.spec.skipGitRepoCheck
+    });
+    this.currentCodex = codex;
+    codex.join(this.envRef);
+    codex.start(this.envRef);
+    let summary;
+    try {
+      summary = await raceWithTimeout(
+        codex.done,
+        this.spec.timeoutSecs * 1e3,
+        `attempt ${attempt} timeout after ${this.spec.timeoutSecs}s`
+      );
+    } catch (e) {
+      codex.abort();
+      const error = e instanceof Error ? e.message : String(e);
+      try {
+        await codex.done;
+      } catch {
+      }
+      codex.leave(this.envRef);
+      this.currentCodex = null;
+      return { success: false, summary: null, error };
+    }
+    codex.leave(this.envRef);
+    this.currentCodex = null;
+    const success = summary.exitCode === 0 && summary.error == null;
+    if (!success) {
+      const reason = summary.error ? summary.error.message : `non-zero exit ${summary.exitCode}`;
+      return { success: false, summary, error: reason };
+    }
+    return { success: true, summary, error: null };
+  }
+  emitStoryResult(success, attempts, durationSecs, error) {
+    if (!this.envRef) return;
+    this.envRef.deliverSemanticEvent(
+      this,
+      StoryResult.create({
+        storyId: this.spec.id,
+        success,
+        attempts,
+        durationSecs,
+        error
+      })
+    );
+  }
+  transition(next, detail) {
+    if (next === this.currentPhase) return;
+    this.currentPhase = next;
+    if (this.envRef) {
+      this.envRef.deliverSemanticEvent(
+        this,
+        AgentState.create({
+          agentId: this.spec.id,
+          phase: next,
+          detail
+        })
+      );
+    }
+  }
+};
+function raceWithTimeout(p, ms, label) {
+  return Promise.race([
+    p,
+    new Promise((_, rej) => setTimeout(() => rej(new Error(label)), ms))
+  ]);
+}
+
 // ../baro-orchestrator/src/planning/story-tools.ts
 import * as fs2 from "fs";
 import * as path3 from "path";
@@ -12549,10 +13131,10 @@ function sleep2(ms) {
 }
 
 // ../baro-orchestrator/src/participants/story-agent.ts
-import { setTimeout as setTimeoutPromise } from "timers/promises";
+import { setTimeout as setTimeoutPromise2 } from "timers/promises";
 
 // ../baro-orchestrator/src/participants/claude-cli-participant.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 
 // ../baro-orchestrator/src/stream-json-mapper.ts
 function mapClaudeEvent(agentId, event) {
@@ -12725,7 +13307,7 @@ var ClaudeCliParticipant = class _ClaudeCliParticipant extends BaseObserver {
     const args = this.buildArgs();
     let proc;
     try {
-      proc = spawn(this.options.claudeBin, args, {
+      proc = spawn2(this.options.claudeBin, args, {
         cwd: this.options.cwd,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -13011,7 +13593,7 @@ var StoryAgent = class extends BaseObserver {
             "waiting",
             `retrying (attempt ${attempt}/${maxAttempts})`
           );
-          await setTimeoutPromise(this.spec.retryDelayMs);
+          await setTimeoutPromise2(this.spec.retryDelayMs);
           if (hardTimedOut) {
             lastError = `hard timeout after ${this.spec.hardTimeoutSecs}s`;
             break;
@@ -13082,7 +13664,7 @@ var StoryAgent = class extends BaseObserver {
     const cancelMultiTurn = this.setupMultiTurnLifecycle(claude);
     let summary;
     try {
-      summary = await raceWithTimeout(
+      summary = await raceWithTimeout2(
         claude.done,
         this.spec.timeoutSecs * 1e3,
         `attempt ${attempt} timeout after ${this.spec.timeoutSecs}s`
@@ -13183,7 +13765,7 @@ var StoryAgent = class extends BaseObserver {
     }
   }
 };
-function raceWithTimeout(p, ms, label) {
+function raceWithTimeout2(p, ms, label) {
   return Promise.race([
     p,
     new Promise((_, rej) => setTimeout(() => rej(new Error(label)), ms))
@@ -13223,7 +13805,15 @@ var StoryFactory = class extends BaseObserver {
     const llm = this.opts.llm ?? "claude";
     const claudeModel = this.opts.storyModelOverride ?? req.model;
     const openaiModel = this.opts.storyModelOverride ?? this.opts.openaiModel ?? "gpt-5.5";
-    const agent = llm === "openai" ? new OpenAIStoryAgent(
+    const codexModel = this.opts.storyModelOverride;
+    const agent = llm === "codex" ? new CodexStoryAgent({
+      id: req.storyId,
+      prompt: req.prompt,
+      cwd: this.opts.cwd,
+      model: codexModel,
+      retries: req.retries,
+      timeoutSecs: req.timeoutSecs
+    }) : llm === "openai" ? new OpenAIStoryAgent(
       {
         id: req.storyId,
         prompt: req.prompt,
@@ -13579,6 +14169,10 @@ async function orchestrate(config) {
     process.stderr.write(
       "[orchestrate] llm=openai: Architect, Planner, Critic, Surgeon, StoryAgent all running through Mozaik's native OpenAI runner (gpt-5.x).\n"
     );
+  } else if (llm === "codex") {
+    process.stderr.write(
+      "[orchestrate] llm=codex: Story phase shells out to `codex exec --json` (ChatGPT subscription path). Architect / Planner / Critic / Surgeon fall back to Claude in v1 \u2014 codex-* siblings for those phases are a v2 follow-up.\n"
+    );
   } else {
     process.stderr.write(
       "[orchestrate] llm=claude: every LLM phase shells out to the Claude Code CLI.\n"
@@ -14019,9 +14613,11 @@ function parseArgs(argv) {
         break;
       case "--llm": {
         const v = required(argv, ++i, "--llm");
-        if (v !== "claude" && v !== "openai") {
-          process.stderr.write(`[cli] --llm must be 'claude' or 'openai', got '${v}'
-`);
+        if (v !== "claude" && v !== "openai" && v !== "codex") {
+          process.stderr.write(
+            `[cli] --llm must be 'claude' | 'openai' | 'codex', got '${v}'
+`
+          );
           process.exit(2);
         }
         args.llm = v;