clew-code 0.4.9 → 0.6.0

package/scripts/agent-room.ts

@@ -0,0 +1,741 @@
+#!/usr/bin/env bun
+/**
+ * agent-room — free multi-agent conversation room
+ *
+ * Spawns local AI CLIs so they can talk to each other with a shared transcript:
+ *   Claude Code · OpenCode · Clew Code · Codex
+ *
+ * Examples:
+ *   bun run scripts/agent-room.ts "How should we design peer messaging?"
+ *   bun run agent-room --agents claude,codex --rounds 6 "Review our tool API"
+ *   bun run agent-room --mode free --max-passes 2 "Debate monorepo vs multi-repo"
+ *   bun run agent-room --dry-run "Smoke test without calling models"
+ *
+ * Modes:
+ *   round-robin  each agent speaks once per round, in order (default)
+ *   free         same order, but agents may PASS; stop early when enough PASSes
+ *   parallel     all agents reply to the same snapshot each round (faster, less dialogue)
+ */
+
+import { spawn } from 'node:child_process'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as readline from 'node:readline'
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+type AgentId = 'claude' | 'opencode' | 'clew' | 'codex'
+
+type RoomMode = 'round-robin' | 'free' | 'parallel'
+
+type Message = {
+  id: number
+  ts: string
+  from: AgentId | 'human' | 'system'
+  text: string
+  durationMs?: number
+  exitCode?: number | null
+  error?: string
+}
+
+type AgentDef = {
+  id: AgentId
+  label: string
+  color: string
+  /** Resolve command + args for a single turn. Prompt is always last or via stdin. */
+  build: (prompt: string, cwd: string) => { command: string; args: string[]; stdin?: string }
+  formatOutput?: (raw: string) => string
+}
+
+type RoomOptions = {
+  topic: string
+  agents: AgentId[]
+  mode: RoomMode
+  rounds: number
+  maxPasses: number
+  cwd: string
+  timeoutMs: number
+  transcriptPath: string
+  dryRun: boolean
+  interactive: boolean
+  tools: boolean
+  maxHistoryChars: number
+}
+
+// ─── ANSI ────────────────────────────────────────────────────────────────────
+
+const RESET = '\x1b[0m'
+const DIM = '\x1b[2m'
+const BOLD = '\x1b[1m'
+const COLORS: Record<string, string> = {
+  claude: '\x1b[38;5;208m', // orange
+  opencode: '\x1b[38;5;39m', // blue
+  clew: '\x1b[38;5;120m', // green
+  codex: '\x1b[38;5;213m', // pink
+  human: '\x1b[38;5;229m', // yellow
+  system: '\x1b[38;5;245m', // gray
+}
+
+function paint(who: string, text: string): string {
+  const c = COLORS[who] ?? COLORS.system
+  return `${c}${text}${RESET}`
+}
+
+// ─── Windows command resolution ──────────────────────────────────────────────
+
+function resolveCommand(command: string): string {
+  if (process.platform !== 'win32') return command
+  if (/\.(exe|com|cmd|bat)$/i.test(command)) return command
+  const pathDirs = (process.env.PATH || '').split(path.delimiter)
+  for (const ext of ['.cmd', '.exe', '.bat', '.com']) {
+    for (const dir of pathDirs) {
+      const fp = path.join(dir, command + ext)
+      try {
+        if (fs.existsSync(fp)) return fp
+      } catch {
+        /* skip */
+      }
+    }
+  }
+  return command
+}
+
+function commandOnPath(command: string): boolean {
+  if (process.platform === 'win32') {
+    return resolveCommand(command) !== command || fs.existsSync(command)
+  }
+  const pathDirs = (process.env.PATH || '').split(path.delimiter)
+  return pathDirs.some(dir => {
+    try {
+      return fs.existsSync(path.join(dir, command))
+    } catch {
+      return false
+    }
+  })
+}
+
+function shouldUseShell(command: string): boolean {
+  if (process.platform !== 'win32') return false
+  // .cmd/.bat need shell; bare .exe usually does not
+  return /\.(cmd|bat)$/i.test(command)
+}
+
+// ─── Output formatters ───────────────────────────────────────────────────────
+
+function formatCodexJsonl(raw: string): string {
+  const messages: string[] = []
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue
+    try {
+      const event = JSON.parse(line)
+      if (event.type === 'item.completed' && event.item?.type === 'agent_message' && event.item.text) {
+        messages.push(event.item.text)
+      }
+    } catch {
+      /* keep going */
+    }
+  }
+  return messages.join('\n').trim() || stripNoise(raw)
+}
+
+function stripNoise(raw: string): string {
+  return raw
+    .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+    .replace(/\r/g, '')
+    .trim()
+}
+
+// ─── Agent definitions ───────────────────────────────────────────────────────
+
+const AGENTS: Record<AgentId, AgentDef> = {
+  claude: {
+    id: 'claude',
+    label: 'Claude Code',
+    color: COLORS.claude,
+    build(prompt, cwd) {
+      const command = resolveCommand(process.env.AGENT_ROOM_CLAUDE || 'claude')
+      // Conversation-only by default: max 1 turn, text out, no permission prompts hang
+      const args = [
+        '-p',
+        '--output-format',
+        'text',
+        '--max-turns',
+        '1',
+        '--permission-mode',
+        'dontAsk',
+        prompt,
+      ]
+      return { command, args, stdin: undefined }
+    },
+  },
+  clew: {
+    id: 'clew',
+    label: 'Clew Code',
+    color: COLORS.clew,
+    build(prompt, _cwd) {
+      const command = resolveCommand(process.env.AGENT_ROOM_CLEW || 'clew')
+      const args = [
+        '-p',
+        '--output-format',
+        'text',
+        '--max-turns',
+        '1',
+        '--permission-mode',
+        'dontAsk',
+        prompt,
+      ]
+      return { command, args }
+    },
+  },
+  opencode: {
+    id: 'opencode',
+    label: 'OpenCode',
+    color: COLORS.opencode,
+    build(prompt, cwd) {
+      const command = resolveCommand(process.env.AGENT_ROOM_OPENCODE || 'opencode')
+      // `opencode run` takes message positionals; --dir sets workspace
+      const args = ['run', '--format', 'default', '--dir', cwd, prompt]
+      return { command, args }
+    },
+  },
+  codex: {
+    id: 'codex',
+    label: 'Codex',
+    color: COLORS.codex,
+    formatOutput: formatCodexJsonl,
+    build(prompt, cwd) {
+      const command = resolveCommand(process.env.AGENT_ROOM_CODEX || process.env.CLEW_CODEX_COMMAND || 'codex')
+      const args = ['exec', '-C', cwd, '--color', 'never', '--json', prompt]
+      return { command, args }
+    },
+  },
+}
+
+const ALL_AGENT_IDS = Object.keys(AGENTS) as AgentId[]
+
+// ─── Spawn one turn ──────────────────────────────────────────────────────────
+
+async function runAgentTurn(
+  agent: AgentDef,
+  prompt: string,
+  opts: { cwd: string; timeoutMs: number; dryRun: boolean },
+): Promise<{ text: string; durationMs: number; exitCode: number | null; error?: string }> {
+  const started = Date.now()
+  const inv = agent.build(prompt, opts.cwd)
+
+  if (opts.dryRun) {
+    return {
+      text: `[dry-run] ${agent.label} would respond to a ${prompt.length}-char prompt.`,
+      durationMs: Date.now() - started,
+      exitCode: 0,
+    }
+  }
+
+  return await new Promise(resolve => {
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    const maxBytes = 512 * 1024
+
+    const child = spawn(inv.command, inv.args, {
+      cwd: opts.cwd,
+      env: process.env,
+      windowsHide: true,
+      shell: shouldUseShell(inv.command),
+    })
+
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM')
+    }, opts.timeoutMs)
+
+    child.stdout?.on('data', (chunk: Buffer) => {
+      if (stdout.length < maxBytes) stdout += chunk.toString('utf8')
+    })
+    child.stderr?.on('data', (chunk: Buffer) => {
+      if (stderr.length < maxBytes) stderr += chunk.toString('utf8')
+    })
+
+    const finish = (exitCode: number | null, error?: string) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      const raw = stdout || stderr
+      const formatted = agent.formatOutput ? agent.formatOutput(raw) : stripNoise(raw)
+      const text = (formatted || stripNoise(stderr) || error || '(empty response)').trim()
+      resolve({
+        text,
+        durationMs: Date.now() - started,
+        exitCode,
+        error,
+      })
+    }
+
+    child.on('error', err => {
+      finish(null, `${agent.label} failed to start (${inv.command}): ${err.message}`)
+    })
+    child.on('close', (code, signal) => {
+      if (signal === 'SIGTERM') {
+        finish(code, `${agent.label} timed out after ${opts.timeoutMs}ms`)
+        return
+      }
+      finish(code)
+    })
+
+    if (inv.stdin !== undefined) {
+      child.stdin?.end(inv.stdin)
+    } else {
+      child.stdin?.end()
+    }
+  })
+}
+
+// ─── Prompt construction ─────────────────────────────────────────────────────
+
+function isPass(text: string): boolean {
+  const t = text.trim()
+  if (!t) return true
+  if (/^pass\.?$/i.test(t)) return true
+  if (/^(i\s+)?pass\.?$/i.test(t)) return true
+  // Short "nothing to add" variants
+  if (/^pass\b.{0,40}$/i.test(t) && /nothing|no\s+(more|further)|skip/i.test(t)) return true
+  return false
+}
+
+function buildTurnPrompt(
+  agent: AgentDef,
+  others: AgentDef[],
+  topic: string,
+  history: Message[],
+  mode: RoomMode,
+  maxHistoryChars: number,
+  tools: boolean,
+): string {
+  const lines: string[] = []
+  lines.push(`You are ${agent.label} (${agent.id}) in a multi-agent free-talk room.`)
+  lines.push(`Other participants: ${others.map(o => `${o.label} (${o.id})`).join(', ')}.`)
+  lines.push(`Topic / seed: ${topic}`)
+  lines.push('')
+  lines.push('Rules:')
+  lines.push('1. Talk freely with the other agents. Address them by name when useful.')
+  lines.push('2. Be concise (about 2–8 sentences) unless a deeper technical dive is needed.')
+  lines.push('3. You may agree, disagree, build on ideas, ask questions, or propose next steps.')
+  if (!tools) {
+    lines.push(
+      '4. This is CONVERSATION ONLY. Do not edit files, run shell commands, or use tools. Discuss only.',
+    )
+  } else {
+    lines.push('4. Prefer discussion; only use tools if essential to answer a factual question.')
+  }
+  lines.push('5. If you have nothing useful to add this turn, reply with exactly: PASS')
+  if (mode === 'free') {
+    lines.push('6. Free mode: only speak if you have a real contribution; otherwise PASS.')
+  }
+  lines.push('')
+  lines.push('Conversation so far:')
+  lines.push('---')
+
+  let body = ''
+  for (const m of history) {
+    const chunk = `[${m.from}] ${m.text}\n\n`
+    if (body.length + chunk.length > maxHistoryChars) {
+      body = `…(earlier messages truncated)…\n\n` + body.slice(-(maxHistoryChars - 80))
+    }
+    body += chunk
+  }
+  lines.push(body.trim() || '(no messages yet — open the discussion)')
+  lines.push('---')
+  lines.push(`Your turn as ${agent.label}. Respond now.`)
+  return lines.join('\n')
+}
+
+// ─── Transcript I/O ──────────────────────────────────────────────────────────
+
+function ensureDir(filePath: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+}
+
+function appendTranscript(filePath: string, msg: Message): void {
+  ensureDir(filePath)
+  fs.appendFileSync(filePath, JSON.stringify(msg) + '\n', 'utf8')
+}
+
+function writeMarkdownMirror(filePath: string, topic: string, messages: Message[]): void {
+  const mdPath = filePath.replace(/\.jsonl$/i, '.md')
+  const lines = [`# Agent Room Transcript`, ``, `**Topic:** ${topic}`, ``, `---`, ``]
+  for (const m of messages) {
+    lines.push(`### ${m.from} · ${m.ts}`)
+    lines.push('')
+    lines.push(m.text)
+    lines.push('')
+  }
+  ensureDir(mdPath)
+  fs.writeFileSync(mdPath, lines.join('\n'), 'utf8')
+}
+
+// ─── CLI parsing ─────────────────────────────────────────────────────────────
+
+function printHelp(): void {
+  console.log(`
+${BOLD}agent-room${RESET} — free multi-agent conversation (Claude · OpenCode · Clew · Codex)
+
+${BOLD}Usage${RESET}
+  bun run scripts/agent-room.ts [options] "<topic or opening message>"
+  bun run agent-room [options] "<topic>"
+
+${BOLD}Options${RESET}
+  --agents <list>     Comma list: claude,opencode,clew,codex  (default: all found on PATH)
+  --mode <mode>       round-robin | free | parallel           (default: free)
+  --rounds <n>        Max rounds                              (default: 4)
+  --max-passes <n>    Stop free mode after N consecutive all-PASS rounds (default: 2)
+  --cwd <dir>         Working directory                       (default: cwd)
+  --timeout <sec>     Per-turn timeout seconds                (default: 180)
+  --transcript <path> JSONL transcript path                   (default: .clew/agent-room/<ts>.jsonl)
+  --interactive       After each round, allow human to inject a message (or quit)
+  --tools             Allow tool use (default: conversation-only)
+  --max-history <n>   Max chars of history injected per turn  (default: 12000)
+  --dry-run           Simulate replies without spawning CLIs
+  -h, --help          Show help
+
+${BOLD}Examples${RESET}
+  bun run agent-room "How should peer messaging work across LAN agents?"
+  bun run agent-room --agents claude,codex --rounds 6 "Design a rule system"
+  bun run agent-room --mode parallel --dry-run "Smoke test"
+  bun run agent-room --interactive "Brainstorm product name ideas"
+
+${BOLD}Env overrides${RESET}
+  AGENT_ROOM_CLAUDE / AGENT_ROOM_OPENCODE / AGENT_ROOM_CLEW / AGENT_ROOM_CODEX
+  CLEW_CODEX_COMMAND
+`.trim())
+}
+
+function parseArgs(argv: string[]): RoomOptions | { help: true } | { error: string } {
+  const agentsDefault: AgentId[] | null = null
+  let agents: AgentId[] | null = agentsDefault
+  let mode: RoomMode = 'free'
+  let rounds = 4
+  let maxPasses = 2
+  let cwd = process.cwd()
+  let timeoutMs = 180_000
+  let transcriptPath = ''
+  let dryRun = false
+  let interactive = false
+  let tools = false
+  let maxHistoryChars = 12_000
+  const topicParts: string[] = []
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!
+    if (a === '-h' || a === '--help') return { help: true }
+    if (a === '--dry-run') {
+      dryRun = true
+      continue
+    }
+    if (a === '--interactive') {
+      interactive = true
+      continue
+    }
+    if (a === '--tools') {
+      tools = true
+      continue
+    }
+    if (a === '--agents') {
+      // Accept comma-separated and/or multiple tokens until next flag/topic.
+      // PowerShell turns `a,b,c` into separate args, so gather consecutive non-flag tokens.
+      const collected: string[] = []
+      while (i + 1 < argv.length && !argv[i + 1]!.startsWith('-')) {
+        const next = argv[++i]!
+        // Stop gathering once we hit something that looks like the topic sentence
+        // (has spaces from prior join? no — argv is already split). Keep tokens that
+        // are agent ids or comma-lists thereof; break on first non-agent word if we already have some.
+        const pieces = next.split(/[,\s]+/).map(s => s.trim().toLowerCase()).filter(Boolean)
+        const allAgents = pieces.every(p => ALL_AGENT_IDS.includes(p as AgentId))
+        if (!allAgents && collected.length > 0) {
+          i-- // put topic token back
+          break
+        }
+        if (!allAgents) {
+          return { error: `Unknown agent "${next}". Valid: ${ALL_AGENT_IDS.join(', ')}` }
+        }
+        collected.push(...pieces)
+      }
+      if (collected.length === 0) return { error: '--agents requires a list (e.g. claude,codex or claude codex)' }
+      agents = [...new Set(collected)] as AgentId[]
+      continue
+    }
+    if (a === '--mode') {
+      const m = argv[++i] as RoomMode
+      if (!m || !['round-robin', 'free', 'parallel'].includes(m)) {
+        return { error: '--mode must be round-robin | free | parallel' }
+      }
+      mode = m
+      continue
+    }
+    if (a === '--rounds') {
+      rounds = Number(argv[++i])
+      if (!Number.isFinite(rounds) || rounds < 1) return { error: '--rounds must be >= 1' }
+      continue
+    }
+    if (a === '--max-passes') {
+      maxPasses = Number(argv[++i])
+      if (!Number.isFinite(maxPasses) || maxPasses < 1) return { error: '--max-passes must be >= 1' }
+      continue
+    }
+    if (a === '--cwd') {
+      cwd = path.resolve(argv[++i] || cwd)
+      continue
+    }
+    if (a === '--timeout') {
+      const sec = Number(argv[++i])
+      if (!Number.isFinite(sec) || sec <= 0) return { error: '--timeout must be positive seconds' }
+      timeoutMs = Math.round(sec * 1000)
+      continue
+    }
+    if (a === '--transcript') {
+      transcriptPath = path.resolve(argv[++i] || '')
+      continue
+    }
+    if (a === '--max-history') {
+      maxHistoryChars = Number(argv[++i])
+      if (!Number.isFinite(maxHistoryChars) || maxHistoryChars < 500) {
+        return { error: '--max-history must be >= 500' }
+      }
+      continue
+    }
+    if (a.startsWith('-')) {
+      return { error: `Unknown flag: ${a}` }
+    }
+    topicParts.push(a)
+  }
+
+  const topic = topicParts.join(' ').trim()
+  if (!topic) return { error: 'Missing topic / opening message. Pass it as the final argument.' }
+
+  if (!transcriptPath) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+    transcriptPath = path.join(cwd, '.clew', 'agent-room', `${stamp}.jsonl`)
+  }
+
+  // Auto-detect agents on PATH if not specified
+  if (!agents) {
+    agents = ALL_AGENT_IDS.filter(id => {
+      const cmd =
+        process.env[`AGENT_ROOM_${id.toUpperCase()}`] ||
+        (id === 'codex' ? process.env.CLEW_CODEX_COMMAND : undefined) ||
+        (id === 'clew' ? 'clew' : id)
+      return commandOnPath(cmd)
+    })
+  }
+
+  if (agents.length < 2) {
+    return {
+      error: `Need at least 2 agents on PATH (found: ${agents.join(', ') || 'none'}). Install claude / opencode / clew / codex, or pass --agents.`,
+    }
+  }
+
+  return {
+    topic,
+    agents,
+    mode,
+    rounds,
+    maxPasses,
+    cwd,
+    timeoutMs,
+    transcriptPath,
+    dryRun,
+    interactive,
+    tools,
+    maxHistoryChars,
+  }
+}
+
+// ─── Interactive human inject ────────────────────────────────────────────────
+
+async function promptHuman(rl: readline.Interface): Promise<string | null> {
+  return await new Promise(resolve => {
+    rl.question(
+      `${paint('human', 'you')}${DIM} (message, or empty=continue, /quit=stop): ${RESET}`,
+      answer => {
+        const t = (answer ?? '').trim()
+        if (t === '/quit' || t === '/exit' || t === '/q') resolve(null)
+        else resolve(t)
+      },
+    )
+  })
+}
+
+// ─── Room loop ───────────────────────────────────────────────────────────────
+
+function printBanner(opts: RoomOptions, roster: AgentDef[]): void {
+  console.log('')
+  console.log(`${BOLD}┌─ agent-room ─────────────────────────────────────────┐${RESET}`)
+  console.log(`${BOLD}│${RESET} mode: ${opts.mode.padEnd(12)} rounds: ${String(opts.rounds).padEnd(4)} dry: ${opts.dryRun}`)
+  console.log(`${BOLD}│${RESET} agents: ${roster.map(a => paint(a.id, a.id)).join(' · ')}`)
+  console.log(`${BOLD}│${RESET} topic:  ${opts.topic.slice(0, 60)}${opts.topic.length > 60 ? '…' : ''}`)
+  console.log(`${BOLD}│${RESET} log:    ${opts.transcriptPath}`)
+  console.log(`${BOLD}└──────────────────────────────────────────────────────┘${RESET}`)
+  console.log('')
+}
+
+function printMessage(msg: Message): void {
+  const label = paint(msg.from, msg.from.padEnd(9))
+  const meta =
+    msg.durationMs !== undefined
+      ? `${DIM}${(msg.durationMs / 1000).toFixed(1)}s${msg.exitCode && msg.exitCode !== 0 ? ` exit=${msg.exitCode}` : ''}${RESET}`
+      : ''
+  console.log(`${label} ${meta}`)
+  for (const line of msg.text.split('\n')) {
+    console.log(`  ${line}`)
+  }
+  if (msg.error) console.log(`  ${DIM}error: ${msg.error}${RESET}`)
+  console.log('')
+}
+
+async function runRoom(opts: RoomOptions): Promise<number> {
+  const roster = opts.agents.map(id => AGENTS[id])
+  const messages: Message[] = []
+  let nextId = 1
+  let consecutiveAllPass = 0
+
+  const push = (from: Message['from'], text: string, extra?: Partial<Message>): Message => {
+    const msg: Message = {
+      id: nextId++,
+      ts: new Date().toISOString(),
+      from,
+      text,
+      ...extra,
+    }
+    messages.push(msg)
+    appendTranscript(opts.transcriptPath, msg)
+    writeMarkdownMirror(opts.transcriptPath, opts.topic, messages)
+    printMessage(msg)
+    return msg
+  }
+
+  printBanner(opts, roster)
+  push('system', `Room opened. Mode=${opts.mode}. Conversation-only=${!opts.tools}.`)
+  push('human', opts.topic)
+
+  const rl = opts.interactive
+    ? readline.createInterface({ input: process.stdin, output: process.stdout })
+    : null
+
+  try {
+    for (let round = 1; round <= opts.rounds; round++) {
+      console.log(`${DIM}── round ${round}/${opts.rounds} ──${RESET}`)
+
+      if (opts.mode === 'parallel') {
+        // Snapshot history so all agents see the same state
+        const snapshot = [...messages]
+        const results = await Promise.all(
+          roster.map(async agent => {
+            const others = roster.filter(a => a.id !== agent.id)
+            const prompt = buildTurnPrompt(
+              agent,
+              others,
+              opts.topic,
+              snapshot,
+              opts.mode,
+              opts.maxHistoryChars,
+              opts.tools,
+            )
+            const result = await runAgentTurn(agent, prompt, {
+              cwd: opts.cwd,
+              timeoutMs: opts.timeoutMs,
+              dryRun: opts.dryRun,
+            })
+            return { agent, result }
+          }),
+        )
+        let passes = 0
+        for (const { agent, result } of results) {
+          const text = result.text
+          if (isPass(text)) passes++
+          push(agent.id, text, {
+            durationMs: result.durationMs,
+            exitCode: result.exitCode,
+            error: result.error,
+          })
+        }
+        if (opts.mode === 'parallel' && passes === roster.length) {
+          consecutiveAllPass++
+        } else {
+          consecutiveAllPass = 0
+        }
+      } else {
+        // round-robin / free: sequential so later agents see earlier replies
+        let passCount = 0
+        for (const agent of roster) {
+          const others = roster.filter(a => a.id !== agent.id)
+          const prompt = buildTurnPrompt(
+            agent,
+            others,
+            opts.topic,
+            messages,
+            opts.mode,
+            opts.maxHistoryChars,
+            opts.tools,
+          )
+          process.stdout.write(`${DIM}… waiting on ${agent.label}${RESET}\n`)
+          const result = await runAgentTurn(agent, prompt, {
+            cwd: opts.cwd,
+            timeoutMs: opts.timeoutMs,
+            dryRun: opts.dryRun,
+          })
+          if (isPass(result.text)) passCount++
+          push(agent.id, result.text, {
+            durationMs: result.durationMs,
+            exitCode: result.exitCode,
+            error: result.error,
+          })
+        }
+        if (opts.mode === 'free' && passCount === roster.length) {
+          consecutiveAllPass++
+        } else {
+          consecutiveAllPass = 0
+        }
+      }
+
+      if (opts.mode !== 'round-robin' && consecutiveAllPass >= opts.maxPasses) {
+        push('system', `All agents PASS for ${consecutiveAllPass} round(s) — closing room.`)
+        break
+      }
+
+      if (rl) {
+        const human = await promptHuman(rl)
+        if (human === null) {
+          push('system', 'Human ended the room.')
+          break
+        }
+        if (human) push('human', human)
+      }
+    }
+
+    push('system', `Room closed. Transcript: ${opts.transcriptPath}`)
+    console.log(`${BOLD}Done.${RESET} Markdown: ${opts.transcriptPath.replace(/\.jsonl$/i, '.md')}`)
+    return 0
+  } finally {
+    rl?.close()
+  }
+}
+
+// ─── main ────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const parsed = parseArgs(process.argv.slice(2))
+  if ('help' in parsed) {
+    printHelp()
+    process.exit(0)
+  }
+  if ('error' in parsed) {
+    console.error(`${BOLD}error:${RESET} ${parsed.error}`)
+    console.error(`Run with --help for usage.`)
+    process.exit(1)
+  }
+  const code = await runRoom(parsed)
+  process.exit(code)
+}
+
+main().catch(err => {
+  console.error(err)
+  process.exit(1)
+})