flatbread-cli 0.4.0 → 0.5.0

package/README.md

@@ -168,8 +168,16 @@ reload the VS Code window) afterwards.
 A connected tool is not a used one: in a real session the agent read the tool list and implemented
 the fix without searching. So setup also writes a skill that says when to search - before the first
 edit, after a failure - to `~/.claude/skills/flatbread/SKILL.md` (or under `$CLAUDE_CONFIG_DIR`) and
-`~/.agents/skills/flatbread/SKILL.md`, the shared skills folder Codex reads. A file there that
-flatbread did not write is left alone. `--no-mcp` skips the server and the skill.
+`~/.agents/skills/flatbread/SKILL.md`, the shared skills folder Codex, Cursor and Gemini CLI read.
+Where Antigravity is installed it also goes inside a plugin
+(`~/.gemini/config/plugins/flatbread/`, with its `plugin.json`), and where OpenCode is installed to
+`~/.config/opencode/skills/flatbread/SKILL.md`. A file there that flatbread did not write is left alone.
+
+The other agents get the MCP server too, each only if it is installed (its folder exists): Codex as a
+`[mcp_servers.flatbread]` table in `~/.codex/config.toml` (or `$CODEX_HOME`), Cursor in
+`~/.cursor/mcp.json`, Antigravity in `~/.gemini/config/mcp_config.json`. Same rules as Claude Code's
+file, and in the TOML every other line, comment and table stays where it was. `--no-mcp` skips every
+server and every skill.
 
 `setup --dry-run` writes nothing. `setup --uninstall` removes the handlers, the MCP entry, the skill and
 the hook, and puts a chained hook back byte for byte. `FLATBREAD_HOOK_DISABLED=1` stops every capture.

package/dist/flatbread.mjs

@@ -7,9 +7,9 @@ var __export = (target, all) => {
 
 // src/index.ts
 import { spawn as spawn3 } from "node:child_process";
-import fs24 from "node:fs";
+import fs26 from "node:fs";
 import os9 from "node:os";
-import path23 from "node:path";
+import path25 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../../node_modules/zod/v3/external.js
@@ -490,8 +490,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path24, errorMaps, issueData } = params;
-  const fullPath = [...path24, ...issueData.path || []];
+  const { data, path: path26, errorMaps, issueData } = params;
+  const fullPath = [...path26, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -607,11 +607,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path24, key) {
+  constructor(parent, value, path26, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path24;
+    this._path = path26;
     this._key = key;
   }
   get path() {
@@ -4461,8 +4461,8 @@ function firstLine(text2) {
 function labelOf(step, cwd) {
   const tool = step.tool;
   if (tool === void 0) return step.type;
-  const path24 = firstString(tool.input, FILE_PATH_KEYS);
-  if (path24 !== void 0) return `${tool.name} ${repoRelative(path24, cwd)}`;
+  const path26 = firstString(tool.input, FILE_PATH_KEYS);
+  if (path26 !== void 0) return `${tool.name} ${repoRelative(path26, cwd)}`;
   const other = firstString(tool.input, TARGET_KEYS);
   if (other !== void 0) return cut(`${tool.name}: ${repoRelative(firstLine(other), cwd)}`, BRIEF_LIMITS.quote);
   return tool.name;
@@ -4714,9 +4714,9 @@ function runDiagnostics(trace) {
       searches.set(key, found);
     }
   }
-  for (const [path24, entries] of reads) {
+  for (const [path26, entries] of reads) {
     const hit = densest(entries, WASTE_RULES.repeatedRead.times, WASTE_RULES.repeatedRead.windowMinutes * 6e4);
-    if (hit) waste.push({ kind: "repeated-read", path: path24, steps: hit, windowMinutes: WASTE_RULES.repeatedRead.windowMinutes });
+    if (hit) waste.push({ kind: "repeated-read", path: path26, steps: hit, windowMinutes: WASTE_RULES.repeatedRead.windowMinutes });
   }
   for (const { label, entries } of searches.values()) {
     const hit = densest(entries, WASTE_RULES.repeatedSearch.times, WASTE_RULES.repeatedSearch.windowMinutes * 6e4);
@@ -4795,19 +4795,19 @@ function filesOf(steps, cwd) {
   const patches = [];
   steps.forEach((step, index) => {
     if (!isSuccessfulEdit(step) || step.tool === void 0) return;
-    const path24 = repoRelative(firstString(step.tool.input, FILE_PATH_KEYS), cwd);
-    const file = files.get(path24) ?? { path: path24 };
+    const path26 = repoRelative(firstString(step.tool.input, FILE_PATH_KEYS), cwd);
+    const file = files.get(path26) ?? { path: path26 };
     if (step.diff !== void 0) {
       const counted = countPatch(step.diff.patch);
       file.added = (file.added ?? 0) + counted.added;
       file.removed = (file.removed ?? 0) + counted.removed;
-      patches.push({ path: path24, patch: repoRelative(step.diff.patch, cwd), step: step.stepNumber });
+      patches.push({ path: path26, patch: repoRelative(step.diff.patch, cwd), step: step.stepNumber });
     }
     const result = resultOf(steps, index);
     if (step.tool.name.toLowerCase() === "write" && result !== void 0 && /^File created successfully\b/.test(result.trim())) {
       file.created = true;
     }
-    files.set(path24, file);
+    files.set(path26, file);
   });
   return { files: [...files.values()], patches };
 }
@@ -5120,13 +5120,13 @@ function categorizeTrace(trace) {
     };
   }
   if (paths.length > 0) {
-    if (paths.every((path24) => matchesAny(path24, DOC_PATTERNS))) {
+    if (paths.every((path26) => matchesAny(path26, DOC_PATTERNS))) {
       return { category: "docs", evidence: [`all ${paths.length} touched path(s) are documentation`, ...paths.slice(0, 3)] };
     }
-    if (paths.every((path24) => matchesAny(path24, TEST_PATTERNS))) {
+    if (paths.every((path26) => matchesAny(path26, TEST_PATTERNS))) {
       return { category: "tests", evidence: [`all ${paths.length} touched path(s) are tests`, ...paths.slice(0, 3)] };
     }
-    if (paths.every((path24) => matchesAny(path24, INFRA_PATTERNS))) {
+    if (paths.every((path26) => matchesAny(path26, INFRA_PATTERNS))) {
       return { category: "infra", evidence: [`all ${paths.length} touched path(s) are build/CI/deploy config`, ...paths.slice(0, 3)] };
     }
   }
@@ -11236,7 +11236,6 @@ async function searchRemote(query, options = {}) {
   if (query.query) params.set("q", query.query);
   if (query.harness) params.set("harness", query.harness);
   if (query.category) params.set("category", query.category);
-  if (query.onlyWithRecoveries) params.set("recoveries", "1");
   const answer = await get(`${apiUrl}/api/search?${params.toString()}`, headersFor(apiUrl, options, "application/json"), options);
   if (!answer.ok) return answer;
   if (answer.status !== 200) return failureOf(answer.status, answer.body);
@@ -11357,7 +11356,6 @@ function readBucketRecord(dir, slug) {
 function matchesQuery(summary, query) {
   if (query.harness !== void 0 && summary.harness !== query.harness) return false;
   if (query.category !== void 0 && summary.category !== query.category) return false;
-  if (query.onlyWithRecoveries === true && summary.failuresRecovered === 0) return false;
   return matchesSearch(summary, query.query ?? "");
 }
 async function captureToBucket(options) {
@@ -11422,7 +11420,7 @@ function logCapture(dir, line, now = (/* @__PURE__ */ new Date()).toISOString())
 
 // src/mcp.ts
 var MCP_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
-var MCP_SERVER_VERSION = "0.4.0";
+var MCP_SERVER_VERSION = "0.5.0";
 function defaultMcpDeps(storeDir2, bucketDir2) {
   return {
     storeDir: storeDir2,
@@ -11441,8 +11439,7 @@ var MCP_TOOLS = [
       properties: {
         query: { type: "string", description: "Words that must all appear in the run's title or ID" },
         harness: { type: "string", enum: [...HARNESS_IDS], description: "Only runs from this agent harness" },
-        category: { type: "string", enum: [...TASK_CATEGORIES], description: "Only runs of this kind of job" },
-        onlyWithRecoveries: { type: "boolean", description: "Only runs where the agent recovered from a failure" }
+        category: { type: "string", enum: [...TASK_CATEGORIES], description: "Only runs of this kind of job" }
       },
       additionalProperties: false
     }
@@ -11489,10 +11486,7 @@ function readQuery(args) {
     }
     query.category = args["category"];
   }
-  if (args["onlyWithRecoveries"] !== void 0) {
-    if (typeof args["onlyWithRecoveries"] !== "boolean") return "onlyWithRecoveries must be true or false";
-    query.onlyWithRecoveries = args["onlyWithRecoveries"];
-  }
+  if (args["onlyWithRecoveries"] !== void 0) return "onlyWithRecoveries was removed: search by words, harness and category";
   return query;
 }
 function localRecords(deps) {
@@ -11641,6 +11635,10 @@ async function runMcpServer(deps, io) {
   return 0;
 }
 
+// src/setup.ts
+import fs25 from "node:fs";
+import path24 from "node:path";
+
 // src/claude-mcp.ts
 import fs20 from "node:fs";
 import os8 from "node:os";
@@ -11694,7 +11692,7 @@ function write(file, read2, next) {
     } catch {
       return `${file} is read-only, so it was left as it was`;
     }
-    if (fs20.readFileSync(file, "utf8") !== read2.raw) return `${file} changed while setup ran (Claude Code writes it); run setup again`;
+    if (fs20.readFileSync(file, "utf8") !== read2.raw) return `${file} changed while setup ran; run setup again`;
     const backup = `${file}.flatbread.bak`;
     if (!fs20.existsSync(backup)) fs20.copyFileSync(file, backup);
   }
@@ -11706,12 +11704,22 @@ function write(file, read2, next) {
   return null;
 }
 function registerClaudeMcp(options) {
+  return registerMcpJson({
+    ...options,
+    entry: { ...mcpEntryFor(options.execPath, options.entryPath) },
+    app: "Claude Code",
+    scope: "for every project (user scope)",
+    restart: "restart Claude Code (or reload the VS Code window) so it starts the server",
+    byHand: `claude mcp add --scope user ${MCP_SERVER_NAME} -- "${options.execPath}" "${options.entryPath}" mcp`
+  });
+}
+function registerMcpJson(options) {
   const { file, log } = options;
   const read2 = readConfig(file);
   if ("problem" in read2) {
     log(`  mcp          refused: ${file}: ${read2.problem}`);
-    log("               Claude Code's own state lives there, so a file we cannot read is not one we rewrite.");
-    if (options.uninstall !== true) log(`               by hand: claude mcp add --scope user ${MCP_SERVER_NAME} -- "${options.execPath}" "${options.entryPath}" mcp`);
+    log(`               ${options.app}'s own config lives there, so a file we cannot read is not one we rewrite.`);
+    if (options.uninstall !== true && options.byHand !== void 0) log(`               by hand: ${options.byHand}`);
     return 1;
   }
   const servers = isObject(read2.root["mcpServers"]) ? read2.root["mcpServers"] : void 0;
@@ -11741,13 +11749,13 @@ function registerClaudeMcp(options) {
     if (fs20.existsSync(backup)) log(`               ${backup} is the copy setup took before its first write; delete it when you like`);
     return 0;
   }
-  const entry = mcpEntryFor(options.execPath, options.entryPath);
+  const entry = options.entry;
   if (current !== void 0 && !runsFlatbreadMcp(current)) {
     log(`  mcp          refused: ${file} already has a server named ${MCP_SERVER_NAME} that does not run flatbread, left alone`);
     return 1;
   }
   if (JSON.stringify(current) === JSON.stringify(entry)) {
-    log(`  mcp          ${file}: registered for every project, unchanged`);
+    log(`  mcp          ${file}: registered ${options.scope}, unchanged`);
     return 0;
   }
   const verb = current === void 0 ? "register" : "update";
@@ -11761,14 +11769,367 @@ function registerClaudeMcp(options) {
     log(`  mcp          refused: ${problem}`);
     return 1;
   }
-  log(`  mcp          ${file}: ${verb === "register" ? "registered" : "updated"} for every project (user scope)`);
-  log("               restart Claude Code (or reload the VS Code window) so it starts the server");
+  log(`  mcp          ${file}: ${verb === "register" ? "registered" : "updated"} ${options.scope}`);
+  log(`               ${options.restart}`);
   return 0;
 }
 
-// src/git-hook.ts
+// src/codex-mcp.ts
 import fs21 from "node:fs";
 import path20 from "node:path";
+var BOM2 = "\uFEFF";
+var OWNED_KEYS = /* @__PURE__ */ new Set(["type", "command", "args"]);
+function codexConfigPath(codexHome2) {
+  return path20.join(codexHome2, "config.toml");
+}
+function quote(value) {
+  return JSON.stringify(value);
+}
+function codexBlock(execPath, entryPath) {
+  return `[mcp_servers.${MCP_SERVER_NAME}]
+type = "stdio"
+command = ${quote(execPath)}
+args = [${[entryPath, "mcp"].map(quote).join(", ")}]
+`;
+}
+function tomlCode(line) {
+  let out = "";
+  let inQuote = "";
+  let escaped = false;
+  for (const c of line) {
+    if (inQuote !== "") {
+      out += c;
+      if (inQuote === '"' && escaped) escaped = false;
+      else if (inQuote === '"' && c === "\\") escaped = true;
+      else if (c === inQuote) inQuote = "";
+      continue;
+    }
+    if (c === "#") break;
+    if (c === '"' || c === "'") inQuote = c;
+    out += c;
+  }
+  return out.trim();
+}
+function openAfter(line, open) {
+  let i = 0;
+  while (i < line.length) {
+    if (open === '"""') {
+      if (line[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (line.startsWith('"""', i)) {
+        i += 3;
+        while (line[i] === '"') i++;
+        open = "";
+        continue;
+      }
+      i++;
+    } else if (open === "'''") {
+      const j = line.indexOf("'''", i);
+      if (j < 0) return open;
+      i = j + 3;
+      while (line[i] === "'") i++;
+      open = "";
+    } else if (line.startsWith('"""', i)) {
+      open = '"""';
+      i += 3;
+    } else if (line.startsWith("'''", i)) {
+      open = "'''";
+      i += 3;
+    } else if (line[i] === "#") {
+      return "";
+    } else if (line[i] === '"') {
+      i++;
+      while (i < line.length && line[i] !== '"') i += line[i] === "\\" ? 2 : 1;
+      i++;
+    } else if (line[i] === "'") {
+      const j = line.indexOf("'", i + 1);
+      if (j < 0) return "";
+      i = j + 1;
+    } else {
+      i++;
+    }
+  }
+  return open;
+}
+function tomlCodeLines(text2) {
+  let open = "";
+  return text2.split("\n").map((line) => {
+    const was = open;
+    open = openAfter(line, open);
+    return was !== "" ? "" : line;
+  });
+}
+function tomlKeyPath(key) {
+  const parts = [];
+  let part = "";
+  let inQuote = "";
+  for (const c of key) {
+    if (inQuote !== "") {
+      part += c;
+      if (c === inQuote) inQuote = "";
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inQuote = c;
+      part += c;
+    } else if (c === ".") {
+      parts.push(part);
+      part = "";
+    } else {
+      part += c;
+    }
+  }
+  parts.push(part);
+  return parts.map((p) => {
+    const t = p.trim();
+    if (t.length >= 2 && (t[0] === '"' || t[0] === "'") && t[t.length - 1] === t[0]) {
+      if (t[0] === "'") return t.slice(1, -1);
+      try {
+        return JSON.parse(t);
+      } catch {
+        return t;
+      }
+    }
+    return t;
+  });
+}
+function startsWithPath(full, prefix) {
+  return prefix.length <= full.length && prefix.every((part, i) => full[i] === part);
+}
+function headerPath(line) {
+  const code = tomlCode(line);
+  if (!code.startsWith("[") || code.startsWith("[[") || !code.endsWith("]")) return null;
+  return tomlKeyPath(code.slice(1, -1));
+}
+function arrayDelta(text2) {
+  let depth = 0;
+  let inQuote = "";
+  let escaped = false;
+  for (const c of text2) {
+    if (inQuote !== "") {
+      if (inQuote === '"' && escaped) escaped = false;
+      else if (inQuote === '"' && c === "\\") escaped = true;
+      else if (c === inQuote) inQuote = "";
+      continue;
+    }
+    if (c === '"' || c === "'") inQuote = c;
+    else if (c === "[") depth++;
+    else if (c === "]") depth--;
+  }
+  return depth;
+}
+function stringValues(text2) {
+  const out = [];
+  const re = /"((?:[^"\\]|\\.)*)"|'([^']*)'/g;
+  for (const match of text2.matchAll(re)) {
+    if (match[2] !== void 0) out.push(match[2]);
+    else {
+      try {
+        out.push(JSON.parse(`"${match[1] ?? ""}"`));
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+var OURS = ["mcp_servers", MCP_SERVER_NAME];
+function ourBlocks(code) {
+  const all = [];
+  let main2 = null;
+  code.forEach((line, i) => {
+    const header = headerPath(line);
+    if (header === null || !startsWithPath(header, OURS)) return;
+    let end = code.length;
+    for (let j = i + 1; j < code.length; j++) {
+      if (tomlCode(code[j] ?? "").startsWith("[")) {
+        end = j;
+        break;
+      }
+    }
+    const block = { start: i, end };
+    all.push(block);
+    if (header.length === OURS.length && main2 === null) main2 = block;
+  });
+  return { main: main2, all };
+}
+function blockRunsFlatbread(code, block) {
+  const words = [];
+  for (let i = block.start + 1; i < block.end; i++) {
+    const line = tomlCode(code[i] ?? "");
+    const at = line.indexOf("=");
+    if (at < 0) continue;
+    const key = line.slice(0, at).trim();
+    let value = line.slice(at + 1).trim();
+    if (key === "command") words.unshift(...stringValues(value));
+    if (key === "args") {
+      let depth = arrayDelta(value);
+      while (depth > 0 && i + 1 < block.end) {
+        i++;
+        const next = tomlCode(code[i] ?? "");
+        value += `
+${next}`;
+        depth += arrayDelta(next);
+      }
+      words.push(...stringValues(value));
+    }
+  }
+  return words[words.length - 1] === "mcp" && words.some((word) => /flatbread/i.test(word));
+}
+function tomlProblem(code) {
+  let table = [];
+  for (const [i, line] of code.entries()) {
+    const text2 = tomlCode(line);
+    if (text2.startsWith("[")) {
+      if (!text2.endsWith("]")) return `line ${i + 1} is a table header that never closes: ${line.trim()}`;
+      table = text2.startsWith("[[") ? tomlKeyPath(text2.slice(2, -2)) : tomlKeyPath(text2.slice(1, -1));
+      continue;
+    }
+    const at = text2.indexOf("=");
+    if (at < 0 || startsWithPath(table, OURS)) continue;
+    const full = [...table, ...tomlKeyPath(text2.slice(0, at))];
+    if (startsWithPath(OURS, full) || startsWithPath(full, OURS)) {
+      return `line ${i + 1} sets ${full.join(".")} inline, and the [mcp_servers.${MCP_SERVER_NAME}] table would define it twice`;
+    }
+  }
+  return null;
+}
+function writeLike(file, raw, lf) {
+  let next = lf;
+  if (raw !== null && raw.includes("\r\n")) next = next.replace(/\n/g, "\r\n");
+  if (raw !== null && raw.startsWith(BOM2)) next = BOM2 + next;
+  if (raw !== null) {
+    try {
+      fs21.accessSync(file, fs21.constants.W_OK);
+    } catch {
+      return `${file} is read-only, so it was left as it was`;
+    }
+    if (fs21.readFileSync(file, "utf8") !== raw) return `${file} changed while setup ran; run setup again`;
+    const backup = `${file}.flatbread.bak`;
+    if (!fs21.existsSync(backup)) fs21.copyFileSync(file, backup);
+  }
+  const mode = raw !== null ? fs21.statSync(file).mode & 511 : 384;
+  fs21.mkdirSync(path20.dirname(file), { recursive: true });
+  const temp = `${file}.flatbread-${process.pid}.tmp`;
+  fs21.writeFileSync(temp, next, { encoding: "utf8", mode });
+  fs21.renameSync(temp, file);
+  return null;
+}
+function removeBlocks(lines2, blocks) {
+  const drop = /* @__PURE__ */ new Set();
+  for (const block of blocks) for (let i = block.start; i < block.end; i++) drop.add(i);
+  return lines2.filter((_, i) => !drop.has(i));
+}
+function tidy(lines2) {
+  const text2 = lines2.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n+$/, "");
+  return text2 === "" ? "" : `${text2}
+`;
+}
+function registerCodexMcp(options) {
+  const { file, log } = options;
+  let raw;
+  try {
+    raw = fs21.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      log(`  mcp          refused: ${file}: ${error.message}`);
+      return 1;
+    }
+    raw = null;
+  }
+  const text2 = (raw ?? "").replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+  const lines2 = text2.split("\n");
+  const code = tomlCodeLines(text2);
+  const { main: main2, all } = ourBlocks(code);
+  if (options.uninstall === true) {
+    if (main2 === null) {
+      log(`  mcp          no ${MCP_SERVER_NAME} server in ${file}`);
+      return 0;
+    }
+    if (!blockRunsFlatbread(code, main2)) {
+      log(`  mcp          ${file}: the ${MCP_SERVER_NAME} server there does not run flatbread, left alone`);
+      return 0;
+    }
+    if (options.dryRun === true) {
+      log(`  mcp          ${file}: would remove the ${MCP_SERVER_NAME} server`);
+      return 0;
+    }
+    const problem2 = writeLike(file, raw, tidy(removeBlocks(lines2, all)));
+    if (problem2 !== null) {
+      log(`  mcp          refused: ${problem2}`);
+      return 1;
+    }
+    log(`  mcp          ${file}: removed the ${MCP_SERVER_NAME} server`);
+    return 0;
+  }
+  const problem = tomlProblem(code);
+  if (problem !== null) {
+    log(`  mcp          refused: ${file}: ${problem}`);
+    log("               fix that line, or add this table by hand:");
+    for (const line of codexBlock(options.execPath, options.entryPath).trimEnd().split("\n")) log(`                 ${line}`);
+    return 1;
+  }
+  if (main2 !== null && !blockRunsFlatbread(code, main2)) {
+    log(`  mcp          refused: ${file} already has a server named ${MCP_SERVER_NAME} that does not run flatbread, left alone`);
+    return 1;
+  }
+  const block = codexBlock(options.execPath, options.entryPath);
+  const ownLines = block.trimEnd().split("\n").slice(1);
+  let next;
+  if (main2 === null) {
+    const kept = text2.replace(/\n+$/, "");
+    next = `${kept}${kept === "" ? "" : "\n\n"}${block}`;
+  } else {
+    const body = [];
+    let inserted = false;
+    for (let i = main2.start + 1; i < main2.end; i++) {
+      const lineCode = tomlCode(code[i] ?? "");
+      const at = lineCode.indexOf("=");
+      const key = at >= 0 ? lineCode.slice(0, at).trim() : "";
+      if (!OWNED_KEYS.has(key)) {
+        body.push(lines2[i] ?? "");
+        continue;
+      }
+      if (!inserted) {
+        body.push(...ownLines);
+        inserted = true;
+      }
+      if (key === "args") {
+        let depth = arrayDelta(lineCode.slice(at + 1));
+        while (depth > 0 && i + 1 < main2.end) {
+          i++;
+          depth += arrayDelta(tomlCode(code[i] ?? ""));
+        }
+      }
+    }
+    if (!inserted) body.unshift(...ownLines);
+    const out = [...lines2.slice(0, main2.start + 1), ...body, ...lines2.slice(main2.end)];
+    next = out.join("\n");
+    if (!next.endsWith("\n")) next += "\n";
+  }
+  if (next === text2) {
+    log(`  mcp          ${file}: registered for Codex, unchanged`);
+    return 0;
+  }
+  const verb = main2 === null ? "register" : "update";
+  if (options.dryRun === true) {
+    log(`  mcp          ${file}: would ${verb} [mcp_servers.${MCP_SERVER_NAME}]`);
+    return 0;
+  }
+  const failed = writeLike(file, raw, next);
+  if (failed !== null) {
+    log(`  mcp          refused: ${failed}`);
+    return 1;
+  }
+  log(`  mcp          ${file}: ${verb === "register" ? "registered" : "updated"} for Codex`);
+  log("               start a new Codex session so it starts the server");
+  return 0;
+}
+
+// src/git-hook.ts
+import fs22 from "node:fs";
+import path21 from "node:path";
 var POST_COMMIT_MARKER = "# flatbread post-commit hook - remove with: flatbread setup --uninstall";
 var CHAINED_HOOK = "post-commit.pre-flatbread";
 var sq = (value) => `'${value.replace(/\\/g, "/").replace(/'/g, "'\\''")}'`;
@@ -11812,25 +12173,25 @@ function hooksDirFor(cwd, options = {}) {
   }
   const common = git(top, ["rev-parse", "--git-common-dir"], options)?.trim();
   if (common === void 0 || common.length === 0) return { ok: false, reason: "unreadable", detail: `git could not name the git directory of ${top}` };
-  return { ok: true, repo: path20.resolve(top), dir: path20.resolve(top, common, "hooks"), ...machineHooksPath !== void 0 ? { machineHooksPath } : {} };
+  return { ok: true, repo: path21.resolve(top), dir: path21.resolve(top, common, "hooks"), ...machineHooksPath !== void 0 ? { machineHooksPath } : {} };
 }
 var read = (file) => {
   try {
-    return fs21.readFileSync(file, "utf8");
+    return fs22.readFileSync(file, "utf8");
   } catch {
     return null;
   }
 };
 function installGitHook(dir, script, options = {}) {
-  const hook = path20.join(dir, "post-commit");
-  const chained = path20.join(dir, CHAINED_HOOK);
+  const hook = path21.join(dir, "post-commit");
+  const chained = path21.join(dir, CHAINED_HOOK);
   const current = read(hook);
   const write2 = (lines2) => {
     if (options.dryRun === true) return { code: 0, lines: [...lines2, "--dry-run: nothing was written"] };
-    fs21.mkdirSync(dir, { recursive: true });
-    if (current !== null && !isOurs(current)) fs21.renameSync(hook, chained);
-    fs21.writeFileSync(hook, script, { encoding: "utf8", mode: 493 });
-    fs21.chmodSync(hook, 493);
+    fs22.mkdirSync(dir, { recursive: true });
+    if (current !== null && !isOurs(current)) fs22.renameSync(hook, chained);
+    fs22.writeFileSync(hook, script, { encoding: "utf8", mode: 493 });
+    fs22.chmodSync(hook, 493);
     return { code: 0, lines: lines2 };
   };
   if (current === null) return write2([`post-commit  ${hook} (new)`]);
@@ -11838,7 +12199,7 @@ function installGitHook(dir, script, options = {}) {
     if (current === script) return { code: 0, lines: [`post-commit  ${hook}`, "already installed, unchanged"] };
     return write2([`post-commit  ${hook}`, "updated the flatbread hook"]);
   }
-  if (fs21.existsSync(chained)) {
+  if (fs22.existsSync(chained)) {
     return {
       code: 1,
       lines: [
@@ -11854,10 +12215,10 @@ function installGitHook(dir, script, options = {}) {
   ]);
 }
 function uninstallGitHook(dir, options = {}) {
-  const hook = path20.join(dir, "post-commit");
-  const chained = path20.join(dir, CHAINED_HOOK);
+  const hook = path21.join(dir, "post-commit");
+  const chained = path21.join(dir, CHAINED_HOOK);
   const current = read(hook);
-  const hasChained = fs21.existsSync(chained);
+  const hasChained = fs22.existsSync(chained);
   const done = (lines2, act) => {
     if (options.dryRun === true) return { code: 0, lines: [...lines2, "--dry-run: nothing was written"] };
     act();
@@ -11875,17 +12236,17 @@ function uninstallGitHook(dir, options = {}) {
   if (current === null && !hasChained) return { code: 0, lines: [`no flatbread post-commit in ${dir}`] };
   if (hasChained) {
     return done([`post-commit  ${hook}`, `restored your post-commit from ${CHAINED_HOOK}`], () => {
-      if (current !== null) fs21.rmSync(hook);
-      fs21.renameSync(chained, hook);
+      if (current !== null) fs22.rmSync(hook);
+      fs22.renameSync(chained, hook);
     });
   }
-  return done([`post-commit  ${hook}`, "removed the flatbread hook"], () => fs21.rmSync(hook));
+  return done([`post-commit  ${hook}`, "removed the flatbread hook"], () => fs22.rmSync(hook));
 }
 
 // src/hook.ts
 import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
-import fs22 from "node:fs";
-import path21 from "node:path";
+import fs23 from "node:fs";
+import path22 from "node:path";
 var HOOK_EVENTS = ["Stop", "SessionEnd"];
 var OFFER_AFTER_STOPS = 2;
 var MAX_TRACKED_SESSIONS = 50;
@@ -11895,14 +12256,14 @@ function emptyHookState() {
   return { version: HOOK_STATE_VERSION, sessions: {} };
 }
 function hookStatePath(env = process.env) {
-  return path21.join(flatbreadHome(env), "hook-state.json");
+  return path22.join(flatbreadHome(env), "hook-state.json");
 }
 function readHookState(env = process.env) {
   const file = hookStatePath(env);
-  if (!fs22.existsSync(file)) return { ok: true, state: emptyHookState(), present: false };
+  if (!fs23.existsSync(file)) return { ok: true, state: emptyHookState(), present: false };
   let raw;
   try {
-    raw = fs22.readFileSync(file, "utf8");
+    raw = fs23.readFileSync(file, "utf8");
   } catch (error) {
     return { ok: false, reason: "unreadable", detail: error.message };
   }
@@ -11945,9 +12306,9 @@ function pruneHookState(state, keep = MAX_TRACKED_SESSIONS) {
 }
 function writeHookState(state, env = process.env) {
   const dir = flatbreadHome(env);
-  fs22.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs23.mkdirSync(dir, { recursive: true, mode: 448 });
   const file = hookStatePath(env);
-  fs22.writeFileSync(file, JSON.stringify(pruneHookState(state), null, 2) + "\n", {
+  fs23.writeFileSync(file, JSON.stringify(pruneHookState(state), null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
   });
@@ -12093,7 +12454,7 @@ async function runHookNotify(io) {
   const stdout = io.stdout ?? ((line) => process.stdout.write(line + "\n"));
   const stderr = io.stderr ?? ((line) => process.stderr.write(line + "\n"));
   const now = io.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const exists = io.exists ?? ((filePath) => fs22.existsSync(filePath));
+  const exists = io.exists ?? ((filePath) => fs23.existsSync(filePath));
   const execPath = io.execPath ?? process.execPath;
   const entryPath = io.entryPath ?? process.argv[1] ?? "";
   try {
@@ -12250,10 +12611,10 @@ function removeHookConfig(settings) {
   return { settings: root, removed };
 }
 function readSettingsFile(file) {
-  if (!fs22.existsSync(file)) return { present: false, file };
+  if (!fs23.existsSync(file)) return { present: false, file };
   let raw;
   try {
-    raw = fs22.readFileSync(file, "utf8");
+    raw = fs23.readFileSync(file, "utf8");
   } catch (error) {
     return { present: true, file, unreadable: error.message };
   }
@@ -12265,10 +12626,10 @@ function readSettingsFile(file) {
   }
 }
 function writeSettingsFile(file, settings) {
-  fs22.mkdirSync(path21.dirname(file), { recursive: true });
+  fs23.mkdirSync(path22.dirname(file), { recursive: true });
   const temp = `${file}.flatbread-${process.pid}.tmp`;
-  fs22.writeFileSync(temp, JSON.stringify(settings, null, 2) + "\n", "utf8");
-  fs22.renameSync(temp, file);
+  fs23.writeFileSync(temp, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  fs23.renameSync(temp, file);
 }
 function handlersFor(execPath, entryPath, capture = false) {
   return {
@@ -12426,8 +12787,8 @@ function runHookUninstall(options = {}) {
 function settingsCandidates(env, cwd) {
   return [
     { label: "user", file: claudeSettingsPath(env) },
-    { label: "project", file: path21.join(cwd, ".claude", "settings.json") },
-    { label: "local", file: path21.join(cwd, ".claude", "settings.local.json") }
+    { label: "project", file: path22.join(cwd, ".claude", "settings.json") },
+    { label: "local", file: path22.join(cwd, ".claude", "settings.local.json") }
   ];
 }
 function installedEventsIn(parsed, exists) {
@@ -12457,7 +12818,7 @@ function runHookStatus(options = {}) {
   const env = options.env ?? process.env;
   const log = options.log ?? ((line) => console.log(line));
   const cwd = options.cwd ?? process.cwd();
-  const exists = options.exists ?? ((filePath) => fs22.existsSync(filePath));
+  const exists = options.exists ?? ((filePath) => fs23.existsSync(filePath));
   const candidates = options.settingsPath === void 0 ? settingsCandidates(env, cwd) : [{ label: "settings", file: options.settingsPath }];
   log("");
   log("flatbread hook");
@@ -12578,8 +12939,8 @@ function probeHandler(handler, run = spawnSync2) {
 }
 
 // src/skill.ts
-import fs23 from "node:fs";
-import path22 from "node:path";
+import fs24 from "node:fs";
+import path23 from "node:path";
 var SKILL_NAME = "flatbread";
 var MARKER = "<!-- written by flatbread setup; flatbread setup --uninstall removes it -->";
 var DESCRIPTION = "Search recorded AI coding-agent runs - this machine's own and public ones on flatbread.io - for one that already did this task or hit this error. Use BEFORE your first edit in any coding task, however small it looks; when a command, test or build fails; when the user says it was done or fixed before; and before you call a change done.";
@@ -12617,28 +12978,57 @@ function homeOf3(env) {
   const home = (process.platform === "win32" ? env["USERPROFILE"] : env["HOME"])?.trim();
   return home ? home : null;
 }
-function skillPaths(env = process.env) {
+var ANTIGRAVITY_PLUGIN_MANIFEST = `${JSON.stringify({ name: SKILL_NAME }, null, 2)}
+`;
+function isDir(dir) {
+  try {
+    return fs24.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function skillTargets(env) {
   const home = homeOf3(env);
   if (home === null) return [];
-  const claudeDir = env["CLAUDE_CONFIG_DIR"]?.trim() || path22.join(home, ".claude");
-  return [path22.join(claudeDir, "skills", SKILL_NAME, "SKILL.md"), path22.join(home, ".agents", "skills", SKILL_NAME, "SKILL.md")];
+  const claudeDir = env["CLAUDE_CONFIG_DIR"]?.trim() || path23.join(home, ".claude");
+  const targets = [
+    { file: path23.join(claudeDir, "skills", SKILL_NAME, "SKILL.md") },
+    { file: path23.join(home, ".agents", "skills", SKILL_NAME, "SKILL.md") }
+  ];
+  const gemini = path23.join(home, ".gemini");
+  if (["antigravity", "antigravity-cli", "config"].some((dir) => isDir(path23.join(gemini, dir)))) {
+    const plugin = path23.join(gemini, "config", "plugins", SKILL_NAME);
+    targets.push({
+      file: path23.join(plugin, "skills", SKILL_NAME, "SKILL.md"),
+      companion: { file: path23.join(plugin, "plugin.json"), text: ANTIGRAVITY_PLUGIN_MANIFEST }
+    });
+  }
+  const opencode = path23.join(env["XDG_CONFIG_HOME"]?.trim() || path23.join(home, ".config"), "opencode");
+  if (isDir(opencode)) targets.push({ file: path23.join(opencode, "skills", SKILL_NAME, "SKILL.md") });
+  return targets;
+}
+function removeIfEmpty(dir) {
+  try {
+    fs24.rmdirSync(dir);
+  } catch {
+  }
 }
 function readOrNull(file) {
   try {
-    return fs23.readFileSync(file, "utf8");
+    return fs24.readFileSync(file, "utf8");
   } catch {
     return null;
   }
 }
 function installSkill(options) {
   const text2 = skillText();
-  const files = skillPaths(options.env);
-  if (files.length === 0) {
+  const targets = skillTargets(options.env ?? process.env);
+  if (targets.length === 0) {
     options.log(`  skill        skipped: no ${process.platform === "win32" ? "USERPROFILE" : "HOME"} in the environment`);
     return 1;
   }
   let code = 0;
-  for (const file of files) {
+  for (const { file, companion } of targets) {
     const current = readOrNull(file);
     const ours = current !== null && current.includes(MARKER);
     if (current !== null && !ours) {
@@ -12655,10 +13045,12 @@ function installSkill(options) {
         options.log(`  skill        would remove ${file}`);
         continue;
       }
-      fs23.rmSync(file);
-      try {
-        fs23.rmdirSync(path22.dirname(file));
-      } catch {
+      fs24.rmSync(file);
+      removeIfEmpty(path23.dirname(file));
+      if (companion !== void 0) {
+        removeIfEmpty(path23.dirname(path23.dirname(file)));
+        if (readOrNull(companion.file) === companion.text) fs24.rmSync(companion.file);
+        removeIfEmpty(path23.dirname(companion.file));
       }
       options.log(`  skill        removed ${file}`);
       continue;
@@ -12671,14 +13063,68 @@ function installSkill(options) {
       options.log(`  skill        would ${current === null ? "write" : "update"} ${file}`);
       continue;
     }
-    fs23.mkdirSync(path22.dirname(file), { recursive: true });
-    fs23.writeFileSync(file, text2);
+    fs24.mkdirSync(path23.dirname(file), { recursive: true });
+    if (companion !== void 0 && readOrNull(companion.file) === null) fs24.writeFileSync(companion.file, companion.text);
+    fs24.writeFileSync(file, text2);
     options.log(`  skill        ${current === null ? "wrote" : "updated"} ${file}`);
   }
   return code;
 }
 
 // src/setup.ts
+function isDir2(dir) {
+  try {
+    return fs25.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function otherAgents(env, step) {
+  const { log } = step;
+  const home = homeOf3(env);
+  if (home === null) {
+    log("Other agents");
+    log("  skipped      no home directory in the environment");
+    return 1;
+  }
+  const entry = { command: step.execPath, args: [step.entryPath, "mcp"] };
+  let code = 0;
+  log("Codex");
+  const codexHome2 = env["CODEX_HOME"]?.trim() || path24.join(home, ".codex");
+  if (!isDir2(codexHome2)) log(`  skipped      not installed here (no ${codexHome2})`);
+  else code = Math.max(code, registerCodexMcp({ file: codexConfigPath(codexHome2), ...step }));
+  if (isDir2(codexHome2) && !step.uninstall) log("  skill        Codex reads the shared ~/.agents/skills copy above");
+  log("");
+  log("Cursor");
+  const cursorHome = path24.join(home, ".cursor");
+  if (!isDir2(cursorHome)) log(`  skipped      not installed here (no ${cursorHome})`);
+  else {
+    code = Math.max(code, registerMcpJson({
+      file: path24.join(cursorHome, "mcp.json"),
+      entry,
+      app: "Cursor",
+      scope: "for every project",
+      restart: "restart Cursor so it starts the server",
+      ...step
+    }));
+  }
+  log("");
+  log("Antigravity");
+  const gemini = path24.join(home, ".gemini");
+  if (!["antigravity", "antigravity-cli", "config"].some((dir) => isDir2(path24.join(gemini, dir)))) {
+    log(`  skipped      not installed here (no ${path24.join(gemini, "antigravity")})`);
+  } else {
+    code = Math.max(code, registerMcpJson({
+      file: path24.join(gemini, "config", "mcp_config.json"),
+      entry,
+      app: "Antigravity",
+      scope: "for Antigravity",
+      restart: "restart Antigravity so it starts the server",
+      ...step
+    }));
+  }
+  return code;
+}
 function runSetup(options = {}) {
   const env = options.env ?? process.env;
   const log = options.log ?? ((line) => console.log(line));
@@ -12710,20 +13156,18 @@ function runSetup(options = {}) {
   });
   let mcp = 0;
   let skill = 0;
+  const uninstall = options.uninstall === true;
   if (options.noMcp === true) {
-    log("  --no-mcp: Claude Code's MCP servers and the flatbread skill were not touched");
-  } else if (claude === 0 || options.uninstall === true) {
-    mcp = registerClaudeMcp({
-      file: options.claudeConfigPath ?? claudeUserConfigPath(env),
-      execPath,
-      entryPath,
-      uninstall: options.uninstall === true,
-      dryRun,
-      log
-    });
-    skill = installSkill({ env, dryRun, uninstall: options.uninstall === true, log });
+    log("  --no-mcp: no agent's MCP servers and no flatbread skill were touched");
   } else {
-    log("  mcp          not registered, because the hook step above was refused");
+    if (claude === 0 || uninstall) {
+      mcp = registerClaudeMcp({ file: options.claudeConfigPath ?? claudeUserConfigPath(env), execPath, entryPath, uninstall, dryRun, log });
+    } else {
+      log("  mcp          not registered, because the hook step above was refused");
+    }
+    skill = installSkill({ env, dryRun, uninstall, log });
+    log("");
+    mcp = Math.max(mcp, otherAgents(env, { execPath, entryPath, uninstall, dryRun, log }));
   }
   log("");
   let git2 = 0;
@@ -12974,13 +13418,13 @@ async function bindFirst(server, ports) {
 }
 
 // src/index.ts
-var PACKAGE_ROOT = path23.resolve(path23.dirname(fileURLToPath2(import.meta.url)), "..");
-var SOURCE_CHECKOUT = fs24.existsSync(path23.join(PACKAGE_ROOT, "src", "index.ts"));
-var TMP_DIR = process.env["FLATBREAD_TMP_DIR"]?.trim() || (SOURCE_CHECKOUT ? path23.join(PACKAGE_ROOT, ".tmp") : path23.join(os9.homedir(), ".flatbread"));
-var OUTPUT_PATH = path23.join(TMP_DIR, "last-parse.json");
-var SHARE_OUTPUT_PATH = path23.join(TMP_DIR, "last-share.json");
+var PACKAGE_ROOT = path25.resolve(path25.dirname(fileURLToPath2(import.meta.url)), "..");
+var SOURCE_CHECKOUT = fs26.existsSync(path25.join(PACKAGE_ROOT, "src", "index.ts"));
+var TMP_DIR = process.env["FLATBREAD_TMP_DIR"]?.trim() || (SOURCE_CHECKOUT ? path25.join(PACKAGE_ROOT, ".tmp") : path25.join(os9.homedir(), ".flatbread"));
+var OUTPUT_PATH = path25.join(TMP_DIR, "last-parse.json");
+var SHARE_OUTPUT_PATH = path25.join(TMP_DIR, "last-share.json");
 function storeDir() {
-  return resolveStoreDir() ?? (SOURCE_CHECKOUT ? null : path23.join(TMP_DIR, DEFAULT_STORE_DIRNAME));
+  return resolveStoreDir() ?? (SOURCE_CHECKOUT ? null : path25.join(TMP_DIR, DEFAULT_STORE_DIRNAME));
 }
 var USAGE = `flatbread - registry of AI agent runs
 
@@ -13036,7 +13480,6 @@ Options for share:
 
 Options for search:
   --harness <id>  --category <kind>     Only runs from that harness, or of that kind of job
-  --recovered                           Only runs where the agent recovered from a failure
   --local                               This machine only; the site is not asked
 
 Options for setup:
@@ -13044,7 +13487,7 @@ Options for setup:
   --uninstall                           Remove the handlers, the MCP server and the post-commit;
                                         restore a post-commit hook setup had chained
   --no-git                              Leave the repository's hooks alone
-  --no-mcp                              Leave Claude Code's MCP servers and the flatbread skill alone
+  --no-mcp                              Leave every agent's MCP servers and the flatbread skill alone
   --settings <path>  --no-probe         As for hook install
 
 Options for capture:
@@ -13067,8 +13510,8 @@ Options for adapters:
 Notes:
   parse and share record the git branch, HEAD commit and uncommitted file names when the
   session ran inside a git repository. Nothing else from git is read.
-  parse --save writes ${path23.relative(process.cwd(), OUTPUT_PATH) || OUTPUT_PATH}
-  Share drafts are written to ${path23.relative(process.cwd(), SHARE_OUTPUT_PATH) || SHARE_OUTPUT_PATH}
+  parse --save writes ${path25.relative(process.cwd(), OUTPUT_PATH) || OUTPUT_PATH}
+  Share drafts are written to ${path25.relative(process.cwd(), SHARE_OUTPUT_PATH) || SHARE_OUTPUT_PATH}
   (the latest only; every shared run is also kept under its ID, for search and pull)
   Every parsed run defaults to visibility "private".
   Nothing is uploaded unless you pass --publish, or set FLATBREAD_API_URL and
@@ -13105,10 +13548,10 @@ function parseArgv(argv) {
     } else if (arg === "--out") {
       const value = argv[i + 1];
       if (value === void 0 || value.startsWith("--")) throw new Error("--out needs a file path");
-      args.out = path23.resolve(value);
+      args.out = path25.resolve(value);
       i += 1;
     } else if (arg !== void 0 && arg.startsWith("--out=")) {
-      args.out = path23.resolve(arg.slice("--out=".length));
+      args.out = path25.resolve(arg.slice("--out=".length));
     } else if (arg === "--harness") {
       const value = argv[i + 1];
       if (value === void 0 || value.startsWith("--")) {
@@ -13229,12 +13672,12 @@ async function runParse(args) {
     target = found[0];
     console.log(`latest ${harness} session: ${target}`);
   } else if (args.file) {
-    target = path23.resolve(args.file);
-    if (!fs24.existsSync(target)) {
+    target = path25.resolve(args.file);
+    if (!fs26.existsSync(target)) {
       console.error(`file not found: ${target}`);
       return 1;
     }
-    if (!fs24.statSync(target).isFile()) {
+    if (!fs26.statSync(target).isFile()) {
       console.error(`not a file: ${target}`);
       return 1;
     }
@@ -13265,8 +13708,8 @@ async function runParse(args) {
   const trace = withLineage(result.trace, readGitLineage(result.trace.source.cwd));
   FlatbreadTraceSchema.parse(trace);
   if (args.out !== void 0) {
-    fs24.mkdirSync(path23.dirname(args.out), { recursive: true });
-    fs24.writeFileSync(args.out, JSON.stringify(trace, null, 2) + "\n", "utf8");
+    fs26.mkdirSync(path25.dirname(args.out), { recursive: true });
+    fs26.writeFileSync(args.out, JSON.stringify(trace, null, 2) + "\n", "utf8");
   }
   report({ ...result, trace }, args.out);
   return 0;
@@ -13330,8 +13773,8 @@ async function runAdapters(args) {
   }
   let input = null;
   if (args.file !== void 0) {
-    const resolved = path23.resolve(args.file);
-    if (!fs24.existsSync(resolved)) {
+    const resolved = path25.resolve(args.file);
+    if (!fs26.existsSync(resolved)) {
       console.error(`file not found: ${resolved}`);
       return 1;
     }
@@ -13765,9 +14208,9 @@ async function runPull(args, deps = { ...defaultMcpDeps(storeDir(), bucketDir())
     process.stdout.write(result.capsule);
     return 0;
   }
-  const target = path23.resolve(args.out);
-  fs24.mkdirSync(path23.dirname(target), { recursive: true });
-  fs24.writeFileSync(target, result.capsule, "utf8");
+  const target = path25.resolve(args.out);
+  fs26.mkdirSync(path25.dirname(target), { recursive: true });
+  fs26.writeFileSync(target, result.capsule, "utf8");
   console.error(`wrote ${target}${result.from === "site" ? "" : ` (from this machine's ${result.from === "store" ? "shared runs" : "captured runs"})`}`);
   return 0;
 }
@@ -13790,8 +14233,6 @@ function parseSearchArgv(argv) {
       const value = valueOf("--category");
       if (!TASK_CATEGORIES.includes(value)) throw new Error(`unknown --category "${value}". Known: ${TASK_CATEGORIES.join(", ")}`);
       query.category = value;
-    } else if (arg === "--recovered") {
-      query.onlyWithRecoveries = true;
     } else if (arg === "--local") {
       local = true;
     } else if (arg.startsWith("--")) {
@@ -14017,9 +14458,9 @@ var invokedDirectly = (() => {
   if (entry === void 0) return false;
   const real = (file) => {
     try {
-      return fs24.realpathSync(file);
+      return fs26.realpathSync(file);
     } catch {
-      return path23.resolve(file);
+      return path25.resolve(file);
     }
   };
   return real(entry) === real(fileURLToPath2(import.meta.url));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flatbread-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Flatbread: read a coding agent's session off disk, redact it, share it, and pull a run's Context Capsule into another agent.",
   "type": "module",
   "bin": {