brain-colonies 0.1.1

package/README.md

@@ -0,0 +1,67 @@
+# brain-colonies — `bc` CLI
+
+Wisdom-layer counsel for the terminal. Wrap any AI CLI for per-turn drift-protection, or talk to BC brains directly.
+
+## Install
+
+```bash
+npm install -g brain-colonies
+```
+
+## Quick start
+
+```bash
+# 1. Authenticate (paste your bc_live_ key)
+bc auth
+
+# 2. See your colonies
+bc colonies
+bc colonies --set-default <colony-id-or-name>
+
+# 3. Check in before doing something
+bc check "should i delete this migration?"
+
+# 4. Talk to a specific brain
+bc consult @security-engineer "is JWT decode-without-verify ever fine?"
+
+# 5. Interactive chat with Alt-me
+bc chat
+
+# 6. THE KILLER FEATURE — wrap any AI CLI
+bc wrap -- claude "should i refactor this auth code?"
+bc wrap --inject -- aichat "review my plan to migrate to Postgres"
+```
+
+## What `bc wrap` does
+
+For every turn, BC fires `bc.checkIn` against the user message **before** the wrapped CLI runs. The check-in returns:
+
+- **drift signal** — high if you're about to repeat a known pattern
+- **missing perspectives** — brains in your colony you haven't consulted that probably apply
+- **pending reflections** — deferred patches waiting for your review
+- **observations** — Alt-me's read on the message
+
+Default mode prints the check-in to stderr (you see it, the wrapped CLI doesn't). `--inject` mode prepends the check-in block into the prompt — the wrapped LLM reads it inline.
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `bc auth` | Store API key in `~/.bc/config.json` |
+| `bc check "<msg>"` | One-off `bc.checkIn` call |
+| `bc consult @brain "<q>"` | Single-turn brain consult |
+| `bc colonies` | List colonies + brains; `--set-default` to choose |
+| `bc chat` | REPL against any brain (default: Alt-me) |
+| `bc wrap -- <cli>` | Pre-turn check-in + forward to any CLI |
+
+## Config
+
+Lives at `~/.bc/config.json` (0600). Contains `apiKey`, `apiBase`, `defaultColonyId`.
+
+## Development
+
+```bash
+npm install
+npm run dev -- check "test"
+npm run build
+```

package/dist/commands/auth.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authCommand = authCommand;
+const promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const config_js_1 = require("../lib/config.js");
+const api_js_1 = require("../lib/api.js");
+const ui_js_1 = require("../lib/ui.js");
+async function authCommand(opts) {
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        const existing = (0, config_js_1.loadConfig)();
+        if (existing)
+            (0, ui_js_1.info)(`existing config: ${(0, config_js_1.configPath)()}`);
+        const apiBase = opts.apiBase || existing?.apiBase || (0, config_js_1.defaultApiBase)();
+        (0, ui_js_1.info)(`API base: ${apiBase}`);
+        const apiKey = (await rl.question('Paste your bc_live_ API key: ')).trim();
+        if (!apiKey.startsWith('bc_live_')) {
+            (0, ui_js_1.err)('API keys must start with bc_live_. Generate one at https://braincolonies.com/settings/developers');
+            process.exit(1);
+        }
+        let userId;
+        try {
+            const me = await (0, api_js_1.whoami)({ apiKey, apiBase, defaultColonyId: existing?.defaultColonyId });
+            userId = me.userId;
+            if (!userId) {
+                (0, ui_js_1.err)('Server returned no userId — please report this to support.');
+                process.exit(1);
+            }
+        }
+        catch (e) {
+            (0, ui_js_1.err)(`Key validation failed: ${e.message}`);
+            process.exit(1);
+        }
+        const cfg = { apiKey, apiBase, userId, defaultColonyId: existing?.defaultColonyId };
+        (0, config_js_1.saveConfig)(cfg);
+        (0, ui_js_1.ok)(`Authenticated as ${userId}`);
+        (0, ui_js_1.ok)(`Config saved to ${(0, config_js_1.configPath)()}`);
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/chat.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatCommand = chatCommand;
+const promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const config_js_1 = require("../lib/config.js");
+const api_js_1 = require("../lib/api.js");
+const ui_js_1 = require("../lib/ui.js");
+const kleur_1 = __importDefault(require("kleur"));
+async function chatCommand(opts) {
+    const cfg = (0, config_js_1.requireConfig)();
+    const brain = opts.brain || 'alt-me';
+    process.stdout.write((0, ui_js_1.banner)() + '\n');
+    process.stdout.write(kleur_1.default.dim(`talking to @${brain}. type /quit to exit.\n\n`));
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    rl.on('SIGINT', () => { rl.close(); process.exit(0); });
+    try {
+        while (true) {
+            const userMsg = (await rl.question(kleur_1.default.bold().green('you: '))).trim();
+            if (!userMsg)
+                continue;
+            if (userMsg === '/quit' || userMsg === '/exit')
+                break;
+            if (!opts.noCheckIn) {
+                try {
+                    const r = await (0, api_js_1.checkIn)(cfg, userMsg, opts.colony);
+                    if (r.driftSignal !== 'none' || r.observations.length || r.missingPerspectives.length || r.mustReadAloud) {
+                        process.stdout.write((0, ui_js_1.renderCheckIn)(r) + '\n');
+                    }
+                }
+                catch (e) {
+                    process.stderr.write(kleur_1.default.dim(`(check-in failed: ${e.message})\n`));
+                }
+            }
+            try {
+                const r = await (0, api_js_1.consult)(cfg, brain, userMsg, opts.colony);
+                process.stdout.write(kleur_1.default.bold().cyan(`${r.brainName || brain}: `));
+                process.stdout.write(r.text + '\n\n');
+            }
+            catch (e) {
+                (0, ui_js_1.err)(e.message);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/check.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCommand = checkCommand;
+const config_js_1 = require("../lib/config.js");
+const api_js_1 = require("../lib/api.js");
+const ui_js_1 = require("../lib/ui.js");
+async function checkCommand(message, opts) {
+    const cfg = (0, config_js_1.requireConfig)();
+    if (!message || !message.trim()) {
+        (0, ui_js_1.err)('Usage: bc check "<message>"');
+        process.exit(1);
+    }
+    try {
+        const r = await (0, api_js_1.checkIn)(cfg, message, opts.colony);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(r, null, 2) + '\n');
+        }
+        else {
+            process.stdout.write((0, ui_js_1.renderCheckIn)(r) + '\n');
+        }
+    }
+    catch (e) {
+        (0, ui_js_1.err)(e.message);
+        process.exit(1);
+    }
+}

package/dist/commands/colonies.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coloniesCommand = coloniesCommand;
+const config_js_1 = require("../lib/config.js");
+const api_js_1 = require("../lib/api.js");
+const ui_js_1 = require("../lib/ui.js");
+const kleur_1 = __importDefault(require("kleur"));
+async function coloniesCommand(opts) {
+    const cfg = (0, config_js_1.requireConfig)();
+    try {
+        const cols = await (0, api_js_1.listColonies)(cfg);
+        if (opts.setDefault) {
+            const match = cols.find((c) => c.id === opts.setDefault || c.name === opts.setDefault);
+            if (!match) {
+                (0, ui_js_1.err)(`No colony matching '${opts.setDefault}'`);
+                process.exit(1);
+            }
+            (0, config_js_1.saveConfig)({ ...cfg, defaultColonyId: match.id });
+            (0, ui_js_1.ok)(`Default colony set to ${match.name} (${match.id})`);
+            return;
+        }
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(cols, null, 2) + '\n');
+            return;
+        }
+        if (cols.length === 0) {
+            process.stdout.write(kleur_1.default.dim('No colonies yet.\n'));
+            return;
+        }
+        for (const c of cols) {
+            const tag = c.id === cfg.defaultColonyId ? kleur_1.default.green(' (default)') : '';
+            process.stdout.write(`${kleur_1.default.bold(c.name)} ${kleur_1.default.dim(c.id)}${tag}\n`);
+            for (const b of c.brains ?? []) {
+                process.stdout.write(`  ${kleur_1.default.cyan('@' + b.id)} ${b.name}\n`);
+            }
+        }
+    }
+    catch (e) {
+        (0, ui_js_1.err)(e.message);
+        process.exit(1);
+    }
+}

package/dist/commands/consult.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consultCommand = consultCommand;
+const config_js_1 = require("../lib/config.js");
+const api_js_1 = require("../lib/api.js");
+const ui_js_1 = require("../lib/ui.js");
+const kleur_1 = __importDefault(require("kleur"));
+async function consultCommand(brainSpec, question, opts) {
+    const cfg = (0, config_js_1.requireConfig)();
+    if (!brainSpec || !question?.trim()) {
+        (0, ui_js_1.err)('Usage: bc consult @brainId "<question>"');
+        process.exit(1);
+    }
+    const brainId = brainSpec.replace(/^@/, '');
+    (0, ui_js_1.info)(`→ @${brainId}`);
+    try {
+        const r = await (0, api_js_1.consult)(cfg, brainId, question, opts.colony);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(r, null, 2) + '\n');
+        }
+        else {
+            process.stdout.write(kleur_1.default.bold().cyan(r.brainName || brainId) + ':\n');
+            process.stdout.write(r.text + '\n');
+        }
+    }
+    catch (e) {
+        (0, ui_js_1.err)(e.message);
+        process.exit(1);
+    }
+}

package/dist/commands/wrap.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCommand = wrapCommand;
+const node_child_process_1 = require("node:child_process");
+const config_js_1 = require("../lib/config.js");
+const api_js_1 = require("../lib/api.js");
+const ui_js_1 = require("../lib/ui.js");
+async function wrapCommand(rawArgs, opts) {
+    if (rawArgs.length === 0) {
+        (0, ui_js_1.err)('Usage: bc wrap [--inject] [--message "..."] -- <cli> [args...]');
+        (0, ui_js_1.err)('Example: bc wrap -- claude "should i refactor this auth code?"');
+        process.exit(1);
+    }
+    const cfg = (0, config_js_1.requireConfig)();
+    const target = rawArgs[0];
+    const targetArgs = rawArgs.slice(1);
+    let userMessage = opts.message;
+    let messageArgIdx = -1;
+    if (!userMessage) {
+        for (let i = targetArgs.length - 1; i >= 0; i--) {
+            const a = targetArgs[i];
+            if (a && !a.startsWith('-')) {
+                userMessage = a;
+                messageArgIdx = i;
+                break;
+            }
+        }
+    }
+    if (!userMessage) {
+        (0, ui_js_1.info)('bc wrap: no user message found in args — forwarding without check-in');
+        return forward(target, targetArgs);
+    }
+    try {
+        const r = await (0, api_js_1.checkIn)(cfg, userMessage, opts.colony);
+        if (!opts.silent) {
+            process.stderr.write((0, ui_js_1.renderCheckIn)(r) + '\n');
+        }
+        if (opts.inject && messageArgIdx >= 0) {
+            const block = formatInjectBlock(r);
+            if (block) {
+                targetArgs[messageArgIdx] = `${block}\n\n${userMessage}`;
+            }
+        }
+    }
+    catch (e) {
+        process.stderr.write(`⚠ bc.checkIn failed: ${e.message} — forwarding anyway\n`);
+    }
+    return forward(target, targetArgs);
+}
+function formatInjectBlock(r) {
+    const parts = [];
+    parts.push('[BrainColonies check-in — read before responding]');
+    parts.push(`drift signal: ${r.driftSignal}`);
+    if (r.missingPerspectives.length)
+        parts.push(`missing perspectives: ${r.missingPerspectives.join(', ')}`);
+    for (const o of r.observations)
+        parts.push(`observation: ${o}`);
+    if (r.message)
+        parts.push(r.mustReadAloud ? `MUST READ ALOUD: ${r.message}` : r.message);
+    parts.push('[end check-in]');
+    return parts.length > 2 ? parts.join('\n') : '';
+}
+function forward(target, args) {
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)(target, args, { stdio: 'inherit' });
+        child.on('error', (e) => {
+            if (e.code === 'ENOENT') {
+                (0, ui_js_1.err)(`Command not found: ${target}`);
+                process.exit(127);
+            }
+            (0, ui_js_1.err)(`Failed to spawn ${target}: ${e.message}`);
+            process.exit(1);
+        });
+        child.on('exit', (code, signal) => {
+            if (signal) {
+                process.kill(process.pid, signal);
+            }
+            else {
+                process.exit(code ?? 0);
+            }
+            resolve();
+        });
+    });
+}

package/dist/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const auth_js_1 = require("./commands/auth.js");
+const check_js_1 = require("./commands/check.js");
+const consult_js_1 = require("./commands/consult.js");
+const colonies_js_1 = require("./commands/colonies.js");
+const wrap_js_1 = require("./commands/wrap.js");
+const chat_js_1 = require("./commands/chat.js");
+const program = new commander_1.Command();
+program
+    .name('bc')
+    .description('BrainColonies — wisdom-layer counsel for the terminal')
+    .version('0.1.1');
+program
+    .command('auth')
+    .description('Authenticate with a bc_live_ API key (stored in ~/.bc/config.json)')
+    .option('--api-base <url>', 'override API base URL')
+    .action(auth_js_1.authCommand);
+program
+    .command('check <message...>')
+    .description('Call bc.checkIn for a user message — prints drift signal, missing perspectives, observations')
+    .option('-c, --colony <id>', 'colony id (defaults to your default colony)')
+    .option('--json', 'emit raw JSON instead of pretty output')
+    .action((message, opts) => (0, check_js_1.checkCommand)(message.join(' '), opts));
+program
+    .command('consult <brain> <question...>')
+    .description('Ask a specific brain a question (single turn)')
+    .option('-c, --colony <id>', 'colony id (defaults to your default colony)')
+    .option('--json', 'emit raw JSON')
+    .action((brain, question, opts) => (0, consult_js_1.consultCommand)(brain, question.join(' '), opts));
+program
+    .command('colonies')
+    .description('List your colonies and the brains inside each')
+    .option('--set-default <idOrName>', 'set a colony as the CLI default')
+    .option('--json', 'emit raw JSON')
+    .action(colonies_js_1.coloniesCommand);
+program
+    .command('wrap')
+    .description('Wrap another CLI: bc.checkIn fires first, then forwards. Use -- to separate args.')
+    .option('-m, --message <text>', 'explicit user message (otherwise: last positional arg of wrapped cmd)')
+    .option('-i, --inject', "inject the check-in block INTO the wrapped CLI's prompt (default: print only)")
+    .option('-c, --colony <id>', 'colony id (defaults to your default colony)')
+    .option('-s, --silent', 'do not print the check-in block to stderr')
+    .allowUnknownOption(true)
+    .helpOption('-h, --help', 'show help')
+    .action(function () {
+    const opts = this.opts();
+    const raw = this.args ?? [];
+    (0, wrap_js_1.wrapCommand)(raw, opts);
+});
+program
+    .command('chat')
+    .description('Interactive chat with a BC brain — fires bc.checkIn per turn')
+    .option('-b, --brain <id>', 'brain id (default: alt-me)')
+    .option('-c, --colony <id>', 'colony id (defaults to your default colony)')
+    .option('--no-check-in', 'skip the per-turn bc.checkIn call')
+    .action(chat_js_1.chatCommand);
+program.parseAsync(process.argv).catch((e) => {
+    process.stderr.write(`✖ ${e.message}\n`);
+    process.exit(1);
+});

package/dist/lib/api.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BcApiError = void 0;
+exports.bcFetch = bcFetch;
+exports.checkIn = checkIn;
+exports.consult = consult;
+exports.listColonies = listColonies;
+exports.whoami = whoami;
+class BcApiError extends Error {
+    status;
+    body;
+    constructor(status, body, message) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = 'BcApiError';
+    }
+}
+exports.BcApiError = BcApiError;
+async function bcFetch(cfg, path, opts = {}) {
+    const url = `${cfg.apiBase.replace(/\/$/, '')}${path}`;
+    const res = await fetch(url, {
+        method: opts.method ?? (opts.body ? 'POST' : 'GET'),
+        headers: {
+            Authorization: `Bearer ${cfg.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: opts.body ? JSON.stringify(opts.body) : undefined,
+        signal: opts.signal,
+    });
+    const text = await res.text();
+    let parsed = text;
+    try {
+        parsed = text ? JSON.parse(text) : null;
+    }
+    catch { }
+    if (!res.ok) {
+        const msg = (parsed && typeof parsed === 'object' && 'error' in parsed)
+            ? String(parsed.error)
+            : `HTTP ${res.status}`;
+        throw new BcApiError(res.status, parsed, msg);
+    }
+    return parsed;
+}
+async function checkIn(cfg, userMessage, colonyId) {
+    return bcFetch(cfg, '/mcp', {
+        method: 'POST',
+        body: {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'tools/call',
+            params: {
+                name: 'bc.checkIn',
+                arguments: { userMessage, colonyId: colonyId ?? cfg.defaultColonyId },
+            },
+        },
+    }).then((raw) => {
+        const r = raw;
+        const first = r?.result?.content?.[0];
+        if (first?.type === 'text' && first.text) {
+            try {
+                return JSON.parse(first.text);
+            }
+            catch { }
+        }
+        return {
+            driftSignal: 'none',
+            pendingReflections: 0,
+            missingPerspectives: [],
+            observations: [],
+            mustReadAloud: false,
+        };
+    });
+}
+async function consult(cfg, brainId, question, colonyId) {
+    const resolvedColony = colonyId ?? cfg.defaultColonyId;
+    if (!resolvedColony) {
+        throw new Error('No colony selected. Run `bc colonies` and set one as default, or pass --colony.');
+    }
+    return bcFetch(cfg, `/api/colony/${resolvedColony}/interact`, {
+        method: 'POST',
+        body: {
+            brainId,
+            mode: 'chat',
+            messages: [{ role: 'user', content: question }],
+        },
+    });
+}
+async function listColonies(cfg) {
+    const raw = await bcFetch(cfg, `/colonies?userId=${encodeURIComponent(cfg.userId)}`);
+    return Array.isArray(raw) ? raw : (raw?.colonies ?? []);
+}
+async function whoami(cfg) {
+    return bcFetch(cfg, '/api/me');
+}

package/dist/lib/config.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.configPath = configPath;
+exports.defaultApiBase = defaultApiBase;
+exports.requireConfig = requireConfig;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const CONFIG_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), '.bc');
+const CONFIG_PATH = (0, node_path_1.join)(CONFIG_DIR, 'config.json');
+const DEFAULT_API_BASE = 'https://ma3yuktnyh.execute-api.us-east-1.amazonaws.com';
+function loadConfig() {
+    if (!(0, node_fs_1.existsSync)(CONFIG_PATH))
+        return null;
+    try {
+        const raw = (0, node_fs_1.readFileSync)(CONFIG_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.apiKey || !parsed.userId)
+            return null;
+        return {
+            apiKey: parsed.apiKey,
+            apiBase: parsed.apiBase || DEFAULT_API_BASE,
+            userId: parsed.userId,
+            defaultColonyId: parsed.defaultColonyId,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function saveConfig(cfg) {
+    if (!(0, node_fs_1.existsSync)(CONFIG_DIR)) {
+        (0, node_fs_1.mkdirSync)(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    (0, node_fs_1.writeFileSync)(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+    (0, node_fs_1.chmodSync)(CONFIG_PATH, 0o600);
+}
+function configPath() {
+    return CONFIG_PATH;
+}
+function defaultApiBase() {
+    return DEFAULT_API_BASE;
+}
+function requireConfig() {
+    const cfg = loadConfig();
+    if (!cfg) {
+        throw new Error('Not authenticated. Run `bc auth` first.');
+    }
+    return cfg;
+}

package/dist/lib/ui.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.banner = banner;
+exports.err = err;
+exports.ok = ok;
+exports.info = info;
+exports.renderCheckIn = renderCheckIn;
+const kleur_1 = __importDefault(require("kleur"));
+function banner() {
+    return kleur_1.default.bold().cyan('🧠 BrainColonies');
+}
+function err(msg) {
+    process.stderr.write(kleur_1.default.red('✖ ') + msg + '\n');
+}
+function ok(msg) {
+    process.stdout.write(kleur_1.default.green('✓ ') + msg + '\n');
+}
+function info(msg) {
+    process.stdout.write(kleur_1.default.dim(msg) + '\n');
+}
+const DRIFT_COLORS = {
+    none: kleur_1.default.dim,
+    low: kleur_1.default.cyan,
+    medium: kleur_1.default.yellow,
+    high: kleur_1.default.red,
+};
+function renderCheckIn(r) {
+    const lines = [];
+    lines.push(kleur_1.default.bold().cyan('━━━ bc.checkIn ━━━'));
+    const colorFn = DRIFT_COLORS[r.driftSignal] ?? kleur_1.default.dim;
+    lines.push(`drift: ${colorFn(r.driftSignal.toUpperCase())}`);
+    if (r.pendingReflections > 0) {
+        lines.push(`pending reflections: ${kleur_1.default.yellow(String(r.pendingReflections))}`);
+    }
+    if (r.missingPerspectives.length > 0) {
+        lines.push(`missing perspectives: ${kleur_1.default.magenta(r.missingPerspectives.join(', '))}`);
+    }
+    if (r.observations.length > 0) {
+        lines.push(kleur_1.default.bold('observations:'));
+        for (const o of r.observations)
+            lines.push(`  • ${o}`);
+    }
+    if (r.message) {
+        lines.push('');
+        lines.push(r.mustReadAloud ? kleur_1.default.bold().yellow(r.message) : r.message);
+    }
+    lines.push(kleur_1.default.dim('━━━━━━━━━━━━━━━━━━'));
+    return lines.join('\n');
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "brain-colonies",
+  "version": "0.1.1",
+  "description": "BrainColonies CLI — wisdom-layer counsel for the terminal. Wrap any AI CLI for per-turn drift-protection.",
+  "main": "dist/index.js",
+  "bin": {
+    "bc": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": ["dist", "README.md"],
+  "keywords": [
+    "ai",
+    "cli",
+    "brain-colonies",
+    "wisdom-layer",
+    "drift-protection",
+    "ontology",
+    "mcp"
+  ],
+  "homepage": "https://braincolonies.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ganbarone/brain-colony-collective.git",
+    "directory": "cli"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "kleur": "^4.1.5"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^20.11.0",
+    "tsx": "^4.7.0"
+  }
+}