@brainbase-labs/cli 0.54.0 → 0.55.0

package/dist/index.js

@@ -35184,7 +35184,7 @@ var require_dist2 = __commonJS((exports, module) => {
 // src/index.ts
 var import_picocolors81 = __toESM(require_picocolors(), 1);
 import process14 from "node:process";
-import fs94 from "node:fs";
+import fs96 from "node:fs";
 
 // src/cli/template.ts
 var import_picocolors12 = __toESM(require_picocolors(), 1);
@@ -36091,7 +36091,7 @@ function padStart(s, n) {
 // package.json
 var package_default = {
   name: "@brainbase-labs/cli",
-  version: "0.54.0",
+  version: "0.55.0",
   description: "Pack, share, and install agent templates across harnesses (Claude Code, Codex, ...).",
   type: "module",
   bin: {
@@ -82445,6 +82445,10 @@ var SyncedScheduleTriggerSchema = exports_external.object({
   node_id: exports_external.string(),
   hash: exports_external.string()
 });
+var SyncedDecisionSchema = exports_external.object({
+  id: exports_external.string(),
+  hash: exports_external.string()
+});
 var SyncedOrchestrationMetaSchema = exports_external.object({
   name: exports_external.string().optional(),
   description: exports_external.string().optional(),
@@ -82460,6 +82464,7 @@ var OrchestrationSyncStateSchema = exports_external.object({
   members: exports_external.array(SyncedMemberSchema),
   edges: exports_external.array(SyncedEdgeSchema),
   triggers: exports_external.array(SyncedScheduleTriggerSchema).optional(),
+  decisions: exports_external.array(SyncedDecisionSchema).optional(),
   meta: SyncedOrchestrationMetaSchema.optional()
 });
 function orchLinkPath(cwd2) {
@@ -82881,6 +82886,9 @@ var TriggerEdgeSchema = exports_external.object({
   payload_schema: exports_external.record(exports_external.unknown()).optional()
 });
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function canonicalUuid2(value2) {
+  return UUID_RE.test(value2) ? value2.toLowerCase() : value2;
+}
 var ScheduleTriggerSchema = exports_external.object({
   type: exports_external.literal("schedule"),
   node_id: exports_external.string().regex(UUID_RE, "must be a UUID"),
@@ -82898,12 +82906,52 @@ var ReadOnlyTriggerSchema = exports_external.object({
   to: exports_external.array(TriggerEdgeSchema).default([])
 });
 var TriggerSchema = exports_external.union([ScheduleTriggerSchema, ReadOnlyTriggerSchema]);
+var DECISION_MODELS = [
+  "jev",
+  "kev-4b",
+  "clef",
+  "clef-flash",
+  "gpt-6-luna"
+];
+var DEFAULT_DECISION_MODEL = "clef-flash";
+var DECISION_LIMITS = {
+  name: 200,
+  model: 100,
+  instructions: 4000,
+  answersMin: 2,
+  answersMax: 20,
+  answer: 200,
+  criterion: 1000
+};
+var DecisionTargetSchema = exports_external.object({
+  agent: exports_external.string().min(1).optional(),
+  decision: exports_external.string().regex(UUID_RE, "must be a UUID").optional(),
+  description: exports_external.string().optional()
+}).refine((t) => t.agent === undefined !== (t.decision === undefined), {
+  message: "set exactly one of agent or decision"
+});
+var DecisionAnswerSchema = exports_external.object({
+  answer: exports_external.string(),
+  criterion: exports_external.string().optional(),
+  to: exports_external.array(DecisionTargetSchema).default([])
+});
+var DecisionSchema = exports_external.object({
+  id: exports_external.string().regex(UUID_RE, "must be a UUID"),
+  name: exports_external.string(),
+  model: exports_external.string().optional(),
+  instructions: exports_external.string().optional(),
+  confidence_threshold: exports_external.number().min(0).max(1).nullable().optional(),
+  from: exports_external.array(exports_external.object({ trigger: exports_external.string().regex(UUID_RE, "must be a UUID") })).default([]),
+  answers: exports_external.array(DecisionAnswerSchema),
+  fallback: exports_external.array(DecisionTargetSchema).default([])
+});
 var OrchestrationManifestSchema = exports_external.object({
   schema: exports_external.literal(1),
   orchestration: OrchMetaSchema,
   members: exports_external.array(MemberSchema).default([]),
   edges: exports_external.array(EdgeSchema).default([]),
-  triggers: exports_external.array(TriggerSchema).optional()
+  triggers: exports_external.array(TriggerSchema).optional(),
+  decisions: exports_external.array(DecisionSchema).optional()
 });
 function orchManifestPath(cwd2) {
   return path96.join(cwd2, ORCH_MANIFEST_FILE);
@@ -83328,6 +83376,132 @@ function syncedScheduleTriggers(triggers) {
     hash: scheduleTriggerHash(t)
   }));
 }
+var DECISION = "decision";
+function manifestDecisions(manifest, slugToAgentId) {
+  const target = (t) => {
+    const agentId = t.agent !== undefined ? slugToAgentId?.get(t.agent) : undefined;
+    return {
+      ...t.agent !== undefined ? { agent: t.agent, ...agentId ? { agent_id: agentId } : {} } : { decision: canonicalUuid2(t.decision) },
+      description: t.description ?? ""
+    };
+  };
+  return (manifest?.decisions ?? []).map((d3) => ({
+    id: canonicalUuid2(d3.id),
+    name: d3.name.trim(),
+    model: (d3.model ?? DEFAULT_DECISION_MODEL).trim(),
+    instructions: d3.instructions ?? "",
+    confidence_threshold: d3.confidence_threshold ?? null,
+    triggers: d3.from.map((f4) => canonicalUuid2(f4.trigger)),
+    answers: d3.answers.map((a3) => ({
+      answer: a3.answer.trim(),
+      criterion: (a3.criterion ?? "").trim(),
+      to: a3.to.map(target)
+    })),
+    fallback: d3.fallback.map(target)
+  }));
+}
+function liveDecisionLinks(cloud) {
+  const agents = new Set(cloud.members.map((m3) => m3.agent_id));
+  const decisions = new Set((cloud.decisions ?? []).map((d3) => canonicalUuid2(d3.id)));
+  const triggers = new Set((cloud.triggers ?? []).map((t) => canonicalUuid2(t.node_id)));
+  return (d3) => {
+    const answers = new Set(d3.answers.map((a3) => a3.answer));
+    return {
+      routes: d3.routes.filter((r2) => (r2.is_fallback || r2.answer != null && answers.has(r2.answer)) && (r2.to_agent_id ? agents.has(r2.to_agent_id) : r2.to_decision_id != null && decisions.has(canonicalUuid2(r2.to_decision_id)))),
+      inputs: d3.inputs.filter((i) => triggers.has(canonicalUuid2(i.from_trigger_node_id)))
+    };
+  };
+}
+function cloudDecisions(cloud, slugForAgent) {
+  if (cloud.decisions == null)
+    return null;
+  const live = liveDecisionLinks(cloud);
+  return cloud.decisions.map((d3) => {
+    const { routes, inputs } = live(d3);
+    const target = (r2) => ({
+      ...r2.to_agent_id ? {
+        agent: slugForAgent(r2.to_agent_id, r2.to_slug ?? r2.to_agent_id),
+        agent_id: r2.to_agent_id
+      } : { decision: canonicalUuid2(r2.to_decision_id) },
+      description: r2.description ?? ""
+    });
+    return {
+      id: canonicalUuid2(d3.id),
+      name: d3.name.trim(),
+      model: d3.model.trim(),
+      instructions: d3.instructions ?? "",
+      confidence_threshold: d3.confidence_threshold ?? null,
+      triggers: inputs.map((i) => canonicalUuid2(i.from_trigger_node_id)),
+      answers: d3.answers.map((a3) => ({
+        answer: a3.answer.trim(),
+        criterion: (a3.criterion ?? "").trim(),
+        to: routes.filter((r2) => !r2.is_fallback && r2.answer === a3.answer).map(target)
+      })),
+      fallback: routes.filter((r2) => r2.is_fallback).map(target)
+    };
+  });
+}
+function deadDecisionLinks(cloud) {
+  const live = liveDecisionLinks(cloud);
+  const out = new Map;
+  for (const d3 of cloud.decisions ?? []) {
+    const { routes, inputs } = live(d3);
+    const dead = d3.routes.length - routes.length + d3.inputs.length - inputs.length;
+    if (dead > 0)
+      out.set(d3.id, dead);
+  }
+  return out;
+}
+function decisionHash(d3) {
+  const targets = (ts2) => ts2.map(({ agent, agent_id, ...rest2 }) => stableJson(agent_id !== undefined ? { agent_id, ...rest2 } : { agent, ...rest2 })).sort();
+  const canonical = {
+    name: d3.name,
+    model: d3.model,
+    instructions: d3.instructions,
+    confidence_threshold: d3.confidence_threshold,
+    triggers: [...d3.triggers].sort(),
+    answers: d3.answers.map((a3) => ({
+      answer: a3.answer,
+      criterion: a3.criterion,
+      to: targets(a3.to)
+    })),
+    fallback: targets(d3.fallback)
+  };
+  return crypto6.createHash("sha256").update(stableJson(canonical)).digest("hex");
+}
+function decisionLabel(d3) {
+  return `decision "${d3.name}" (${d3.id})`;
+}
+function decideDecisionReconcile(input) {
+  const rows = threeWayDiff({
+    local: input.local.map((d3) => ({
+      type: DECISION,
+      slug: d3.id,
+      hash: decisionHash(d3)
+    })),
+    lock: (input.baseline ?? []).map((d3) => ({
+      type: DECISION,
+      slug: d3.id,
+      hash: d3.hash,
+      installedPaths: []
+    })),
+    cloud: input.cloud.map((d3) => ({
+      type: DECISION,
+      slug: d3.id,
+      hash: decisionHash(d3),
+      files: []
+    }))
+  });
+  return decideCollectionReconcile({
+    rows,
+    type: DECISION,
+    claims: input.local.length > 0,
+    force: input.force
+  });
+}
+function syncedDecisions(decisions) {
+  return decisions.map((d3) => ({ id: d3.id, hash: decisionHash(d3) }));
+}
 var ORCH_META_FIELDS = [
   "name",
   "description",
@@ -83410,6 +83584,26 @@ function triggersForManifest(triggers, slugFor) {
     };
   });
 }
+function decisionsForManifest(decisions) {
+  const target = (t) => ({
+    ...t.agent !== undefined ? { agent: t.agent } : { decision: t.decision },
+    ...t.description ? { description: t.description } : {}
+  });
+  return decisions.map((d3) => ({
+    id: d3.id,
+    name: d3.name,
+    model: d3.model,
+    ...d3.instructions ? { instructions: d3.instructions } : {},
+    ...d3.confidence_threshold != null ? { confidence_threshold: d3.confidence_threshold } : {},
+    ...d3.triggers.length ? { from: d3.triggers.map((trigger) => ({ trigger })) } : {},
+    answers: d3.answers.map((a3) => ({
+      answer: a3.answer,
+      ...a3.criterion ? { criterion: a3.criterion } : {},
+      ...a3.to.length ? { to: a3.to.map(target) } : {}
+    })),
+    ...d3.fallback.length ? { fallback: d3.fallback.map(target) } : {}
+  }));
+}
 async function runOrchestrationPull(cwd2, args) {
   banner("orchestration pull — fetch orchestration + all member agents");
   let orchId = null;
@@ -83460,6 +83654,14 @@ async function runOrchestrationPull(cwd2, args) {
       planLines.push(`    ${import_picocolors52.default.cyan(from)} ${import_picocolors52.default.dim("→")} ${import_picocolors52.default.cyan(to2)}${desc}`);
     }
   }
+  const pulledDecisions = cloudDecisions(cloud, (agentId, fallback) => slugByAgent.get(agentId) ?? fallback);
+  if (pulledDecisions?.length) {
+    planLines.push("");
+    planLines.push(`  ${import_picocolors52.default.dim("decisions:")}`);
+    for (const d3 of pulledDecisions) {
+      planLines.push(`    ${import_picocolors52.default.cyan("◆")} ${import_picocolors52.default.bold(d3.name)} ${import_picocolors52.default.dim(`(${d3.model}, ${d3.answers.length} answers)`)}`);
+    }
+  }
   planLines.push("");
   console.log(planLines.join(`
 `));
@@ -83525,6 +83727,19 @@ async function runOrchestrationPull(cwd2, args) {
     }
   }
   const manifestTriggers = triggersForManifest(cloud.triggers ?? [], slugFor);
+  let manifestDecisions2 = pulledDecisions ? decisionsForManifest(pulledDecisions) : undefined;
+  let decisionBaseline = pulledDecisions ? syncedDecisions(pulledDecisions) : undefined;
+  if (!pulledDecisions) {
+    try {
+      manifestDecisions2 = readOrchManifest(cwd2)?.decisions;
+    } catch {}
+    const lock = readOrchSyncState(cwd2);
+    decisionBaseline = lock?.orchestration_id === cloud.id ? lock.decisions : undefined;
+  }
+  for (const [decisionId, count] of deadDecisionLinks(cloud)) {
+    const name = pulledDecisions?.find((d3) => d3.id === decisionId)?.name;
+    f2.warn(`Decision ${import_picocolors52.default.bold(name ?? decisionId)} has ${count} route${count === 1 ? "" : "s"} or input${count === 1 ? "" : "s"} that lead${count === 1 ? "s" : ""} nowhere: on an answer it no longer has, or to an agent, decision or trigger no longer in this orchestration. They never run and are not in ${import_picocolors52.default.bold("brainbase-orchestration.yaml")}; the next push of decisions removes them.`);
+  }
   const manifest = {
     schema: 1,
     orchestration: {
@@ -83548,7 +83763,8 @@ async function runOrchestrationPull(cwd2, args) {
       ...e2.payload_schema && Object.keys(e2.payload_schema).length ? { payload_schema: e2.payload_schema } : {},
       ...e2.settings && Object.keys(e2.settings).length ? { settings: e2.settings } : {}
     })),
-    ...manifestTriggers.length ? { triggers: manifestTriggers } : {}
+    ...manifestTriggers.length ? { triggers: manifestTriggers } : {},
+    ...manifestDecisions2?.length ? { decisions: manifestDecisions2 } : {}
   };
   writeOrchManifest(cwd2, manifest);
   writeOrchLink(cwd2, {
@@ -83574,6 +83790,7 @@ async function runOrchestrationPull(cwd2, args) {
       payload_schema: e2.payload_schema ?? {}
     })),
     triggers: syncedScheduleTriggers(cloudScheduleTriggers(cloud, (agentId, fallback) => slugFor(agentId) || fallback)),
+    ...decisionBaseline ? { decisions: decisionBaseline } : {},
     meta: syncedOrchestrationMeta(cloud)
   });
   if (missingMembers.length > 0) {
@@ -83601,6 +83818,83 @@ function handleApiError5(err) {
 var import_picocolors53 = __toESM(require_picocolors(), 1);
 
 // src/core/orchestration-outgoing.ts
+function charLength(value2) {
+  return Array.from(value2).length;
+}
+function validateDecisions(decisions, memberSlugs, triggerNodeIds) {
+  const ids = new Set;
+  for (const d3 of decisions) {
+    if (ids.has(d3.id))
+      throw new Error(`Decision ${d3.id} is duplicated.`);
+    ids.add(d3.id);
+  }
+  for (const d3 of decisions) {
+    const label2 = `Decision "${d3.name || d3.id}"`;
+    const fail3 = (message) => {
+      throw new Error(`${label2}: ${message}`);
+    };
+    if (!d3.name || charLength(d3.name) > DECISION_LIMITS.name) {
+      fail3(`name must be 1 to ${DECISION_LIMITS.name} characters.`);
+    }
+    if (!d3.model || charLength(d3.model) > DECISION_LIMITS.model) {
+      fail3(`model must be 1 to ${DECISION_LIMITS.model} characters.`);
+    }
+    if (charLength(d3.instructions) > DECISION_LIMITS.instructions) {
+      fail3(`instructions must be ${DECISION_LIMITS.instructions} characters or fewer.`);
+    }
+    const count = d3.answers.length;
+    if (count < DECISION_LIMITS.answersMin || count > DECISION_LIMITS.answersMax) {
+      fail3(`needs ${DECISION_LIMITS.answersMin} to ${DECISION_LIMITS.answersMax} answers (has ${count}).`);
+    }
+    const answers = new Set;
+    for (const a3 of d3.answers) {
+      if (!a3.answer || charLength(a3.answer) > DECISION_LIMITS.answer) {
+        fail3(`each answer must be 1 to ${DECISION_LIMITS.answer} characters.`);
+      }
+      if (answers.has(a3.answer))
+        fail3(`answer "${a3.answer}" appears twice.`);
+      answers.add(a3.answer);
+      if (charLength(a3.criterion) > DECISION_LIMITS.criterion) {
+        fail3(`the criterion for "${a3.answer}" must be ${DECISION_LIMITS.criterion} characters or fewer.`);
+      }
+    }
+    const fed = new Set;
+    for (const nodeId of d3.triggers) {
+      if (!triggerNodeIds.has(nodeId)) {
+        fail3(`from trigger ${nodeId}, which isn't in triggers.`);
+      }
+      if (fed.has(nodeId))
+        fail3(`trigger ${nodeId} is listed twice in from.`);
+      fed.add(nodeId);
+    }
+    const checkTargets = (targets, branch) => {
+      const seen = new Set;
+      for (const t of targets) {
+        if (t.agent !== undefined && !memberSlugs.has(t.agent)) {
+          fail3(`${branch} routes to "${t.agent}", which isn't in members.`);
+        }
+        if (t.decision !== undefined) {
+          if (t.decision === d3.id)
+            fail3(`${branch} routes to the decision itself.`);
+          if (!ids.has(t.decision)) {
+            fail3(`${branch} routes to decision ${t.decision}, which isn't in decisions.`);
+          }
+        }
+        const key2 = t.agent !== undefined ? `agent:${t.agent}` : `decision:${t.decision}`;
+        if (seen.has(key2))
+          fail3(`${branch} routes to ${key2.replace(":", " ")} twice.`);
+        seen.add(key2);
+      }
+    };
+    for (const a3 of d3.answers)
+      checkTargets(a3.to, `answer "${a3.answer}"`);
+    checkTargets(d3.fallback, "fallback");
+  }
+}
+function unknownDecisionModels(manifest) {
+  const known = new Set(DECISION_MODELS);
+  return manifestDecisions(manifest).filter((d3) => !known.has(d3.model)).map((d3) => ({ name: d3.name, model: d3.model }));
+}
 function buildOrchestrationGraphPayload(manifest, slugToAgentId) {
   const memberSlugs = new Set(manifest.members.map((m3) => m3.slug));
   for (const e2 of manifest.edges) {
@@ -83661,6 +83955,32 @@ function buildOrchestrationGraphPayload(manifest, slugToAgentId) {
     }))
   };
 }
+function buildDecisionsPayload(manifest, slugToAgentId) {
+  const decisions = manifestDecisions(manifest, slugToAgentId);
+  validateDecisions(decisions, new Set(manifest.members.map((m3) => m3.slug)), new Set((manifest.triggers ?? []).map((t) => canonicalUuid2(t.node_id))));
+  return decisions.map((d3) => decisionPayload(d3, slugToAgentId));
+}
+function decisionPayload(d3, slugToAgentId) {
+  const route = (answer, t) => ({
+    answer,
+    is_fallback: answer === null,
+    ...t.agent !== undefined ? { to_agent_id: slugToAgentId.get(t.agent) } : { to_decision_id: t.decision },
+    description: t.description
+  });
+  return {
+    id: d3.id,
+    name: d3.name,
+    model: d3.model,
+    instructions: d3.instructions,
+    answers: d3.answers.map((a3) => ({ answer: a3.answer, criterion: a3.criterion })),
+    confidence_threshold: d3.confidence_threshold,
+    inputs: d3.triggers.map((nodeId) => ({ from_trigger_node_id: nodeId })),
+    routes: [
+      ...d3.answers.flatMap((a3) => a3.to.map((t) => route(a3.answer, t))),
+      ...d3.fallback.map((t) => route(null, t))
+    ]
+  };
+}
 
 // src/cli/orchestration-push.ts
 function joinList(items) {
@@ -83788,7 +84108,21 @@ async function runOrchestrationPush(cwd2, args) {
   const metaOverwrites = metaDecisions.filter((d3) => d3.kind === "push");
   const metaKept = metaDecisions.filter((d3) => d3.kind === "keep");
   const blockedTriggers = triggerDecision.kind === "blocked" ? triggerDecision : null;
-  if (blockedTriggers || metaConflicts.length > 0) {
+  const localDecisions = manifestDecisions(manifest, slugToAgentId);
+  const cloudDecisionList = cloudDecisions(cloud, slugForAgent);
+  const decisionPlan = cloudDecisionList ? decideDecisionReconcile({
+    local: localDecisions,
+    cloud: cloudDecisionList,
+    baseline: lock?.decisions,
+    force: !!args.force
+  }) : null;
+  const decisionById = new Map([...cloudDecisionList ?? [], ...localDecisions].map((d3) => [d3.id, d3]));
+  const decisionLabelFor = (id) => {
+    const d3 = decisionById.get(id);
+    return d3 ? decisionLabel(d3) : id;
+  };
+  const blockedDecisions = decisionPlan?.kind === "blocked" ? decisionPlan : null;
+  if (blockedTriggers || blockedDecisions || metaConflicts.length > 0) {
     const pullTargets = [];
     const forceEffects = [];
     if (blockedTriggers) {
@@ -83807,6 +84141,22 @@ async function runOrchestrationPush(cwd2, args) {
       pullTargets.push(`${total} schedule trigger${total === 1 ? "" : "s"}`);
       forceEffects.push("make your local schedule triggers authoritative (deleting the cloud ones above)");
     }
+    if (blockedDecisions) {
+      const { unseen, cloudModified, staleArchives } = blockedDecisions;
+      f2.error(unseen.length > 0 ? "Cannot push: the cloud has decisions this folder has never seen." : "Cannot push: decisions changed both locally and in the cloud.");
+      for (const id of unseen) {
+        console.error(`  ${import_picocolors53.default.red("!")} ${import_picocolors53.default.bold(decisionLabelFor(id))} ${import_picocolors53.default.dim("(only in the cloud — pushing would delete it)")}`);
+      }
+      for (const id of cloudModified) {
+        console.error(`  ${import_picocolors53.default.red("!")} ${import_picocolors53.default.bold(decisionLabelFor(id))} ${import_picocolors53.default.dim("(edited in the cloud — pushing would overwrite that edit)")}`);
+      }
+      for (const id of staleArchives) {
+        console.error(`  ${import_picocolors53.default.red("!")} ${import_picocolors53.default.bold(decisionLabelFor(id))} ${import_picocolors53.default.dim("(deleted here, edited in the cloud since — pushing would delete that edit)")}`);
+      }
+      const total = unseen.length + cloudModified.length + staleArchives.length;
+      pullTargets.push(`${total} decision${total === 1 ? "" : "s"}`);
+      forceEffects.push("make your local decisions authoritative (deleting or overwriting the cloud ones above)");
+    }
     if (metaConflicts.length > 0) {
       f2.error("Cannot push: orchestration metadata changed both locally and in the cloud.");
       for (const d3 of metaConflicts) {
@@ -83839,9 +84189,30 @@ async function runOrchestrationPush(cwd2, args) {
     f2.warn(`${cloudTriggers.length} cloud schedule trigger${cloudTriggers.length === 1 ? "" : "s"} ${cloudTriggers.length === 1 ? "is" : "are"} not in ${import_picocolors53.default.bold(ORCH_MANIFEST_FILE)} and will be left untouched. Run ${import_picocolors53.default.cyan("brainbase orchestration pull")} to manage ${cloudTriggers.length === 1 ? "it" : "them"} from here.`);
   }
   const triggerDeletes = triggerDecision.kind === "reconcile" ? triggerDecision.archives : [];
+  const decisionDeletes = decisionPlan?.kind === "reconcile" ? decisionPlan.archives : [];
+  const sendDecisions = decisionPlan?.kind === "reconcile" && (localDecisions.length > 0 || decisionDeletes.length > 0);
+  if (!cloudDecisionList && localDecisions.length > 0) {
+    f2.warn(`The cloud did not return decision nodes for this account, so the ${localDecisions.length} decision${localDecisions.length === 1 ? "" : "s"} in ${import_picocolors53.default.bold(ORCH_MANIFEST_FILE)} ${localDecisions.length === 1 ? "is" : "are"} left out of this push and the cloud's are left alone.`);
+  } else if (decisionPlan?.kind === "skip") {
+    const left = decisionPlan.unseen.length + decisionPlan.cloudModified.length;
+    f2.warn(`${left} cloud decision${left === 1 ? "" : "s"} ${left === 1 ? "is" : "are"} not in ${import_picocolors53.default.bold(ORCH_MANIFEST_FILE)} and will be left untouched. Run ${import_picocolors53.default.cyan("brainbase orchestration pull")} to manage ${left === 1 ? "it" : "them"} from here.`);
+  }
+  let decisionsPayload = [];
+  if (sendDecisions) {
+    try {
+      decisionsPayload = buildDecisionsPayload(manifest, slugToAgentId);
+    } catch (err) {
+      f2.error(err.message);
+      process.exitCode = 1;
+      return;
+    }
+    for (const { name, model } of unknownDecisionModels(manifest)) {
+      f2.warn(`Decision ${import_picocolors53.default.bold(name)} uses model ${import_picocolors53.default.bold(model)}, which is not one the canvas offers. It is pushed as written; if the gateway does not know it, the decision fails when its trigger fires.`);
+    }
+  }
   const plan = [""];
   plan.push(`  ${import_picocolors53.default.bold(link2.name)} ${import_picocolors53.default.dim(`(${link2.orchestration_id})`)}`);
-  plan.push(`  ${import_picocolors53.default.dim(`${manifest.members.length} member${manifest.members.length === 1 ? "" : "s"}, ${manifest.edges.length} edge${manifest.edges.length === 1 ? "" : "s"}, ${graph.triggers.length} trigger${graph.triggers.length === 1 ? "" : "s"}`)}`);
+  plan.push(`  ${import_picocolors53.default.dim(`${manifest.members.length} member${manifest.members.length === 1 ? "" : "s"}, ${manifest.edges.length} edge${manifest.edges.length === 1 ? "" : "s"}, ${graph.triggers.length} trigger${graph.triggers.length === 1 ? "" : "s"}${sendDecisions ? `, ${decisionsPayload.length} decision${decisionsPayload.length === 1 ? "" : "s"}` : ""}`)}`);
   plan.push("");
   if (!args.graphOnly) {
     plan.push(`  ${import_picocolors53.default.dim("per-member agent push:")}`);
@@ -83857,6 +84228,13 @@ async function runOrchestrationPush(cwd2, args) {
     }
     plan.push("");
   }
+  if (decisionDeletes.length) {
+    plan.push(`  ${import_picocolors53.default.bold("decisions this push will delete")} ${import_picocolors53.default.dim(`(${decisionDeletes.length})`)}`);
+    for (const id of decisionDeletes) {
+      plan.push(`    ${import_picocolors53.default.yellow("⨯")} ${decisionLabelFor(id)}`);
+    }
+    plan.push("");
+  }
   if (metaOverwrites.length) {
     plan.push(`  ${import_picocolors53.default.bold("orchestration metadata this push will overwrite")}`);
     for (const m3 of metaOverwrites) {
@@ -83875,9 +84253,13 @@ async function runOrchestrationPush(cwd2, args) {
   console.log(plan.join(`
 `));
   if (!autoProceed(args.yes)) {
+    const deletions = [
+      ...triggerDeletes.length ? [`${triggerDeletes.length} schedule trigger${triggerDeletes.length === 1 ? "" : "s"}`] : [],
+      ...decisionDeletes.length ? [`${decisionDeletes.length} decision${decisionDeletes.length === 1 ? "" : "s"}`] : []
+    ];
     const ok = await se({
-      message: triggerDeletes.length ? `Push, deleting ${triggerDeletes.length} schedule trigger${triggerDeletes.length === 1 ? "" : "s"}?` : args.graphOnly ? "Push graph (members, edges + triggers) only?" : "Push each member, then update the graph?",
-      initialValue: triggerDeletes.length === 0
+      message: deletions.length ? `Push, deleting ${joinList(deletions)}?` : args.graphOnly ? "Push graph (members, edges + triggers) only?" : "Push each member, then update the graph?",
+      initialValue: deletions.length === 0
     });
     if (!ensureNotCancelled(ok)) {
       $e("Aborted.");
@@ -83923,9 +84305,11 @@ async function runOrchestrationPush(cwd2, args) {
       members: graph.memberIds,
       edges: graph.edges,
       triggers: graph.triggers,
+      ...sendDecisions ? { decisions: decisionsPayload } : {},
       ...lock?.revision != null ? { base_revision: lock.revision } : {}
     });
     sp.stop(`Graph updated. New cloud revision ${updated.revision}.`);
+    const settledDecisions = sendDecisions ? cloudDecisions(updated, slugForAgent) : decisionPlan?.kind === "reconcile" ? cloudDecisionList : null;
     writeOrchSyncState(cwd2, {
       schemaVersion: 1,
       orchestration_id: updated.id,
@@ -83943,6 +84327,7 @@ async function runOrchestrationPush(cwd2, args) {
         payload_schema: e2.payload_schema ?? {}
       })),
       triggers: triggerDecision.kind === "skip" ? lock?.triggers ?? [] : syncedScheduleTriggers(cloudScheduleTriggers(updated, slugForAgent)),
+      ...settledDecisions ? { decisions: syncedDecisions(settledDecisions) } : lock?.decisions ? { decisions: lock.decisions } : {},
       meta: nextOrchestrationMeta({
         applied: updated,
         decisions: metaDecisions,
@@ -84115,6 +84500,64 @@ async function runOrchestrationStatus(cwd2) {
     lines.push(`  ${import_picocolors54.default.dim(`${left.length} cloud schedule trigger${left.length === 1 ? "" : "s"} not managed by this manifest — push leaves ${left.length === 1 ? "it" : "them"} untouched`)}`);
     lines.push("");
   }
+  const localDecisions = manifestDecisions(localManifest, new Map([...localSlugByAgentId].map(([agentId, slug]) => [slug, agentId])));
+  const cloudDecisionList = cloudDecisions(cloud, slugForAgent);
+  let decisionsToPush = [];
+  let decisionsToPull = [];
+  if (!cloudDecisionList) {
+    if (localDecisions.length) {
+      lines.push(`  ${import_picocolors54.default.dim(`${localDecisions.length} decision${localDecisions.length === 1 ? "" : "s"} in yaml, but the cloud does not show decision nodes to this account — push leaves ${localDecisions.length === 1 ? "it" : "them"} alone`)}`);
+      lines.push("");
+    }
+  } else {
+    const decisionPlan = decideDecisionReconcile({
+      local: localDecisions,
+      cloud: cloudDecisionList,
+      baseline: lock?.decisions,
+      force: false
+    });
+    const byId = new Map([...cloudDecisionList, ...localDecisions].map((d3) => [d3.id, d3]));
+    const label2 = (id) => {
+      const d3 = byId.get(id);
+      return d3 ? decisionLabel(d3) : id;
+    };
+    const localIds = new Set(localDecisions.map((d3) => d3.id));
+    const cloudById = new Map(cloudDecisionList.map((d3) => [d3.id, d3]));
+    decisionsToPush = localDecisions.filter((d3) => {
+      const remote = cloudById.get(d3.id);
+      return !remote || decisionHash(remote) !== decisionHash(d3);
+    });
+    decisionsToPull = cloudDecisionList.filter((d3) => !localIds.has(d3.id));
+    const decisionDeletes = decisionPlan.kind === "reconcile" ? decisionPlan.archives : [];
+    if (decisionsToPush.length || decisionsToPull.length) {
+      lines.push(`  ${import_picocolors54.default.bold("decisions")}`);
+      for (const d3 of decisionsToPush) {
+        lines.push(`    ${import_picocolors54.default.yellow("→ push")}  added/changed in yaml: ${decisionLabel(d3)}`);
+      }
+      for (const d3 of decisionsToPull) {
+        lines.push(decisionDeletes.includes(d3.id) ? `    ${import_picocolors54.default.red("⨯ push deletes")}  ${decisionLabel(d3)}` : `    ${import_picocolors54.default.cyan("← pull")}  only on cloud: ${decisionLabel(d3)}`);
+      }
+      lines.push("");
+    }
+    if (decisionPlan.kind === "blocked") {
+      lines.push(`  ${import_picocolors54.default.bold(import_picocolors54.default.red("decisions: push blocked"))}`);
+      for (const id of decisionPlan.unseen) {
+        lines.push(`    ${import_picocolors54.default.red("!")} ${label2(id)} ${import_picocolors54.default.dim("— only in the cloud; pushing would delete it")}`);
+      }
+      for (const id of decisionPlan.cloudModified) {
+        lines.push(`    ${import_picocolors54.default.red("!")} ${label2(id)} ${import_picocolors54.default.dim("— edited in the cloud; pushing would overwrite that edit")}`);
+      }
+      for (const id of decisionPlan.staleArchives) {
+        lines.push(`    ${import_picocolors54.default.red("!")} ${label2(id)} ${import_picocolors54.default.dim("— deleted here, edited in the cloud since; pushing would delete that edit")}`);
+      }
+      lines.push(`    ${import_picocolors54.default.dim("run")} ${import_picocolors54.default.cyan("brainbase orchestration pull")} ${import_picocolors54.default.dim("first")}`);
+      lines.push("");
+    } else if (decisionPlan.kind === "skip") {
+      const left = untouchedRows(decisionPlan);
+      lines.push(`  ${import_picocolors54.default.dim(`${left.length} cloud decision${left.length === 1 ? "" : "s"} not managed by this manifest — push leaves ${left.length === 1 ? "it" : "them"} untouched`)}`);
+      lines.push("");
+    }
+  }
   const lockByAgentId = new Map((lock?.members ?? []).map((m3) => [m3.agent_id, m3]));
   const memberDrift = [];
   for (const m3 of cloud.members) {
@@ -84148,7 +84591,7 @@ async function runOrchestrationStatus(cwd2) {
     lines.push(`    ${import_picocolors54.default.cyan("← pull")}  cloud changed since last pull: ${import_picocolors54.default.dim(`lock ${lock.revision} → cloud ${cloud.revision}`)}`);
     lines.push("");
   }
-  if (!membersAdded.length && !membersRemoved.length && !edgesAdded.length && !edgesRemoved.length && !triggersToPush.length && !triggersToPull.length && !metaDecisions.length && !memberDrift.length && !revisionDrift) {
+  if (!membersAdded.length && !membersRemoved.length && !edgesAdded.length && !edgesRemoved.length && !triggersToPush.length && !triggersToPull.length && !decisionsToPush.length && !decisionsToPull.length && !metaDecisions.length && !memberDrift.length && !revisionDrift) {
     lines.push(`  ${import_picocolors54.default.green("✓")} everything is in sync`);
     lines.push("");
     console.log(lines.join(`
@@ -84503,6 +84946,10 @@ async function runOrchestrationCreate(cwd2, args) {
         payload_schema: e2.payload_schema ?? {}
       }))
     });
+    const decisionCount = manifest.decisions?.length ?? 0;
+    if (decisionCount) {
+      f2.info(`Run ${import_picocolors57.default.cyan("brainbase orchestration push")} to add the ${decisionCount} decision${decisionCount === 1 ? "" : "s"} in this manifest.`);
+    }
     $e(`Created ${created.name} at revision ${created.revision}.`);
   } catch (err) {
     sp.stop("Failed.");
@@ -97544,6 +97991,806 @@ async function runBenchmark(sub, args, write3 = (value2) => process.stdout.write
   }
 }
 
+// src/cli/decide.ts
+import fs95 from "node:fs";
+import path107 from "node:path";
+
+// src/core/decide-api.ts
+import path105 from "node:path";
+function decideKeysFile() {
+  return path105.join(process.env.BRAINBASE_HOME ?? BRAINBASE_HOME, "decide-keys.json");
+}
+var ATTEMPTS = 3;
+var RETRY_STATUSES = new Set([429, 502, 503, 504]);
+var MAX_RETRY_DELAY_MS = 30000;
+var REQUEST_TIMEOUT_MS3 = 5 * 60000;
+
+class DecideHttpError extends Error {
+  status;
+  constructor(message3, status) {
+    super(message3);
+    this.status = status;
+    this.name = "DecideHttpError";
+  }
+}
+function cacheKey(base2, agentId) {
+  return `${base2}|${agentId}`;
+}
+async function resolveDecideCredential(cwd2, agentFlag) {
+  const base2 = proxyBaseUrl(authStatus().session ?? null);
+  const taskKey = process.env.BB_TASK_KEY?.trim();
+  if (taskKey)
+    return { key: taskKey, base: base2, source: "task_key" };
+  const agentId = agentFlag?.trim() || readLink(cwd2)?.agent_id;
+  if (!agentId) {
+    throw new DecideHttpError("No agent to bill. Run inside a linked folder, or pass --agent <id> (see `brainbase agent list`).", null);
+  }
+  const cached2 = readJsonOr(decideKeysFile(), {})[cacheKey(base2, agentId)];
+  if (cached2?.key)
+    return { key: cached2.key, base: base2, source: "agent_key", agentId };
+  return mintAgentKey(base2, agentId);
+}
+async function mintAgentKey(base2, agentId) {
+  const created = await api.createCliKey(agentId, { name: "brainbase decide" });
+  const cache3 = readJsonOr(decideKeysFile(), {});
+  cache3[cacheKey(base2, agentId)] = { key: created.key, key_id: created.id };
+  writeJsonAtomic(decideKeysFile(), cache3);
+  return { key: created.key, base: base2, source: "agent_key", agentId };
+}
+async function replaceAgentKey(credential) {
+  if (credential.source !== "agent_key" || !credential.agentId)
+    return credential;
+  const cache3 = readJsonOr(decideKeysFile(), {});
+  delete cache3[cacheKey(credential.base, credential.agentId)];
+  writeJsonAtomic(decideKeysFile(), cache3);
+  return mintAgentKey(credential.base, credential.agentId);
+}
+function retryDelayMs(attempt2, retryAfter) {
+  const seconds = retryAfter === null ? Number.NaN : Number(retryAfter);
+  const base2 = Number.isFinite(seconds) ? seconds * 1000 : 1000 * 2 ** attempt2;
+  return Math.min(Math.max(base2, 0), MAX_RETRY_DELAY_MS) + Math.random() * 500;
+}
+function errorMessage2(status, text4) {
+  try {
+    const body = JSON.parse(text4);
+    const message3 = body.error?.message ?? body.detail;
+    if (typeof message3 === "string" && message3)
+      return message3;
+  } catch {}
+  return `HTTP ${status}`;
+}
+async function postDecide(credential, body, options = {}) {
+  const sleep3 = options.sleep ?? ((ms2) => new Promise((resolve) => setTimeout(resolve, ms2)));
+  const payload = JSON.stringify(body);
+  let failure = new DecideHttpError("The decide request failed", null);
+  for (let attempt2 = 0;attempt2 < ATTEMPTS; attempt2 += 1) {
+    let retryAfter = null;
+    try {
+      const response = await fetch(`${credential.base}/v1/decide`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${credential.key}`,
+          "Content-Type": "application/json"
+        },
+        body: payload,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+      });
+      const text4 = await response.text();
+      if (response.ok) {
+        try {
+          return JSON.parse(text4);
+        } catch {
+          throw new DecideHttpError("The server sent an unreadable response", response.status);
+        }
+      }
+      failure = new DecideHttpError(errorMessage2(response.status, text4), response.status);
+      if (!RETRY_STATUSES.has(response.status))
+        throw failure;
+      retryAfter = response.headers.get("retry-after");
+    } catch (error2) {
+      if (error2 instanceof DecideHttpError)
+        throw error2;
+      failure = new DecideHttpError(`Network error: ${error2.message}`, null);
+    }
+    if (attempt2 + 1 < ATTEMPTS)
+      await sleep3(retryDelayMs(attempt2, retryAfter));
+  }
+  throw failure;
+}
+
+// src/core/decide-items.ts
+import fs94 from "node:fs";
+import path106 from "node:path";
+
+class DecideInputError extends Error {
+  constructor(message3) {
+    super(message3);
+    this.name = "DecideInputError";
+  }
+}
+var GLOB_CHARS = /[*?[{]/;
+function fileId(cwd2, file) {
+  return path106.relative(cwd2, file).split(path106.sep).join("/") || path106.basename(file);
+}
+function isHidden2(name) {
+  return name.startsWith(".") || name === "node_modules";
+}
+function appendAll(into, from) {
+  for (const value2 of from)
+    into.push(value2);
+}
+function walk(dir, out = []) {
+  for (const entry of fs94.readdirSync(dir, { withFileTypes: true })) {
+    if (isHidden2(entry.name))
+      continue;
+    const full = path106.join(dir, entry.name);
+    if (entry.isDirectory())
+      walk(full, out);
+    else if (entry.isFile())
+      out.push(full);
+    else if (entry.isSymbolicLink()) {
+      try {
+        if (fs94.statSync(full).isFile())
+          out.push(full);
+      } catch {}
+    }
+  }
+  return out;
+}
+function walkSorted(dir) {
+  return walk(dir).sort();
+}
+function globToRegExp(pattern2) {
+  let source = "";
+  for (let i = 0;i < pattern2.length; i += 1) {
+    const char = pattern2[i];
+    if (char === "*") {
+      if (pattern2[i + 1] === "*") {
+        const slashFollows = pattern2[i + 2] === "/";
+        source += slashFollows ? "(?:.*/)?" : ".*";
+        i += slashFollows ? 2 : 1;
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else if (char === "{") {
+      const close = pattern2.indexOf("}", i);
+      if (close === -1) {
+        source += "\\{";
+        continue;
+      }
+      const choices = pattern2.slice(i + 1, close).split(",");
+      source += `(?:${choices.map((choice) => globToRegExp(choice).source.slice(1, -1)).join("|")})`;
+      i = close;
+    } else if (char === "[") {
+      const close = pattern2.indexOf("]", i + 1);
+      if (close === -1) {
+        source += "\\[";
+        continue;
+      }
+      let body = pattern2.slice(i + 1, close);
+      if (body.startsWith("!"))
+        body = `^${body.slice(1)}`;
+      source += `[${body.replace(/\\/g, "\\\\")}]`;
+      i = close;
+    } else {
+      source += char.replace(/[.+^$()|\\/]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+function expandGlob(cwd2, pattern2) {
+  const absolute = path106.isAbsolute(pattern2);
+  const segments = pattern2.split("/");
+  const fixed = [];
+  for (const segment of segments) {
+    if (GLOB_CHARS.test(segment))
+      break;
+    fixed.push(segment);
+  }
+  if (fixed.length === segments.length) {
+    return [path106.resolve(cwd2, pattern2)];
+  }
+  const root = path106.resolve(cwd2, fixed.join("/") || ".");
+  if (!fs94.existsSync(root) || !fs94.statSync(root).isDirectory())
+    return [];
+  const matcher = globToRegExp(absolute ? pattern2 : path106.posix.normalize(segments.join("/")));
+  return walkSorted(root).filter((file) => {
+    const candidate = absolute ? file.split(path106.sep).join("/") : fileId(cwd2, file);
+    return matcher.test(candidate);
+  });
+}
+function readFileItem(cwd2, file) {
+  const id = fileId(cwd2, file);
+  let bytes;
+  try {
+    bytes = fs94.readFileSync(file);
+  } catch (error2) {
+    return { id, error: `Could not read the file: ${error2.message}` };
+  }
+  if (bytes.includes(0))
+    return { id, error: "Not a text file" };
+  let text4;
+  try {
+    text4 = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return { id, error: "Not UTF-8 text" };
+  }
+  if (!text4.trim())
+    return { id, error: "Empty file" };
+  return { id, text: text4 };
+}
+function fileItems(cwd2, paths, globs) {
+  const files = [];
+  for (const entry of paths) {
+    const full = path106.resolve(cwd2, entry);
+    let stat;
+    try {
+      stat = fs94.statSync(full);
+    } catch {
+      throw new DecideInputError(`No such file or directory: ${entry}`);
+    }
+    if (stat.isDirectory())
+      appendAll(files, walkSorted(full));
+    else
+      files.push(full);
+  }
+  for (const pattern2 of globs) {
+    const matched = expandGlob(cwd2, pattern2);
+    if (matched.length === 0 || !matched.some((file) => fs94.existsSync(file))) {
+      throw new DecideInputError(`No files match ${pattern2}`);
+    }
+    appendAll(files, matched);
+  }
+  return [...new Set(files)];
+}
+function readFileItems(cwd2, files) {
+  const set3 = { items: [], failures: [] };
+  for (const file of files) {
+    const item = readFileItem(cwd2, file);
+    if ("error" in item)
+      set3.failures.push(item);
+    else
+      set3.items.push(item);
+  }
+  return set3;
+}
+function isRecord2(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function rowItem(row, options, fallbackId) {
+  const idField = options.idField ?? "id";
+  const rawId = isRecord2(row) ? row[idField] : undefined;
+  let id = fallbackId;
+  if (rawId !== undefined && rawId !== null && rawId !== "")
+    id = String(rawId);
+  else if (options.idField)
+    return { id: fallbackId, error: `Missing ${options.idField}` };
+  if (options.textFields.length === 0)
+    return { id, json: row };
+  if (!isRecord2(row))
+    return { id, error: "Not an object, so --text-field has nothing to select" };
+  if (options.textFields.length === 1) {
+    const field2 = options.textFields[0];
+    const value2 = row[field2];
+    if (value2 === undefined || value2 === null || value2 === "")
+      return { id, error: `Empty ${field2}` };
+    return { id, text: typeof value2 === "string" ? value2 : JSON.stringify(value2) };
+  }
+  const missing = options.textFields.filter((field2) => row[field2] === undefined);
+  if (missing.length)
+    return { id, error: `Missing ${missing.join(", ")}` };
+  const picked = {};
+  for (const field2 of options.textFields)
+    picked[field2] = row[field2];
+  return { id, json: picked };
+}
+function sourceLabel(cwd2, file) {
+  return fileId(cwd2, path106.resolve(cwd2, file));
+}
+function readSource(cwd2, file) {
+  try {
+    return fs94.readFileSync(path106.resolve(cwd2, file), "utf8");
+  } catch (error2) {
+    throw new DecideInputError(`Could not read ${file}: ${error2.message}`);
+  }
+}
+function jsonlItems(cwd2, file, options) {
+  const set3 = { items: [], failures: [] };
+  const label3 = sourceLabel(cwd2, file);
+  readSource(cwd2, file).split(`
+`).forEach((line3, index) => {
+    if (!line3.trim())
+      return;
+    const fallbackId = `${label3}:${index + 1}`;
+    let row;
+    try {
+      row = JSON.parse(line3);
+    } catch {
+      set3.failures.push({ id: fallbackId, error: "Not valid JSON" });
+      return;
+    }
+    const item = rowItem(row, options, fallbackId);
+    if ("error" in item)
+      set3.failures.push(item);
+    else
+      set3.items.push(item);
+  });
+  return set3;
+}
+function parseCsv(text4) {
+  const rows = [];
+  let row = [];
+  let field2 = "";
+  let quoted = false;
+  for (let i = 0;i < text4.length; i += 1) {
+    const char = text4[i];
+    if (quoted) {
+      if (char === '"' && text4[i + 1] === '"') {
+        field2 += '"';
+        i += 1;
+      } else if (char === '"') {
+        quoted = false;
+      } else {
+        field2 += char;
+      }
+    } else if (char === '"' && field2 === "") {
+      quoted = true;
+    } else if (char === ",") {
+      row.push(field2);
+      field2 = "";
+    } else if (char === `
+` || char === "\r") {
+      if (char === "\r" && text4[i + 1] === `
+`)
+        i += 1;
+      row.push(field2);
+      rows.push(row);
+      row = [];
+      field2 = "";
+    } else {
+      field2 += char;
+    }
+  }
+  if (field2 !== "" || row.length > 0) {
+    row.push(field2);
+    rows.push(row);
+  }
+  return rows.filter((cells) => cells.some((cell) => cell !== ""));
+}
+function csvItems(cwd2, file, options) {
+  const set3 = { items: [], failures: [] };
+  const label3 = sourceLabel(cwd2, file);
+  const [header, ...rows] = parseCsv(readSource(cwd2, file).replace(/^/, ""));
+  if (!header)
+    return set3;
+  rows.forEach((cells, index) => {
+    const row = {};
+    header.forEach((name, column) => {
+      row[name] = cells[column] ?? "";
+    });
+    const item = rowItem(row, options, `${label3}:${index + 2}`);
+    if ("error" in item)
+      set3.failures.push(item);
+    else
+      set3.items.push(item);
+  });
+  return set3;
+}
+function readResults(file) {
+  const rows = new Map;
+  if (!fs94.existsSync(file))
+    return rows;
+  for (const line3 of fs94.readFileSync(file, "utf8").split(`
+`)) {
+    if (!line3.trim())
+      continue;
+    try {
+      const row = JSON.parse(line3);
+      if (row && typeof row.id === "string")
+        rows.set(row.id, row);
+    } catch {}
+  }
+  return rows;
+}
+function repairResultsTail(file) {
+  if (!fs94.existsSync(file))
+    return;
+  const text4 = fs94.readFileSync(file, "utf8");
+  if (!text4 || text4.endsWith(`
+`))
+    return;
+  const cut = text4.lastIndexOf(`
+`) + 1;
+  const tail2 = text4.slice(cut);
+  let complete = false;
+  try {
+    const row = JSON.parse(tail2);
+    complete = Boolean(row) && typeof row.id === "string";
+  } catch {
+    complete = false;
+  }
+  if (complete)
+    fs94.appendFileSync(file, `
+`);
+  else
+    fs94.truncateSync(file, Buffer.byteLength(text4.slice(0, cut)));
+}
+function parseWhere(value2) {
+  if (value2 === "failed")
+    return { kind: "failed" };
+  if (value2 === "uncertain")
+    return { kind: "uncertain" };
+  const split2 = value2.indexOf("=");
+  if (split2 > 0 && split2 < value2.length - 1) {
+    return { kind: "answer", question: value2.slice(0, split2), answer: value2.slice(split2 + 1) };
+  }
+  throw new DecideInputError(`--where takes failed, uncertain or <question>=<answer>, not ${value2}`);
+}
+function rowMatches(row, where) {
+  switch (where.kind) {
+    case "failed":
+      return row.error !== undefined;
+    case "uncertain":
+      return row.error === undefined && row.uncertain === true;
+    case "answer":
+      return row.error === undefined && row.answers?.[where.question]?.choice === where.answer;
+  }
+}
+
+// src/cli/decide.ts
+var DEFAULT_OUT = "decide-results.jsonl";
+var MAX_ITEMS_PER_REQUEST = 200;
+var MAX_REQUEST_BYTES = 6 * 1024 * 1024;
+var DEFAULT_CONCURRENCY = 4;
+var MAX_CONCURRENCY = 16;
+var SUMMARY_UNCERTAIN_IDS = 20;
+var SUMMARY_FAILED = 10;
+var STOP_STATUSES = new Set([401, 402, 403, 404]);
+var OPTIONS = [
+  { key: "questions", names: ["--questions", "-q"], kind: "value" },
+  { key: "items", names: ["--items"], kind: "value", multiple: true },
+  { key: "jsonl", names: ["--jsonl"], kind: "value", multiple: true },
+  { key: "csv", names: ["--csv"], kind: "value", multiple: true },
+  { key: "idField", names: ["--id-field"], kind: "value" },
+  { key: "textField", names: ["--text-field"], kind: "value", multiple: true },
+  { key: "model", names: ["--model"], kind: "value" },
+  { key: "minConfidence", names: ["--min-confidence"], kind: "value" },
+  { key: "out", names: ["--out", "-o"], kind: "value" },
+  { key: "resume", names: ["--resume"], kind: "boolean" },
+  { key: "overwrite", names: ["--overwrite"], kind: "boolean" },
+  { key: "selectFrom", names: ["--select-from"], kind: "value" },
+  { key: "where", names: ["--where"], kind: "value" },
+  { key: "agent", names: ["--agent"], kind: "value" },
+  { key: "concurrency", names: ["--concurrency"], kind: "value" },
+  { key: "help", names: ["--help", "-h"], kind: "boolean" }
+];
+var DECIDE_USAGE = `Usage: brainbase decide --questions <file.json> <sources...> [options]
+
+Answer the same decision-model questions over many items. Items are read on
+this machine and never pass through your agent's context.
+
+Sources (at least one):
+  <path>...                 files, or directories (every file under them)
+  --items <glob>            files matching a glob; quote it ('docs/**/*.md')
+  --jsonl <file>            one item per line
+  --csv <file>              one item per row; the first row names the fields
+  --id-field <name>         JSONL/CSV field holding each item's id
+                            (default: id when present, else file:line)
+  --text-field <name>       field to judge; repeat for several (a row
+                            missing any of them fails without being sent)
+                            (default: the whole row)
+
+Questions:
+  --questions, -q <file>    JSON object of System One questions, e.g.
+                            {"team": {"type": "choice", "instructions": "Which team?",
+                                      "criteria": {"billing": "...", "infra": "..."}}}
+  --model <slug>            jev, kev-4b, clef, clef-flash or gpt-6-luna
+                            (default: the server's default)
+  --min-confidence <0-1>    mark answers below this confidence as uncertain
+
+Results:
+  --out, -o <file>          one JSON line per item (default: ${DEFAULT_OUT})
+  --resume                  skip ids already answered in --out; append the rest
+  --overwrite               replace an existing --out
+  --select-from <file>      only items whose row in this earlier results file
+  --where <filter>            matches: failed, uncertain or <question>=<answer>
+
+Other:
+  --agent <id>              agent to bill outside a Brainbase task
+                            (default: this folder's linked agent)
+  --concurrency <n>         requests in flight, 1-${MAX_CONCURRENCY} (default: ${DEFAULT_CONCURRENCY})
+
+Prints one JSON summary on stdout. Exits 0 when every item was sent (check
+counts.failed), 1 when the run stopped early (rerun with --resume), 2 for a
+usage error.
+`;
+function usageError2(stderr, message3) {
+  stderr(`brainbase decide: ${message3}
+Run \`brainbase decide --help\` for usage.
+`);
+  return 2;
+}
+function readQuestions(cwd2, file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs95.readFileSync(path107.resolve(cwd2, file), "utf8"));
+  } catch (error2) {
+    throw new DecideInputError(`Could not read questions from ${file}: ${error2.message}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || !Object.keys(parsed).length) {
+    throw new DecideInputError(`${file} must hold a JSON object of questions`);
+  }
+  return parsed;
+}
+function mergeSets(sets) {
+  const merged = { items: [], failures: [] };
+  for (const set3 of sets) {
+    appendAll(merged.items, set3.items);
+    appendAll(merged.failures, set3.failures);
+  }
+  const seen = new Set;
+  for (const { id } of [...merged.items, ...merged.failures]) {
+    if (seen.has(id)) {
+      throw new DecideInputError(`Two items share the id ${JSON.stringify(id)}; pass --id-field naming a unique field`);
+    }
+    seen.add(id);
+  }
+  return merged;
+}
+function chunk2(items, failures) {
+  const chunks = [];
+  let current = [];
+  let bytes = 0;
+  for (const item of items) {
+    const size2 = Buffer.byteLength(JSON.stringify(item));
+    if (size2 > MAX_REQUEST_BYTES) {
+      failures.push({ id: item.id, error: "Larger than one request can carry (6 MB)" });
+      continue;
+    }
+    if (current.length === MAX_ITEMS_PER_REQUEST || bytes + size2 > MAX_REQUEST_BYTES) {
+      chunks.push(current);
+      current = [];
+      bytes = 0;
+    }
+    current.push(item);
+    bytes += size2;
+  }
+  if (current.length)
+    chunks.push(current);
+  return chunks;
+}
+
+class Tally {
+  done = 0;
+  uncertainIds = [];
+  failed = [];
+  answers = {};
+  credits = 0;
+  model = null;
+  addRow(row) {
+    if (row.error !== undefined) {
+      this.failed.push({ id: row.id, reason: row.error });
+      return;
+    }
+    this.done += 1;
+    if (row.uncertain)
+      this.uncertainIds.push(row.id);
+  }
+  addResponse(response) {
+    this.model ??= response.model;
+    this.credits += response.credits;
+    for (const [question, counts] of Object.entries(response.answers)) {
+      const into = this.answers[question] ??= {};
+      for (const [answer, count] of Object.entries(counts)) {
+        into[answer] = (into[answer] ?? 0) + count;
+      }
+    }
+  }
+}
+async function runDecide(cwd2, argv, deps = {}) {
+  const stdout = deps.stdout ?? ((text4) => void process.stdout.write(text4));
+  const stderr = deps.stderr ?? ((text4) => void process.stderr.write(text4));
+  const started = Date.now();
+  let parsed;
+  try {
+    parsed = parseArgv(argv, OPTIONS);
+  } catch (error2) {
+    if (error2 instanceof ArgvParseError)
+      return usageError2(stderr, error2.message);
+    throw error2;
+  }
+  if (booleanOption(parsed, "help")) {
+    stdout(DECIDE_USAGE);
+    return 0;
+  }
+  const questionsFile = stringOption(parsed, "questions");
+  if (!questionsFile)
+    return usageError2(stderr, "--questions <file.json> is required");
+  const paths = parsed.positionals;
+  const globs = stringOptions(parsed, "items");
+  const jsonlFiles = stringOptions(parsed, "jsonl");
+  const csvFiles = stringOptions(parsed, "csv");
+  if (!paths.length && !globs.length && !jsonlFiles.length && !csvFiles.length) {
+    return usageError2(stderr, "name at least one source: paths, --items, --jsonl or --csv");
+  }
+  const minConfidenceRaw = stringOption(parsed, "minConfidence");
+  const minConfidence = minConfidenceRaw === undefined ? undefined : Number(minConfidenceRaw);
+  if (minConfidence !== undefined && !(minConfidence >= 0 && minConfidence <= 1)) {
+    return usageError2(stderr, "--min-confidence takes a number from 0 to 1");
+  }
+  const concurrencyRaw = stringOption(parsed, "concurrency");
+  const concurrency = concurrencyRaw === undefined ? DEFAULT_CONCURRENCY : Number(concurrencyRaw);
+  if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > MAX_CONCURRENCY) {
+    return usageError2(stderr, `--concurrency takes a whole number from 1 to ${MAX_CONCURRENCY}`);
+  }
+  const selectFrom = stringOption(parsed, "selectFrom");
+  const whereRaw = stringOption(parsed, "where");
+  if (Boolean(selectFrom) !== Boolean(whereRaw)) {
+    return usageError2(stderr, "--select-from and --where go together");
+  }
+  const resume = booleanOption(parsed, "resume");
+  const overwrite = booleanOption(parsed, "overwrite");
+  if (resume && overwrite)
+    return usageError2(stderr, "--resume and --overwrite cannot be combined");
+  const outArg = stringOption(parsed, "out") ?? DEFAULT_OUT;
+  const outPath = path107.resolve(cwd2, outArg);
+  let questions;
+  let set3;
+  let skipped = 0;
+  try {
+    questions = readQuestions(cwd2, questionsFile);
+    const rowOptions = {
+      idField: stringOption(parsed, "idField"),
+      textFields: stringOptions(parsed, "textField")
+    };
+    set3 = mergeSets([
+      readFileItems(cwd2, fileItems(cwd2, paths, globs)),
+      ...jsonlFiles.map((file) => jsonlItems(cwd2, file, rowOptions)),
+      ...csvFiles.map((file) => csvItems(cwd2, file, rowOptions))
+    ]);
+    if (selectFrom && whereRaw) {
+      const where = parseWhere(whereRaw);
+      const earlier = path107.resolve(cwd2, selectFrom);
+      if (!fs95.existsSync(earlier))
+        throw new DecideInputError(`No such results file: ${selectFrom}`);
+      const rows = readResults(earlier);
+      const keep = (id) => {
+        const row = rows.get(id);
+        return row !== undefined && rowMatches(row, where);
+      };
+      set3 = { items: set3.items.filter((item) => keep(item.id)), failures: set3.failures.filter((f4) => keep(f4.id)) };
+    }
+    const outHasRows = fs95.existsSync(outPath) && fs95.statSync(outPath).size > 0;
+    if (outHasRows && !resume && !overwrite) {
+      throw new DecideInputError(`${outArg} already has results; pass --resume to continue it or --overwrite to replace it`);
+    }
+    if (resume) {
+      const answered = new Set([...readResults(outPath).values()].filter((row) => row.error === undefined).map((row) => row.id));
+      const before2 = set3.items.length + set3.failures.length;
+      set3 = {
+        items: set3.items.filter((item) => !answered.has(item.id)),
+        failures: set3.failures.filter((failure) => !answered.has(failure.id))
+      };
+      skipped = before2 - set3.items.length - set3.failures.length;
+    }
+  } catch (error2) {
+    if (error2 instanceof DecideInputError)
+      return usageError2(stderr, error2.message);
+    throw error2;
+  }
+  fs95.mkdirSync(path107.dirname(outPath), { recursive: true });
+  if (resume)
+    repairResultsTail(outPath);
+  else
+    fs95.writeFileSync(outPath, "");
+  const append = (rows) => {
+    if (rows.length)
+      fs95.appendFileSync(outPath, rows.map((row) => JSON.stringify(row)).join(`
+`) + `
+`);
+  };
+  const tally = new Tally;
+  const localFailures = [...set3.failures];
+  const chunks = chunk2(set3.items, localFailures);
+  const localRows = localFailures.map((failure) => ({ id: failure.id, error: failure.error }));
+  append(localRows);
+  localRows.forEach((row) => tally.addRow(row));
+  const total = set3.items.length + set3.failures.length;
+  let stopError;
+  let unsent = 0;
+  let next = 0;
+  if (chunks.length) {
+    let credential;
+    try {
+      credential = await resolveDecideCredential(cwd2, stringOption(parsed, "agent"));
+    } catch (error2) {
+      stopError = error2.message;
+    }
+    if (credential) {
+      const modelFlag = stringOption(parsed, "model");
+      const body = (items) => ({
+        questions,
+        items,
+        ...modelFlag ? { model: modelFlag } : {},
+        ...minConfidence !== undefined ? { min_confidence: minConfidence } : {},
+        output: "full"
+      });
+      const progress2 = process.stderr.isTTY && !deps.stderr;
+      let answeredSoFar = localRows.length;
+      let replacement;
+      const send = async (items) => {
+        const used = credential;
+        try {
+          return await postDecide(used, body(items), deps);
+        } catch (error2) {
+          if (!(error2 instanceof DecideHttpError && error2.status === 401 && used.source === "agent_key")) {
+            throw error2;
+          }
+          replacement ??= replaceAgentKey(used).then((fresh2) => credential = fresh2);
+          const fresh = await replacement;
+          if (fresh.key === used.key)
+            throw error2;
+          return postDecide(fresh, body(items), deps);
+        }
+      };
+      const worker = async () => {
+        while (next < chunks.length && stopError === undefined) {
+          const items = chunks[next++];
+          let rows;
+          try {
+            const response = await send(items);
+            tally.addResponse(response);
+            rows = response.rows;
+          } catch (error2) {
+            const message3 = error2.message;
+            const refusal = error2 instanceof DecideHttpError;
+            if (!refusal || error2.status !== null && STOP_STATUSES.has(error2.status)) {
+              stopError ??= refusal && error2.status === 404 ? `/v1/decide is not available on ${credential.base} (${message3})` : message3;
+              unsent += items.length;
+              continue;
+            }
+            rows = items.map((item) => ({ id: item.id, error: `Request failed: ${message3}` }));
+          }
+          append(rows);
+          rows.forEach((row) => tally.addRow(row));
+          answeredSoFar += rows.length;
+          if (progress2)
+            process.stderr.write(`\rdecided ${answeredSoFar}/${total}`);
+        }
+      };
+      await Promise.all(Array.from({ length: Math.min(concurrency, chunks.length) }, worker));
+      if (progress2)
+        process.stderr.write(`
+`);
+    }
+    unsent += chunks.slice(next).reduce((count, items) => count + items.length, 0);
+  }
+  const summary = {
+    status: stopError === undefined ? "done" : "stopped",
+    model: tally.model ?? stringOption(parsed, "model") ?? null,
+    counts: {
+      total,
+      done: tally.done,
+      uncertain: tally.uncertainIds.length,
+      failed: tally.failed.length,
+      skipped,
+      unsent
+    },
+    answers: tally.answers,
+    uncertain_ids: tally.uncertainIds.slice(0, SUMMARY_UNCERTAIN_IDS),
+    failed: tally.failed.slice(0, SUMMARY_FAILED),
+    credits: tally.credits,
+    elapsed_ms: Date.now() - started,
+    out: path107.relative(cwd2, outPath) || outArg,
+    ...stopError !== undefined ? { error: `${stopError}. Answers so far are in ${outArg}; rerun with --resume to continue.` } : {}
+  };
+  stdout(JSON.stringify(summary, null, 2) + `
+`);
+  return stopError === undefined ? 0 : 1;
+}
+
 // src/ui/console-streams.ts
 import { format as format3 } from "node:util";
 function routeConsoleThroughStreams() {
@@ -97601,6 +98848,7 @@ var COMMANDS3 = [
   "status",
   "mcp",
   "integrations",
+  "decide",
   "run",
   "help",
   "version"
@@ -97728,6 +98976,10 @@ function help() {
   out.push(`  ${import_picocolors81.default.cyan("token rename")} ${import_picocolors81.default.dim("<id>")}                  ${import_picocolors81.default.dim("relabel a token")}`);
   out.push(`  ${import_picocolors81.default.cyan("token revoke")} ${import_picocolors81.default.dim("<id>")}                  ${import_picocolors81.default.dim("revoke a token")}`);
   out.push("");
+  out.push(divider("DECISIONS"));
+  out.push("");
+  out.push(`  ${import_picocolors81.default.cyan("decide")} ${import_picocolors81.default.dim("-q <questions.json> <sources...>")}  ${import_picocolors81.default.dim("answer decision-model questions over many files or rows in a few requests (`decide --help`)")}`);
+  out.push("");
   out.push(divider("MCP"));
   out.push("");
   out.push(`  ${import_picocolors81.default.cyan("mcp check")} ${import_picocolors81.default.dim("[--json]")}              ${import_picocolors81.default.dim("verify MCP server connectivity through the brainbase proxy (runs at sandbox bootstrap)")}`);
@@ -97988,7 +99240,7 @@ async function main() {
   const rawCwd = process14.cwd();
   const cwd2 = (() => {
     try {
-      return fs94.realpathSync(rawCwd);
+      return fs96.realpathSync(rawCwd);
     } catch {
       return rawCwd;
     }
@@ -98005,7 +99257,7 @@ async function main() {
     await runRun(cwd2, argv);
     return;
   }
-  const ownsArgs = new Set(["task", "benchmark", "interface", "interfaces"]);
+  const ownsArgs = new Set(["task", "benchmark", "interface", "interfaces", "decide"]);
   if (cmd === "agent")
     argv.splice(0, argv.length, ...routeAgentSurfaceArgs(argv));
   const sharedArgs = ownsArgs.has(cmd) || cmd === "agent" && ["versions", "surface", "connect", "disconnect", "connections"].includes(argv[0] ?? "") ? [] : argv;
@@ -98242,6 +99494,10 @@ async function main() {
         process14.exitCode = code;
         break;
       }
+      case "decide": {
+        process14.exitCode = await runDecide(cwd2, argv);
+        break;
+      }
       case "integration":
       case "integrations": {
         const sub = argv.shift();