@spinabot/brigade 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.0 — 2026-05-02
+
+- Initial release.
+- Polished terminal TUI for Anthropic, OpenAI, Gemini, Groq, xAI, DeepSeek, Mistral, OpenRouter, Cerebras, Ollama, and any OpenAI-compatible endpoint.
+- Subcommands: `brigade chat`, `brigade gateway`, `brigade connect`, `brigade onboard`, `brigade doctor`, `brigade config`.
+- Provider onboarding wizard on first launch.
+- `/model`, `/provider`, `/thinking`, `/help` in-chat commands.
+- Local-only — no telemetry, no cloud component.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brigade contributors
+
+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

@@ -0,0 +1,154 @@
+<p>
+  <img src="https://github.com/user-attachments/assets/44afe91e-bc06-4b85-a8a9-dcc608041e28#gh-dark-mode-only" alt="Brigade demo" width="180" align="right" />
+  <img src="https://github.com/user-attachments/assets/3cc8ad09-259b-4eef-889a-23ded6eabab3#gh-light-mode-only" alt="Brigade demo" width="180" align="right" />
+  <img src="./assets/brigade-wordmark.png#gh-dark-mode-only" alt="BRIGADE" width="600" />
+  <img src="./assets/brigade-wordmark-on-black.png#gh-light-mode-only" alt="BRIGADE" width="600" />
+</p>
+
+<br clear="all" />
+
+Brigade is a polished terminal interface for working with the world's
+leading language models — Anthropic Claude, OpenAI GPT, Google Gemini,
+Groq, xAI, DeepSeek, Mistral, OpenRouter, Cerebras — and your own local
+models via Ollama or any OpenAI-compatible endpoint.
+
+It runs in two modes: a single-process chat TUI (the default) or as a
+headless WebSocket gateway you can connect multiple thin clients to.
+
+## Install
+
+```bash
+npm install -g @spinabot/brigade
+```
+
+Requires Node.js 20 or newer.
+
+## Quick start
+
+```bash
+brigade
+```
+
+First launch walks you through three steps:
+
+1. Pick a provider.
+2. Connect it (paste an API key, or scan your local Ollama).
+3. Choose a default model.
+
+That's it. Subsequent launches resume right where you left off.
+
+## Commands
+
+Brigade is a single binary with subcommands. `brigade` on its own is
+shorthand for `brigade chat`.
+
+| Command            | What it does                                                  |
+|--------------------|---------------------------------------------------------------|
+| `brigade`          | Start the chat TUI (default)                                  |
+| `brigade chat`     | Start the chat TUI                                            |
+| `brigade gateway`  | Run the headless WebSocket gateway, no TUI                    |
+| `brigade connect`  | Open a TUI that talks to a running gateway                    |
+| `brigade onboard`  | Re-run the provider/model setup wizard                        |
+| `brigade doctor`   | Health-check Node, config, providers, prompts, and log sink   |
+| `brigade config`   | Read & write `~/.brigade/config.json`                         |
+| `brigade --version`| Print the version                                             |
+| `brigade --help`   | Print the full help text                                      |
+
+### `brigade gateway`
+
+Runs Brigade as a WebSocket server with no terminal UI of its own.
+Useful when you want a long-lived agent process you can attach and
+detach clients to.
+
+```bash
+brigade gateway --port 7777 --host 127.0.0.1 --verbose
+```
+
+| Flag             | Default       | Notes                                        |
+|------------------|---------------|----------------------------------------------|
+| `--port N`       | `7777`        | Listen port (also `BRIGADE_PORT` env var)    |
+| `--host A`       | `127.0.0.1`   | Bind address                                 |
+| `--verbose`      | off           | Stream a one-line summary of every event     |
+| `--quiet`        | off           | Suppress the live console stream             |
+| `--log-level X`  | `info`        | `debug`, `info`, `warn`, `error`             |
+
+### `brigade connect`
+
+Attaches a TUI to a running gateway. Same chat experience as `brigade`,
+but the agent runs in the gateway process — so you can disconnect, walk
+away, reconnect later, and pick up where you left off.
+
+```bash
+brigade connect --host 127.0.0.1 --port 7777
+```
+
+| Flag           | Default       | Notes                                |
+|----------------|---------------|--------------------------------------|
+| `--host A`     | `127.0.0.1`   | Gateway host to connect to           |
+| `--port N`     | `7777`        | Gateway port                         |
+| `--timeout MS` | `60000`       | Per-request timeout                  |
+
+### `brigade doctor`
+
+Runs a health check across Node version, your `~/.brigade/` directory,
+config, configured providers, log sink, prompt files, and (optionally)
+a running gateway. Exits 0 if everything passes, 1 if anything fails.
+
+```bash
+brigade doctor
+brigade doctor --gateway ws://127.0.0.1:7777
+```
+
+### `brigade config`
+
+Read and write the local config without opening the TUI.
+
+```bash
+brigade config list
+brigade config get defaultProvider
+brigade config set defaultProvider anthropic
+brigade config unset thinkingLevel
+```
+
+Known keys: `defaultProvider`, `defaultModelId`, `thinkingLevel`,
+`fallbackProvider`, `fallbackModelId`, `installedAt`.
+
+## In-chat commands
+
+When you're in the chat TUI (whether via `brigade` or `brigade connect`):
+
+| Command             | What it does                                                |
+|---------------------|-------------------------------------------------------------|
+| `/model`            | Switch to a different configured model (picker)             |
+| `/model <id>`       | Switch directly by model id                                 |
+| `/provider`         | Add a new provider mid-session — no restart required        |
+| `/thinking <level>` | Adjust reasoning effort (off, minimal, low, medium, high)   |
+| `/compact`          | Force a context compaction now                              |
+| `/help`             | Show all commands                                           |
+| `/exit`             | Quit Brigade                                                |
+
+Keyboard:
+
+- **Enter** — send (mid-turn submits steer the model without aborting)
+- **Ctrl+C** — stop the current response (doesn't exit)
+- **Ctrl+D** — quit
+- **↑** / **↓** — message history
+
+## Supported providers
+
+Out of the box: Anthropic, OpenAI, Google Gemini, OpenRouter, Groq, xAI,
+Cerebras, DeepSeek, Mistral, **Ollama** (local), and **Custom
+OpenAI-compatible** endpoints (Together AI, Fireworks, vLLM, on-prem
+gateways, anything that speaks `/v1/chat/completions`).
+
+You can mix and match — connect three providers, switch between their
+models with `/model`, and Brigade keeps your conversation context
+across the switch.
+
+## Privacy
+
+Brigade is a local CLI. Your API keys never leave your computer; they're
+stored in your home directory and used only to talk to the providers you
+connect. No telemetry, no analytics, no cloud component.
+
+For Ollama and Custom endpoints, requests stay entirely on your network.

package/SECURITY.md

@@ -0,0 +1,208 @@
+# Security Policy
+
+Brigade is a local CLI that connects you to the language-model
+providers you choose. We take its security posture seriously because it
+sits in the trust path between your machine, your API keys, and the
+models that act on your behalf.
+
+If you believe you have found a security issue in Brigade, please
+follow the disclosure process below. Do **not** open a public GitHub
+issue or pull request for a suspected vulnerability — public reports
+expose users before a fix can ship.
+
+## Reporting a Vulnerability
+
+The preferred channel is GitHub's private vulnerability reporting:
+
+- Open https://github.com/Bhasvanth-Dev9380/brigade/security/advisories/new
+- Provide a clear description, reproduction steps, affected version, and
+  the impact you believe the issue has.
+
+If you cannot use GitHub, email **bhasvanth02@gmail.com** with
+"Brigade security" in the subject line. PGP is available on request.
+
+You will receive an acknowledgement within a few business days. We will
+keep you informed as we investigate, and we'll credit you in the
+release notes for the fix unless you prefer to remain anonymous.
+
+Please do **not** publish details of an unpatched issue. Coordinated
+disclosure protects every Brigade user.
+
+## Supported Versions
+
+Brigade is on a rolling release. Security fixes ship to the latest
+published version on npm. Earlier versions are not back-patched.
+
+| Version    | Supported              |
+|------------|------------------------|
+| latest     | Yes (security + bugs)  |
+| previous   | Best-effort, ~30 days  |
+| older      | No                     |
+
+When in doubt, run `npm install -g @spinabot/brigade@latest` and
+verify with `brigade --version`.
+
+## Scope
+
+In scope for security reports:
+
+- The published package `@spinabot/brigade` and its compiled `dist/`.
+- The `brigade.mjs` bin wrapper.
+- The Brigade gateway (`brigade gateway`) — the WebSocket server, its
+  default bind, its protocol surface, and any server-side handlers.
+- The Brigade client (`brigade connect`) — connection logic, framing,
+  command dispatch.
+- The local on-disk state under `~/.brigade/` (config, sessions, logs,
+  prompts, auth/model storage).
+- The build and release pipeline (`scripts/prepack.mjs`, `prepublishOnly`).
+
+Out of scope:
+
+- Vulnerabilities in upstream dependencies that have not been
+  exploited through Brigade's own code paths. Please report those to
+  the upstream project. We track and update Pi SDK packages
+  (`@mariozechner/pi-*`) on a tight schedule.
+- Behavior of the language-model providers themselves (Anthropic,
+  OpenAI, Google, Groq, xAI, DeepSeek, Mistral, OpenRouter, Cerebras,
+  Ollama, custom OpenAI-compatible endpoints). Their security posture
+  is governed by their own policies.
+- Compromise of the user's local machine, OS account, terminal, or
+  shell — Brigade trusts the user that runs it.
+- Issues that require physical access, an already-rooted device, or
+  malware running with the same privileges as the Brigade process.
+- Rate-limit or denial-of-service against your *own* providers via
+  your own API keys.
+- Findings that depend on a non-default, user-edited configuration
+  that explicitly weakens the defaults documented here.
+
+## Trust Model
+
+Brigade's defaults assume a single-user developer machine. The tool is
+designed to run on hardware you control, with credentials you own, and
+to talk to models you have selected.
+
+Three trust boundaries are worth calling out:
+
+1. **You trust your own machine.** API keys, conversation history, and
+   logs live on disk in your home directory. Brigade does not encrypt
+   files at rest — it relies on your OS user permissions. Anyone with
+   read access to your home directory has read access to your keys.
+
+2. **You trust the providers you connect.** Your prompts, file
+   contents shared via tools, and model output are sent to the
+   provider you chose. Brigade does not interpose, redact, or filter
+   that content. Use providers whose data-handling matches your needs.
+
+3. **You trust the prompts you send.** Brigade exposes capable tools
+   to the agent loop (file read, write, edit, shell). A model that
+   follows instructions from untrusted text — pasted code, scraped
+   web content, attacker-supplied documents — can be steered into
+   acting on your machine. Treat prompt input the same way you treat
+   shell input.
+
+## Where Secrets Live
+
+| Item                        | Location                              | Format         |
+|-----------------------------|---------------------------------------|----------------|
+| Provider API keys           | `~/.brigade/auth.json`                | JSON, plain    |
+| Provider catalogs / models  | `~/.brigade/models.json`              | JSON, plain    |
+| User preferences            | `~/.brigade/config.json`              | JSON, plain    |
+| Conversation transcripts    | `~/.brigade/sessions/`                | JSONL, plain   |
+| Event logs                  | `~/.brigade/logs/`                    | JSONL, plain   |
+| Layered system prompts      | `~/.brigade/prompts/`                 | Markdown       |
+
+The location can be redirected by setting the `BRIGADE_DIR`
+environment variable before launching Brigade. This is useful for
+test harnesses, dotfile managers, and ephemeral CI runners.
+
+`rm -rf ~/.brigade` removes one hundred percent of Brigade's local
+state. Nothing important to Brigade lives elsewhere. (On Windows, the
+equivalent path is `%USERPROFILE%\.brigade`.)
+
+## Network Exposure
+
+By default Brigade does not listen on any network port.
+
+When you opt in by running `brigade gateway`:
+
+- The WebSocket server binds to `127.0.0.1` — localhost only, not
+  reachable from your LAN.
+- The default port is `7777`, configurable with `--port`.
+- The default bind is configurable with `--host`. Setting
+  `--host 0.0.0.0` exposes the gateway to your network and is **not
+  recommended** without an external authentication or firewall layer.
+
+Brigade gateway has **no built-in authentication or authorization in
+v1.** Anyone who can connect to the listening socket can drive the
+agent and read every conversation. This is by design for the
+single-user, single-machine target. If you bind the gateway to a
+non-loopback address, you are responsible for restricting access.
+
+Outbound traffic is limited to the providers you have configured —
+Brigade itself sends no telemetry, no analytics, and no crash reports.
+There is no Brigade-operated cloud component.
+
+## Tool Execution Model
+
+Brigade ships with the standard agent toolkit: read files, edit files,
+write files, search files, and run shell commands. These tools execute
+with the same privileges as the Brigade process and operate on your
+real filesystem.
+
+A model with tool access is, by design, capable of doing anything your
+shell can. This includes deleting files, exfiltrating data via curl,
+or installing software. We surface tool calls in the chat UI and the
+JSONL log so you can see what is being attempted, but we do not
+sandbox or veto the calls themselves in v1. Treat the agent as a
+junior engineer with shell access who you authorized to act on your
+behalf — and review what it does, especially with prompts that
+include third-party text.
+
+A future Brigade release will add per-tool allowlisting, a confirmation
+prompt for destructive operations, and an optional sandbox. Until then,
+run Brigade in directories whose blast radius you accept.
+
+## Hardening Recommendations
+
+For users who want a tighter posture:
+
+1. **Restrict `~/.brigade/` permissions.** On Unix, `chmod 700
+   ~/.brigade && chmod 600 ~/.brigade/*.json` prevents other local
+   users from reading your keys.
+2. **Use scoped API keys.** Most providers support keys scoped by
+   model, project, or budget. Use the most restrictive scope that fits
+   your use.
+3. **Prefer Ollama or a custom OpenAI-compatible endpoint** for
+   sensitive content — requests then stay entirely on your network.
+4. **Keep Brigade up to date.** Run `npm update -g @spinabot/brigade`
+   periodically. Security fixes only land in the latest version.
+5. **Run Brigade in a workspace, not your home directory.** The agent
+   can read and write the directory it runs in. Limiting its working
+   directory limits what it can touch.
+6. **Audit `~/.brigade/logs/`.** The JSONL event log records every
+   tool call. Review it the way you would review shell history.
+7. **Do not bind the gateway to `0.0.0.0`** unless you have a
+   reverse proxy or VPN in front of it.
+
+## Disclosure Timeline
+
+Once a valid report is acknowledged, we aim for the following:
+
+- **Day 0:** acknowledgement of receipt.
+- **By day 7:** initial triage, severity assessment, and reproduction
+  in a clean environment.
+- **By day 30:** patch released to npm under a new version, advisory
+  published on the GitHub repo, and the CHANGELOG updated.
+- **Day 30+:** for issues that require a coordinated upstream fix in
+  the Pi SDK or another dependency, we work with the upstream
+  maintainers and may extend this window. Reporters are kept in the
+  loop throughout.
+
+If a report turns out to be a feature working as intended, we will
+explain why and document it more clearly so the next person to look
+at it does not have to rediscover the rationale.
+
+## Acknowledgements
+
+We will list reporters who follow coordinated disclosure here as
+issues are fixed. Thank you for keeping Brigade users safe.

package/brigade.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import module from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+
+// ── Node version guard ──────────────────────────────────────────────
+const MIN_NODE_MAJOR = 20;
+const [majorRaw = "0"] = process.versions.node.split(".");
+if (Number(majorRaw) < MIN_NODE_MAJOR) {
+  process.stderr.write(
+    `brigade: Node.js v${MIN_NODE_MAJOR}.0+ is required (current: v${process.versions.node}).\n` +
+      "If you use nvm, run:\n" +
+      `  nvm install ${MIN_NODE_MAJOR}\n` +
+      `  nvm use ${MIN_NODE_MAJOR}\n` +
+      `  nvm alias default ${MIN_NODE_MAJOR}\n`,
+  );
+  process.exit(1);
+}
+
+// ── Compile cache (Node 22.1+) ──────────────────────────────────────
+if (module.enableCompileCache && !process.env.NODE_DISABLE_COMPILE_CACHE) {
+  try {
+    module.enableCompileCache();
+  } catch {
+    // ignore — older Node versions or sandboxed environments
+  }
+}
+
+// ── Resolve the compiled entry ──────────────────────────────────────
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const entry = join(__dirname, "dist", "cli.js");
+
+if (!existsSync(entry)) {
+  // Distinguish "installed package without dist" (shouldn't happen — files
+  // field guarantees dist/) from "raw source checkout that wasn't built".
+  const pkgPath = join(__dirname, "package.json");
+  const looksInstalled = !existsSync(join(__dirname, "src"));
+  if (looksInstalled) {
+    process.stderr.write(
+      "brigade: the installed package is missing dist/cli.js.\n" +
+        "Try reinstalling:\n" +
+        "  npm install -g @spinabot/brigade\n",
+    );
+  } else {
+    process.stderr.write(
+      "brigade: missing dist/cli.js (build output).\n" +
+        "This looks like an unbuilt source checkout. Build it first:\n" +
+        "  npm install && npm run build\n" +
+        "Or install the published package:\n" +
+        "  npm install -g @spinabot/brigade\n",
+    );
+  }
+  void pkgPath;
+  process.exit(1);
+}
+
+// ── Spawn the CLI ───────────────────────────────────────────────────
+// We spawn a child instead of dynamic-importing so that:
+//   1. process.argv[1] is dist/cli.js, satisfying the self-execution
+//      guard (import.meta.url === pathToFileURL(argv[1]).href)
+//   2. fatal startup errors give a stack pointing at the real file
+//      instead of bouncing through this wrapper
+const child = spawn(process.execPath, [entry, ...process.argv.slice(2)], {
+  stdio: "inherit",
+});
+
+child.on("error", (err) => {
+  // Rare: process.execPath itself is missing, or EACCES on the entry.
+  // Surface a clean line instead of the raw Node trace.
+  const code = (err && err.code) || "UNKNOWN";
+  if (code === "ENOENT") {
+    process.stderr.write(
+      "brigade: could not launch Node — the runtime executable is missing.\n",
+    );
+  } else if (code === "EACCES") {
+    process.stderr.write(
+      "brigade: permission denied launching the CLI. Check file permissions on dist/cli.js.\n",
+    );
+  } else {
+    process.stderr.write(`brigade: failed to launch (${code}): ${err.message}\n`);
+  }
+  process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    // Re-raise the signal to ourselves so the parent shell sees the
+    // correct exit cause (e.g. SIGINT → 130).
+    process.kill(process.pid, signal);
+  } else {
+    process.exit(code ?? 0);
+  }
+});

package/dist/cli/chat-cmd.js

@@ -0,0 +1,120 @@
+/**
+ * `brigade chat` — in-process TUI + Pi session in a single process.
+ *
+ * This is the default subcommand and the simplest path: one terminal, one
+ * process, no gateway, full feature set. Everything the user sees in the
+ * conversation runs through the local Pi loop with the 6-layer wrapper
+ * composition wired in src/ui/chat.ts.
+ *
+ * Wraps the original boot flow (auth + model resolution → onboarding-if-needed
+ * → buildAgent → runChat) and surfaces a clean SIGINT chain so Ctrl+C aborts
+ * a turn first, exits second.
+ */
+import process from "node:process";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { ProcessTerminal, TUI } from "@mariozechner/pi-tui";
+import chalk from "chalk";
+import { buildAgent } from "../core/agent.js";
+import { BRIGADE_DIR, loadConfig } from "../core/config.js";
+import { attachEventLogger, getTodayLogPath } from "../core/event-logger.js";
+import { findProvider } from "../providers/catalog.js";
+import { runChat } from "../ui/chat.js";
+import { runOnboarding } from "../ui/onboarding.js";
+/**
+ * Boot the in-process chat TUI. Returns once the editor is ready; the chat
+ * runs until SIGINT/Ctrl+D/`/exit`. Resolves with the chat handle in case
+ * the caller wants to introspect or wire additional signal handlers.
+ */
+export async function runChatCommand(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    // Boot the TUI renderer FIRST. From this point on, addChild/requestRender
+    // actually paint to the screen. Onboarding, splash, and chat all depend on it.
+    const tui = new TUI(new ProcessTerminal());
+    tui.start();
+    // Wire the SIGINT handler IMMEDIATELY — before splash, onboarding, or chat.
+    // Without this, Ctrl+C during the splash or onboarding wizard would crash with
+    // `chat is undefined`. We hold a mutable ChatHandle reference that gets filled
+    // in once runChat() returns, and the handler delegates to it when present.
+    let chatHandle = null;
+    // Re-entrant SIGINT handler: first Ctrl+C aborts a running turn (handler
+    // stays attached so a SECOND Ctrl+C in idle state quits). We re-arm with
+    // process.once after each turn-abort so handlers never stack across
+    // re-invocations of runChatCommand within the same process (matters for
+    // tests and for any future supervisor that might restart the chat).
+    const onSigint = () => {
+        if (chatHandle) {
+            const wasRunning = chatHandle.abort();
+            if (!wasRunning) {
+                tui.stop();
+                process.exit(0);
+            }
+            // A turn was aborted — re-arm so the next Ctrl+C is heard.
+            process.once("SIGINT", onSigint);
+            return;
+        }
+        // During splash / onboarding (no chat yet): clean exit.
+        tui.stop();
+        process.exit(130); // 128 + SIGINT
+    };
+    process.once("SIGINT", onSigint);
+    const authStorage = AuthStorage.create(`${BRIGADE_DIR}/auth.json`);
+    const modelRegistry = ModelRegistry.create(authStorage, `${BRIGADE_DIR}/models.json`);
+    // Try saved config + existing key first.
+    const config = await loadConfig();
+    let provider = config.defaultProvider;
+    let modelId = config.defaultModelId;
+    let model = provider && modelId ? modelRegistry.find(provider, modelId) : undefined;
+    if (model && provider) {
+        // Skip the saved-key check for noAuth providers (Ollama, LM Studio) —
+        // they don't store anything in AuthStorage. The model registration in
+        // models.json is itself the persistence mechanism.
+        const providerInfo = findProvider(provider);
+        if (!providerInfo?.noAuth) {
+            const apiKey = await authStorage.getApiKey(provider);
+            if (!apiKey) {
+                model = undefined; // saved model but no key — re-onboard
+            }
+        }
+    }
+    // Onboard if needed.
+    if (!model || !provider || !modelId) {
+        try {
+            const result = await runOnboarding(tui, authStorage, modelRegistry);
+            provider = result.provider;
+            modelId = result.modelId;
+            modelRegistry.refresh();
+            model = modelRegistry.find(provider, modelId);
+        }
+        catch (_err) {
+            tui.stop();
+            console.error(chalk.red("Onboarding cancelled."));
+            process.exit(1);
+        }
+    }
+    if (!model || !provider || !modelId) {
+        tui.stop();
+        console.error(chalk.red("Brigade couldn't get ready. Please run setup again."));
+        process.exit(1);
+    }
+    // Build the Pi agent session. Note: do NOT overwrite session.agent.streamFn —
+    // createAgentSession installs an auth-aware wrapper that resolves the API key
+    // from modelRegistry and attaches Authorization headers per request. Replacing
+    // it with raw streamSimple strips the auth and requests silently 401.
+    const session = await buildAgent({
+        authStorage,
+        modelRegistry,
+        model,
+        cwd,
+    });
+    // Stream every Pi event to ~/.brigade/logs/<date>.jsonl. Brigade's only
+    // log sink — when something goes wrong (hang, hallucination, mid-turn
+    // switch confusion) the user can grep today's file.
+    attachEventLogger(session);
+    process.stderr.write(`\x1b[2mlogs: ${getTodayLogPath()}\x1b[0m\n`);
+    // Hand off to the chat TUI. runChat returns a ChatHandle synchronously once
+    // the UI is wired — the editor's onSubmit drives subsequent turns until
+    // /exit, Ctrl+D, or SIGINT (already wired above) tears it down.
+    chatHandle = await runChat({ session, tui, provider, modelId, authStorage, modelRegistry });
+    return chatHandle;
+}
+//# sourceMappingURL=chat-cmd.js.map