brainstorming 0.1.0

package/dist/index.js

@@ -0,0 +1,1495 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import React4 from "react";
+import { render as render2 } from "ink";
+
+// ../../packages/core/src/mentions.ts
+var MENTION_RE = /@([a-z0-9][a-z0-9._:-]*)/gi;
+var ALL_MENTION = "all";
+function parseMentions(content, roster) {
+  const known = new Set(roster.map((n) => n.toLowerCase()));
+  const found = [];
+  for (const match of content.matchAll(MENTION_RE)) {
+    const name = match[1].toLowerCase();
+    if (name === ALL_MENTION) return [...roster];
+    if (known.has(name) && !found.includes(name)) found.push(name);
+  }
+  return found;
+}
+
+// ../../packages/core/src/transcript.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname } from "path";
+var TranscriptStore = class _TranscriptStore {
+  #messages = [];
+  #filePath;
+  constructor(filePath) {
+    this.#filePath = filePath;
+    if (filePath) mkdirSync(dirname(filePath), { recursive: true });
+  }
+  static load(filePath) {
+    const store = new _TranscriptStore(filePath);
+    if (existsSync(filePath)) {
+      for (const line of readFileSync(filePath, "utf8").split("\n")) {
+        if (line.trim()) store.#messages.push(JSON.parse(line));
+      }
+    }
+    return store;
+  }
+  append(msg) {
+    this.#messages.push(msg);
+    if (this.#filePath) appendFileSync(this.#filePath, JSON.stringify(msg) + "\n");
+  }
+  all() {
+    return this.#messages;
+  }
+  get length() {
+    return this.#messages.length;
+  }
+};
+
+// ../../packages/core/src/router.ts
+function resolveTargets(args2) {
+  if (args2.mentions.length > 0) return [...args2.mentions];
+  return [...args2.sticky];
+}
+
+// ../../packages/core/src/prompt.ts
+function formatLine(msg) {
+  return `[${msg.author}]: ${msg.content}`;
+}
+function renderPrompt(input) {
+  const lines = [];
+  if (input.digest.length > 0) {
+    lines.push("[Chat since your last turn]");
+    for (const m of input.digest) lines.push(formatLine(m));
+    lines.push("---");
+  }
+  lines.push("[You are addressed]");
+  lines.push(formatLine(input.addressed));
+  return lines.join("\n");
+}
+
+// ../../packages/core/src/fake-adapter.ts
+import { randomUUID } from "crypto";
+import { setTimeout as sleep } from "timers/promises";
+var FakeAdapter = class {
+  constructor(name, script = {}) {
+    this.name = name;
+    this.#script = { replies: [], defaultReply: "(no reply)", chunkDelayMs: 0, ...script };
+  }
+  name;
+  capabilities = { tools: false, steering: false, resume: false };
+  lastInput = null;
+  #script;
+  async start(_ctx) {
+  }
+  async interrupt() {
+  }
+  async stop() {
+    return void 0;
+  }
+  async *prompt(input, signal) {
+    this.lastInput = input;
+    const rule = this.#script.replies.find(
+      (r) => !r.match || r.match.test(input.addressed.content)
+    );
+    if (rule?.error) {
+      yield { type: "error", error: { message: rule.error, fatal: false } };
+      return;
+    }
+    let reply = rule?.reply ?? this.#script.defaultReply;
+    let denied = false;
+    if (rule?.permission) {
+      let resolveDecision;
+      const decision = new Promise((res) => resolveDecision = res);
+      yield {
+        type: "permission-request",
+        request: {
+          id: randomUUID(),
+          agent: this.name,
+          action: rule.permission.action,
+          preview: rule.permission.preview
+        },
+        respond: (d) => resolveDecision(d)
+      };
+      denied = await decision === "deny";
+      if (denied) reply = rule.permission.denyReply ?? "Understood, I won't.";
+    }
+    if (rule?.activity && !denied) yield { type: "activity", activity: rule.activity };
+    for (const chunk of reply.split(/(?<= )/)) {
+      if (signal.aborted) return;
+      if (this.#script.chunkDelayMs > 0) await sleep(this.#script.chunkDelayMs);
+      yield { type: "text-delta", text: chunk };
+    }
+    yield { type: "done", finalText: reply };
+  }
+};
+
+// ../../packages/core/src/persona.ts
+function buildPersona(opts) {
+  const others = opts.roster.filter((n) => n !== opts.name);
+  const lines = [
+    `You are @${opts.name}, one of several AI agents collaborating with a human in a shared group chat over a codebase.`,
+    others.length > 0 ? `Other agents in the room: ${others.map((n) => "@" + n).join(", ")}. The human user is here too.` : `The human user is here too.`,
+    `Messages appear as "[author]: text". To address someone directly, write @their-name; write @all to ask everyone.`,
+    `Keep chat replies short and concrete. When you are asked to do real work, do it in the shared workspace.`,
+    `Only speak when you are addressed or can add clear value \u2014 avoid repeating what others already said.`
+  ];
+  const extra = opts.extra?.trim();
+  if (extra) lines.push(extra);
+  return lines.join("\n");
+}
+
+// ../../packages/core/src/room.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var Room = class {
+  #transcript;
+  #adapters = /* @__PURE__ */ new Map();
+  #cursors = /* @__PURE__ */ new Map();
+  #sticky = [];
+  #listeners = /* @__PURE__ */ new Set();
+  #roundBudget;
+  #abort = null;
+  #pending = [];
+  constructor(opts) {
+    this.#transcript = opts.transcript;
+    for (const a of opts.adapters) this.#adapters.set(a.name, a);
+    this.#roundBudget = opts.roundBudget ?? 3;
+  }
+  get roster() {
+    return [...this.#adapters.keys()];
+  }
+  get stickyTargets() {
+    return [...this.#sticky];
+  }
+  get pendingMentions() {
+    return [...this.#pending];
+  }
+  get transcript() {
+    return this.#transcript;
+  }
+  setRoundBudget(n) {
+    this.#roundBudget = n;
+  }
+  /**
+   * Mark the entire current transcript as already seen by every agent.
+   * Used when resuming a room so agents receive only NEW messages as digests
+   * (their pre-resume context comes from their backend session or ctx.transcript).
+   */
+  markAllSeen() {
+    const n = this.#transcript.length;
+    for (const name of this.#adapters.keys()) this.#cursors.set(name, n);
+  }
+  on(fn) {
+    this.#listeners.add(fn);
+    return () => this.#listeners.delete(fn);
+  }
+  async start(ctx) {
+    await Promise.all([...this.#adapters.values()].map((a) => a.start(ctx)));
+  }
+  async sendUserMessage(content) {
+    const mentions = parseMentions(content, this.roster);
+    const targets = resolveTargets({ mentions, sticky: this.#sticky });
+    if (targets.length === 0) return { status: "needs-target" };
+    this.#sticky = targets;
+    const msg = this.#append("user", content, "chat", targets);
+    await this.#runCascade([{ to: targets, message: msg }]);
+    return { status: "sent" };
+  }
+  async continueCascade() {
+    if (this.#pending.length === 0) return;
+    const pending = this.#pending;
+    this.#pending = [];
+    await this.#runCascade(pending.map((p) => ({ to: [p.to], message: p.message })));
+  }
+  interrupt() {
+    this.#abort?.abort();
+  }
+  /** Append a system note to the transcript (e.g. a recorded decision). */
+  note(content) {
+    return this.#append("system", content, "system", []);
+  }
+  #emit(ev) {
+    for (const fn of this.#listeners) fn(ev);
+  }
+  #append(author, content, kind, mentions) {
+    const msg = { id: randomUUID2(), ts: Date.now(), author, content, mentions, kind };
+    this.#transcript.append(msg);
+    this.#emit({ type: "message", message: msg });
+    return msg;
+  }
+  #status(agent, status) {
+    this.#emit({ type: "agent-status", agent, status });
+  }
+  async #runCascade(firstWave) {
+    const ac = new AbortController();
+    this.#abort = ac;
+    let wave = firstWave;
+    let round = 0;
+    try {
+      while (wave.length > 0) {
+        const deliveries = wave.flatMap((d) => d.to.map((agent) => ({ agent, message: d.message })));
+        const replies = await Promise.all(
+          deliveries.map((d) => this.#deliver(d.agent, d.message, ac.signal))
+        );
+        if (ac.signal.aborted) {
+          this.#append("system", "cascade interrupted", "system", []);
+          return;
+        }
+        const next = [];
+        for (const reply of replies) {
+          if (!reply) continue;
+          const targets = reply.mentions.filter((t) => t !== reply.author);
+          if (targets.length > 0) next.push({ to: targets, message: reply });
+        }
+        if (next.length === 0) return;
+        round += 1;
+        if (round > this.#roundBudget) {
+          this.#pending = next.flatMap(
+            (d) => d.to.map((to) => ({ from: d.message.author, to, message: d.message }))
+          );
+          this.#append(
+            "system",
+            `round budget (${this.#roundBudget}) exhausted \u2014 pending: ` + this.#pending.map((p) => `${p.from}\u2192@${p.to}`).join(", ") + " \u2014 use /continue to let them proceed",
+            "system",
+            []
+          );
+          this.#emit({ type: "budget-exhausted", pending: this.pendingMentions });
+          return;
+        }
+        wave = next;
+      }
+    } finally {
+      this.#abort = null;
+    }
+  }
+  async #deliver(agentName, addressed, signal) {
+    const adapter = this.#adapters.get(agentName);
+    if (!adapter || signal.aborted) return null;
+    const snapshot = this.#transcript.all();
+    const cursor = this.#cursors.get(agentName) ?? 0;
+    const digest = snapshot.slice(cursor).filter(
+      (m) => m.id !== addressed.id && m.author !== agentName && m.kind !== "activity" && m.kind !== "permission"
+    );
+    this.#cursors.set(agentName, snapshot.length);
+    this.#status(agentName, "thinking");
+    let acc = "";
+    let final = null;
+    try {
+      for await (const ev of adapter.prompt({ digest, addressed }, signal)) {
+        switch (ev.type) {
+          case "text-delta":
+            acc += ev.text;
+            this.#emit({ type: "stream-delta", agent: agentName, text: ev.text });
+            break;
+          case "activity":
+            this.#append(agentName, `\u25B8 ${ev.activity.title}`, "activity", []);
+            break;
+          case "permission-request": {
+            this.#status(agentName, "awaiting-permission");
+            const respond = (d) => {
+              this.#status(agentName, "thinking");
+              ev.respond(d);
+            };
+            this.#emit({ type: "permission", agent: agentName, request: ev.request, respond });
+            break;
+          }
+          case "usage":
+            break;
+          // surfaced in a later phase
+          case "done":
+            final = ev.finalText;
+            break;
+          case "error":
+            this.#emit({ type: "agent-error", agent: agentName, error: ev.error });
+            this.#append("system", `@${agentName} failed: ${ev.error.message}`, "system", []);
+            return null;
+        }
+      }
+    } catch (err) {
+      if (!signal.aborted) {
+        const error = { message: String(err), fatal: false };
+        this.#emit({ type: "agent-error", agent: agentName, error });
+        this.#append("system", `@${agentName} failed: ${error.message}`, "system", []);
+      }
+      return null;
+    } finally {
+      this.#status(agentName, "idle");
+    }
+    if (signal.aborted) return null;
+    const text = (final ?? acc).trim();
+    if (!text) return null;
+    const mentions = parseMentions(text, this.roster).filter((n) => n !== agentName);
+    return this.#append(agentName, text, "chat", mentions);
+  }
+};
+
+// ../../packages/core/src/room-store.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join } from "path";
+var RoomStore = class {
+  #dir;
+  constructor(workspaceDir) {
+    this.#dir = join(workspaceDir, ".brainstorming");
+    mkdirSync2(this.#dir, { recursive: true });
+  }
+  get dir() {
+    return this.#dir;
+  }
+  get transcriptPath() {
+    return join(this.#dir, "room.jsonl");
+  }
+  get metaPath() {
+    return join(this.#dir, "room.json");
+  }
+  get exists() {
+    return existsSync2(this.metaPath);
+  }
+  loadTranscript() {
+    return TranscriptStore.load(this.transcriptPath);
+  }
+  loadMeta() {
+    if (!existsSync2(this.metaPath)) return null;
+    try {
+      return JSON.parse(readFileSync2(this.metaPath, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  saveMeta(meta) {
+    writeFileSync(this.metaPath, JSON.stringify(meta, null, 2) + "\n");
+  }
+};
+
+// ../../packages/tui/src/app.tsx
+import { useCallback, useState as useState3 } from "react";
+import { Box as Box6, Text as Text6, useApp, useInput as useInput2 } from "ink";
+
+// ../../packages/tui/src/use-room.ts
+import { useEffect, useState } from "react";
+function useRoom(room) {
+  const [messages, setMessages] = useState([...room.transcript.all()]);
+  const [live, setLive] = useState(/* @__PURE__ */ new Map());
+  const [statuses, setStatuses] = useState(
+    new Map(room.roster.map((n) => [n, "idle"]))
+  );
+  const [permissions, setPermissions] = useState([]);
+  const [notice, setNotice] = useState(null);
+  useEffect(() => {
+    return room.on((ev) => {
+      switch (ev.type) {
+        case "message":
+          setMessages([...room.transcript.all()]);
+          if (ev.message.author !== "user" && ev.message.author !== "system") {
+            setLive((prev) => {
+              const next = new Map(prev);
+              next.delete(ev.message.author);
+              return next;
+            });
+          }
+          break;
+        case "stream-delta":
+          setLive((prev) => {
+            const next = new Map(prev);
+            next.set(ev.agent, (next.get(ev.agent) ?? "") + ev.text);
+            return next;
+          });
+          break;
+        case "agent-status":
+          setStatuses((prev) => new Map(prev).set(ev.agent, ev.status));
+          if (ev.status === "idle") {
+            setLive((prev) => {
+              const next = new Map(prev);
+              next.delete(ev.agent);
+              return next;
+            });
+          }
+          break;
+        case "permission": {
+          const prompt = {
+            agent: ev.agent,
+            request: ev.request,
+            respond: ev.respond
+          };
+          setPermissions((prev) => [...prev, prompt]);
+          break;
+        }
+        case "budget-exhausted":
+          setNotice("Round budget exhausted \u2014 /continue to let agents proceed.");
+          break;
+        case "agent-error":
+          setNotice(`@${ev.agent} error: ${ev.error.message}`);
+          break;
+      }
+    });
+  }, [room]);
+  return { messages, live, statuses, permissions, notice };
+}
+
+// ../../packages/tui/src/components/transcript.tsx
+import { Box, Static, Text } from "ink";
+
+// ../../packages/tui/src/theme.ts
+var PALETTE = ["yellow", "green", "blue", "magenta", "red", "white"];
+function authorColor(name) {
+  if (name === "user") return "cyan";
+  if (name === "system") return "gray";
+  let hash = 0;
+  for (const ch of name) hash = hash * 31 + ch.charCodeAt(0) >>> 0;
+  return PALETTE[hash % PALETTE.length];
+}
+
+// ../../packages/tui/src/components/transcript.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function Transcript({ messages }) {
+  return /* @__PURE__ */ jsx(Static, { items: messages, children: (m) => /* @__PURE__ */ jsx(Box, { marginBottom: m.kind === "chat" ? 1 : 0, children: m.kind === "chat" ? /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, color: authorColor(m.author), children: [
+      "[",
+      m.author,
+      "]"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      m.content
+    ] })
+  ] }) : /* @__PURE__ */ jsx(Text, { dimColor: true, italic: m.kind === "system", children: m.kind === "system" ? `\u2014 ${m.content} \u2014` : m.content }) }, m.id) });
+}
+
+// ../../packages/tui/src/components/live-blocks.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function LiveBlocks({ live }) {
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: [...live.entries()].map(([agent, text]) => /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, color: authorColor(agent), children: [
+      "[",
+      agent,
+      "]"
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      " ",
+      text
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u258B" })
+  ] }) }, agent)) });
+}
+
+// ../../packages/tui/src/components/status-bar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var DOT = {
+  idle: "\u25CF",
+  thinking: "\u25D0",
+  "awaiting-permission": "\u25CD"
+};
+function StatusBar({
+  title,
+  statuses
+}) {
+  return /* @__PURE__ */ jsxs3(Box3, { borderStyle: "round", paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: title }),
+    /* @__PURE__ */ jsx3(Text3, { children: [...statuses.entries()].map(([name, status]) => /* @__PURE__ */ jsxs3(Text3, { children: [
+      " ",
+      /* @__PURE__ */ jsx3(Text3, { color: status === "idle" ? "gray" : authorColor(name), children: DOT[status] }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        " ",
+        name
+      ] })
+    ] }, name)) })
+  ] });
+}
+
+// ../../packages/tui/src/components/chat-input.tsx
+import { useRef, useState as useState2 } from "react";
+import { Box as Box4, Text as Text4, useInput } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function mentionPrefix(value) {
+  const m = /(?:^|\s)@([a-z0-9._:-]*)$/i.exec(value);
+  return m ? m[1].toLowerCase() : null;
+}
+function suggestions(value, roster) {
+  const prefix = mentionPrefix(value);
+  if (prefix === null) return [];
+  return ["all", ...roster].filter((n) => n.startsWith(prefix) && n !== prefix);
+}
+function ChatInput({
+  roster,
+  onSubmit,
+  disabled
+}) {
+  const [value, setValue] = useState2("");
+  const valueRef = useRef("");
+  const setVal = (next) => {
+    valueRef.current = next;
+    setValue(next);
+  };
+  const hints = suggestions(value, roster);
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        const line = valueRef.current.trim();
+        if (line) {
+          setVal("");
+          onSubmit(line);
+        }
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setVal(valueRef.current.slice(0, -1));
+        return;
+      }
+      if (key.tab) {
+        const prefix = mentionPrefix(valueRef.current);
+        const options = prefix === null ? [] : suggestions(valueRef.current, roster);
+        if (prefix !== null && options.length > 0) {
+          setVal(valueRef.current.slice(0, valueRef.current.length - prefix.length) + options[0] + " ");
+        }
+        return;
+      }
+      if (input && !key.ctrl && !key.meta && !key.escape) setVal(valueRef.current + input);
+    },
+    { isActive: !disabled }
+  );
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Box4, { borderStyle: "round", paddingX: 1, children: /* @__PURE__ */ jsxs4(Text4, { children: [
+      "> ",
+      value,
+      /* @__PURE__ */ jsx4(Text4, { inverse: true, children: " " })
+    ] }) }),
+    hints.length > 0 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "tab: ",
+      hints.map((h) => "@" + h).join("  ")
+    ] }) : null
+  ] });
+}
+
+// ../../packages/tui/src/components/permission-card.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function PermissionCard({ prompt }) {
+  return /* @__PURE__ */ jsxs5(Box5, { borderStyle: "double", borderColor: "yellow", flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "yellow", children: [
+        "PERMISSION",
+        " "
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { bold: true, color: authorColor(prompt.agent), children: [
+        "@",
+        prompt.agent
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        " wants to ",
+        prompt.request.action
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: prompt.request.preview }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "green", children: "[i]" }),
+      " allow once ",
+      /* @__PURE__ */ jsx5(Text5, { color: "green", children: "[o]" }),
+      " allow for session",
+      " ",
+      /* @__PURE__ */ jsx5(Text5, { color: "red", children: "[r]" }),
+      " deny"
+    ] })
+  ] });
+}
+
+// ../../packages/tui/src/commands.ts
+function parseCommand(line) {
+  if (!line.startsWith("/")) return { kind: "message", content: line };
+  const [name, ...rest] = line.slice(1).split(/\s+/);
+  switch (name) {
+    case "quit":
+      return { kind: "quit" };
+    case "continue":
+      return { kind: "continue" };
+    case "help":
+      return { kind: "help" };
+    case "decide": {
+      const text = rest.join(" ").trim();
+      if (text) return { kind: "decide", text };
+      return { kind: "unknown", name: "decide" };
+    }
+    case "budget": {
+      const n = Number(rest[0]);
+      if (Number.isInteger(n) && n > 0) return { kind: "budget", n };
+      return { kind: "unknown", name: "budget" };
+    }
+    default:
+      return { kind: "unknown", name };
+  }
+}
+var HELP_TEXT = "commands: /decide <text> /continue /budget N /help /quit \u2014 mention with @name or @all; ESC interrupts";
+
+// ../../packages/tui/src/app.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function App({
+  room,
+  title = "brainstorming",
+  onDecide
+}) {
+  const view = useRoom(room);
+  const { exit } = useApp();
+  const [localNotice, setLocalNotice] = useState3(null);
+  const [answered, setAnswered] = useState3([]);
+  const activeCard = view.permissions.find((p) => !answered.includes(p)) ?? null;
+  const answer = (card, decision) => {
+    setAnswered((prev) => [...prev, card]);
+    card.respond(decision);
+  };
+  useInput2((input, key) => {
+    if (key.escape) {
+      room.interrupt();
+      return;
+    }
+    if (activeCard) {
+      if (input === "i") answer(activeCard, "allow-once");
+      else if (input === "o") answer(activeCard, "allow-session");
+      else if (input === "r") answer(activeCard, "deny");
+    }
+  });
+  const handleSubmit = useCallback(
+    (line) => {
+      setLocalNotice(null);
+      const cmd = parseCommand(line);
+      switch (cmd.kind) {
+        case "quit":
+          exit();
+          return;
+        case "help":
+          setLocalNotice(HELP_TEXT);
+          return;
+        case "budget":
+          room.setRoundBudget(cmd.n);
+          setLocalNotice(`round budget set to ${cmd.n}`);
+          return;
+        case "continue":
+          void room.continueCascade();
+          return;
+        case "decide":
+          room.note(`DECISION: ${cmd.text}`);
+          onDecide?.(cmd.text);
+          setLocalNotice(`decision recorded: ${cmd.text}`);
+          return;
+        case "unknown":
+          setLocalNotice(`unknown command: /${cmd.name} \u2014 ${HELP_TEXT}`);
+          return;
+        case "message":
+          void room.sendUserMessage(cmd.content).then((res) => {
+            if (res.status === "needs-target") {
+              setLocalNotice("No target: mention someone, e.g. @claude or @all.");
+            }
+          });
+      }
+    },
+    [room, exit, onDecide]
+  );
+  const notice = localNotice ?? view.notice;
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(StatusBar, { title, statuses: view.statuses }),
+    /* @__PURE__ */ jsx6(Transcript, { messages: view.messages }),
+    /* @__PURE__ */ jsx6(LiveBlocks, { live: view.live }),
+    activeCard ? /* @__PURE__ */ jsx6(PermissionCard, { prompt: activeCard }) : null,
+    notice ? /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: notice }) : null,
+    /* @__PURE__ */ jsx6(ChatInput, { roster: room.roster, onSubmit: handleSubmit, disabled: activeCard !== null })
+  ] });
+}
+
+// src/demo.ts
+function demoAdapters() {
+  return [
+    new FakeAdapter("claude", {
+      chunkDelayMs: 15,
+      replies: [
+        {
+          match: /rest|graphql|api/i,
+          reply: "I lean REST here \u2014 simpler caching. @codex do you agree?"
+        },
+        { match: /ping|pong/i, reply: "@codex pong" }
+      ],
+      defaultReply: "Interesting. What is the goal?"
+    }),
+    new FakeAdapter("codex", {
+      chunkDelayMs: 15,
+      replies: [
+        { match: /do you agree/i, reply: "Agreed \u2014 versioned REST plus OpenAPI. I can scaffold it." },
+        { match: /ping|pong/i, reply: "@claude ping" },
+        {
+          match: /test/i,
+          reply: "Ran the tests \u2014 all green.",
+          permission: {
+            action: "run command",
+            preview: "pnpm test",
+            denyReply: "Okay, skipping the test run."
+          },
+          activity: { kind: "command", title: "ran: pnpm test (12 passed)", status: "ok" }
+        }
+      ],
+      defaultReply: "Give me a concrete task and I will do it."
+    }),
+    new FakeAdapter("antigravity", {
+      chunkDelayMs: 15,
+      defaultReply: "Alternative view: consider the long-term client list before deciding."
+    }),
+    new FakeAdapter("ollama", {
+      chunkDelayMs: 15,
+      defaultReply: "Opinion: keep it boring and ship."
+    })
+  ];
+}
+
+// src/run.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { appendFileSync as appendFileSync2 } from "fs";
+import { join as join3 } from "path";
+import React3 from "react";
+import { render } from "ink";
+
+// src/agents.ts
+import { execFileSync } from "child_process";
+
+// ../../packages/adapters/src/antigravity.ts
+import { spawn as nodeSpawn } from "child_process";
+import readline from "readline";
+var AntigravityAdapter = class {
+  constructor(name = "antigravity", opts = {}) {
+    this.name = name;
+    this.#bin = opts.binPath ?? process.env.AGY_BIN ?? "agy";
+    this.#model = opts.model;
+    this.#permissionMode = opts.permissionMode ?? "accept-edits";
+    this.#printTimeout = opts.printTimeout ?? "30m";
+    this.#spawn = opts.spawn ?? this.#defaultSpawn;
+  }
+  name;
+  capabilities = { tools: true, steering: false, resume: true };
+  #conversationId;
+  #cwd = process.cwd();
+  #persona = "";
+  #child = null;
+  #bin;
+  #model;
+  #permissionMode;
+  #printTimeout;
+  #spawn;
+  /** The captured conversation id, once a turn has run (persist to resume later). */
+  get sessionId() {
+    return this.#conversationId;
+  }
+  #defaultSpawn = (args2, opts) => {
+    const child = nodeSpawn(this.#bin, args2, {
+      cwd: opts.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    if (!child.stdout || !child.stderr) throw new Error("agy: stdout/stderr pipes unavailable");
+    return {
+      stdout: child.stdout,
+      stderr: child.stderr,
+      on: (event, listener) => child.on(event, listener),
+      kill: (signal) => void child.kill(signal)
+    };
+  };
+  async start(ctx) {
+    this.#cwd = ctx.workspaceDir;
+    this.#persona = ctx.persona;
+    this.#conversationId = ctx.savedSessionId ?? this.#conversationId;
+  }
+  async interrupt() {
+    this.#child?.kill("SIGTERM");
+  }
+  async stop() {
+    this.#child?.kill("SIGTERM");
+    this.#child = null;
+    return this.#conversationId;
+  }
+  #buildArgs(promptText) {
+    const args2 = ["--output-format", "stream-json", "--print-timeout", this.#printTimeout];
+    if (this.#model) args2.push("--model", this.#model);
+    args2.push("--add-dir", this.#cwd);
+    if (this.#permissionMode === "sandbox-auto") args2.push("--sandbox", "--dangerously-skip-permissions");
+    else if (this.#permissionMode === "plan") args2.push("--mode", "plan");
+    else args2.push("--mode", "accept-edits");
+    if (this.#conversationId) args2.push("--conversation", this.#conversationId);
+    args2.push("-p", promptText);
+    return args2;
+  }
+  async *prompt(input, signal) {
+    const base = renderPrompt(input);
+    const promptText = this.#conversationId || !this.#persona ? base : `${this.#persona}
+
+${base}`;
+    const child = this.#spawn(this.#buildArgs(promptText), { cwd: this.#cwd });
+    this.#child = child;
+    const queue = [];
+    let wake = null;
+    let finished = false;
+    let closeCode = null;
+    let sawResult = false;
+    const push = (ev) => {
+      queue.push(ev);
+      wake?.();
+      wake = null;
+    };
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      let ev;
+      try {
+        ev = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      switch (ev.event) {
+        case "init":
+          if (ev.conversation_id) this.#conversationId = ev.conversation_id;
+          break;
+        case "step_update": {
+          const s = ev.step_update ?? {};
+          const stepType = s.step_type;
+          if (stepType === "agent_response" && typeof s.text_delta === "string" && s.text_delta) {
+            push({ type: "text-delta", text: s.text_delta });
+          } else if (stepType === "tool_call") {
+            push({
+              type: "activity",
+              activity: {
+                kind: "tool",
+                title: s.tool_name ?? "tool call",
+                status: s.state === "DONE" ? "ok" : "running"
+              }
+            });
+          }
+          break;
+        }
+        case "result": {
+          const r = ev.result ?? {};
+          sawResult = true;
+          if (r.conversation_id) this.#conversationId = r.conversation_id;
+          if (r.status === "SUCCESS") {
+            push({ type: "done", finalText: r.response ?? "" });
+          } else {
+            push({
+              type: "error",
+              error: { message: r.error || r.status || "antigravity error", fatal: false }
+            });
+          }
+          break;
+        }
+      }
+    });
+    child.on("close", (code) => {
+      closeCode = code;
+    });
+    rl.on("close", () => {
+      finished = true;
+      wake?.();
+      wake = null;
+    });
+    const onAbort = () => child.kill("SIGTERM");
+    if (signal.aborted) child.kill("SIGTERM");
+    else signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      while (true) {
+        while (queue.length) yield queue.shift();
+        if (finished) break;
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+      while (queue.length) yield queue.shift();
+      if (!sawResult && !signal.aborted) {
+        yield {
+          type: "error",
+          error: { message: `agy exited (code ${closeCode ?? "unknown"}) with no result`, fatal: false }
+        };
+      }
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+      rl.close();
+      this.#child = null;
+    }
+  }
+};
+
+// ../../packages/adapters/src/claude.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function preview(input) {
+  try {
+    return JSON.stringify(input).slice(0, 500);
+  } catch {
+    return String(input).slice(0, 500);
+  }
+}
+var ClaudeAdapter = class {
+  constructor(name = "claude", opts = {}) {
+    this.name = name;
+    this.#permissionMode = opts.permissionMode ?? "default";
+    this.#query = opts.queryFn ?? this.#defaultQuery;
+  }
+  name;
+  capabilities = { tools: true, steering: false, resume: true };
+  #sessionId;
+  #cwd = process.cwd();
+  #persona = "";
+  #permissionMode;
+  #query;
+  get sessionId() {
+    return this.#sessionId;
+  }
+  #defaultQuery = async function* (params) {
+    const { query } = await import("@anthropic-ai/claude-agent-sdk");
+    const q = query({ prompt: params.prompt, options: params.options });
+    for await (const message of q) yield message;
+  };
+  async start(ctx) {
+    this.#cwd = ctx.workspaceDir;
+    this.#persona = ctx.persona;
+    this.#sessionId = ctx.savedSessionId ?? this.#sessionId;
+  }
+  async interrupt() {
+  }
+  async stop() {
+    return this.#sessionId;
+  }
+  async *prompt(input, signal) {
+    const promptText = renderPrompt(input);
+    const queue = [];
+    let wake = null;
+    let finished = false;
+    let final = null;
+    let errored = false;
+    const push = (ev) => {
+      queue.push(ev);
+      wake?.();
+      wake = null;
+    };
+    const ac = new AbortController();
+    const onAbort = () => ac.abort();
+    if (signal.aborted) ac.abort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+    const canUseTool = (toolName, toolInput) => {
+      if (ac.signal.aborted) return Promise.resolve({ behavior: "deny", message: "aborted" });
+      return new Promise((resolve) => {
+        push({
+          type: "permission-request",
+          request: { id: randomUUID3(), agent: this.name, action: `use ${toolName}`, preview: preview(toolInput) },
+          respond: (d) => resolve(
+            d === "deny" ? { behavior: "deny", message: "Denied by the user." } : { behavior: "allow", updatedInput: toolInput }
+          )
+        });
+      });
+    };
+    const run = async () => {
+      try {
+        const q = this.#query({
+          prompt: promptText,
+          options: {
+            resume: this.#sessionId,
+            cwd: this.#cwd,
+            // Persona rides on the first turn; the resumed session already has it.
+            systemPrompt: this.#sessionId ? void 0 : { type: "preset", preset: "claude_code", append: this.#persona },
+            permissionMode: this.#permissionMode,
+            canUseTool,
+            settingSources: ["project"],
+            abortController: ac
+          }
+        });
+        for await (const msg of q) {
+          if (msg.type === "system" && msg.subtype === "init") {
+            const id = msg.session_id;
+            if (id) this.#sessionId = id;
+          } else if (msg.type === "assistant") {
+            const m = msg;
+            if (m.session_id) this.#sessionId = m.session_id;
+            for (const block of m.message?.content ?? []) {
+              if (block.type === "text" && block.text) push({ type: "text-delta", text: block.text });
+              else if (block.type === "tool_use")
+                push({ type: "activity", activity: { kind: "tool", title: block.name ?? "tool", status: "running" } });
+            }
+          } else if (msg.type === "result") {
+            const r = msg;
+            if (r.session_id) this.#sessionId = r.session_id;
+            if (r.is_error || r.subtype && r.subtype !== "success") {
+              errored = true;
+              if (!ac.signal.aborted)
+                push({ type: "error", error: { message: r.result || r.subtype || "claude error", fatal: false } });
+            } else if (typeof r.result === "string") {
+              final = r.result;
+            }
+          }
+        }
+      } catch (err) {
+        errored = true;
+        if (!ac.signal.aborted) push({ type: "error", error: { message: String(err), fatal: false } });
+      } finally {
+        finished = true;
+        wake?.();
+        wake = null;
+      }
+    };
+    const runPromise = run();
+    try {
+      while (true) {
+        while (queue.length) yield queue.shift();
+        if (finished) break;
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+      while (queue.length) yield queue.shift();
+      if (!ac.signal.aborted && !errored && final !== null) yield { type: "done", finalText: final };
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+      await runPromise.catch(() => {
+      });
+    }
+  }
+};
+
+// ../../packages/adapters/src/codex.ts
+import { spawn } from "child_process";
+import readline2 from "readline";
+var DECISION_MAP = {
+  "allow-once": "accept",
+  "allow-session": "acceptForSession",
+  deny: "decline"
+};
+var CodexAdapter = class {
+  constructor(name = "codex", opts = {}) {
+    this.name = name;
+    this.#bin = opts.binPath ?? process.env.CODEX_BIN ?? "codex";
+    this.#model = opts.model;
+    this.#approvalPolicy = opts.approvalPolicy ?? "on-request";
+    this.#sandbox = opts.sandbox ?? "workspace-write";
+    this.#connect = opts.connect ?? this.#defaultConnect;
+  }
+  name;
+  capabilities = { tools: true, steering: true, resume: true };
+  #cwd = process.cwd();
+  #persona = "";
+  #threadId;
+  #transport = null;
+  #nextId = 0;
+  #pending = /* @__PURE__ */ new Map();
+  #turn = null;
+  #bin;
+  #model;
+  #approvalPolicy;
+  #sandbox;
+  #connect;
+  get sessionId() {
+    return this.#threadId;
+  }
+  #defaultConnect = ({ cwd }) => {
+    const child = spawn(this.#bin, ["app-server"], { cwd, stdio: ["pipe", "pipe", "inherit"], env: process.env });
+    const rl = readline2.createInterface({ input: child.stdout });
+    return {
+      send: (message) => child.stdin.write(JSON.stringify(message) + "\n"),
+      onMessage: (cb) => rl.on("line", (line) => {
+        const t = line.trim();
+        if (!t) return;
+        try {
+          cb(JSON.parse(t));
+        } catch {
+        }
+      }),
+      close: () => child.kill("SIGTERM")
+    };
+  };
+  #request(method, params) {
+    const id = ++this.#nextId;
+    this.#transport.send({ jsonrpc: "2.0", id, method, params });
+    return new Promise((resolve, reject) => this.#pending.set(id, { resolve, reject }));
+  }
+  #notify(method, params) {
+    this.#transport.send({ jsonrpc: "2.0", method, params });
+  }
+  #respond(id, result) {
+    this.#transport.send({ jsonrpc: "2.0", id, result });
+  }
+  #handleMessage(msg) {
+    const method = msg.method;
+    const id = msg.id;
+    if (method && id !== void 0) {
+      this.#handleServerRequest(id, method, msg.params ?? {});
+    } else if (id !== void 0) {
+      const p = this.#pending.get(id);
+      if (!p) return;
+      this.#pending.delete(id);
+      if (msg.error) p.reject(new Error(JSON.stringify(msg.error)));
+      else p.resolve(msg.result ?? {});
+    } else if (method) {
+      this.#turn?.onNotification(method, msg.params ?? {});
+    }
+  }
+  #handleServerRequest(id, method, params) {
+    const isApproval = method.endsWith("requestApproval");
+    if (isApproval && this.#turn) {
+      const preview2 = method.includes("command") ? params.command ?? JSON.stringify(params).slice(0, 300) : JSON.stringify(params.changes ?? params).slice(0, 300);
+      this.#turn.push({
+        type: "permission-request",
+        request: {
+          id: String(id),
+          agent: this.name,
+          action: method.includes("command") ? "run command" : "edit files",
+          preview: String(preview2)
+        },
+        respond: (d) => this.#respond(id, { decision: DECISION_MAP[d] })
+      });
+    } else {
+      this.#respond(id, isApproval ? { decision: "decline" } : {});
+    }
+  }
+  async start(ctx) {
+    this.#cwd = ctx.workspaceDir;
+    this.#persona = ctx.persona;
+    this.#threadId = ctx.savedSessionId ?? this.#threadId;
+    this.#transport = this.#connect({ cwd: this.#cwd });
+    this.#transport.onMessage((msg) => this.#handleMessage(msg));
+    await this.#request("initialize", {
+      clientInfo: { name: "brainstorming", title: "brainstorming", version: "0.1.0" },
+      capabilities: null
+    });
+    this.#notify("initialized", {});
+    if (this.#threadId) {
+      try {
+        await this.#request("thread/resume", { threadId: this.#threadId });
+        return;
+      } catch {
+        this.#threadId = void 0;
+      }
+    }
+    const params = {
+      cwd: this.#cwd,
+      approvalPolicy: this.#approvalPolicy,
+      sandbox: this.#sandbox,
+      developerInstructions: this.#persona
+    };
+    if (this.#model) params.model = this.#model;
+    const res = await this.#request("thread/start", params);
+    this.#threadId = res.thread?.id;
+  }
+  async interrupt() {
+    if (this.#threadId) await this.#request("turn/interrupt", { threadId: this.#threadId }).catch(() => {
+    });
+  }
+  async stop() {
+    this.#transport?.close();
+    this.#transport = null;
+    return this.#threadId;
+  }
+  async *prompt(input, signal) {
+    const queue = [];
+    let wake = null;
+    let finished = false;
+    let errored = false;
+    let final = "";
+    const push = (ev) => {
+      queue.push(ev);
+      wake?.();
+      wake = null;
+    };
+    const onNotification = (method, params) => {
+      switch (method) {
+        case "item/agentMessage/delta":
+          push({ type: "text-delta", text: String(params.delta ?? "") });
+          break;
+        case "item/completed": {
+          const item = params.item;
+          const type = item?.type;
+          if (type === "agentMessage") final = String(item?.text ?? final);
+          else if (type === "commandExecution")
+            push({
+              type: "activity",
+              activity: {
+                kind: "command",
+                title: `ran: ${String(item?.command ?? "command")}`,
+                status: item?.exitCode === 0 ? "ok" : item?.exitCode == null ? "running" : "failed"
+              }
+            });
+          else if (type === "fileChange")
+            push({ type: "activity", activity: { kind: "file-change", title: "edited files", status: "ok" } });
+          break;
+        }
+        case "error":
+          errored = true;
+          push({ type: "error", error: { message: String(params.message ?? "codex error"), fatal: false } });
+          finished = true;
+          wake?.();
+          break;
+        case "turn/completed":
+          finished = true;
+          wake?.();
+          break;
+      }
+    };
+    this.#turn = { push, onNotification };
+    const onAbort = () => void this.interrupt();
+    if (signal.aborted) void this.interrupt();
+    else signal.addEventListener("abort", onAbort, { once: true });
+    const text = renderPrompt(input);
+    this.#request("turn/start", {
+      threadId: this.#threadId,
+      input: [{ type: "text", text, text_elements: [] }]
+    }).catch((err) => {
+      errored = true;
+      push({ type: "error", error: { message: err.message, fatal: false } });
+      finished = true;
+      wake?.();
+    });
+    try {
+      while (true) {
+        while (queue.length) yield queue.shift();
+        if (finished) break;
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+      while (queue.length) yield queue.shift();
+      if (!signal.aborted && !errored) yield { type: "done", finalText: final };
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+      this.#turn = null;
+    }
+  }
+};
+
+// ../../packages/adapters/src/ollama.ts
+var OllamaAdapter = class {
+  constructor(name = "ollama", opts = { model: "" }) {
+    this.name = name;
+    this.#model = opts.model;
+    this.#host = opts.host;
+    this.#clientOverride = opts.client;
+  }
+  name;
+  capabilities = { tools: false, steering: false, resume: true };
+  #history = [];
+  #model;
+  #host;
+  #clientOverride;
+  #client = null;
+  #lock = Promise.resolve();
+  async start(ctx) {
+    if (this.#clientOverride) {
+      this.#client = this.#clientOverride;
+    } else {
+      const { Ollama } = await import("ollama");
+      this.#client = new Ollama({ host: this.#host ?? "http://127.0.0.1:11434" });
+    }
+    this.#history = ctx.persona ? [{ role: "system", content: ctx.persona }] : [];
+    for (const m of ctx.transcript ?? []) this.#history.push(this.#toMessage(m));
+  }
+  async interrupt() {
+    this.#client?.abort();
+  }
+  async stop() {
+    return void 0;
+  }
+  #toMessage(m) {
+    return m.author === this.name ? { role: "assistant", content: m.content } : { role: "user", content: `[${m.author}]: ${m.content}` };
+  }
+  async *prompt(input, signal) {
+    const previous = this.#lock;
+    let release;
+    this.#lock = new Promise((r) => release = r);
+    await previous;
+    try {
+      if (!this.#client) throw new Error("OllamaAdapter.start was not called");
+      for (const m of input.digest) this.#history.push(this.#toMessage(m));
+      this.#history.push(this.#toMessage(input.addressed));
+      const onAbort = () => this.#client?.abort();
+      if (signal.aborted) return;
+      signal.addEventListener("abort", onAbort, { once: true });
+      let acc = "";
+      try {
+        const stream = await this.#client.chat({
+          model: this.#model,
+          messages: [...this.#history],
+          // snapshot: history keeps growing after this call
+          stream: true
+        });
+        for await (const chunk of stream) {
+          if (signal.aborted) break;
+          const text = chunk.message?.content ?? "";
+          if (text) {
+            acc += text;
+            yield { type: "text-delta", text };
+          }
+        }
+      } catch (err) {
+        if (!signal.aborted) yield { type: "error", error: { message: String(err), fatal: false } };
+        return;
+      } finally {
+        signal.removeEventListener("abort", onAbort);
+      }
+      if (signal.aborted) return;
+      this.#history.push({ role: "assistant", content: acc });
+      yield { type: "done", finalText: acc };
+    } finally {
+      release();
+    }
+  }
+};
+
+// src/agents.ts
+function detectOllamaModel() {
+  try {
+    const out = execFileSync("ollama", ["list"], { encoding: "utf8" });
+    const names = out.trim().split("\n").slice(1).map((line) => line.split(/\s+/)[0]).filter(Boolean);
+    return names.find((m) => m.includes(":cloud")) ?? names.find((m) => !m.includes("embed")) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildAgents(config, notes) {
+  const adapters = [];
+  const a = config.agents;
+  if (a.claude.enabled) adapters.push(new ClaudeAdapter("claude"));
+  if (a.codex.enabled) adapters.push(new CodexAdapter("codex", { model: a.codex.model }));
+  if (a.antigravity.enabled) adapters.push(new AntigravityAdapter("antigravity", { model: a.antigravity.model }));
+  if (a.ollama.enabled) {
+    const model = a.ollama.model ?? detectOllamaModel();
+    if (model) adapters.push(new OllamaAdapter("ollama", { model }));
+    else notes.push("ollama disabled: no model configured and none detected (set agents.ollama.model in config).");
+  }
+  return adapters;
+}
+
+// src/config.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+import { z } from "zod";
+var AgentConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  /** Exact model string for the backend; omit to use its default (or auto-detect for Ollama). */
+  model: z.string().optional(),
+  /** Extra persona guidance appended to the group-chat protocol. */
+  personaExtra: z.string().optional()
+});
+var ConfigSchema = z.object({
+  roundBudget: z.number().int().positive().default(3),
+  agents: z.object({
+    claude: AgentConfigSchema.default({ enabled: true }),
+    codex: AgentConfigSchema.default({ enabled: true }),
+    antigravity: AgentConfigSchema.default({ enabled: true }),
+    ollama: AgentConfigSchema.default({ enabled: true })
+  }).default({
+    claude: { enabled: true },
+    codex: { enabled: true },
+    antigravity: { enabled: true },
+    ollama: { enabled: true }
+  })
+});
+function configPath() {
+  const base = process.env.XDG_CONFIG_HOME ?? join2(homedir(), ".config");
+  return join2(base, "brainstorming", "config.json");
+}
+function loadConfig() {
+  const path = configPath();
+  if (existsSync3(path)) {
+    try {
+      return ConfigSchema.parse(JSON.parse(readFileSync3(path, "utf8")));
+    } catch {
+    }
+  }
+  const defaults = ConfigSchema.parse({});
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(defaults, null, 2) + "\n");
+  return defaults;
+}
+
+// src/run.ts
+function isGitRepo(dir) {
+  try {
+    execFileSync2("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runLive(workspace) {
+  const config = loadConfig();
+  const store = new RoomStore(workspace);
+  const transcript = store.loadTranscript();
+  const meta = store.loadMeta();
+  const notes = [];
+  let adapters = buildAgents(config, notes);
+  if (!isGitRepo(workspace) && adapters.some((a) => a.name === "codex")) {
+    adapters = adapters.filter((a) => a.name !== "codex");
+    notes.push("codex disabled: workspace is not a git repository (run `git init` to enable it).");
+  }
+  if (adapters.length === 0) {
+    console.error(`No agents available. Edit ${configPath()} to enable agents, then retry.`);
+    process.exit(1);
+  }
+  const roundBudget = meta?.roundBudget ?? config.roundBudget;
+  const room = new Room({ transcript, adapters, roundBudget });
+  const resuming = transcript.length > 0;
+  if (resuming) room.markAllSeen();
+  const roster = adapters.map((a) => a.name);
+  const savedSessions = new Map(
+    (meta?.participants ?? []).map((p) => [p.name, p.sessionId])
+  );
+  const priorMessages = [...transcript.all()];
+  await Promise.all(
+    adapters.map(
+      (adapter) => adapter.start({
+        workspaceDir: workspace,
+        persona: buildPersona({
+          name: adapter.name,
+          roster,
+          extra: config.agents[adapter.name]?.personaExtra
+        }),
+        savedSessionId: savedSessions.get(adapter.name),
+        transcript: priorMessages
+      })
+    )
+  );
+  for (const note of notes) room.note(note);
+  if (resuming) room.note(`resumed room with ${transcript.length} prior messages`);
+  const decisionsPath = join3(workspace, "DECISIONS.md");
+  const onDecide = (text) => appendFileSync2(decisionsPath, `- ${(/* @__PURE__ */ new Date()).toISOString()} \u2014 ${text}
+`);
+  const instance = render(
+    React3.createElement(App, { room, title: `brainstorming \u2014 ${workspace}`, onDecide })
+  );
+  await instance.waitUntilExit();
+  const participants = [];
+  for (const adapter of adapters) {
+    const sessionId = await adapter.stop().catch(() => void 0);
+    participants.push({ name: adapter.name, sessionId });
+  }
+  store.saveMeta({ participants, roundBudget });
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+function argValue(flag) {
+  const i = args.indexOf(flag);
+  return i >= 0 ? args[i + 1] : void 0;
+}
+async function main() {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(
+      "brainstorming \u2014 multi-agent collaborative dev chat\n\nUsage:\n  brainstorming            Live chat with real agents in the current directory\n  brainstorming --demo     Scripted demo, no AI quota used\n  brainstorming --budget N Set the agent-to-agent round budget (demo)\n"
+    );
+    return;
+  }
+  if (args.includes("--demo")) {
+    const budget = Number(argValue("--budget") ?? 3);
+    const room = new Room({
+      transcript: new TranscriptStore(),
+      adapters: demoAdapters(),
+      roundBudget: Number.isInteger(budget) && budget > 0 ? budget : 3
+    });
+    await room.start({ workspaceDir: process.cwd(), persona: "" });
+    render2(React4.createElement(App, { room, title: "brainstorming (demo)" }));
+    return;
+  }
+  await runLive(process.cwd());
+}
+void main();