@spinabot/brigade 0.1.2 → 1.0.1

package/SECURITY.md

@@ -1,208 +0,0 @@
-# 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/dist/cli/chat-cmd.js

@@ -1,191 +0,0 @@
-/**
- * `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 * 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, 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
- * the caller wants to introspect or wire additional signal handlers.
- */
-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());
-    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();
-                // 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.
-            process.once("SIGINT", onSigint);
-            return;
-        }
-        // During splash / onboarding (no chat yet): clean exit.
-        tui.stop();
-        restoreTerminal();
-        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
-            }
-        }
-    }
-    // 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, {
-                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);
-    }
-    // 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`);
-    // 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,
-        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

@@ -1,171 +0,0 @@
-/**
- * `brigade config` — read & write `~/.brigade/config.json`.
- *
- *   brigade config list                — print all keys
- *   brigade config get <key>           — print one value
- *   brigade config set <key> <value>   — set one value (merges, doesn't overwrite)
- *   brigade config unset <key>         — remove one key
- *
- * Keys are dotted paths but the schema is flat in v1, so the only valid keys
- * are top-level: defaultProvider, defaultModelId, thinkingLevel,
- * fallbackProvider, fallbackModelId, installedAt. Unknown keys are rejected
- * to keep the file from accumulating typos that silently do nothing.
- */
-import process from "node:process";
-import chalk from "chalk";
-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",
-    "defaultModelId",
-    "thinkingLevel",
-    "fallbackProvider",
-    "fallbackModelId",
-    "installedAt",
-];
-/**
- * Dispatch one config subcommand. Splits parsing from I/O so tests can
- * exercise the same logic without spawning a subprocess.
- */
-export async function runConfigCommand(args) {
-    const sub = args[0];
-    switch (sub) {
-        case "list":
-        case undefined:
-            return listConfig();
-        case "get":
-            return getConfig(args[1]);
-        case "set":
-            return setConfig(args[1], args[2]);
-        case "unset":
-            return unsetConfig(args[1]);
-        default:
-            process.stderr.write(chalk.red(`unknown config subcommand: ${sub}\n`) +
-                chalk.dim("usage: brigade config [list|get <key>|set <key> <value>|unset <key>]\n"));
-            return { exitCode: 2 };
-    }
-}
-async function listConfig() {
-    const cfg = await loadConfig();
-    if (Object.keys(cfg).length === 0) {
-        process.stderr.write(chalk.dim("(empty — run `brigade onboard` to set up)\n"));
-        return { exitCode: 0 };
-    }
-    for (const key of KNOWN_KEYS) {
-        const v = cfg[key];
-        if (v === undefined || v === null)
-            continue;
-        process.stdout.write(`${key}=${String(v)}\n`);
-    }
-    return { exitCode: 0 };
-}
-async function getConfig(key) {
-    if (!key) {
-        process.stderr.write(chalk.red("usage: brigade config get <key>\n"));
-        return { exitCode: 2 };
-    }
-    if (!KNOWN_KEYS.includes(key)) {
-        process.stderr.write(chalk.red(`unknown key: ${key}\n`) +
-            chalk.dim(`valid keys: ${KNOWN_KEYS.join(", ")}\n`));
-        return { exitCode: 2 };
-    }
-    const cfg = await loadConfig();
-    const v = cfg[key];
-    if (v === undefined) {
-        // Empty stdout, exit 1 — matches `git config` semantics for missing keys.
-        return { exitCode: 1 };
-    }
-    process.stdout.write(`${String(v)}\n`);
-    return { exitCode: 0 };
-}
-async function setConfig(key, value) {
-    if (!key || value === undefined) {
-        process.stderr.write(chalk.red("usage: brigade config set <key> <value>\n"));
-        return { exitCode: 2 };
-    }
-    if (!KNOWN_KEYS.includes(key)) {
-        process.stderr.write(chalk.red(`unknown key: ${key}\n`) +
-            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 };
-    await saveConfig(partial);
-    process.stderr.write(chalk.green(`set ${key}\n`));
-    return { exitCode: 0 };
-}
-async function unsetConfig(key) {
-    if (!key) {
-        process.stderr.write(chalk.red("usage: brigade config unset <key>\n"));
-        return { exitCode: 2 };
-    }
-    if (!KNOWN_KEYS.includes(key)) {
-        process.stderr.write(chalk.red(`unknown key: ${key}\n`) +
-            chalk.dim(`valid keys: ${KNOWN_KEYS.join(", ")}\n`));
-        return { exitCode: 2 };
-    }
-    const existing = await loadConfig();
-    if (!(key in existing)) {
-        // Nothing to do, but report it so scripts can detect.
-        process.stderr.write(chalk.dim(`${key} was not set\n`));
-        return { exitCode: 0 };
-    }
-    // saveConfig only merges set fields — to delete one we have to write the
-    // remainder explicitly. Read-modify-write through the same merge path so
-    // we keep the installedAt-preservation behavior.
-    const remainder = { ...existing };
-    delete remainder[key];
-    // Force overwrite by going through fs directly here would skip the merge
-    // guard. Easier path: write the whole remainder via saveConfig — since
-    // saveConfig merges, this replaces all fields with the post-delete values,
-    // AND any field already absent stays absent. The only edge: installedAt
-    // is preserved by saveConfig's defaulting behavior.
-    const fsP = await import("node:fs/promises");
-    const path = await import("node:path");
-    const os = await import("node:os");
-    const file = path.join(os.homedir(), ".brigade", "config.json");
-    await fsP.writeFile(file, JSON.stringify(remainder, null, 2), "utf8");
-    process.stderr.write(chalk.green(`unset ${key}\n`));
-    return { exitCode: 0 };
-}
-//# sourceMappingURL=config-cmd.js.map