baro-ai 0.70.11 → 0.70.13

package/dist/run-planner.mjs

@@ -22283,38 +22283,29 @@ If the goal is NON-TRIVIAL: decompose normally per the rules below.
 When in doubt, prefer FEWER stories over more. A single 2-file story is better
 than two artificially-split 1-file stories.
 
-PARALLELISM IS THE WHOLE POINT \u2014 DO NOT BUILD LINEAR CHAINS:
-baro spawns one agent per DAG level concurrently. A plan where every story
-depends on the previous one (S1 \u2192 S2 \u2192 S3 \u2192 S4 \u2192 S5) collapses that into a
-sequential run and wastes the orchestrator. This is a BUG in the plan, not a
-feature. Treat \`dependsOn\` as expensive: every edge you add removes a parallel
-slot. Only add a dependency when story B literally cannot start until A is
-merged because B imports a symbol A defines, modifies a file A creates, or
-relies on a schema A introduces.
-
-Heuristics for parallel-friendly DAGs:
-  - Stories touching disjoint files/modules \u2192 NO dependency, same level.
-  - Multiple provider/integration/feature variants of the same shape (e.g.
-    "Add provider X", "Add provider Y", "Add provider Z" after a shared
-    abstraction exists) \u2192 all parallel siblings.
-  - Tests, docs, and config changes that don't read newly-introduced symbols
-    \u2192 usually parallel to the implementation, not downstream of it.
-  - "Wiring" stories that connect already-existing pieces \u2192 depend only on
-    the pieces they actually wire, not on every prior story.
-
-Anti-patterns (DO NOT DO):
-  - Decorative chains: S2 dependsOn S1, S3 dependsOn S2, S4 dependsOn S3 with
-    no real symbol/import/schema reason. If you cannot name the specific
-    symbol or file that forces the order, REMOVE the edge.
-  - "S1 = setup, then everything dependsOn S1" when S1 only adds an
-    interface/abstraction the other stories don't actually consume.
-  - One-story-per-level "staircase" plans for goals that obviously have
-    independent pieces (e.g. five new providers, three new endpoints, four
-    new components).
-
-Target shape: most non-trivial plans should have AT LEAST one DAG level with
-2+ siblings. If your output is a single linear chain, re-examine \u2014 you almost
-certainly over-specified \`dependsOn\`.
+RUN SHAPE:
+baro can run focused, sequential, or parallel work. Parallelism is valuable only
+when stories have independent write surfaces. Do NOT create parallel stories
+that edit the same file, component, state machine, schema, or API contract.
+
+Mode semantics:
+  - focused: exactly one story. Use this for one bug, one UI/component issue,
+    one failing build/runtime error, or anything likely centered on a shared
+    file/surface. The story should carry enough context to finish the PR.
+  - sequential: several small stories with real dependencies. Use this when the
+    work is one feature that must be implemented in ordered steps.
+  - parallel: a DAG with sibling stories only where you can prove independence
+    (different files/modules/contracts). Parallelism requires a reason; do not
+    fan out just to use agents.
+
+Dependency rules:
+  - Stories touching disjoint files/modules may run in parallel.
+  - Stories touching the same file/component/state/API must be sequential or one
+    focused story.
+  - Only add dependsOn when story B literally cannot start until A is merged
+    because B imports a symbol A defines, modifies a file A creates, or relies
+    on a schema/API A introduces.
+  - Decorative chains are bad, but unsafe parallel edits are worse.
 
 Output ONLY valid JSON matching this exact schema (no markdown, no explanation, just JSON):
 {
@@ -22375,6 +22366,139 @@ Rules:
 - IDs: S1, S2, S3...
 - Build on existing code, don't recreate what exists
 - Output ONLY the JSON, nothing else`;
+function heuristicModeContract(args) {
+  if (args.quick) {
+    return {
+      mode: "focused",
+      confidence: 1,
+      reason: "Quick mode was explicitly requested.",
+      maxStories: 1,
+      parallelism: 1
+    };
+  }
+  const goal = args.goal.toLowerCase();
+  const bugLike = /\b(fix|bug|error|crash|broken|console|build|doesn'?t|isn'?t|still|again|issue|problem|wrong|shifted|display|render)\b/.test(goal);
+  const uiLike = /\b(ui|frontend|react|component|button|card|tab|modal|page|screen|css|style|layout|episode|season)\b/.test(goal);
+  const bigLike = /\b(refactor|rewrite|migrate|redesign|implement|add support|multiple|several|backend|frontend|database|api|tests|docs)\b/.test(goal);
+  if (bugLike || uiLike && !bigLike) {
+    return {
+      mode: "focused",
+      confidence: 0.7,
+      reason: "The goal looks like a localized bugfix/follow-up likely centered on shared UI or one code surface.",
+      maxStories: 1,
+      parallelism: 1
+    };
+  }
+  if (bigLike) {
+    return {
+      mode: "sequential",
+      confidence: 0.55,
+      reason: "The goal may need multiple steps, but no LLM intake proved independent write surfaces.",
+      maxStories: 5,
+      parallelism: 1
+    };
+  }
+  return {
+    mode: "focused",
+    confidence: 0.5,
+    reason: "Uncertain goals default to focused mode to avoid unsafe parallel decomposition.",
+    maxStories: 1,
+    parallelism: 1
+  };
+}
+function renderModeContract(decision) {
+  const lines = [
+    `mode: ${decision.mode}`,
+    `confidence: ${decision.confidence}`,
+    `reason: ${decision.reason}`
+  ];
+  if (decision.maxStories) lines.push(`maxStories: ${decision.maxStories}`);
+  if (decision.parallelism) lines.push(`parallelism: ${decision.parallelism}`);
+  if (decision.mode === "focused") {
+    lines.push(
+      'Planner rules: output EXACTLY ONE story. Do not split. Set model to "opus" so this focused run uses the strong route.',
+      "The story must include enough implementation context and acceptance criteria for one agent to finish the PR."
+    );
+  } else if (decision.mode === "sequential") {
+    lines.push(
+      "Planner rules: output a small ordered chain. Use dependsOn for real shared-surface dependencies.",
+      "Do not create parallel siblings that edit the same file/component/state/API. Keep each story cheap-model-capable."
+    );
+  } else {
+    lines.push(
+      "Planner rules: output parallel siblings only where write surfaces are independent.",
+      "For each sibling story, name its expected write surface in the description. Shared files/components must be sequential."
+    );
+  }
+  return lines.join("\n");
+}
+function buildIntakePrompt(args) {
+  if (args.quick) {
+    return JSON.stringify({
+      mode: "focused",
+      confidence: 1,
+      reason: "Quick mode was explicitly requested.",
+      maxStories: 1,
+      parallelism: 1
+    });
+  }
+  return [
+    "You are Baro Intake. Choose the execution shape BEFORE planning.",
+    "",
+    "Return ONLY valid JSON with this schema:",
+    '{"mode":"focused|sequential|parallel","confidence":0.0,"reason":"short","maxStories":1,"parallelism":1}',
+    "",
+    "Definitions:",
+    "- focused: one strong agent/story. Use for small bugfixes, UI tweaks, build/runtime errors, one component/file/surface, or unclear shared-write work.",
+    "- sequential: multiple small ordered stories. Use when one feature naturally requires steps that touch shared code.",
+    "- parallel: only when there are independent write surfaces (different modules/files/contracts) that can safely run at the same time.",
+    "",
+    "Bias rules:",
+    "- If several agents would edit the same file/component/state/schema, choose focused or sequential, not parallel.",
+    "- If the prompt is a follow-up bug report from screenshots/console output, choose focused unless it clearly spans independent surfaces.",
+    "- If uncertain, choose focused. Unsafe parallelism is worse than leaving speed on the table.",
+    "- maxStories is a cap for the planner, not a target.",
+    "",
+    args.projectContext?.trim() ? `Project context summary:
+${args.projectContext.trim().slice(0, 3e3)}
+` : "",
+    args.decisionDocument?.trim() ? `Architect decision exists; prefer a compact plan that implements it.
+${args.decisionDocument.trim().slice(0, 3e3)}
+` : "",
+    `User goal:
+${args.goal.trim()}`
+  ].filter(Boolean).join("\n");
+}
+function parseModeContract(text) {
+  const json = JSON.parse(extractJsonObject(text));
+  const mode = json.mode === "parallel" || json.mode === "sequential" || json.mode === "focused" ? json.mode : "focused";
+  const confidence = Number.isFinite(Number(json.confidence)) ? Math.max(0, Math.min(1, Number(json.confidence))) : 0.5;
+  return {
+    mode,
+    confidence,
+    reason: typeof json.reason === "string" && json.reason.trim() ? json.reason.trim() : "No reason supplied by intake.",
+    maxStories: Number.isFinite(Number(json.maxStories)) ? Math.max(1, Math.floor(Number(json.maxStories))) : void 0,
+    parallelism: Number.isFinite(Number(json.parallelism)) ? Math.max(1, Math.floor(Number(json.parallelism))) : void 0
+  };
+}
+function extractJsonObject(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
+  const fence = trimmed.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+  if (fence) return fence[1];
+  const start = trimmed.indexOf("{");
+  if (start < 0) throw new Error(`no JSON object in response: ${trimmed.slice(0, 200)}`);
+  let depth = 0;
+  for (let i2 = start; i2 < trimmed.length; i2++) {
+    const ch = trimmed[i2];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return trimmed.slice(start, i2 + 1);
+    }
+  }
+  throw new Error(`unbalanced JSON in response: ${trimmed.slice(0, 200)}`);
+}
 function buildPlannerUserMessage(args) {
   const sections = [];
   if (args.projectContext && args.projectContext.trim().length > 0) {
@@ -22395,6 +22519,15 @@ function buildPlannerUserMessage(args) {
     sections.push("---");
     sections.push("");
   }
+  const modeContract = typeof args.modeContract === "string" ? args.modeContract : args.modeContract ? renderModeContract(args.modeContract) : void 0;
+  if (modeContract && modeContract.trim().length > 0) {
+    sections.push("EXECUTION MODE CONTRACT (chosen by Baro Intake \u2014 obey it):");
+    sections.push("");
+    sections.push(modeContract.trim());
+    sections.push("");
+    sections.push("---");
+    sections.push("");
+  }
   if (args.quick) {
     sections.push(
       "QUICK MODE OVERRIDE \u2014 the user invoked `baro --quick`. They have told us this goal is trivial. You MUST output EXACTLY ONE story. Do not split. Do not decompose. Do not add a `verify` story. If you genuinely cannot do this in one story, emit the one story anyway with a description that explains what's missing; the user will rerun without --quick. One story, tight acceptance, minimum useful test command."
@@ -22424,11 +22557,19 @@ function effortTimeoutMs(effort) {
   }
 }
 async function runPlannerClaude(opts) {
+  const modeContract = await runClaudeIntake(opts).catch((e2) => {
+    process.stderr.write(`[planner-claude] intake failed (${e2?.message ?? String(e2)}) \u2014 using heuristic mode contract
+`);
+    return heuristicModeContract(opts);
+  });
+  process.stderr.write(`[planner-claude] intake mode=${modeContract.mode} confidence=${modeContract.confidence}
+`);
   const userMessage = buildPlannerUserMessage({
     goal: opts.goal,
     decisionDocument: opts.decisionDocument,
     quick: opts.quick,
-    projectContext: opts.projectContext
+    projectContext: opts.projectContext,
+    modeContract
   });
   const { stdout } = await execFileAsync(
     opts.claudeBin ?? "claude",
@@ -22456,9 +22597,37 @@ async function runPlannerClaude(opts) {
   if (!planText) {
     throw new Error("PlannerClaude: claude returned empty result");
   }
-  return extractJsonObject(planText);
+  return extractJsonObject2(planText);
 }
-function extractJsonObject(text) {
+async function runClaudeIntake(opts) {
+  if (opts.quick) return heuristicModeContract(opts);
+  const { stdout } = await execFileAsync(
+    opts.claudeBin ?? "claude",
+    [
+      "--print",
+      "--output-format",
+      "json",
+      ...opts.model ? ["--model", opts.model] : [],
+      ...opts.effort ? ["--effort", opts.effort] : [],
+      "--permission-mode",
+      "bypassPermissions",
+      "--system-prompt",
+      "You classify software tasks for an autonomous PR workflow. Output JSON only.",
+      "-p",
+      buildIntakePrompt(opts)
+    ],
+    {
+      cwd: opts.cwd,
+      timeout: Math.min(opts.timeoutMs ?? effortTimeoutMs(opts.effort), 18e4),
+      maxBuffer: 2 * 1024 * 1024
+    }
+  );
+  const wrapper = JSON.parse(stdout);
+  const text = typeof wrapper.result === "string" ? wrapper.result.trim() : "";
+  if (!text) throw new Error("empty intake result");
+  return parseModeContract(text);
+}
+function extractJsonObject2(text) {
   const trimmed = text.trim();
   if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
   const fence = trimmed.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
@@ -22603,11 +22772,19 @@ ${item.text}` : item.text;
 
 // ../baro-orchestrator/src/planning/planner-codex.ts
 async function runPlannerCodex(opts) {
+  const modeContract = await runCodexIntake(opts).catch((e2) => {
+    process.stderr.write(`[planner-codex] intake failed (${e2?.message ?? String(e2)}) \u2014 using heuristic mode contract
+`);
+    return heuristicModeContract(opts);
+  });
+  process.stderr.write(`[planner-codex] intake mode=${modeContract.mode} confidence=${modeContract.confidence}
+`);
   const userMessage = buildPlannerUserMessage({
     goal: opts.goal,
     decisionDocument: opts.decisionDocument,
     quick: opts.quick,
-    projectContext: opts.projectContext
+    projectContext: opts.projectContext,
+    modeContract
   });
   const prompt = `${PLANNER_SYSTEM_PROMPT}
 
@@ -22624,9 +22801,23 @@ ${userMessage}`;
   if (!planText) {
     throw new Error("PlannerCodex: codex returned empty result");
   }
-  return extractJsonObject2(planText);
+  return extractJsonObject3(planText);
 }
-function extractJsonObject2(text) {
+async function runCodexIntake(opts) {
+  if (opts.quick) return heuristicModeContract(opts);
+  const text = await runCodexOneShot({
+    prompt: `You classify software tasks for an autonomous PR workflow. Output JSON only.
+
+${buildIntakePrompt(opts)}`,
+    cwd: opts.cwd,
+    model: opts.model,
+    codexBin: opts.codexBin,
+    timeoutMs: Math.min(opts.timeoutMs ?? 9e5, 18e4),
+    label: "codex-intake"
+  });
+  return parseModeContract(text.trim());
+}
+function extractJsonObject3(text) {
   const trimmed = text.trim();
   if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
   const fence = trimmed.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
@@ -40110,6 +40301,19 @@ function pickModel(name) {
 }
 async function runPlannerOpenAI(opts) {
   const model = pickModel(opts.model ?? "gpt-5.5");
+  const intake = await decideExecutionMode(opts, model).catch((e2) => {
+    process.stderr.write(`[planner-openai] intake failed (${e2?.message ?? String(e2)}) \u2014 defaulting to focused
+`);
+    return {
+      mode: "focused",
+      confidence: 0,
+      reason: "Intake failed, so Baro uses the conservative focused mode instead of unsafe parallel decomposition.",
+      maxStories: 1,
+      parallelism: 1
+    };
+  });
+  process.stderr.write(`[planner-openai] intake mode=${intake.mode} confidence=${intake.confidence} reason=${oneLine(intake.reason).slice(0, 180)}
+`);
   const tools = createCodebaseTools(opts.cwd);
   setModelTools(model, tools);
   let context = ModelContext.create("planner").addContextItem(SystemMessageItem.create(PLANNER_SYSTEM_PROMPT)).addContextItem(
@@ -40118,7 +40322,8 @@ async function runPlannerOpenAI(opts) {
         goal: opts.goal,
         decisionDocument: opts.decisionDocument,
         quick: opts.quick,
-        projectContext: opts.projectContext
+        projectContext: opts.projectContext,
+        modeContract: renderModeContract(intake)
       })
     )
   );
@@ -40187,7 +40392,7 @@ async function runPlannerOpenAI(opts) {
       process.stderr.write(`[planner-openai] ${usage.summary()}
 `);
       try {
-        return extractJsonObject3(raw);
+        return extractJsonObject(raw);
       } catch (e2) {
         process.stderr.write(`[planner-openai] invalid final JSON (${e2?.message ?? String(e2)}) \u2014 using fallback PRD
 `);
@@ -40199,6 +40404,24 @@ async function runPlannerOpenAI(opts) {
 `);
   return fallbackPrdJson(opts.goal, `Planner exceeded maxRounds=${maxRounds} without producing a final plan.`);
 }
+async function decideExecutionMode(opts, plannerModel) {
+  if (opts.quick) {
+    return {
+      mode: "focused",
+      confidence: 1,
+      reason: "The user explicitly invoked quick mode.",
+      maxStories: 1,
+      parallelism: 1
+    };
+  }
+  const intakeModel = pickModel(process.env.BARO_INTAKE_MODEL || plannerModel.specification.name);
+  setModelTools(intakeModel, []);
+  const prompt = buildIntakePrompt(opts);
+  const context = ModelContext.create("intake").addContextItem(SystemMessageItem.create("You classify software tasks for an autonomous PR workflow. Output JSON only.")).addContextItem(UserMessageItem.create(prompt));
+  const result = await runInferenceRound(context, intakeModel);
+  const raw = result.items.filter((i2) => i2.type === "message").map((i2) => i2.toJSON().content?.[0]?.text ?? "").join("\n").trim();
+  return parseModeContract(raw);
+}
 function numberEnv(name, fallback) {
   const n = Number(process.env[name]);
   return Number.isFinite(n) && n > 0 ? n : fallback;
@@ -40264,26 +40487,6 @@ function setModelTools(model, tools) {
   }
   m2.setTools(tools);
 }
-function extractJsonObject3(text) {
-  const trimmed = text.trim();
-  if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
-  const fence = trimmed.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
-  if (fence) return fence[1];
-  const start = trimmed.indexOf("{");
-  if (start < 0) {
-    throw new Error(`PlannerOpenAI: no JSON object in response: ${trimmed.slice(0, 200)}`);
-  }
-  let depth = 0;
-  for (let i2 = start; i2 < trimmed.length; i2++) {
-    const ch = trimmed[i2];
-    if (ch === "{") depth++;
-    else if (ch === "}") {
-      depth--;
-      if (depth === 0) return trimmed.slice(start, i2 + 1);
-    }
-  }
-  throw new Error(`PlannerOpenAI: unbalanced JSON in response: ${trimmed.slice(0, 200)}`);
-}
 
 // ../baro-orchestrator/src/opencode-one-shot.ts
 import { spawn as spawn2 } from "child_process";
@@ -40407,11 +40610,19 @@ ${part.text}` : part.text;
 
 // ../baro-orchestrator/src/planning/planner-opencode.ts
 async function runPlannerOpenCode(opts) {
+  const modeContract = await runOpenCodeIntake(opts).catch((e2) => {
+    process.stderr.write(`[planner-opencode] intake failed (${e2?.message ?? String(e2)}) \u2014 using heuristic mode contract
+`);
+    return heuristicModeContract(opts);
+  });
+  process.stderr.write(`[planner-opencode] intake mode=${modeContract.mode} confidence=${modeContract.confidence}
+`);
   const userMessage = buildPlannerUserMessage({
     goal: opts.goal,
     decisionDocument: opts.decisionDocument,
     quick: opts.quick,
-    projectContext: opts.projectContext
+    projectContext: opts.projectContext,
+    modeContract
   });
   const prompt = `${PLANNER_SYSTEM_PROMPT}
 
@@ -40430,6 +40641,20 @@ ${userMessage}`;
   }
   return extractJsonObject4(planText);
 }
+async function runOpenCodeIntake(opts) {
+  if (opts.quick) return heuristicModeContract(opts);
+  const text = await runOpenCodeOneShot({
+    prompt: `You classify software tasks for an autonomous PR workflow. Output JSON only.
+
+${buildIntakePrompt(opts)}`,
+    cwd: opts.cwd,
+    model: opts.model,
+    opencodeBin: opts.opencodeBin,
+    timeoutMs: Math.min(opts.timeoutMs ?? 9e5, 18e4),
+    label: "opencode-intake"
+  });
+  return parseModeContract(text.trim());
+}
 function extractJsonObject4(text) {
   const trimmed = text.trim();
   if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
@@ -40623,11 +40848,19 @@ ${block.text}` : block.text;
 
 // ../baro-orchestrator/src/planning/planner-pi.ts
 async function runPlannerPi(opts) {
+  const modeContract = await runPiIntake(opts).catch((e2) => {
+    process.stderr.write(`[planner-pi] intake failed (${e2?.message ?? String(e2)}) \u2014 using heuristic mode contract
+`);
+    return heuristicModeContract(opts);
+  });
+  process.stderr.write(`[planner-pi] intake mode=${modeContract.mode} confidence=${modeContract.confidence}
+`);
   const userMessage = buildPlannerUserMessage({
     goal: opts.goal,
     decisionDocument: opts.decisionDocument,
     quick: opts.quick,
-    projectContext: opts.projectContext
+    projectContext: opts.projectContext,
+    modeContract
   });
   const prompt = `${PLANNER_SYSTEM_PROMPT}
 
@@ -40647,6 +40880,21 @@ ${userMessage}`;
   }
   return extractJsonObject5(planText);
 }
+async function runPiIntake(opts) {
+  if (opts.quick) return heuristicModeContract(opts);
+  const text = await runPiOneShot({
+    prompt: `You classify software tasks for an autonomous PR workflow. Output JSON only.
+
+${buildIntakePrompt(opts)}`,
+    cwd: opts.cwd,
+    provider: opts.provider,
+    model: opts.model,
+    piBin: opts.piBin,
+    timeoutMs: Math.min(opts.timeoutMs ?? 9e5, 18e4),
+    label: "pi-intake"
+  });
+  return parseModeContract(text.trim());
+}
 function extractJsonObject5(text) {
   const trimmed = text.trim();
   if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;