@spinabot/brigade 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,10 +1,48 @@
-# 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.
+# Changelog
+
+## [0.1.2](https://github.com/Bhasvanth-Dev9380/brigade/compare/v0.1.1...v0.1.2) (2026-05-03)
+
+
+### Bug Fixes
+
+* **readme:** use absolute raw URL for banner so npm renders it ([975f5f2](https://github.com/Bhasvanth-Dev9380/brigade/commit/975f5f2884ef98af017720c0eaa499eb4c9f3572))
+
+## [0.1.1](https://github.com/Bhasvanth-Dev9380/brigade/compare/v0.1.0...v0.1.1) (2026-05-03)
+
+
+### Features
+
+* add CI and release workflows, configure automated npm publishing, and enhance README with badges ([7cda18d](https://github.com/Bhasvanth-Dev9380/brigade/commit/7cda18dfecd320fb0cf70553a64baecf291175fb))
+* add injected-content defence section to AGENTS.md and update image layout in README.md ([7180544](https://github.com/Bhasvanth-Dev9380/brigade/commit/718054476cc02687cbc84fc79b9e029ec894568e))
+* **brand:** enhance layout handling for terminal width and add wordmark indentation ([0f68c83](https://github.com/Bhasvanth-Dev9380/brigade/commit/0f68c8357f27d966ce4b4cfa0bf6450cf999f7bc))
+* **brand:** enhance layout handling for terminal widths and add scrollback-friendly rendering ([28b280b](https://github.com/Bhasvanth-Dev9380/brigade/commit/28b280bc3ffdcbd3b60e7937885eda8995ee3d9b))
+* enhance README with new images for dark mode and adjust wordmark size; add demo GIF ([cd9c607](https://github.com/Bhasvanth-Dev9380/brigade/commit/cd9c6074fff29b793bb486cef4a5dc91e262b2c7))
+* enhance README with responsive wordmark and add new image for dark mode ([5de16f7](https://github.com/Bhasvanth-Dev9380/brigade/commit/5de16f7118114c209f6eea46e078cec18ae5da75))
+* implement Brigade-native auth error translation and guidance messages; add tests for auth-error handling ([1f57ba5](https://github.com/Bhasvanth-Dev9380/brigade/commit/1f57ba567701e77f83ee24ae50bf8e776a6cba2a))
+* implement ephemeral system prompt feature with sanitization and context framing ([cd9c607](https://github.com/Bhasvanth-Dev9380/brigade/commit/cd9c6074fff29b793bb486cef4a5dc91e262b2c7))
+* implement injected text sanitization and defensive framing for project context ([5de16f7](https://github.com/Bhasvanth-Dev9380/brigade/commit/5de16f7118114c209f6eea46e078cec18ae5da75))
+* **tests:** add comprehensive CLI tests for argument parsing, dispatching, and command execution ([1c398c5](https://github.com/Bhasvanth-Dev9380/brigade/commit/1c398c5611349a5765022306478d7ba133a7613d))
+* **tests:** add comprehensive tests for onboarding, provider commands, and error handling ([c1d5a77](https://github.com/Bhasvanth-Dev9380/brigade/commit/c1d5a77238bf5f02e8a20054671140b0169f7e63))
+* update README and add brigade wordmark image ([55a2a1b](https://github.com/Bhasvanth-Dev9380/brigade/commit/55a2a1b9f7c1f8cae51307052e4603713865e3bd))
+* update README with new image layout, add demo GIFs, and clean up package.json assets ([378529a](https://github.com/Bhasvanth-Dev9380/brigade/commit/378529a6b815f1aaab557bccca8a18e589c013c8))
+
+
+### Bug Fixes
+
+* adjust image layout and alignment in README ([a80268b](https://github.com/Bhasvanth-Dev9380/brigade/commit/a80268b1fb1d363306f27dcd93b1a290442ab3c4))
+* **tests:** add connect-cmd footer note for /provider command visibility ([2367deb](https://github.com/Bhasvanth-Dev9380/brigade/commit/2367deb4b445740bd556ed22b3acac924fd2bd4a))
+* update demo image link in README ([f688f01](https://github.com/Bhasvanth-Dev9380/brigade/commit/f688f01d92e56805aeaa78b8da6b7aa40d619c16))
+
+
+### Refactor
+
+* **tests:** enhance brigade-config migration tests to prevent product name leakage ([2367deb](https://github.com/Bhasvanth-Dev9380/brigade/commit/2367deb4b445740bd556ed22b3acac924fd2bd4a))
+
+## 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

@@ -1,21 +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.
+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

@@ -1,11 +1,13 @@
-<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 align="center">
+  <img src="https://raw.githubusercontent.com/Bhasvanth-Dev9380/brigade/main/assets/brigade-banner-on-black.gif" alt="BRIGADE — your personal AI crew" width="900" />
 </p>
 
-<br clear="all" />
+<p>
+  <a href="https://github.com/Bhasvanth-Dev9380/brigade/actions/workflows/ci.yml"><img src="https://github.com/Bhasvanth-Dev9380/brigade/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
+  <a href="https://www.npmjs.com/package/@spinabot/brigade"><img src="https://img.shields.io/npm/v/@spinabot/brigade" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/@spinabot/brigade"><img src="https://img.shields.io/npm/l/@spinabot/brigade" alt="license" /></a>
+  <a href="https://www.npmjs.com/package/@spinabot/brigade"><img src="https://img.shields.io/node/v/@spinabot/brigade" alt="node engine" /></a>
+</p>
 
 Brigade is a polished terminal interface for working with the world's
 leading language models — Anthropic Claude, OpenAI GPT, Google Gemini,

package/dist/cli/chat-cmd.js

@@ -10,16 +10,20 @@
  * → buildAgent → runChat) and surfaces a clean SIGINT chain so Ctrl+C aborts
  * a turn first, exits second.
  */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 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 { BRIGADE_DIR, getBrigadeWorkspaceDir, loadConfig } from "../core/config.js";
 import { attachEventLogger, getTodayLogPath } from "../core/event-logger.js";
 import { findProvider } from "../providers/catalog.js";
+import { EXIT_CONFIG_ERROR } from "../protocol.js";
 import { runChat } from "../ui/chat.js";
 import { runOnboarding } from "../ui/onboarding.js";
+import { restoreTerminal } from "../ui/terminal-cleanup.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
@@ -27,6 +31,17 @@ import { runOnboarding } from "../ui/onboarding.js";
  */
 export async function runChatCommand(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
+    // Refuse to boot in a non-TTY environment (CI, piped stdin, redirected
+    // stdout) — the onboarding wizard would block forever waiting for keystrokes
+    // that never arrive. Better to fail loudly with a fixable instruction than
+    // hang the parent process indefinitely.
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.error(chalk.red("brigade chat needs an interactive terminal."));
+        console.error(chalk.dim("For non-interactive use, set up your provider first via env vars or `brigade config set`, then call brigade in a TTY."));
+        // Sysexits 78: this is a configuration/usage error that won't fix on
+        // retry. Supervisors should STOP, not restart-loop.
+        process.exit(EXIT_CONFIG_ERROR);
+    }
     // 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());
@@ -46,6 +61,12 @@ export async function runChatCommand(opts = {}) {
             const wasRunning = chatHandle.abort();
             if (!wasRunning) {
                 tui.stop();
+                // Belt-and-braces: tui.stop() runs Pi-TUI's cleanup which
+                // covers the kitty pop in the happy path. We follow it with
+                // an explicit restoreTerminal() so the broader safety net
+                // (focus reporting, mouse, alt-screen, modifyOtherKeys)
+                // also fires before we hand control back to the shell.
+                restoreTerminal();
                 process.exit(0);
             }
             // A turn was aborted — re-arm so the next Ctrl+C is heard.
@@ -54,6 +75,7 @@ export async function runChatCommand(opts = {}) {
         }
         // During splash / onboarding (no chat yet): clean exit.
         tui.stop();
+        restoreTerminal();
         process.exit(130); // 128 + SIGINT
     };
     process.once("SIGINT", onSigint);
@@ -76,23 +98,44 @@ export async function runChatCommand(opts = {}) {
             }
         }
     }
+    // Snapshot whether BOOTSTRAP.md exists BEFORE we touch the workspace.
+    // `buildAgent` calls `seedDefaultPrompts` (idempotent — only writes files
+    // that don't exist), which means by the time the chat is wired BOOTSTRAP.md
+    // will exist regardless. Capturing the pre-boot state is the only honest
+    // way to tell "this is the user's very first run" from "the user previously
+    // completed bootstrap and explicitly deleted BOOTSTRAP.md to mark it done."
+    // We only fire the first-run kickoff in the former case.
+    const bootstrapPathBefore = path.join(getBrigadeWorkspaceDir(), "BOOTSTRAP.md");
+    let bootstrapExistedBeforeBoot = true;
+    try {
+        await fs.stat(bootstrapPathBefore);
+    }
+    catch {
+        bootstrapExistedBeforeBoot = false;
+    }
     // Onboard if needed.
+    let onboardingRan = false;
     if (!model || !provider || !modelId) {
         try {
-            const result = await runOnboarding(tui, authStorage, modelRegistry);
+            const result = await runOnboarding(tui, authStorage, modelRegistry, {
+                noEnvDetect: opts.noEnvDetect,
+            });
             provider = result.provider;
             modelId = result.modelId;
             modelRegistry.refresh();
             model = modelRegistry.find(provider, modelId);
+            onboardingRan = true;
         }
         catch (_err) {
             tui.stop();
+            restoreTerminal();
             console.error(chalk.red("Onboarding cancelled."));
             process.exit(1);
         }
     }
     if (!model || !provider || !modelId) {
         tui.stop();
+        restoreTerminal();
         console.error(chalk.red("Brigade couldn't get ready. Please run setup again."));
         process.exit(1);
     }
@@ -111,10 +154,38 @@ export async function runChatCommand(opts = {}) {
     // switch confusion) the user can grep today's file.
     attachEventLogger(session);
     process.stderr.write(`\x1b[2mlogs: ${getTodayLogPath()}\x1b[0m\n`);
+    // First-run kickoff. ONLY fire when BOTH:
+    //   1. Onboarding actually ran on this boot (the user picked a provider +
+    //      model + key just now — we don't kick off an existing user when
+    //      `~/.brigade/config.json` already had a default).
+    //   2. BOOTSTRAP.md didn't exist before this boot — i.e. the workspace
+    //      is truly fresh, never been here. If the user previously completed
+    //      bootstrap and deleted BOOTSTRAP.md (the file's own instructions
+    //      tell the agent to do so when done), we honour that "I'm an
+    //      established user" signal and skip the kickoff even on re-onboard.
+    //
+    // The kickoff is a synthesised first user turn — same wording every time
+    // so the agent's BOOTSTRAP.md (loaded into the system prompt) reliably
+    // triggers the "Hey. I just came online. Who am I? Who are you?"
+    // name-discovery conversation it was designed to open.
+    const shouldKickoff = onboardingRan && !bootstrapExistedBeforeBoot;
+    const kickoffMessage = shouldKickoff ? "Wake up, my friend!" : undefined;
     // 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 });
+    chatHandle = await runChat({
+        session,
+        tui,
+        provider,
+        modelId,
+        authStorage,
+        modelRegistry,
+        kickoffMessage,
+        // Same gate as the kickoff message — only render the slash-command
+        // discoverability tip on a fresh-workspace boot. Returning users with
+        // an established BOOTSTRAP.md never see it.
+        firstRun: shouldKickoff,
+    });
     return chatHandle;
 }
 //# sourceMappingURL=chat-cmd.js.map

package/dist/cli/config-cmd.js

@@ -13,7 +13,9 @@
  */
 import process from "node:process";
 import chalk from "chalk";
-import { loadConfig, saveConfig } from "../core/config.js";
+import { BRIGADE_DIR, loadConfig, saveConfig } from "../core/config.js";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { findProvider } from "../providers/catalog.js";
 /** Whitelist of known keys. Keep in sync with BrigadeConfig in core/config.ts. */
 const KNOWN_KEYS = [
     "defaultProvider",
@@ -88,6 +90,43 @@ async function setConfig(key, value) {
             chalk.dim(`valid keys: ${KNOWN_KEYS.join(", ")}\n`));
         return { exitCode: 2 };
     }
+    // Guard model+provider writes: refuse to set a default for a provider that
+    // has no key, or a model id that isn't in the registry. Without these,
+    // `brigade config set defaultProvider anthropic` would happily save
+    // anthropic with no key, and the next `brigade chat` would auto-select
+    // it and only fail when the user typed their first message.
+    if (key === "defaultProvider") {
+        const provider = findProvider(value);
+        if (!provider) {
+            process.stderr.write(chalk.red(`unknown provider: ${value}\n`));
+            return { exitCode: 2 };
+        }
+        if (!provider.noAuth) {
+            const authStorage = AuthStorage.create(`${BRIGADE_DIR}/auth.json`);
+            const apiKey = await authStorage.getApiKey(value);
+            if (!apiKey) {
+                process.stderr.write(chalk.red(`${provider.name} has no API key configured. `) +
+                    chalk.dim(`Run \`brigade onboard\` first, or set ${provider.envVar ?? "the env var"}.\n`));
+                return { exitCode: 2 };
+            }
+        }
+    }
+    if (key === "defaultModelId") {
+        const cfg = await loadConfig();
+        const provider = cfg.defaultProvider;
+        if (!provider) {
+            process.stderr.write(chalk.red("set defaultProvider first, then defaultModelId.\n"));
+            return { exitCode: 2 };
+        }
+        const authStorage = AuthStorage.create(`${BRIGADE_DIR}/auth.json`);
+        const registry = ModelRegistry.create(authStorage, `${BRIGADE_DIR}/models.json`);
+        const model = registry.find(provider, value);
+        if (!model) {
+            process.stderr.write(chalk.red(`${value} is not a registered model for ${provider}. `) +
+                chalk.dim(`Run \`brigade chat\` and use /model to see available ids.\n`));
+            return { exitCode: 2 };
+        }
+    }
     // saveConfig MERGES, so passing a single key preserves the rest. Cast through
     // Partial<BrigadeConfig> so unknown extra keys can't sneak in via this path.
     const partial = { [key]: value };

package/dist/cli/connect-cmd.js

@@ -12,11 +12,20 @@
  * available from connect mode in v1 — onboarding writes to the gateway's
  * filesystem and is out-of-band; the user runs `brigade onboard` against
  * the gateway machine instead.
+ *
+ * MAINTAINER NOTE: The footer at `wireConnectUi` deliberately OMITS
+ * `/provider` from the slash-command list. Do NOT add it to the connect
+ * footer "for parity with chat" — connect cannot perform provider
+ * onboarding (no gateway-side filesystem access from the TUI client), and
+ * advertising a command we can't honour confuses users. The chat-mode
+ * footer (in `src/ui/chat.ts`) DOES list `/provider` because in-process
+ * chat owns the filesystem the wizard needs to write to.
  */
 import process from "node:process";
 import { ProcessTerminal, TUI, Text, Markdown, CancellableLoader, Editor } from "@mariozechner/pi-tui";
 import chalk from "chalk";
 import { renderBrandHeader } from "../ui/brand.js";
+import { restoreTerminal } from "../ui/terminal-cleanup.js";
 import { brand, editorTheme, markdownTheme } from "../ui/theme.js";
 import { BrigadeClient } from "../tui/client.js";
 /**
@@ -40,6 +49,12 @@ export async function runConnectCommand(opts = {}) {
             if (!wasRunning) {
                 void chatHandle.close().then(() => {
                     tui.stop();
+                    // tui.stop() already runs Pi-TUI's cleanup (kitty pop on
+                    // the happy path); restoreTerminal() is the broader safety
+                    // net (focus, mouse, alt-screen, modifyOtherKeys) plus an
+                    // unconditional kitty pop in case Pi-TUI's flag tracker
+                    // missed it.
+                    restoreTerminal();
                     process.exit(0);
                 });
                 return;
@@ -48,6 +63,7 @@ export async function runConnectCommand(opts = {}) {
             return;
         }
         tui.stop();
+        restoreTerminal();
         process.exit(130);
     };
     process.once("SIGINT", onSigint);
@@ -60,10 +76,15 @@ export async function runConnectCommand(opts = {}) {
     }
     catch (err) {
         tui.stop();
+        restoreTerminal();
         const msg = err instanceof Error ? err.message : String(err);
         const isRefused = /ECONNREFUSED|connect.*refused/i.test(msg);
         const isTimeout = /ETIMEDOUT|timed?\s*out/i.test(msg);
-        console.error(chalk.red(`✗ Couldn't reach the Brigade gateway at ${url}: ${msg}`));
+        const isUnknownHost = /ENOTFOUND|EAI_AGAIN|getaddrinfo|temporary failure in name resolution/i.test(msg);
+        const isUnreachable = /EHOSTUNREACH|ENETUNREACH|network is unreachable|no route to host/i.test(msg);
+        // Headline: don't interpolate the raw `msg` (it can carry ENOTFOUND-style
+        // internal codes and getaddrinfo jargon). Just say what we tried.
+        console.error(chalk.red(`✗ Couldn't reach the Brigade gateway at ${url}.`));
         // Differentiate the most common failure modes so users don't waste
         // time debugging the wrong cause.
         if (isRefused) {
@@ -75,10 +96,20 @@ export async function runConnectCommand(opts = {}) {
             console.error(chalk.dim(`  Likely cause: gateway is reachable but slow to handshake.`));
             console.error(chalk.dim(`  Check that ${host} resolves and the port isn't blocked by a firewall.`));
         }
+        else if (isUnknownHost) {
+            console.error(chalk.dim(`  Couldn't resolve "${host}" — check the hostname and your DNS.`));
+        }
+        else if (isUnreachable) {
+            console.error(chalk.dim(`  No network route to ${host}. Check your VPN / firewall / network connection.`));
+        }
         else {
             console.error(chalk.dim(`  Start the gateway first:        brigade gateway --port ${port}`));
             console.error(chalk.dim(`  Or check the host/port flags:   brigade connect --host ${host} --port ${port}`));
         }
+        // Surface the raw message only when the operator opts into debug mode.
+        if (process.env.BRIGADE_DEBUG === "1") {
+            console.error(chalk.dim(`  (debug: ${msg})`));
+        }
         process.exit(1);
     }
     chatHandle = await wireConnectUi(tui, client);
@@ -90,7 +121,10 @@ export async function runConnectCommand(opts = {}) {
  * parsing or process.exit.
  */
 export async function wireConnectUi(tui, client) {
-    renderBrandHeader(tui);
+    // Static (last-frame) wordmark — `brigade connect` is the chat surface
+    // just like `brigade chat`, so we want the same still rendering here. The
+    // looping clip is reserved for onboarding's one-time wow moment.
+    renderBrandHeader(tui, { animate: false });
     const header = new Text("", 0, 0);
     tui.addChild(header);
     const divider = new Text(brand.dim("─".repeat(80)), 0, 0);
@@ -126,6 +160,11 @@ export async function wireConnectUi(tui, client) {
     const editor = new Editor(tui, editorTheme);
     tui.addChild(editor);
     tui.setFocus(editor);
+    // Connect mode cannot run the provider-onboarding wizard (it writes to the
+    // gateway machine's filesystem, which we don't have). We surface that gap
+    // inline above the footer so users who notice `/provider` is missing aren't
+    // left guessing — they get the exact escape hatch.
+    tui.addChild(new Text(brand.dim("  connect-mode commands: /model · /thinking · /compact · /help (use 'brigade chat' on the gateway machine for /provider)"), 0, 0));
     tui.addChild(new Text(brand.dim("  Enter to send · Ctrl+C abort · Ctrl+D quit · /model /thinking /compact /help"), 0, 0));
     const insertBeforeEditor = (component) => {
         const children = tui.children;
@@ -306,6 +345,7 @@ export async function wireConnectUi(tui, client) {
         if (trimmed === "/exit" || trimmed === "/quit") {
             client.close();
             tui.stop();
+            restoreTerminal();
             process.exit(0);
         }
         if (trimmed === "/help") {

package/dist/cli/doctor-cmd.js

@@ -21,7 +21,41 @@ import { BRIGADE_DIR, loadConfig } from "../core/config.js";
 import { getTodayLogPath } from "../core/event-logger.js";
 import { assembleSystemPrompt, getPromptDir, seedDefaultPrompts, } from "../core/system-prompt.js";
 import { findProvider, PROVIDERS } from "../providers/catalog.js";
+import { formatAuthLabel, listConfiguredProviders } from "../core/auth-label.js";
+import { getAppliedEnvKeys, loadBrigadeConfig } from "../core/brigade-config.js";
 import { DEFAULT_PORT } from "../protocol.js";
+/**
+ * Translate raw Node `err.message` into a doctor-safe single line. Strips
+ * absolute paths from EACCES/ENOENT/EPERM/EBUSY/EISDIR messages (no
+ * `C:\\Users\\Bob\\.brigade\\auth.json` leaks into doctor output) and
+ * collapses common errno tokens to plain English. Falls back to the raw
+ * message when nothing matches — doctor's audience can read raw messages,
+ * we just don't want absolute-path leaks.
+ */
+function doctorFriendlyError(err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    if (!raw)
+        return "unknown error";
+    // Match `EACCES: permission denied, open 'C:\\Users\\…\\file.json'` shape.
+    const fileErr = raw.match(/^(EACCES|EPERM|ENOENT|EBUSY|EISDIR|ENOTDIR|EROFS):\s*[^,]+,\s*\w+\s*['"]([^'"]+)['"]/);
+    if (fileErr) {
+        const code = fileErr[1];
+        const fullPath = fileErr[2] ?? "";
+        const basename = fullPath.split(/[/\\]/).pop() ?? "";
+        const friendly = {
+            EACCES: "permission denied",
+            EPERM: "permission denied",
+            ENOENT: "missing",
+            EBUSY: "locked by another process",
+            EISDIR: "path is a directory, expected a file",
+            ENOTDIR: "path is a file, expected a directory",
+            EROFS: "filesystem is read-only",
+        };
+        return `${friendly[code] ?? code}: ${basename}`;
+    }
+    // Truncate runaway error messages to keep doctor output scannable.
+    return raw.length > 240 ? `${raw.slice(0, 237)}…` : raw;
+}
 /**
  * Run the full set of checks. Prints a coloured summary to stderr (so the
  * stdout stream stays free for any future machine-readable mode) and returns
@@ -52,7 +86,7 @@ export async function runDoctorCommand(opts = {}) {
         checks.push({
             name: "brigade dir",
             status: "fail",
-            detail: `${BRIGADE_DIR} — ${err instanceof Error ? err.message : String(err)}`,
+            detail: `${BRIGADE_DIR} — ${doctorFriendlyError(err)}`,
         });
     }
     // ── config.json parses ──────────────────────────────────────────────
@@ -72,7 +106,7 @@ export async function runDoctorCommand(opts = {}) {
             checks.push({
                 name: "config.json",
                 status: "warn",
-                detail: `unparseable — ${err instanceof Error ? err.message : String(err)}`,
+                detail: `unparseable — ${doctorFriendlyError(err)}`,
             });
         }
     }
@@ -125,12 +159,38 @@ export async function runDoctorCommand(opts = {}) {
                     /* missing key for this provider is normal — skip */
                 }
             }
+            // Auth source per provider — surfaces WHERE each key came from
+            // (`brigade.json::env`, a shell env var, or unconfigured) so the
+            // user always knows what `rm -rf ~/.brigade` will and won't wipe.
+            try {
+                const cfg = await loadBrigadeConfig(BRIGADE_DIR);
+                const configured = listConfiguredProviders({
+                    provider: "",
+                    brigadeEnvBlock: cfg.env,
+                    processEnv: process.env,
+                    // Threading the boot-time applied set is what makes the
+                    // "file" vs "env" distinction honest: if the shell had a
+                    // key first, loadEnvIntoProcess skipped it, the key is NOT
+                    // in this set, and we correctly label it "env".
+                    appliedFromFile: getAppliedEnvKeys(),
+                });
+                for (const { provider, label } of configured) {
+                    checks.push({
+                        name: `auth source · ${provider}`,
+                        status: "pass",
+                        detail: formatAuthLabel(label),
+                    });
+                }
+            }
+            catch {
+                /* non-fatal — auth-source reporting is informational */
+            }
         }
         catch (err) {
             checks.push({
                 name: "providers",
                 status: "fail",
-                detail: err instanceof Error ? err.message : String(err),
+                detail: doctorFriendlyError(err),
             });
         }
     }
@@ -146,19 +206,29 @@ export async function runDoctorCommand(opts = {}) {
             checks.push({
                 name: "log sink",
                 status: "warn",
-                detail: `${logPath} — ${err instanceof Error ? err.message : String(err)}`,
+                detail: `${logPath} — ${doctorFriendlyError(err)}`,
             });
         }
     }
-    // ── prompt directory present + seeded ───────────────────────────────
-    // Brigade ships 4 default prompt layers (soul / identity / instructions /
-    // tools). seedDefaultPrompts is idempotent — it never overwrites existing
-    // files, so it's safe to call here too. We then count how many of the
-    // expected layers exist; missing layers are "warn", not "fail" because
-    // the assembler always falls back to embedded defaults.
+    // ── workspace dir present + persona layers seeded ───────────────────
+    // Brigade ships 7 default persona layers at the workspace root
+    // (SOUL / IDENTITY / AGENTS / TOOLS / USER / BOOTSTRAP / HEARTBEAT).
+    // seedDefaultPrompts is idempotent — it never overwrites existing files,
+    // so it's safe to call here too. We then count how many of the expected
+    // layers exist; missing layers are "warn", not "fail" because the
+    // assembler always falls back to embedded defaults.
     if (brigadeDirOk) {
         const promptDir = getPromptDir();
-        const expectedLayers = ["soul.md", "identity.md", "instructions.md", "tools.md"];
+        const expectedLayers = [
+            "SOUL.md",
+            "IDENTITY.md",
+            "AGENTS.md",
+            "TOOLS.md",
+            "USER.md",
+            "BOOTSTRAP.md",
+            "BOOT.md",
+            "HEARTBEAT.md",
+        ];
         try {
             await seedDefaultPrompts(promptDir);
             let presentCount = 0;
@@ -198,7 +268,7 @@ export async function runDoctorCommand(opts = {}) {
             checks.push({
                 name: "prompts",
                 status: "warn",
-                detail: `${promptDir} — ${err instanceof Error ? err.message : String(err)}`,
+                detail: `${promptDir} — ${doctorFriendlyError(err)}`,
             });
         }
     }
@@ -220,7 +290,7 @@ export async function runDoctorCommand(opts = {}) {
             checks.push({
                 name: "system prompt",
                 status: "fail",
-                detail: `assembly failed — ${err instanceof Error ? err.message : String(err)}`,
+                detail: `assembly failed — ${doctorFriendlyError(err)}`,
             });
         }
     }
@@ -287,7 +357,7 @@ async function probeGateway(url) {
             resolve({
                 name: "gateway",
                 status: "fail",
-                detail: `${url} — ${err instanceof Error ? err.message : String(err)}`,
+                detail: `${url} — ${doctorFriendlyError(err)}`,
             });
             return;
         }
@@ -309,7 +379,7 @@ async function probeGateway(url) {
             resolve({
                 name: "gateway",
                 status: "fail",
-                detail: `${url} — ${err instanceof Error ? err.message : String(err)}`,
+                detail: `${url} — ${doctorFriendlyError(err)}`,
             });
         });
     });