@@ -590,6 +590,40 @@ moshcode ugig --json gigs list    # arguments/output go straight to ugig
 moshcode coinpay wallet balance   # arguments/output go straight to coinpay
 ```
 
+### BufferOverride — the failure in front of you, already answered
+
+[BufferOverride](https://bufferoverride.com) is where humans and agents debug
+together: every answer declares the versions it works on, who or what wrote it,
+and whether anyone independent reproduced it. `bo` is that from a terminal.
+
+```sh
+moshcode install bo               # npm i -g @profullstack/bufferoverride
+
+moshcode bo run -- pnpm test      # run it, keep what it printed, search for it
+moshcode bo search "worker exited before finishing"
+moshcode bo get a1b2c3d4e5 --markdown
+```
+
+The product is BufferOverride and the binary is `bo` — the same split
+`secrets`/`logicsrc` and `spinifex`/`spx` have, keyed the short way round here
+because this is a command you type every time something fails.
+
+`bo run --` wraps a command rather than replacing it: the wrapped command's exit
+code passes straight through, so it can go in front of something already in CI
+without changing what CI sees. It captures stdout, stderr, the exit code, the
+OS, the architecture and the detected dependency versions, redacts what it
+recognises as a secret, and searches for the failure **before** offering to
+publish it. Nothing leaves the machine until you have seen it, and outside a TTY
+nothing is published at all unless you pass `--ask`.
+
+Redaction is best effort and cannot be complete — no pattern list catches a
+custom-format secret — so `--dry-run` is the habit its own docs ask for.
+
+Reads need no credential: `search` and `get` work before you have ever run `bo
+login`. Publishing needs one, and `bo login` is a device-code exchange, so a
+terminal never handles a browser session. `bo mcp config` prints the MCP
+registration for a coding agent, which is the same graph over a different door.
+
 ### Cloud + infra CLIs
 
 ```sh
@@ -1038,6 +1072,7 @@ Some MCP servers are worth remembering by name rather than by npx invocation:
 ```sh
 moshcode mcp catalog              # what we know how to run
 moshcode mcp add porkbun          # expands to: npx -y @porkbunllc/mcp-server
+moshcode mcp add bufferoverride   # expands to: https://bufferoverride.com/mcp
 ```
 
 That registers it across every engine that supports MCP (claude, gemini, qwen,
@@ -1059,6 +1094,23 @@ from and five to rotate. Porkbun's API access is off by default and enabled
 per-domain — and its documentation tools work with no keys at all, which is a
 sensible way to try the server before trusting it with DNS writes.
 
+**BufferOverride is the useful-unauthenticated one.** Five read tools
+(`search_questions`, `get_question`, `list_questions`, `list_tags`, `whoami`)
+work with no credential, and the write tools are gated on the scopes a key
+actually carries — `tools/list` advertises only what your key can use. So the
+bare `mcp add bufferoverride` above is a complete, working registration. To
+publish from an engine, add the credential as a header:
+
+```sh
+moshcode mcp add bufferoverride -H "Authorization: Bearer bo_..."
+```
+
+`bo mcp config` prints the same thing from a terminal that has already signed
+in, and `bo mcp config --no-token` prints a form safe to paste in public. It is
+registered under the name the CLI uses, so both routes produce one server rather
+than two. See [BufferOverride](#bufferoverride--the-failure-in-front-of-you-already-answered)
+above for the CLI itself.
+
 ## Claude Code plugins
 
 MoshCode publishes its own plugin marketplace, so the pit's slash commands work
@@ -1371,6 +1423,7 @@ chmod +x deploy.mosh
 | `coinpay(args…)` | drive the coinpay workflow CLI |
 | `c0mpute(args…)` | drive the c0mpute workflow CLI |
 | `c0upons(args…)` | drive the c0upons workflow CLI |
+| `bo(args…)` | drive the BufferOverride CLI (capture a failure, search, ask, answer, verify) |
 | `secrets(args…)` | drive the logicsrc secrets CLI |
 | `railway(args…)` | drive the Railway CLI |
 | `gh(args…)` | drive the GitHub CLI |
 
@@ -668,6 +668,7 @@ const COMMANDS = [
   cliVerb("coinpay", "drive the coinpay workflow CLI"),
   cliVerb("c0mpute", "drive the c0mpute workflow CLI"),
   cliVerb("c0upons", "drive the c0upons workflow CLI"),
+  cliVerb("bo", "drive the BufferOverride CLI (capture a failure, search, ask, answer, verify)"),
   cliVerb("secrets", "manage/view team secrets via logicsrc (login, teams, credentials)"),
   cliVerb("railway", "drive the Railway CLI (deploys, services, env vars)"),
   cliVerb("gh", "drive the GitHub CLI (repos, PRs, issues, releases)"),
 
@@ -238,9 +238,14 @@ export async function mcpCommand(tokens, { run, installedSet } = {}) {
   const missing = (parsed.catalog?.env || []).filter((k) => !process.env[k]);
   if (missing.length) {
     console.log(ash(`  note: ${spec.name} needs ${missing.join(" and ")} in the environment.`));
-    if (parsed.catalog?.note) console.log(ash(`        ${parsed.catalog.note}`));
-    if (parsed.catalog?.docs) console.log(ash(`        ${parsed.catalog.docs}`));
   }
+  // The catalog's own note and docs are printed whenever the catalog was used,
+  // not only when a variable is missing. A server whose credential is a header
+  // rather than an environment variable — or one that needs none at all to be
+  // useful — has nothing in `env`, and hanging its note off that check is what
+  // made the note invisible for exactly the servers it was written for.
+  if (parsed.catalog?.note) console.log(ash(`  note: ${parsed.catalog.note}`));
+  if (parsed.catalog?.docs) console.log(ash(`        ${parsed.catalog.docs}`));
   if (spec.headers.length || /^https?:/i.test(spec.target)) {
     console.log(ash("  note: OAuth/HTTP servers may still need per-engine auth (e.g. `opencode mcp auth`, `codex mcp login`)."));
   }
 
@@ -24,6 +24,23 @@ export const MCP_CATALOG = {
     // before deciding whether to trust it with keys.
     note: "API access is off by default and must be enabled per-domain; the docs tools work without keys",
   },
+  bufferoverride: {
+    // A remote HTTP server, so the target is the URL and there are no args —
+    // every engine's builder pushes the target alone for a remote server.
+    target: "https://bufferoverride.com/mcp",
+    args: [],
+    desc: "BufferOverride — version-aware technical answers, with provenance and reproductions",
+    docs: "https://bufferoverride.com/docs/mcp",
+    // Named to match what the CLI's own `bo mcp config` emits, so registering
+    // it either way produces one server rather than two under different names.
+    //
+    // No `env`: the credential is a bearer header, not a variable, and it is
+    // deliberately not listed here. Five read tools work with no key at all,
+    // and the write tools are gated on the scopes a key actually carries — so
+    // the useful default really is unauthenticated. `bo mcp config` prints the
+    // header form for a terminal that has signed in.
+    note: "reads need no credential; to publish, add -H \"Authorization: Bearer bo_…\" (see `bo mcp config`)",
+  },
 };
 
 /** Resolve a catalog name to a spec fragment, or null. Own properties only. */
@@ -44,7 +61,10 @@ export function catalogNames() {
 
 /** One line per known server, for `mcp catalog`. */
 export function catalogList() {
+  // Width from the longest name rather than a fixed pad: `bufferoverride` is
+  // wider than the old 10, and a name that overruns the pad loses the column.
+  const width = Math.max(10, ...Object.keys(MCP_CATALOG).map((key) => key.length));
   return Object.entries(MCP_CATALOG)
-    .map(([key, e]) => `  ${key.padEnd(10)} ${e.desc}`)
+    .map(([key, e]) => `  ${key.padEnd(width)} ${e.desc}`)
     .join("\n");
 }
@@ -82,6 +82,19 @@ export const TOOLS = {
     // where those words mean something else entirely.
     aliases: { cmd: "cli-tools", args: ["aliases", "--json"] },
   },
+  bo: {
+    desc: "BufferOverride — capture a failing command, redact it, and find the answer that already exists",
+    // The product is BufferOverride and the binary is `bo`, the same split
+    // `secrets` → `logicsrc` and `spinifex` → `spx` have. It is keyed the other
+    // way round from those two on purpose: `bo` is what its own documentation
+    // tells you to type, and this is a command you run every time something
+    // fails, so the short word is the one worth having in the pit.
+    bin: "bo",
+    // An ordinary global npm package with no dependencies of its own, and
+    // `npm install -g` is idempotent, so re-running the install IS the upgrade
+    // — no `upgrade` key, the same as mcpjam and railway.
+    install: { cmd: "npm", args: ["install", "-g", "@profullstack/bufferoverride"] },
+  },
   secrets: {
     desc: "LogicSRC — end-to-end-encrypted team credential sharing (login, teams, credentials)",
     // The passthrough target is the `logicsrc` binary; the moshcode command is
 
@@ -114,7 +114,7 @@ test("runMoshcode stringifies args and never spawns under dry-run", async () =>
 
 test("the CLI capabilities are all registered as verbs", () => {
   const reg = moshVocabulary();
-  for (const name of ["agents", "start", "install", "upgrade", "mcp", "skill", "prd", "ugig", "coinpay", "c0mpute", "c0upons", "secrets", "alpaca", "trade", "pwd", "ai"]) {
+  for (const name of ["agents", "start", "install", "upgrade", "mcp", "skill", "prd", "ugig", "coinpay", "c0mpute", "c0upons", "bo", "secrets", "alpaca", "trade", "pwd", "ai"]) {
     assert.ok(reg.has(name), `expected ${name}() in the vocabulary`);
   }
 });
@@ -136,6 +136,7 @@ const VERB_ARGV_CASES = [
   { verb: "coinpay", args: ["wallet", "balance"],            expect: /moshcode coinpay wallet balance/ },
   { verb: "c0mpute", args: ["status"],                       expect: /moshcode c0mpute status/ },
   { verb: "c0upons", args: ["search", "nike"],               expect: /moshcode c0upons search nike/ },
+  { verb: "bo",      args: ["search", "libsql worker"],      expect: /moshcode bo search libsql worker/ },
   { verb: "secrets", args: ["teams", "list"],               expect: /moshcode secrets teams list/ },
   { verb: "alpaca", args: ["asset", "get", "--symbol-or-asset-id", "AAPL"], expect: /moshcode alpaca asset get --symbol-or-asset-id AAPL/ },
   { verb: "trade",  args: ["ticker", "AAPL"],               expect: /moshcode trade ticker AAPL/ },
 
@@ -81,3 +81,40 @@ test("the catalog listing names every entry", () => {
   for (const name of catalogNames()) assert.match(listing, new RegExp(name));
   assert.match(listing, /Porkbun/);
 });
+
+test("bufferoverride resolves to the remote HTTP server, with no args", () => {
+  const e = resolveCatalog("bufferoverride");
+  assert.equal(e.key, "bufferoverride");
+  assert.equal(e.target, "https://bufferoverride.com/mcp");
+  // A remote server takes no command arguments — every engine's builder pushes
+  // the target alone — and parseMcp rejects a leftover one rather than dropping
+  // it, so an entry that carried args would break `mcp add bufferoverride`.
+  assert.deepEqual(e.args, []);
+  // The credential is a bearer header, not a variable: nothing to name here.
+  assert.equal(e.env, undefined);
+});
+
+test("`mcp add bufferoverride` expands to the remote spec", () => {
+  const { spec, catalog, error } = parseMcp(["add", "bufferoverride"]);
+  assert.equal(error, undefined);
+  // Named as the CLI's own `bo mcp config` names it, so registering it either
+  // way produces one server rather than two.
+  assert.equal(spec.name, "bufferoverride");
+  assert.equal(spec.target, "https://bufferoverride.com/mcp");
+  assert.deepEqual(spec.args, []);
+  assert.deepEqual(spec.headers, []);
+  assert.equal(catalog.key, "bufferoverride");
+});
+
+test("the catalog listing keeps its column when a name overruns the old pad", () => {
+  // `bufferoverride` is longer than the fixed pad this used to carry, which
+  // left a single space before its description while porkbun kept a column.
+  const rows = catalogList().split("\n");
+  assert.ok(rows.length >= 2, "this only says anything with more than one entry");
+  const columns = Object.values(MCP_CATALOG).map((e) => {
+    const row = rows.find((line) => line.includes(e.desc));
+    assert.ok(row, `no row for ${e.desc}`);
+    return row.indexOf(e.desc);
+  });
+  assert.equal(new Set(columns).size, 1, `descriptions must line up:\n${catalogList()}`);
+});
@@ -185,6 +185,44 @@ test("MCPJam is a workflow tool installed from its official npm package", () =>
   assert.match(toolList(), /mcpjam/);
 });
 
+test("BufferOverride is a workflow tool installed from its official npm package", () => {
+  // Keyed `bo` rather than `bufferoverride`: the binary, the pit command and
+  // the product's own documentation all say `bo`.
+  assert.deepEqual(resolveTool("BO"), ["bo", TOOLS.bo]);
+  assert.equal(TOOLS.bo.bin, "bo");
+  assert.deepEqual(TOOLS.bo.install, {
+    cmd: "npm",
+    args: ["install", "-g", "@profullstack/bufferoverride"],
+  });
+  // Same reasoning as mcpjam: `npm install -g` is idempotent, so re-running the
+  // install IS the upgrade. Asserted so adding one later is deliberate.
+  assert.equal(TOOLS.bo.upgrade, undefined);
+  assert.deepEqual(toolUpgradeSpec(TOOLS.bo), TOOLS.bo.install);
+  assert.match(toolList(), /bo /);
+  assert.match(toolList(), /BufferOverride/);
+});
+
+test("install bo delegates to the official npm package", async () => {
+  const root = tempDir("moshcode-install-bo-");
+  const nativeBin = path.join(root, "bin");
+  const capture = path.join(root, "npm-args.json");
+  mkdirSync(nativeBin);
+  writeExecutable(nativeBin, "npm", `
+import fs from "node:fs";
+fs.writeFileSync(process.env.NPM_CAPTURE, JSON.stringify(process.argv.slice(2)));
+`);
+
+  const result = await run(["install", "bo"], {
+    binDir: nativeBin,
+    env: { NPM_CAPTURE: capture },
+  });
+
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(readFileSync(capture, "utf8")), [
+    "install", "-g", "@profullstack/bufferoverride",
+  ]);
+});
+
 test("install mcpjam delegates to the official npm package", async () => {
   const root = tempDir("moshcode-install-mcpjam-");
   const nativeBin = path.join(root, "bin");