baro-ai 0.42.2 → 0.43.1

package/dist/cli.mjs

@@ -10752,6 +10752,226 @@ function extractVerdictJson(text) {
   throw new Error(`unbalanced JSON object in critic response: ${trimmed.slice(0, 200)}`);
 }
 
+// ../baro-orchestrator/src/codex-one-shot.ts
+import { spawn } from "child_process";
+async function runCodexOneShot(opts) {
+  const label = opts.label ?? "codex";
+  const args = ["exec", "--json"];
+  if (opts.skipGitRepoCheck) args.push("--skip-git-repo-check");
+  if (opts.bypassSandbox !== false) {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  }
+  if (opts.model) args.push("--model", opts.model);
+  args.push(opts.prompt);
+  const timeoutMs = opts.timeoutMs ?? 6e5;
+  return await new Promise((resolve4, reject) => {
+    let proc;
+    try {
+      proc = spawn(opts.codexBin ?? "codex", args, {
+        cwd: opts.cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (e) {
+      reject(e instanceof Error ? e : new Error(String(e)));
+      return;
+    }
+    let agentMessage = "";
+    let stdoutBuffer = "";
+    const eventTypesSeen = [];
+    const itemTypesSeen = [];
+    let timedOut = false;
+    const startedAt = Date.now();
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+    }, timeoutMs);
+    proc.stdout.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk;
+      let nl;
+      while ((nl = stdoutBuffer.indexOf("\n")) >= 0) {
+        const line = stdoutBuffer.slice(0, nl).trim();
+        stdoutBuffer = stdoutBuffer.slice(nl + 1);
+        if (!line) continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const type = typeof event.type === "string" ? event.type : "";
+        if (type) eventTypesSeen.push(type);
+        if (type === "turn.completed") {
+          const usage = event.usage;
+          if (usage) {
+            process.stderr.write(
+              `[${label}] usage: in=${usage.input_tokens ?? 0} out=${usage.output_tokens ?? 0}
+`
+            );
+          }
+          continue;
+        }
+        if (type === "item.completed") {
+          const item = event.item;
+          if (item) {
+            const innerType = typeof item.type === "string" ? item.type : "?";
+            itemTypesSeen.push(innerType);
+            if (item.type === "agent_message" && typeof item.text === "string") {
+              agentMessage = agentMessage ? `${agentMessage}
+${item.text}` : item.text;
+            } else if (innerType === "command_execution") {
+              const cmd = typeof item.command === "string" ? item.command.slice(0, 120) : "?";
+              process.stderr.write(`[${label}] $ ${cmd}
+`);
+            }
+          }
+          continue;
+        }
+      }
+    });
+    proc.stderr.setEncoding("utf8");
+    proc.stderr.on("data", (chunk) => {
+      const trimmed = chunk.trimEnd();
+      if (trimmed) {
+        process.stderr.write(`[${label}/stderr] ${trimmed}
+`);
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    proc.on("exit", (code, signal) => {
+      clearTimeout(timer);
+      const elapsedMs = Date.now() - startedAt;
+      if (agentMessage.trim()) {
+        resolve4(agentMessage);
+        return;
+      }
+      const ctx = [
+        `elapsed=${elapsedMs}ms`,
+        `exit=${code}`,
+        signal ? `signal=${signal}` : null,
+        timedOut ? `timedOut=true (cap=${timeoutMs}ms)` : null,
+        `events=${eventTypesSeen.length}`,
+        `items=${itemTypesSeen.length}`,
+        eventTypesSeen.length > 0 ? `event_types=[${[...new Set(eventTypesSeen)].join(",")}]` : null,
+        itemTypesSeen.length > 0 ? `item_types=[${[...new Set(itemTypesSeen)].join(",")}]` : null
+      ].filter((x) => x !== null).join(" ");
+      reject(
+        new Error(
+          `runCodexOneShot: codex produced no agent_message (${ctx})`
+        )
+      );
+    });
+  });
+}
+
+// ../baro-orchestrator/src/participants/critic-codex.ts
+var CriticCodex = class extends BaseObserver {
+  opts;
+  emissions = /* @__PURE__ */ new Map();
+  turnCount = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    super();
+    this.opts = {
+      maxEmissionsPerAgent: opts.maxEmissionsPerAgent ?? 2,
+      model: opts.model,
+      codexBin: opts.codexBin ?? "codex",
+      timeoutMs: opts.timeoutMs ?? 18e4,
+      targets: opts.targets
+    };
+  }
+  /** Resolves once every in-flight evaluation has emitted its CritiqueItem. */
+  async idle() {
+    await Promise.allSettled([...this.pending]);
+  }
+  async onExternalEvent(_source, event) {
+    if (!AgentResult.is(event)) return;
+    const { agentId, isError, resultText } = event.data;
+    if (isError || !resultText) return;
+    const criteria = this.opts.targets.get(agentId);
+    if (!criteria || criteria.length === 0) return;
+    const turn = (this.turnCount.get(agentId) ?? 0) + 1;
+    this.turnCount.set(agentId, turn);
+    const work = (async () => {
+      const { verdict, reasoning, violatedCriteria } = await this.evaluate(
+        resultText,
+        criteria
+      );
+      const critiqueEvent = Critique.create({
+        agentId,
+        verdict,
+        reasoning,
+        violatedCriteria,
+        turn,
+        modelUsed: this.opts.model ?? "codex-default"
+      });
+      for (const env of this.getEnvironments()) {
+        env.deliverSemanticEvent(this, critiqueEvent);
+      }
+      if (verdict === "fail") {
+        const emitted = this.emissions.get(agentId) ?? 0;
+        if (emitted < this.opts.maxEmissionsPerAgent) {
+          this.emissions.set(agentId, emitted + 1);
+          const text = buildCorrectiveMessage(reasoning, violatedCriteria);
+          const msg = AgentTargetedMessage.create({
+            recipientId: agentId,
+            text,
+            metadata: {
+              criticTurn: turn,
+              emissionIndex: emitted + 1
+            }
+          });
+          for (const env of this.getEnvironments()) {
+            env.deliverSemanticEvent(this, msg);
+          }
+        }
+      }
+    })();
+    this.pending.add(work);
+    work.finally(() => {
+      this.pending.delete(work);
+    });
+    await work;
+  }
+  async evaluate(resultText, criteria) {
+    const userPrompt = buildEvalPrompt(criteria, resultText);
+    const prompt = `${VERDICT_SYSTEM_PROMPT}
+
+${userPrompt}`;
+    try {
+      const text = await runCodexOneShot({
+        prompt,
+        cwd: process.cwd(),
+        skipGitRepoCheck: true,
+        bypassSandbox: true,
+        model: this.opts.model,
+        codexBin: this.opts.codexBin,
+        timeoutMs: this.opts.timeoutMs,
+        label: "codex-critic"
+      });
+      const verdictJson = extractVerdictJson(text.trim());
+      const parsed = JSON.parse(verdictJson);
+      return {
+        verdict: parsed.verdict === "pass" ? "pass" : "fail",
+        reasoning: parsed.reasoning ?? "",
+        violatedCriteria: Array.isArray(parsed.violated_criteria) ? parsed.violated_criteria : []
+      };
+    } catch (err) {
+      return {
+        verdict: "fail",
+        reasoning: `CriticCodex LLM call failed: ${String(err?.message ?? err)}`,
+        violatedCriteria: ["[critic error \u2014 could not evaluate]"]
+      };
+    }
+  }
+};
+
 // ../baro-orchestrator/src/planning/openai-runtime.ts
 async function runInferenceRound(_context, _model) {
   throw new Error(
@@ -11769,7 +11989,7 @@ function extractPath(item) {
 import { setTimeout as setTimeoutPromise } from "timers/promises";
 
 // ../baro-orchestrator/src/participants/codex-cli-participant.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 
 // ../baro-orchestrator/src/codex-stream-mapper.ts
 function mapCodexEvent(agentId, event) {
@@ -11991,7 +12211,7 @@ var CodexCliParticipant = class _CodexCliParticipant extends BaseObserver {
     const args = this.buildArgs();
     let proc;
     try {
-      proc = spawn(this.options.codexBin, args, {
+      proc = spawn2(this.options.codexBin, args, {
         cwd: this.options.cwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -13136,7 +13356,7 @@ function sleep2(ms) {
 import { setTimeout as setTimeoutPromise2 } from "timers/promises";
 
 // ../baro-orchestrator/src/participants/claude-cli-participant.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 
 // ../baro-orchestrator/src/stream-json-mapper.ts
 function mapClaudeEvent(agentId, event) {
@@ -13309,7 +13529,7 @@ var ClaudeCliParticipant = class _ClaudeCliParticipant extends BaseObserver {
     const args = this.buildArgs();
     let proc;
     try {
-      proc = spawn2(this.options.claudeBin, args, {
+      proc = spawn3(this.options.claudeBin, args, {
         cwd: this.options.cwd,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -14053,6 +14273,86 @@ function surgeonDeterministicReplan(failure) {
   };
 }
 
+// ../baro-orchestrator/src/participants/surgeon-codex.ts
+var SurgeonCodex = class extends BaseObserver {
+  opts;
+  replansEmitted = 0;
+  pending = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    super();
+    this.opts = {
+      useLlm: opts.useLlm ?? true,
+      model: opts.model,
+      maxReplans: opts.maxReplans ?? 10,
+      codexBin: opts.codexBin ?? "codex",
+      timeoutMs: opts.timeoutMs ?? 3e5,
+      snapshot: opts.snapshot
+    };
+  }
+  async idle() {
+    await Promise.allSettled([...this.pending]);
+  }
+  async onExternalEvent(_source, event) {
+    if (!StoryResult.is(event)) return;
+    if (event.data.success) return;
+    if (this.replansEmitted >= this.opts.maxReplans) return;
+    const work = (async () => {
+      const replan = this.opts.useLlm ? await this.evaluateWithLlm(event.data) : surgeonDeterministicReplan(event.data);
+      if (!replan) return;
+      this.replansEmitted += 1;
+      for (const env of this.getEnvironments()) {
+        env.deliverSemanticEvent(this, Replan.create(replan));
+      }
+    })();
+    this.pending.add(work);
+    work.finally(() => this.pending.delete(work));
+    await work;
+  }
+  async evaluateWithLlm(failure) {
+    const snap = this.opts.snapshot();
+    const userPrompt = buildSurgeonPrompt(snap, failure);
+    const prompt = `${SURGEON_SYSTEM_PROMPT}
+
+${userPrompt}`;
+    try {
+      const text = await runCodexOneShot({
+        prompt,
+        cwd: process.cwd(),
+        skipGitRepoCheck: true,
+        bypassSandbox: true,
+        model: this.opts.model,
+        codexBin: this.opts.codexBin,
+        timeoutMs: this.opts.timeoutMs,
+        label: "codex-surgeon"
+      });
+      const verdictText = text.trim();
+      if (!verdictText) throw new Error("empty result");
+      const verdictJson = extractJsonObject(verdictText);
+      const parsed = JSON.parse(verdictJson);
+      if (parsed.action === "abort") return null;
+      const modifiedDeps = {};
+      for (const m of parsed.modifiedDeps ?? []) {
+        if (typeof m.id === "string" && Array.isArray(m.newDependsOn)) {
+          modifiedDeps[m.id] = [...m.newDependsOn];
+        }
+      }
+      return {
+        source: "surgeon",
+        reason: `${parsed.action}: ${parsed.reason ?? ""}`,
+        addedStories: parsed.added ?? [],
+        removedStoryIds: parsed.removed ?? [],
+        modifiedDeps
+      };
+    } catch (err) {
+      const fallback = surgeonDeterministicReplan(failure);
+      return {
+        ...fallback,
+        reason: `${fallback.reason} (codex fallback after error: ${err?.message ?? String(err)})`
+      };
+    }
+  }
+};
+
 // ../baro-orchestrator/src/participants/surgeon-openai.ts
 function pickModel3(name) {
   switch (name) {
@@ -14173,7 +14473,7 @@ async function orchestrate(config) {
     );
   } 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"
+      "[orchestrate] llm=codex: every LLM phase shells out to `codex exec --json` (ChatGPT subscription path). Architect / Planner / Critic / Surgeon / StoryAgent all running through Codex.\n"
     );
   } else {
     process.stderr.write(
@@ -14218,14 +14518,24 @@ async function orchestrate(config) {
         }))
       };
     };
-    surgeon = llm === "openai" ? new SurgeonOpenAI({
-      snapshot,
-      model: config.surgeonModel ?? "gpt-5.5"
-    }) : new Surgeon({
-      snapshot,
-      useLlm: config.surgeonUseLlm ?? false,
-      model: config.surgeonModel ?? "opus"
-    });
+    if (llm === "openai") {
+      surgeon = new SurgeonOpenAI({
+        snapshot,
+        model: config.surgeonModel ?? "gpt-5.5"
+      });
+    } else if (llm === "codex") {
+      surgeon = new SurgeonCodex({
+        snapshot,
+        useLlm: config.surgeonUseLlm ?? true,
+        model: config.surgeonModel
+      });
+    } else {
+      surgeon = new Surgeon({
+        snapshot,
+        useLlm: config.surgeonUseLlm ?? false,
+        model: config.surgeonModel ?? "opus"
+      });
+    }
     surgeon.join(env);
   }
   let critic = null;
@@ -14234,13 +14544,22 @@ async function orchestrate(config) {
     const targets = new Map(
       prd.userStories.filter((s) => s.acceptance && s.acceptance.length > 0).map((s) => [s.id, s.acceptance])
     );
-    critic = llm === "openai" ? new CriticOpenAI({
-      targets,
-      model: config.criticModel ?? "gpt-5.4-mini"
-    }) : new Critic({
-      targets,
-      model: config.criticModel ?? "haiku"
-    });
+    if (llm === "openai") {
+      critic = new CriticOpenAI({
+        targets,
+        model: config.criticModel ?? "gpt-5.4-mini"
+      });
+    } else if (llm === "codex") {
+      critic = new CriticCodex({
+        targets,
+        model: config.criticModel
+      });
+    } else {
+      critic = new Critic({
+        targets,
+        model: config.criticModel ?? "haiku"
+      });
+    }
     critic.join(env);
   }
   const finalizer = useGit ? new Finalizer({