coban 0.0.0-stage → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cenkerarin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,174 @@
-# Temporary Holding Version
+# coban
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![ci](https://github.com/cenkerarin/coban/actions/workflows/ci.yml/badge.svg)](https://github.com/cenkerarin/coban/actions/workflows/ci.yml)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A terminal app (think [herdr](https://www.bitdoze.com/herdr-agent-multiplexer/)) where **one orchestrator agent
+dispatches work to many AI coding agents** — several Claude Code accounts, Codex, OpenCode, Cursor — and those
+agents **talk to each other** over direct messages and a shared board.
+
+*Çoban* is Turkish for shepherd. The UI labels and the prompts coban gives agents are in Turkish for now.
+
+![coban: conversation feed, agent graph and chat](docs/screenshot.svg)
+
+<sub>Rendered by `npm run snapshot` with scripted demo agents. Left: who said what to whom. Middle: the orchestrator
+and its workers — the dots on the edges are messages in flight. Right: the focused agent's real terminal.</sub>
+
+> **Status: early (v0.2).** Its author runs it with three Claude accounts; Codex, OpenCode and Cursor
+> profiles are wired up but barely tested. Issues and PRs welcome.
+
+## How it works
+
+- **One screen, three columns.** A conversation feed (messages, board notes, lifecycle events), the agent graph,
+  and the focused agent's terminal — your chat. Under 140 columns the feed hides; under 100 the graph stacks above
+  the chat.
+- **Real agents, real terminals.** Every agent runs in its own PTY; coban emulates the screen (xterm) and reads a
+  status from it: `working`, `blocked` (permission prompt), `limited` (usage limit), `idle`, `exited`.
+- **The orchestrator drives a CLI, not an MCP server.** Pick its profile with the `+` bubble; it starts with a
+  system prompt that teaches it the `coban` command, which talks to the app over a unix socket. Anything that can
+  run a shell command can take part.
+- **Alive, not busy.** Messages travel along the edges as packets (board notes fan out to everyone), working agents
+  breathe, blocked ones blink, new ones fade in. Frames are drawn only while something moves.
+
+```
+coban agents                                   agents, model, status
+coban map [subdir]                             repo map: files, line counts, symbol:line
+coban spawn <profile> "<task>" [--name x] [--cwd dir] [--ctx where]...
+                                               --ctx "file#sym1,sym2" | "file:10-80" | "file"
+                                               inlines that code (line-numbered) into the task
+coban post <id|user|all> "<message>"           direct message (queued until idle) or a board note (all)
+coban inbox                                    your direct messages + board notes you haven't seen
+coban board [--limit n]                        recent board notes
+coban wait [id...] [--timeout s]               returns when an agent settles or mail arrives
+coban read <id> [--lines n] [--raw]            an agent's screen, UI chrome stripped
+coban approvals                                agents waiting on a permission question, parsed
+coban approve <id> [yes|always|no]             answer it (always = the "Yes, and …" option)
+coban key <id> <keys...>                       enter esc up down tab y 1 2 ...
+coban usage                                    per-account usage, least spent first
+coban kill <id> · coban log                    every command takes --json
+```
+
+## Install
+
+Requires Node ≥ 24 on macOS or Linux.
+
+```sh
+npm install -g coban
+cd ~/your-project && coban
+```
+
+### From source (development)
+
+In a clone, TypeScript runs directly with no build step:
+
+```sh
+git clone https://github.com/cenkerarin/coban && cd coban
+npm install
+ln -s "$PWD/bin/coban" ~/.local/bin/coban
+cd ~/your-project && coban
+```
+
+`npm run build` compiles to `dist/`, which `bin/coban` prefers when present.
+
+## Config
+
+`~/.config/coban/config.json` is created on first run. A profile is a command plus env vars, so several accounts
+are just different `CLAUDE_CONFIG_DIR`s:
+
+```json
+{
+  "orchestrator": "h1",
+  "orchestratorModel": "claude-sonnet-5-5",
+  "profiles": [
+    { "id": "h1", "title": "Claude H1", "cmd": "claude --allowedTools 'Bash(coban:*)'", "model": "claude-opus-5-5",
+      "promptArg": "-- {prompt}", "env": { "CLAUDE_CONFIG_DIR": "~/.claude-hesap1" }, "color": "#F6D5C8" },
+    { "id": "h2", "title": "Claude H2", "cmd": "claude --allowedTools 'Bash(coban:*)'", "model": "claude-sonnet-5-5",
+      "promptArg": "-- {prompt}", "env": { "CLAUDE_CONFIG_DIR": "~/.claude-hesap2" }, "limit5h": 4000000 },
+    { "id": "codex", "title": "Codex", "cmd": "codex", "promptArg": "{prompt}" }
+  ]
+}
+```
+
+`model` is appended as `--model <model>`; `orchestratorModel` overrides it for the profile running as orchestrator —
+coordination is mostly reading and routing, so a cheaper model there saves the most.
+
+## Accounts and limits
+
+`coban usage` (and the bars in the status bar) read each Claude profile's session logs
+(`$CLAUDE_CONFIG_DIR/projects/**/*.jsonl`) and sum input + output + cache-creation tokens over 5 hours and 7 days.
+The percentage is against the profile's `limit5h`; plans don't publish a token number, so the 5M default is a guess —
+tune it per account. The orchestrator is told to give new work to the least-spent account.
+
+When a worker hits a usage limit, coban **hands its task off** to the least-spent account of the same kind: the new
+worker gets the original task plus the old worker's last screen, undelivered mail follows it, and the board and the
+orchestrator are told.
+
+## Approvals and the input line
+
+- **One approval inbox.** When agents stop at a permission question, coban reads it off their screen — title,
+  command or file, and the exact options — and lists them in a panel under the graph. `ctrl+b y` approves the
+  selected one, `ctrl+b a` picks its "Yes, and …" option (shown verbatim, so you see what it grants), `ctrl+b r`
+  rejects, `ctrl+b i` moves to the next; or click the buttons. The orchestrator can do the same with
+  `coban approvals` / `coban approve`. Answers are given by moving the menu selection with arrow keys and pressing
+  Enter (never by digit: Claude Code's folder-trust menu has no numbers and defaults to "No, exit"), and an answer
+  is refused if the question changed since it was shown.
+- **coban's own input line** sits under the chat: `ctrl+b c` (or a click) focuses it. `@h2 also add a refresh
+  endpoint` goes to h2 without switching focus, `@all …` to the board, plain text to the focused agent; Tab
+  completes agent names, Esc returns the keyboard to the agent.
+
+The parser is built against real Claude Code screens (`test/fixtures/prompts`). Driving agents through the Agent SDK
+would give exact events instead of screen reading, but its docs ask third-party tools not to offer claude.ai login,
+so coban keeps running the unmodified Claude Code with your own login.
+
+## Agents talking
+
+- **Direct messages** (`coban post <id>`) are typed into the recipient's terminal once it is idle.
+- **The board** (`coban post all`) is for things everyone should know — changed interfaces, who is on which file,
+  decisions. Notes are pulled, not pushed: `coban inbox` returns each note once, and workers are told to check it
+  after every major step and before editing shared files, so idle agents aren't woken (and billed) for every note.
+  It is mirrored to `.coban/board.md`; `ctrl+b m` opens it as a panel.
+- Agents opened by hand show as `manuel`; the orchestrator is told to use idle ones before spawning new workers, and
+  coban prepends the worker brief to the first message they get.
+
+## Keeping context small
+
+Each request an agent makes re-reads its whole context (Claude Code alone is ~45k tokens before any work), so coban
+keeps what lands there lean:
+
+- one-line CLI output; `coban read` returns 20 lines with agent UI chrome stripped;
+- workers send ≤5-line summaries and put long results in `.coban/reports/<id>.md` (git-ignored automatically);
+- the orchestrator learns the repo from `coban map` (≈400 tokens for this repo) and hands workers the relevant code
+  with `--ctx` — coban extracts symbols/line ranges itself (no model involved) so workers don't spend requests
+  searching;
+- tasks follow a template: **HEDEF / DOSYALAR / KISITLAR / DOĞRULAMA / BİTTİ SAYILIR**
+  (goal, files, constraints, verification, done when).
+
+## Keys
+
+Mouse: click a bubble to focus it, click `+` to add an agent, scroll the feed with the wheel. Mouse events in the
+chat are forwarded when the agent asks for them.
+
+`ctrl+b` then: `c` input line · `y`/`a`/`r` approve / always / reject · `i` next approval · `n` new agent · `1-9` select · `j`/`k` next/prev · `o` orchestrator · `m` board panel ·
+`l` toggle feed · `s` select mode (release the mouse to copy text) · `u` next unread · `x` close agent · `q` quit ·
+`ctrl+b` send a literal ctrl+b.
+
+## Development
+
+```sh
+npm test            # unit tests + an end-to-end run of the real TUI in a pty with fake agents
+npm run typecheck
+npm run snapshot    # regenerate docs/screenshot.svg
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for how the code is laid out.
+
+## Known gaps
+
+No scrollback in the chat, no split view, no kitty keyboard protocol (shift+enter), no session restore yet.
+Codex's sandbox may block the unix socket. Status detection is screen heuristics and may need tuning per CLI
+version. coban captures the mouse: to copy text press `ctrl+b s`, or use your terminal's override (shift-drag in
+Ghostty/cmux, ⌥-drag in iTerm2).
+
+## License
+
+MIT

package/bin/coban

@@ -0,0 +1,10 @@
+#!/bin/sh
+# Resolve the real script location so symlinks (e.g. ~/.local/bin/coban) work.
+SELF=$(readlink -f "$0" 2>/dev/null || echo "$0")
+ROOT="$(dirname "$SELF")/.."
+if [ -f "$ROOT/dist/cli.js" ]; then
+  ENTRY="$ROOT/dist/cli.js"
+else
+  ENTRY="$ROOT/src/cli.ts"
+fi
+exec node --disable-warning=ExperimentalWarning "$ENTRY" "$@"

package/dist/agent.js

@@ -0,0 +1,161 @@
+import pty from 'node-pty';
+import xterm from '@xterm/headless';
+import { EventEmitter } from 'node:events';
+import { parsePrompt } from './prompt.js';
+const { Terminal } = xterm;
+// Screen heuristics. Checked against the bottom of the visible screen.
+const BLOCKED = /Do you want to (proceed|make this edit|create|allow|run)|Would you like to (run|make|proceed|allow)|Allow (this|command|once)|Approve\b.*\?|Press enter to confirm|trust (this|the files in this) folder|Do you trust/i;
+// A plain y/n question only counts while it is still the line being answered; tools rarely clear it afterwards.
+const YN = /\(y\/n\)|\[y\/N\]|\[Y\/n\]/;
+// A CLI's own limit banner: a short line of its own, optionally behind one bullet/box glyph, sitting in the last few
+// non-chrome lines of the screen (just above the idle prompt). Line-anchored on purpose: the same words inside a task
+// text, a prompt echo ('> …'), a quote or mid-sentence tool output must never trigger a handoff.
+const LIMIT_BANNER = /^\s{0,4}(?:[⎿●•✻*·]\s{0,4})?(?:(?:Claude(?: AI)? )?usage limit reached|(?:5-hour|weekly|session|daily|opus|sonnet) limit reached|You(?:'|’)?ve (?:hit|reached) your (?:\w+[ -])?(?:usage )?limit|You have (?:hit|reached) your (?:\w+[ -])?(?:usage )?limit|You(?:'|’)re out of (?:credits|extra usage))(?:\s*$|[\s.!,:;|∙·–—(-])/i;
+const LIMIT_CHROME = /^\s*([─━═╌┄\-]{8,}|[╭╰│┃].*|❯.*|>.*|[⏵►▶]{2}.*|\? for shortcuts.*)$/;
+const LIMIT_TAIL_LINES = 4;
+// Broad form, only for masking quoted screen text (handoff tasks) so it can't re-trigger a limit in the new worker.
+const LIMIT_WORDS = /(?:(?:usage|rate) limit|limit reached|(?:hit|reached) your[^\n]{0,24}?limit|out of (?:credits|extra usage))/gi;
+// A question is live only while nothing has been printed after it: either it sits above an open selection menu
+// (❯ …), or it is one of the last two non-empty lines. Answered questions that linger in the scrollback don't count.
+export function waitingForAnswer(screen) {
+    const p = parsePrompt(screen);
+    if (p?.kind === 'yn')
+        return true;
+    if (p?.kind === 'menu' && BLOCKED.test(screen))
+        return true;
+    const lastTwo = screen.split('\n').filter((l) => l.trim()).slice(-2).join('\n');
+    return BLOCKED.test(lastTwo) || YN.test(lastTwo);
+}
+export function limitBanner(screen) {
+    const lines = screen.split('\n').filter((l) => l.trim() && !LIMIT_CHROME.test(l)).slice(-LIMIT_TAIL_LINES);
+    return lines.some((l) => l.length <= 200 && LIMIT_BANNER.test(l));
+}
+export function maskLimitText(text) {
+    return text.replace(LIMIT_WORDS, (m) => `[${m.replace(/limit/gi, 'l*mit')}]`);
+}
+const BUSY = /esc to interrupt|esc to cancel|ctrl\+c to (interrupt|stop)|Working \(|Thinking\.\.\./i;
+const QUIET_MS = 1500;
+export class Agent extends EventEmitter {
+    id;
+    profile;
+    role;
+    task;
+    cwd;
+    term;
+    proc;
+    status = 'starting';
+    settledSeq = 0; // bumps every time the agent settles (idle/blocked/limited/exited)
+    unread = false; // settled while not focused
+    lastOutput = Date.now();
+    cursorVisible = true;
+    exitCode = null;
+    inbox = [];
+    model = '';
+    briefed = false; // has received the coban worker brief
+    handedOff = false; // hit a limit and its task was already handed to another account (hub.handoff)
+    constructor(o) {
+        super();
+        this.id = o.id;
+        this.profile = o.profile;
+        this.role = o.role;
+        this.task = o.task;
+        this.cwd = o.cwd;
+        this.term = new Terminal({ cols: o.cols, rows: o.rows, scrollback: 2000, allowProposedApi: true });
+        // Track DECTCEM (cursor show/hide); headless xterm doesn't expose it.
+        this.term.parser.registerCsiHandler({ prefix: '?', final: 'h' }, (p) => { if (p.includes(25))
+            this.cursorVisible = true; return false; });
+        this.term.parser.registerCsiHandler({ prefix: '?', final: 'l' }, (p) => { if (p.includes(25))
+            this.cursorVisible = false; return false; });
+        // /bin/sh, not the user's shell: profiles are plain commands and sh exists everywhere (zsh is missing on most Linux).
+        // `exec` keeps the agent as the pty's direct child, but `exec VAR=x cmd` would try to run "VAR=x": skip it then.
+        this.proc = pty.spawn('/bin/sh', ['-c', /^\s*\w+=/.test(o.cmd) ? o.cmd : `exec ${o.cmd}`], {
+            name: 'xterm-256color', cols: o.cols, rows: o.rows, cwd: o.cwd, env: o.env,
+        });
+        this.proc.onData((d) => {
+            this.lastOutput = Date.now();
+            this.term.write(d, () => this.emit('render'));
+        });
+        // Replies to terminal queries (DA, DSR, ...) go back to the program.
+        this.term.onData((d) => { if (this.exitCode === null)
+            this.proc.write(d); });
+        this.proc.onExit(({ exitCode }) => {
+            this.exitCode = exitCode;
+            this.setStatus('exited');
+            this.emit('render');
+        });
+    }
+    screenText(lines = 40, scrollback = false) {
+        const buf = this.term.buffer.active;
+        // Drop blank rows below the content first, then take the last `lines` rows.
+        let end = buf.length;
+        while (end > 0 && !buf.getLine(end - 1)?.translateToString(true).trim())
+            end--;
+        const start = Math.max(scrollback ? 0 : buf.baseY, end - lines);
+        const out = [];
+        for (let y = start; y < end; y++)
+            out.push(buf.getLine(y)?.translateToString(true) ?? '');
+        return out.join('\n');
+    }
+    tick() {
+        if (this.status === 'exited')
+            return;
+        const tail = this.screenText(18);
+        let next;
+        if (limitBanner(tail) && !BUSY.test(tail))
+            next = 'limited';
+        else if (waitingForAnswer(tail))
+            next = 'blocked';
+        // A visible "esc to interrupt" means real work, even right after launch (workers get their task as an argv
+        // prompt and never pass through idle). Bare output without it is still startup noise.
+        else if (BUSY.test(tail))
+            next = 'working';
+        else if (Date.now() - this.lastOutput < QUIET_MS)
+            next = this.status === 'starting' ? 'starting' : 'working';
+        else
+            next = 'idle';
+        this.setStatus(next);
+    }
+    setStatus(s) {
+        if (s === this.status)
+            return;
+        const prev = this.status;
+        this.status = s;
+        if (s !== 'working' && s !== 'starting')
+            this.settledSeq++;
+        this.emit('status', s, prev);
+    }
+    // Type a prompt into the agent and submit it.
+    deliver(text) {
+        if (this.exitCode !== null)
+            return;
+        const body = this.term.modes.bracketedPasteMode ? `\x1b[200~${text}\x1b[201~` : text.replace(/\s*\n\s*/g, ' ');
+        this.proc.write(body);
+        setTimeout(() => this.proc.write('\r'), 250);
+        this.lastOutput = Date.now();
+        this.setStatus('working');
+    }
+    resize(cols, rows) {
+        if (cols === this.term.cols && rows === this.term.rows)
+            return;
+        this.term.resize(cols, rows);
+        if (this.exitCode === null)
+            this.proc.resize(cols, rows);
+    }
+    kill() {
+        if (this.exitCode === null)
+            this.proc.kill();
+        this.term.dispose();
+    }
+}
+const KEYS = {
+    enter: '\r', esc: '\x1b', escape: '\x1b', tab: '\t', 'shift-tab': '\x1b[Z', space: ' ',
+    backspace: '\x7f', 'ctrl-c': '\x03', 'ctrl-d': '\x04',
+    up: '\x1b[A', down: '\x1b[B', right: '\x1b[C', left: '\x1b[D',
+};
+export function keyBytes(agent, key) {
+    const k = key.toLowerCase();
+    if (agent.term.modes.applicationCursorKeysMode && /^(up|down|left|right)$/.test(k)) {
+        return '\x1bO' + { up: 'A', down: 'B', right: 'C', left: 'D' }[k];
+    }
+    return KEYS[k] ?? key;
+}

package/dist/cli.js

@@ -0,0 +1,201 @@
+import net from 'node:net';
+import { loadConfig, SOCK } from './config.js';
+import { repoMap, snippets } from './context.js';
+import { allUsage } from './usage.js';
+const HELP = `coban — çok hesaplı agent orkestratörü
+
+  coban [--cwd dizin]                 arayüzü aç (orkestratörü graf alanındaki + ile seç)
+
+Agent'ların içinden (veya başka bir terminalden):
+  coban agents                        agent listesi ve durumları
+  coban spawn <profil> "<görev>" [--name ad] [--cwd dizin] [--ctx yer]...
+                                      --ctx: "dosya:10-80" | "dosya#sembol1,sembol2" | "dosya"
+                                      ilgili kodu satır numaralı olarak görevin içine ekler (send/post'ta da var)
+  coban map [alt-dizin]               repo haritası: dosyalar, satır sayıları, semboller:satır
+  coban send <id> "<mesaj>"           (post ile aynı)
+  coban post <id|user|all> "<mesaj>"  all = ortak kutu (herkes görür)
+  coban wait [id...] [--timeout sn]   biri durunca / mesaj gelince döner
+  coban read <id> [--lines n] [--scrollback] [--raw]
+  coban approvals                     izin bekleyen agent'lar ve soruları
+  coban approve <id> [yes|always|no]  izni yanıtla (varsayılan yes)
+  coban key <id> <tuş...>             enter esc up down tab 1 2 y ...
+  coban kill <id>
+  coban inbox                         özel mesajlar + ortak kutudaki yeniler
+  coban board [--limit n]             ortak kutunun son notları
+  coban usage                         hesap kullanımı (5s %, 7g token, reset), en az harcayan başta
+  coban log [--limit n]
+
+Her komut --json ile ham çıktı verir.`;
+function call(method, params) {
+    return new Promise((resolve, reject) => {
+        const s = net.connect(SOCK);
+        let buf = '';
+        s.on('connect', () => s.write(JSON.stringify({ caller: process.env.COBAN_AGENT || 'user', method, params }) + '\n'));
+        s.on('data', (d) => {
+            buf += d;
+            const i = buf.indexOf('\n');
+            if (i < 0)
+                return;
+            const res = JSON.parse(buf.slice(0, i));
+            s.end();
+            res.ok ? resolve(res.result) : reject(new Error(res.error));
+        });
+        s.on('error', (e) => reject(e.code === 'ENOENT' || e.code === 'ECONNREFUSED' ? new Error('coban çalışmıyor (önce `coban` ile arayüzü aç)') : e));
+    });
+}
+const BOOL_FLAGS = ['scrollback', 'raw', 'json'];
+function parse(argv) {
+    const pos = [];
+    const flags = {};
+    const ctx = []; // --ctx may repeat
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const [k, v] = a.slice(2).split('=', 2);
+            if (k === 'ctx') {
+                const val = v ?? argv[++i];
+                if (val)
+                    ctx.push(val);
+                continue;
+            }
+            if (v !== undefined)
+                flags[k] = v;
+            else if (argv[i + 1] && !argv[i + 1].startsWith('--') && !BOOL_FLAGS.includes(k))
+                flags[k] = argv[++i];
+            else
+                flags[k] = true;
+        }
+        else
+            pos.push(a);
+    }
+    return { pos, flags, ctx };
+}
+async function main() {
+    const [cmd, ...rest] = process.argv.slice(2);
+    const { pos, flags, ctx } = parse(rest);
+    const num = (v) => (v === undefined || v === true ? undefined : Number(v));
+    if (!cmd || cmd === '--cwd') {
+        if (cmd === '--cwd')
+            process.chdir(rest[0]);
+        const { Hub } = await import('./hub.js');
+        const { Tui } = await import('./tui.js');
+        try {
+            await call('agents', {});
+            console.error('coban zaten açık (soket: ' + SOCK + ')');
+            process.exit(1);
+        }
+        catch { }
+        const hub = new Hub(loadConfig());
+        const tui = new Tui(hub);
+        hub.size = tui.paneSize;
+        hub.listen();
+        tui.start();
+        const quit = () => { tui.stop(); hub.shutdown(); process.exit(0); };
+        process.on('SIGTERM', quit);
+        process.on('SIGHUP', quit);
+        process.on('uncaughtException', (e) => { tui.stop(); hub.shutdown(); console.error(e); process.exit(1); });
+        return;
+    }
+    // Output is plain one-liners on purpose: it lands in the calling agent's context. --json gives the raw result.
+    const json = !!flags.json;
+    const print = (r, text) => console.log(json ? JSON.stringify(r) : text());
+    const short = (m) => (m ? m.replace(/^claude-/, '') : '');
+    const one = (s) => s.replace(/\s+/g, ' ').trim();
+    const agentLine = (a) => [a.id, `${a.profile}${a.model ? '/' + short(a.model) : ''}`, a.role === 'orchestrator' ? '★' : a.role === 'manual' ? 'manuel' : '', a.status,
+        a.unreadMessages ? `✉${a.unreadMessages}` : '', a.boardUnread ? `▤${a.boardUnread}` : '', a.cwd ? `cwd=${a.cwd}` : '', a.task ? `"${a.task}"` : '']
+        .filter(Boolean).join('  ');
+    switch (cmd) {
+        case 'agents': {
+            const r = await call('agents', {});
+            return print(r, () => [...r.agents.map(agentLine), 'profiller: ' + r.profiles.map((p) => `${p.id}${p.model ? '/' + short(p.model) : ''}`).join(' ')].join('\n'));
+        }
+        case 'spawn': {
+            const cwd = typeof flags.cwd === 'string' ? flags.cwd : process.cwd();
+            const r = await call('spawn', { profile: pos[0], task: pos.slice(1).join(' ') + snippets(ctx, cwd), name: flags.name, cwd: flags.cwd });
+            return print(r, () => `açıldı: ${r.id}`);
+        }
+        case 'send':
+        case 'post': {
+            const r = await call('post', { to: pos[0], text: pos.slice(1).join(' ') + snippets(ctx, process.cwd()) });
+            return print(r, () => `gönderildi → ${pos[0]}`);
+        }
+        case 'wait': {
+            const r = await call('wait', { ids: pos, timeout: num(flags.timeout) });
+            return print(r, () => {
+                if (r.timeout)
+                    return 'zaman aşımı · ' + r.agents.map((a) => `${a.id}:${a.status}`).join(' ');
+                const out = [];
+                if (r.settled.length)
+                    out.push('durdu: ' + r.settled.map((a) => `${a.id} ${a.status}`).join(', '));
+                if (r.removed.length)
+                    out.push('artık yok: ' + r.removed.join(', '));
+                for (const m of r.messages)
+                    out.push(`✉ ${m.from}: ${m.text}`);
+                for (const m of r.board ?? [])
+                    out.push(`[ortak] ${m.from}: ${m.text}`);
+                return out.join('\n');
+            });
+        }
+        case 'read': {
+            const r = await call('read', { id: pos[0], lines: num(flags.lines), scrollback: !!flags.scrollback, raw: !!flags.raw });
+            return print(r, () => `[${r.id} · ${r.status}]\n${r.screen}`);
+        }
+        case 'key': {
+            const r = await call('key', { id: pos[0], keys: pos.slice(1) });
+            return print(r, () => 'tamam');
+        }
+        case 'approvals': {
+            const r = await call('approvals', {});
+            return print(r, () => r.approvals.length ? r.approvals.map((x) => {
+                const p = x.prompt;
+                if (!p)
+                    return `${x.id}  ${x.profile}  soru okunamadı — coban read ${x.id}`;
+                const opts = p.options.map((o, i) => `${i + 1}) ${o.label}`).join('  ');
+                return [`${x.id}  ${x.profile}  ${p.title}${p.body.length ? ': ' + p.body.join(' · ') : ''}`, `  ? ${p.question}${opts ? '  ' + opts : ''}`].join('\n');
+            }).join('\n') : '(izin bekleyen yok)');
+        }
+        case 'approve': {
+            const r = await call('approve', { id: pos[0], choice: pos[1] ?? 'yes' });
+            return print(r, () => `${pos[0]}: "${r.picked}" seçildi`);
+        }
+        case 'kill': {
+            const r = await call('kill', { id: pos[0] });
+            return print(r, () => `kapatıldı: ${pos[0]}`);
+        }
+        case 'inbox': {
+            const r = await call('inbox', {});
+            const lines = [...r.messages.map((m) => `✉ ${m.from}: ${m.text}`), ...r.board.map((m) => `[ortak] ${m.from}: ${m.text}`)];
+            return print(r, () => (lines.length ? lines.join('\n') : '(yeni mesaj yok)'));
+        }
+        case 'board': {
+            const r = await call('board', { limit: num(flags.limit) });
+            return print(r, () => (r.board.length ? r.board.map((m) => `${new Date(m.ts).toTimeString().slice(0, 5)} ${m.from}: ${m.text}`).join('\n') : '(ortak kutu boş)'));
+        }
+        case 'log': {
+            const r = await call('log', { limit: num(flags.limit) });
+            return print(r, () => r.messages.map((m) => `${new Date(m.ts).toTimeString().slice(0, 5)} ${m.from}→${m.to}: ${one(m.text)}`).join('\n'));
+        }
+        case 'usage': {
+            // Works without a running coban too (then 'limited' is unknown → false).
+            const r = await call('usage', {}).catch(() => ({ usage: allUsage(loadConfig()) }));
+            const tok = (n) => (n >= 1e6 ? (n / 1e6).toFixed(1) + 'M' : n >= 1e3 ? Math.round(n / 1e3) + 'k' : String(n));
+            const line = (u) => !u.limit5h
+                ? [u.profileId, 'bilinmiyor', u.limited ? 'LİMİTLİ' : ''].filter(Boolean).join('  ')
+                : [u.profileId, `5s ${Math.round(u.pct5h * 100)}% (${tok(u.used5h)}/${tok(u.limit5h)})`, `7g ${tok(u.used7d)}`,
+                    u.resetAt ? `reset ${new Date(u.resetAt).toTimeString().slice(0, 5)}` : 'reset -', u.limited ? 'LİMİTLİ' : ''].filter(Boolean).join('  ');
+            return print(r, () => r.usage.map(line).join('\n'));
+        }
+        case 'map':
+            console.log(repoMap(process.cwd(), pos[0] ?? ''));
+            return;
+        case 'help':
+        case '-h':
+        case '--help':
+            console.log(HELP);
+            return;
+        default:
+            console.error(HELP);
+            process.exit(2);
+    }
+}
+main().catch((e) => { console.error('coban: ' + e.message); process.exit(1); });

package/dist/config.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+export const BIN_DIR = path.join(ROOT, 'bin');
+export const STATE_DIR = path.join(os.homedir(), '.coban');
+export const DEFAULT_SOCK = path.join(STATE_DIR, 'coban.sock');
+export const SOCK = process.env.COBAN_SOCK || DEFAULT_SOCK;
+export const CONFIG_PATH = process.env.COBAN_CONFIG || path.join(os.homedir(), '.config', 'coban', 'config.json');
+export const OPUS = 'claude-opus-5-5';
+export const SONNET = 'claude-sonnet-5-5';
+// Claude may run `coban ...` without a permission prompt.
+const CLAUDE_CMD = "claude --allowedTools 'Bash(coban:*)'";
+const claude = (n, model, color) => ({
+    id: `h${n}`,
+    title: `Claude H${n}`,
+    cmd: CLAUDE_CMD,
+    model,
+    promptArg: '-- {prompt}',
+    env: { CLAUDE_CONFIG_DIR: `~/.claude-hesap${n}` },
+    color,
+});
+export const DEFAULT_CONFIG = {
+    orchestrator: 'h1',
+    // Coordination is mostly reading and routing, so the orchestrator runs on Sonnet;
+    // h1 keeps Opus for heavy coding work when it runs as a worker.
+    orchestratorModel: SONNET,
+    profiles: [
+        claude(1, OPUS, '#F6D5C8'),
+        claude(2, SONNET, '#FFD9A0'),
+        claude(3, SONNET, '#C8E6C9'),
+        { id: 'codex', title: 'Codex', cmd: 'codex', promptArg: '{prompt}', color: '#8FDBFF' },
+        { id: 'opencode', title: 'OpenCode', cmd: 'opencode', promptArg: '--prompt {prompt}', color: '#B5E48C' },
+        { id: 'cursor', title: 'Cursor', cmd: 'cursor-agent', promptArg: '{prompt}', color: '#D0B3FF' },
+    ],
+};
+const expand = (v) => v.replace(/^~(?=\/|$)/, os.homedir());
+export function loadConfig() {
+    if (!fs.existsSync(CONFIG_PATH)) {
+        fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2) + '\n');
+    }
+    const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    for (const p of cfg.profiles) {
+        // Older configs baked the model into cmd; lift it into `model` so overrides work.
+        const m = p.cmd.match(/\s--model[ =](\S+)/);
+        if (m) {
+            p.model ??= m[1];
+            p.cmd = p.cmd.replace(m[0], '');
+        }
+        for (const k of Object.keys(p.env ?? {}))
+            p.env[k] = expand(p.env[k]);
+    }
+    return cfg;
+}