flatbread-cli 0.4.0 → 0.7.0

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 fs27 from "node:fs";
 import os9 from "node:os";
-import path23 from "node:path";
+import path26 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: path27, errorMaps, issueData } = params;
+  const fullPath = [...path27, ...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, path27, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path24;
+    this._path = path27;
     this._key = key;
   }
   get path() {
@@ -4327,7 +4327,7 @@ var HARNESS_INFO = {
     implemented: true,
     humanTest: "A13",
     toolResults: "measured",
-    note: "Read the way three open readers read it (deja-vu, entire, opentraces), from their fixtures. Not yet measured on a real rollout here. A failure is the exit line Codex prints above a tool's output; files changed are not counted (apply_patch names them inside the patch)."
+    note: "Codex 0.163's format measured on two real rollouts: its script tool's calls are read from the item_completed items (commands with their exit codes, MCP calls, file changes). Older rollouts are read the way deja-vu, entire and opentraces read them: a failure is the exit line above a tool's output, and files changed are not counted."
   },
   cursor: {
     id: "cursor",
@@ -4390,7 +4390,10 @@ var MUTATING_TOOL_NAMES = /* @__PURE__ */ new Set([
   "edit",
   "multiedit",
   "notebookedit",
-  "update"
+  "update",
+  // Codex 0.163's FileChange item, one call per file with its `path` (decision 143). An older
+  // rollout's apply_patch carries only the patch text, so it names no path and records no file.
+  "apply_patch"
 ]);
 var FILE_PATH_KEYS = ["file_path", "notebook_path", "filePath", "path"];
 var TARGET_KEYS = [...FILE_PATH_KEYS, "command", "cmd", "pattern", "url", "query", "description", "prompt"];
@@ -4461,8 +4464,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 path27 = firstString(tool.input, FILE_PATH_KEYS);
+  if (path27 !== void 0) return `${tool.name} ${repoRelative(path27, 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 +4717,9 @@ function runDiagnostics(trace) {
       searches.set(key, found);
     }
   }
-  for (const [path24, entries] of reads) {
+  for (const [path27, 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: path27, 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 +4798,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 path27 = repoRelative(firstString(step.tool.input, FILE_PATH_KEYS), cwd);
+    const file = files.get(path27) ?? { path: path27 };
     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: path27, 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(path27, file);
   });
   return { files: [...files.values()], patches };
 }
@@ -4846,7 +4849,8 @@ function buildExecutionBrief(trace) {
     intent: {
       ...first !== void 0 ? { initialPrompt: { step: first.stepNumber, text: repoRelative(first.content.trim(), cwd) } } : {},
       resteers,
-      approvals
+      approvals,
+      ...source.part !== void 0 ? { part: { fromPrompt: source.part.fromPrompt, prompts: source.part.prompts } } : {}
     },
     scars: scarsOf(steps, cwd),
     outcome: {
@@ -4980,6 +4984,8 @@ function buildCapsule(trace, options = {}) {
   out.push(head.join(" \xB7 "));
   const git2 = lineageLine(brief);
   if (git2 !== null) out.push(git2);
+  const part = brief.intent.part;
+  if (part !== void 0) out.push(`Part of a longer session: from prompt ${part.fromPrompt} of ${part.prompts}`);
   const asked = brief.intent.initialPrompt;
   if (asked !== void 0) {
     out.push("", "Asked:");
@@ -5120,13 +5126,13 @@ function categorizeTrace(trace) {
     };
   }
   if (paths.length > 0) {
-    if (paths.every((path24) => matchesAny(path24, DOC_PATTERNS))) {
+    if (paths.every((path27) => matchesAny(path27, 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((path27) => matchesAny(path27, 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((path27) => matchesAny(path27, INFRA_PATTERNS))) {
       return { category: "infra", evidence: [`all ${paths.length} touched path(s) are build/CI/deploy config`, ...paths.slice(0, 3)] };
     }
   }
@@ -5319,13 +5325,22 @@ function matchesSearch(row, q) {
   return matchesText(rowSearchText(row), q);
 }
 function matchesText(text2, q) {
+  const terms = searchTerms(q);
+  return termsMatched(text2, terms) === terms.length;
+}
+function termsMatched(text2, terms) {
   const haystack = normalizeSearch(text2);
   const stems = ` ${stemText(haystack)} `;
-  return searchTerms(q).every((term) => {
+  return terms.filter((term) => {
     if (haystack.includes(term)) return true;
     const stemmed = stemText(term);
     return stemmed.length > 0 && stems.includes(stemmed);
-  });
+  }).length;
+}
+var CLOSEST_LIMIT = 5;
+function closestByTerms(rows, textOf2, q) {
+  const terms = searchTerms(q);
+  return rows.map((row, index) => ({ row, index, matched: termsMatched(textOf2(row), terms), terms: terms.length })).filter((hit) => hit.matched > 0 && hit.matched < hit.terms).sort((a, b) => b.matched - a.matched || a.index - b.index).slice(0, CLOSEST_LIMIT).map(({ row, matched, terms: count }) => ({ row, matched, terms: count }));
 }
 
 // ../schema/src/index.ts
@@ -5436,7 +5451,13 @@ var TraceSourceSchema = external_exports.object({
   /** `flatbread share --pr <url>`: the pull request this run belongs to, as the person sharing it said. */
   prUrl: external_exports.string().url().max(GIT_LIMITS.prUrl).regex(/^https:\/\//, "a PR link must be https").optional(),
   /** Absent on records written before Pass 6, which were all claude-code. */
-  adapter: AdapterProvenanceSchema.optional()
+  adapter: AdapterProvenanceSchema.optional(),
+  /**
+   * A PART OF A SESSION (decision 144): the run is the steps from prompt `fromPrompt` to the end of a
+   * session of `prompts` prompts. Absent = the whole session. Its tokens are null: every harness
+   * records them for the whole session, never per part.
+   */
+  part: external_exports.object({ fromPrompt: external_exports.number().int().min(2), prompts: external_exports.number().int().min(2) }).refine((part) => part.fromPrompt <= part.prompts, "a part cannot start after the session's last prompt").optional()
 }).superRefine((source, ctx) => {
   if (source.harnessVersion !== void 0 && source.claudeCodeVersion !== void 0 && source.harnessVersion !== source.claudeCodeVersion) {
     ctx.addIssue({
@@ -7093,7 +7114,7 @@ var claudeCodeAdapter = {
 import fs8 from "node:fs";
 import os3 from "node:os";
 import path6 from "node:path";
-var CODEX_ADAPTER_VERSION = 1;
+var CODEX_ADAPTER_VERSION = 2;
 var REFUSAL_TEST2 = "A13";
 var ROLLOUT_NAME = /^rollout-.*\.jsonl(\.zst)?$/i;
 var UNDER_CODEX = /[\\/]\.codex[\\/](?:archived_)?sessions[\\/]/i;
@@ -7148,6 +7169,46 @@ function withoutFraming(text2) {
   const at = text2.indexOf("\nOutput:\n");
   return (at >= 0 ? text2.slice(at + "\nOutput:\n".length) : text2).trim();
 }
+var COPY_ITEMS = /* @__PURE__ */ new Set(["UserMessage", "AgentMessage", "Reasoning"]);
+function commandOf(value) {
+  if (!Array.isArray(value) || !value.every((part) => typeof part === "string")) return str(value);
+  const parts = value;
+  const flag = parts[parts.length - 2];
+  return parts.length >= 3 && (flag === "-lc" || flag === "-c") ? parts[parts.length - 1] ?? "" : parts.join(" ");
+}
+function itemEvents(item, at) {
+  const id = str(item["id"]);
+  const type = str(item["type"]);
+  const status = str(item["status"]);
+  if (type === "CommandExecution") {
+    const exit = item["exit_code"];
+    const workdir = str(item["cwd"]).replace(/^file:\/\//, "");
+    return [
+      { kind: "tool_call", ...at, id, name: "exec_command", input: { cmd: commandOf(item["command"]), ...workdir !== "" ? { workdir } : {} } },
+      { kind: "tool_result", ...at, id, text: str(item["aggregated_output"]).trim(), isError: typeof exit === "number" ? exit !== 0 : status === "failed" }
+    ];
+  }
+  if (type === "McpToolCall") {
+    const result = isRecord2(item["result"]) ? item["result"] : {};
+    const args = isRecord2(item["arguments"]) ? item["arguments"] : {};
+    return [
+      { kind: "tool_call", ...at, id, name: `mcp__${str(item["server"])}__${str(item["tool"])}`, input: args },
+      { kind: "tool_result", ...at, id, text: outputText(result["content"]).trim(), isError: status !== "completed" || result["isError"] === true }
+    ];
+  }
+  if (type === "FileChange") {
+    const changes = isRecord2(item["changes"]) ? item["changes"] : {};
+    return Object.keys(changes).flatMap((file, index) => {
+      const change = changes[file];
+      const callId = `${id}#${index}`;
+      return [
+        { kind: "tool_call", ...at, id: callId, name: "apply_patch", input: { path: file, ...isRecord2(change) && str(change["type"]) !== "" ? { change: str(change["type"]) } : {} } },
+        { kind: "tool_result", ...at, id: callId, text: index === 0 ? `${str(item["stdout"])}${str(item["stderr"])}`.trim() : "", isError: status !== "completed" }
+      ];
+    });
+  }
+  return null;
+}
 function parseArguments(value) {
   if (typeof value !== "string") return value ?? {};
   try {
@@ -7167,6 +7228,9 @@ function decodeRollout(text2) {
   let inheritedAt = -1;
   let inheritedStream = 0;
   let dropped = 0;
+  let itemized = false;
+  const openCalls = [];
+  const scripted = /* @__PURE__ */ new Set();
   for (const raw of text2.replace(/\r\n/g, "\n").split("\n")) {
     if (raw.trim() === "") continue;
     let record;
@@ -7218,12 +7282,28 @@ function decodeRollout(text2) {
         const usage = isRecord2(payload["info"]) ? payload["info"]["total_token_usage"] : void 0;
         if (isRecord2(usage) && typeof usage["input_tokens"] === "number" && typeof usage["output_tokens"] === "number") {
           const cached = typeof usage["cached_input_tokens"] === "number" ? usage["cached_input_tokens"] : 0;
-          tokens = { input: usage["input_tokens"], cached, output: usage["output_tokens"] };
+          const cacheWrite = usage["cache_write_input_tokens"];
+          tokens = { input: usage["input_tokens"], cached, output: usage["output_tokens"], ...typeof cacheWrite === "number" ? { cacheWrite } : {} };
         } else {
           tally2(unread, "token_count without info.total_token_usage");
         }
         continue;
       }
+      if (ptype === "item_completed") {
+        const item = isRecord2(payload["item"]) ? payload["item"] : {};
+        const inner = itemEvents(item, at);
+        if (inner !== null) {
+          itemized = true;
+          const script = openCalls[openCalls.length - 1];
+          if (script !== void 0) scripted.add(script);
+          roled.push(...inner);
+        } else if (COPY_ITEMS.has(str(item["type"]))) {
+          tally2(unread, "item_completed copies of response_items");
+        } else {
+          tally2(unread, `item_completed ${str(item["type"]) || "untyped"}`);
+        }
+        continue;
+      }
       const message = str(payload["message"]).trim();
       if (ptype === "user_message" && message !== "" && !isInjectedPrompt(message)) streamed.push({ kind: "prompt", ...at, text: message });
       else if (ptype === "agent_message" && message !== "") streamed.push({ kind: "text", ...at, text: message });
@@ -7234,6 +7314,14 @@ function decodeRollout(text2) {
       tally2(unread, "compaction summary");
       continue;
     }
+    if (type === "world_state") {
+      tally2(unread, "world_state (Codex's environment snapshot)");
+      continue;
+    }
+    if (type === "token_usage_record") {
+      tally2(unread, "token_usage_record (per response; the last token_count is the total)");
+      continue;
+    }
     if (type !== "response_item") {
       tally2(unread, `record ${type || "untyped"}`);
       continue;
@@ -7272,11 +7360,15 @@ function decodeRollout(text2) {
         }
         const input = ptype === "function_call" ? parseArguments(payload["arguments"]) : payload["input"] ?? {};
         roled.push({ kind: "tool_call", ...at, id, name, input });
+        openCalls.push(id);
         break;
       }
       case "function_call_output":
       case "custom_tool_call_output": {
         const id = str(payload["call_id"]);
+        const open = openCalls.lastIndexOf(id);
+        if (open >= 0) openCalls.splice(open, 1);
+        if (scripted.has(id)) break;
         const output = outputText(payload["output"]);
         const exit = EXIT.exec(output);
         roled.push({
@@ -7292,6 +7384,11 @@ function decodeRollout(text2) {
         tally2(unread, `response_item ${ptype || "untyped"}`);
     }
   }
+  if (scripted.size > 0) {
+    const kept = roled.filter((event) => !(event.kind === "tool_call" && scripted.has(event.id)));
+    roled.length = 0;
+    roled.push(...kept);
+  }
   const spoken = roled.some((event) => event.kind === "prompt" || event.kind === "text");
   if (!spoken && streamed.length > 0) {
     roled.push(...streamed);
@@ -7300,7 +7397,7 @@ function decodeRollout(text2) {
     unread.set("event_msg turns (copies of response_items)", streamed.length);
   }
   const events = Object.keys(meta).length > 1 ? [meta, ...roled] : roled;
-  return { events, ...sessionId !== void 0 ? { sessionId } : {}, records, unread, tokens, dropped };
+  return { events, ...sessionId !== void 0 ? { sessionId } : {}, records, unread, tokens, dropped, itemized };
 }
 function homeOf2(env) {
   return (process.platform === "win32" ? env.USERPROFILE : env.HOME) || os3.homedir();
@@ -7374,21 +7471,24 @@ var codexAdapter = {
     }
     const events = [...rollout.events];
     if (rollout.tokens !== null) {
-      const { input: all, cached, output } = rollout.tokens;
+      const { input: all, cached, output, cacheWrite } = rollout.tokens;
+      const write2 = cacheWrite !== void 0 ? { cacheCreationTokens: cacheWrite } : {};
       events.push(
-        cached <= all ? { kind: "usage", inputTokens: all - cached, cacheReadTokens: cached, outputTokens: output } : { kind: "usage", inputTokens: all, outputTokens: output }
+        cached <= all ? { kind: "usage", inputTokens: all - cached, cacheReadTokens: cached, outputTokens: output, ...write2 } : { kind: "usage", inputTokens: all, outputTokens: output, ...write2 }
       );
     }
     const notes = [`${rollout.records} record(s), ${said} prompt/reply event(s)`];
     if (rollout.tokens === null) notes.push("no token_count with total_token_usage: tokens not recorded in this rollout");
     else if (rollout.tokens.cached > rollout.tokens.input) notes.push("cached input exceeds input: cache read left out rather than guessed");
     if (rollout.dropped > 0) notes.push(`${rollout.dropped} event(s) from a parent thread's copied history left out`);
-    notes.push("CONFIDENCE: documented (three readers in .ref, not yet measured here). See HUMAN-TESTS.md A13.");
+    notes.push(
+      rollout.itemized ? "CONFIDENCE: the 0.163 item format, measured on two real rollouts (HUMAN-TESTS.md A13)." : "CONFIDENCE: documented (three readers in .ref; this older format is not measured here). See HUMAN-TESTS.md A13."
+    );
     return {
       events,
-      // apply_patch names its files inside the patch text, which the builder does not read, so a
-      // count from it would be a 0 nobody measured.
-      capabilities: { tokens: rollout.tokens === null ? "unavailable" : "measured", filesChanged: "unavailable" },
+      // An older rollout's apply_patch names its files inside the patch text, which the builder does
+      // not read, so a count from it would be a 0 nobody measured. A 0.163 FileChange names them.
+      capabilities: { tokens: rollout.tokens === null ? "unavailable" : "measured", filesChanged: rollout.itemized ? "measured" : "unavailable" },
       ...rollout.sessionId !== void 0 ? { sessionId: rollout.sessionId } : {},
       unreadFields: [...rollout.unread].sort((a, b) => b[1] - a[1]).map(([field, count]) => `${field} x${count}`),
       notes
@@ -10394,6 +10494,9 @@ button.primary:hover{background:var(--fg-lift);border-color:var(--fg-lift)}
 .done h1{font-size:20px}
 .done .meta{font-size:13.5px;color:var(--fg-2);margin:10px 0 0}
 .done code{display:block;background:var(--inset);border-radius:var(--radius-sm);padding:12px 14px;margin:14px 0;font-size:12.5px;word-break:break-all}
+.done .meta code{display:inline;padding:1px 5px;margin:0;font-size:12px}
+.start{display:flex;gap:6px}
+.start select{flex:1;min-width:0;font:inherit;font-size:12.5px;padding:6px 8px;border:1px solid rgba(var(--shade),.12);border-radius:var(--radius-sm);background:var(--ivory);color:var(--fg)}
 a{color:var(--fg);text-underline-offset:2px}
 @media (max-width:960px){.wrap{grid-template-columns:minmax(0,1fr);padding:16px}aside{position:static;max-height:none;order:-1}.hin{padding:12px 16px}}
 `;
@@ -10440,6 +10543,9 @@ var SCRIPT = `
     // TYPING IS NOT TRIAGE: j, k and space in the title field are letters. Enter submits the form
     // the way any text field does, through the first submit button - Confirm.
     if (tag === 'INPUT' && e.target.type === 'text') return;
+    // A START IS CHOSEN WITH THE ARROWS AND ENTER, so on the select none of them is triage - and
+    // Enter there must never press Confirm.
+    if (tag === 'SELECT') return;
     if (key === 'j' || key === 'ArrowDown') { e.preventDefault(); focusRow(cursor + 1); return; }
     if (key === 'k' || key === 'ArrowUp') { e.preventDefault(); focusRow(cursor - 1); return; }
     if (key === ' ' && cursor >= 0 && tag !== 'BUTTON') {
@@ -10550,7 +10656,7 @@ function renderReviewPage(input) {
   const ruleSummary = [...ruleCounts.entries()].sort((a, b) => b[1] - a[1]).map(([rule, count]) => `${escapeHtml(rule)}&nbsp;${count}`).join(" &middot; ");
   const toolCalls = trace.stats.toolCallCount;
   const publicWarning = input.publishTo === void 0 ? "Visibility public: this draft records that choice, and the run becomes readable by anyone the moment it is uploaded. Continue?" : `Visibility public: confirming uploads this run to ${input.publishTo} where anyone with the link can read it. Continue?`;
-  const destinationHtml = input.publishTo === void 0 ? `<p class="note">Local draft only. Confirm writes ${escapeHtml(input.draftPath ?? "a file in packages/cli/.tmp")} and nothing leaves this machine. The visibility above is stored in the draft. To upload a run, share it with <code>--publish</code> after <code>flatbread login</code>.</p>` : `<p class="warn">Confirm UPLOADS this run to ${escapeHtml(input.publishTo)} with the visibility selected above. Everything you KEEP below is uploaded as written.</p>`;
+  const destinationHtml = input.publishTo === void 0 ? `<p class="note">Local draft only. Confirm writes ${escapeHtml(input.draftPath ?? "a file in packages/cli/.tmp")} and nothing leaves this machine. The visibility above is stored in the draft. To upload a run, share it with <code>--publish</code> after <code>flatbread login</code>, or ask your agent to share it.</p>` : `<p class="warn">Confirm UPLOADS this run to ${escapeHtml(input.publishTo)} with the visibility selected above. Everything you KEEP below is uploaded as written.</p>`;
   const body = `
 <header><div class="hin">
   <div class="bar"><span class="wordmark">flatbread</span><span class="crumb">review before you share</span></div>
@@ -10558,11 +10664,13 @@ function renderReviewPage(input) {
   <div class="meta">
     <b>${escapeHtml(trace.model)}</b> &middot; ${plural2(trace.steps.length, "step")} &middot; ${plural2(toolCalls, "tool call")} &middot;
     ${trace.stats.filesChanged === null ? `${formatCount(null)} files` : plural2(trace.stats.filesChanged, "file")} changed &middot; ${failuresRecorded(trace.source.harness) ? plural2(trace.stats.errorCount, "error") : `${formatCount(null)} errors`} &middot;
-    ${Math.round(trace.stats.durationSeconds)}s &middot; <b>${matches.length}</b> redaction match${matches.length === 1 ? "" : "es"}
+    ${Math.round(trace.stats.durationSeconds)}s &middot; <b>${matches.length}</b> redaction match${matches.length === 1 ? "" : "es"}${trace.source.part === void 0 ? "" : ` &middot; from prompt ${trace.source.part.fromPrompt} of ${trace.source.part.prompts}`}
   </div>
-  <div class="meta path">${escapeHtml(sessionPath)}</div>
-</div></header>
-<form id="review" method="post" action="/confirm">
+  <div class="meta path">${escapeHtml(sessionPath)}</div>${input.foundBy === void 0 ? "" : `
+  <div class="meta">Found as ${escapeHtml(input.foundBy)}</div>`}
+</div></header>${input.startsAt === void 0 ? "" : `
+<form id="starts" method="get" action="/"></form>`}
+<form id="review" method="post" action="/confirm">${input.startsAt === void 0 ? "" : `<input type="hidden" name="from" value="${input.startsAt.current}">`}
 <div class="wrap">
   <main>${metaHtml}${stepsHtml}</main>
   <aside>
@@ -10571,6 +10679,13 @@ function renderReviewPage(input) {
     Every match is redacted by default. Tick a row to KEEP the original text instead.</p>
     <div class="tools"><button id="keep-none" type="button">redact all</button><button id="keep-all" type="button">keep all</button></div>
     <p class="keys"><b>j</b>/<b>k</b> move &middot; <b>space</b> keep or redact &middot; <b>enter</b> confirm</p>
+    ${input.startsAt === void 0 ? "" : `<fieldset>
+      <legend><label for="from">Starts at</label></legend>
+      <div class="start"><select id="from" name="from" form="starts">${input.startsAt.prompts.map(
+    (prompt2) => `<option value="${prompt2.n}"${prompt2.n === input.startsAt?.current ? " selected" : ""}>${prompt2.n}. ${escapeHtml(prompt2.preview.length > 72 ? `${prompt2.preview.slice(0, 71)}\u2026` : prompt2.preview)}</option>`
+  ).join("")}</select><button type="submit" form="starts">Show</button></div>
+      <p class="note">Share the whole session, or only the part from a later prompt. Showing another start resets the choices below.</p>
+    </fieldset>`}
     ${input.titleDraft === void 0 ? "" : `<fieldset>
       <legend><label for="title">Title</label></legend>
       <input class="title" id="title" name="title" type="text" required maxlength="${LIMITS.title}" value="${escapeHtml(input.titleDraft)}">
@@ -10594,18 +10709,20 @@ function renderReviewPage(input) {
 <script>var PUBLIC_WARNING=${JSON.stringify(publicWarning)};${SCRIPT}</script>`;
   return page(`Flatbread review - ${trace.title}`, body);
 }
-function renderDonePage(message, outputPath, publishTo, keepsRun = false) {
-  const network = publishTo === void 0 ? `<p class="meta">Nothing was uploaded. This file is on your machine only.</p>` : `<p class="meta">Uploading this run to ${escapeHtml(publishTo)} now. Your terminal says whether it arrived, and prints its link.</p>`;
+function renderDonePage(report2) {
+  const { upload } = report2;
+  const heading = upload.kind === "published" ? "Shared" : "Saved on this machine";
+  const network = upload.kind === "published" ? `<p class="meta">Uploaded to <a href="${escapeHtml(upload.url)}">${escapeHtml(upload.url)}</a></p>` : upload.kind === "failed" ? `<p class="meta">Upload FAILED: ${escapeHtml(upload.reason)}. Nothing was uploaded, and the run is kept here.</p>` : `<p class="meta">Nothing was uploaded: ${escapeHtml(upload.reason)}.</p>`;
+  const kept = report2.slug === void 0 ? "" : `<p class="meta">That file holds only your latest share, and the next one replaces it. This run is also kept under its own ID, <code>${escapeHtml(report2.slug)}</code>: <code>flatbread pull ${escapeHtml(report2.slug)}</code> prints it again, and <code>flatbread search --local</code> lists every run you have shared.</p>`;
+  const token = report2.manageToken === void 0 ? "" : `<p class="meta"><strong>Copy the manage token now.</strong> It opens this run while it is private. It is shown once: only its hash is stored, so nothing here or on the server can show it again.</p><code>${escapeHtml(report2.manageToken)}</code>`;
   return page(
-    "Flatbread - share draft written",
-    `<div class="done"><h1>${escapeHtml(message)}</h1>
-     <code>${escapeHtml(outputPath)}</code>
+    `Flatbread - ${heading.toLowerCase()}`,
+    `<div class="done"><h1>${heading}</h1>
      ${network}
-     ${keepsRun ? `<p class="meta">That file holds only your latest share, and the next one replaces it. This run is also kept under its own ID, printed in your terminal: <code>flatbread pull &lt;id&gt;</code> prints it again, and <code>flatbread search --local</code> lists every run you have shared.</p>` : ""}
-     <p class="meta"><strong>Go back to your terminal now.</strong> The manage token for this
-     run is printed there, once, at the very bottom. It is the only way to open the run
-     while it is private, and only its hash is stored, so nothing can print it again.</p>
-     <p class="meta">Then you can close this tab; the review server is shutting down.</p></div>`
+     <code>${escapeHtml(report2.draftPath)}</code>
+     ${kept}
+     ${token}
+     <p class="meta">You can close this tab; the review server is shutting down.</p></div>`
   );
 }
 function renderCancelPage() {
@@ -10631,8 +10748,10 @@ function parseDecisionBody(body) {
   const form = new URLSearchParams(body);
   const parsedVisibility = VisibilitySchema.safeParse(form.get("visibility"));
   const title = form.get("title");
+  const from = form.get("from");
   return {
     ...title !== null ? { title: normalizeTitle(title) } : {},
+    ...from !== null ? { from: /^\d{1,6}$/.test(from) ? Number(from) : 0 } : {},
     visibility: parsedVisibility.success ? parsedVisibility.data : "private",
     // ONE CHECKBOX MAY DECIDE MANY MATCHES. A grouped row carries every id it governs,
     // space-separated, so the browser sends one value and the caller still gets the flat
@@ -10665,13 +10784,18 @@ async function listenOnFirstFreePort(server, ports) {
 }
 async function startReviewServer(options) {
   const ports = options.ports ?? REVIEW_SERVER.ports;
-  const html = renderReviewPage(options);
+  const { starts } = options;
+  const offered = (n) => starts?.prompts.some((prompt2) => prompt2.n === n) === true;
+  const inputAt = (n) => starts === void 0 ? options : { ...starts.inputOf(n), startsAt: { current: n, prompts: starts.prompts } };
+  const current = starts?.current;
+  const html = renderReviewPage(current === void 0 ? options : inputAt(current));
   let settle = () => {
   };
   const decision = new Promise((resolve) => {
     settle = resolve;
   });
   let settled = false;
+  let confirming = false;
   const finish = (value) => {
     if (settled) return;
     settled = true;
@@ -10690,7 +10814,8 @@ async function startReviewServer(options) {
       res.end(body);
     };
     if (method === "GET" && (url === "/" || url.startsWith("/?"))) {
-      send(200, html);
+      const asked = Number(new URLSearchParams(url.slice(url.indexOf("?") + 1)).get("from"));
+      send(200, starts !== void 0 && url.startsWith("/?") && offered(asked) && asked !== current ? renderReviewPage(inputAt(asked)) : html);
       return;
     }
     if (method === "GET" && url === "/favicon.ico") {
@@ -10706,7 +10831,29 @@ async function startReviewServer(options) {
       void (async () => {
         try {
           const body = await readBody(req);
-          const { visibility, keepIds, title } = parseDecisionBody(body);
+          const { visibility, keepIds, title, from } = parseDecisionBody(body);
+          if (confirming || settled) {
+            send(
+              409,
+              page(
+                "Flatbread - already decided",
+                `<div class="done"><h1>This review is already decided</h1><p class="meta">Confirm runs once. The first tab that pressed it shows what happened.</p></div>`
+              )
+            );
+            return;
+          }
+          if (from !== void 0 && !offered(from)) {
+            send(
+              400,
+              page(
+                "Flatbread - start refused",
+                `<div class="done"><h1>That start is not one this review offered</h1><p class="meta"><a href="/">Back to the review</a>. Nothing was written.</p></div>`
+              )
+            );
+            return;
+          }
+          const start = from ?? current;
+          const shown = start === void 0 ? options : inputAt(start);
           if (title === null) {
             send(
               400,
@@ -10717,15 +10864,17 @@ async function startReviewServer(options) {
             );
             return;
           }
-          const changed = title !== void 0 && options.titleDraft !== void 0 && title !== normalizeTitle(options.titleDraft);
+          const changed = title !== void 0 && shown.titleDraft !== void 0 && title !== normalizeTitle(shown.titleDraft);
           const confirmed = {
             action: "confirm",
             visibility,
             keepIds,
-            ...changed ? { title } : {}
+            ...changed ? { title } : {},
+            ...start !== void 0 ? { from: start } : {}
           };
-          const message = options.onConfirm ? await options.onConfirm(confirmed) : "";
-          send(200, renderDonePage("Share draft written", message, options.publishTo, options.keepsRun === true));
+          confirming = true;
+          const report2 = options.onConfirm ? await options.onConfirm(confirmed) : { draftPath: options.draftPath ?? "", upload: { kind: "none", reason: "nothing was asked to keep this run" } };
+          send(200, renderDonePage(report2));
           finish(confirmed);
         } catch (error) {
           send(500, page("Flatbread - error", `<div class="done"><h1>Could not write the share draft</h1><code>${escapeHtml(error instanceof Error ? error.message : String(error))}</code></div>`));
@@ -10748,7 +10897,9 @@ async function startReviewServer(options) {
     });
   };
   if (options.timeoutMs !== void 0) {
-    const timer = setTimeout(() => finish({ action: "timeout" }), options.timeoutMs);
+    const timer = setTimeout(() => {
+      if (!confirming) finish({ action: "timeout" });
+    }, options.timeoutMs);
     timer.unref();
   }
   return {
@@ -10759,6 +10910,80 @@ async function startReviewServer(options) {
   };
 }
 
+// src/part.ts
+function promptsOf(trace) {
+  return trace.steps.flatMap((step, stepIndex) => step.type === "user_prompt" ? [{ stepIndex, text: step.content }] : []).map((prompt2, index) => ({ n: index + 1, ...prompt2 }));
+}
+function isShareCall(step) {
+  if (step.type !== "tool_call" || step.tool === void 0) return false;
+  if (/(^|__)flatbread_share$/.test(step.tool.name)) return true;
+  const command = firstStringKey(step.tool.input, ["command", "cmd"]);
+  return command !== null && /\bflatbread(?:-cli(?:@[\w.-]+)?)?(?:\.mjs)?\s+share\b/.test(command.value);
+}
+function lastIndex(items, test, before = items.length) {
+  for (let i = before - 1; i >= 0; i -= 1) if (test(items[i])) return i;
+  return -1;
+}
+function withoutShareTurn(trace, options = {}) {
+  const prompt2 = lastIndex(trace.steps, (step) => step.type === "user_prompt");
+  const call = lastIndex(trace.steps, isShareCall);
+  const requested = call > prompt2;
+  if (!requested && options.requestIsLast !== true) return trace;
+  let end = requested ? call : trace.steps.length;
+  if (prompt2 >= 0 && !trace.steps.slice(prompt2 + 1, end).some((step) => step.type === "tool_call")) end = prompt2;
+  return end === trace.steps.length ? trace : recount(trace, trace.steps.slice(0, end));
+}
+function resolveFrom(prompts, from) {
+  const asked = from.trim();
+  if (/^\d+$/.test(asked)) {
+    const n = Number(asked);
+    if (n >= 1 && n <= prompts.length) return { n };
+    return { problem: `there is no prompt ${n}: this session has ${plural2(prompts.length, "prompt")}`, candidates: [...prompts] };
+  }
+  const phrase = normalizeSearch(asked);
+  if (phrase.length === 0) return { problem: "no prompt was named", candidates: [...prompts] };
+  const exact = prompts.filter((prompt2) => normalizeSearch(prompt2.text).includes(phrase));
+  const terms = searchTerms(asked);
+  const hits = exact.length > 0 ? exact : prompts.filter((prompt2) => termsMatched(prompt2.text, terms) === terms.length);
+  if (hits.length === 1) return { n: hits[0].n };
+  return hits.length === 0 ? { problem: `no prompt holds "${asked}"`, candidates: [...prompts] } : { problem: `${hits.length} prompts hold "${asked}"`, candidates: hits };
+}
+function partFrom(trace, n) {
+  const prompts = promptsOf(trace);
+  const start = prompts[n - 1];
+  if (start === void 0) throw new Error(`no prompt ${n} in a session of ${prompts.length}`);
+  if (n === 1) return trace;
+  return recount(trace, trace.steps.slice(start.stepIndex), { fromPrompt: n, prompts: prompts.length });
+}
+function recount(trace, kept, part) {
+  const steps = kept.map((step, index) => ({ ...step, stepNumber: index }));
+  const toolCallCount = steps.filter((step) => step.type === "tool_call").length;
+  const errorCount = steps.filter((step) => step.type === "error_recovery").length;
+  const changed = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (step.type !== "tool_call" || step.tool === void 0 || step.tool.isError === true) continue;
+    if (!MUTATING_TOOL_NAMES.has(step.tool.name.toLowerCase())) continue;
+    const hit = firstStringKey(step.tool.input, FILE_PATH_KEYS2);
+    if (hit !== null) changed.add(hit.value);
+  }
+  const filesChanged = trace.stats.filesChanged === null ? null : changed.size;
+  const times = steps.map((step) => Date.parse(step.timestamp)).filter((ms) => !Number.isNaN(ms)).sort((a, b) => a - b);
+  const startedAt = times.length > 0 ? new Date(times[0]).toISOString() : trace.stats.startedAt;
+  const endedAt = times.length > 0 ? new Date(times[times.length - 1]).toISOString() : trace.stats.endedAt;
+  const durationSeconds = Math.max(0, (Date.parse(endedAt) - Date.parse(startedAt)) / 1e3);
+  const filesPhrase = filesChanged === null ? "an unrecorded number of files changed" : `${plural2(filesChanged, "file")} changed`;
+  const errorsPhrase = failuresRecorded(trace.source.harness) ? plural2(errorCount, "tool error") : "tool errors not recorded";
+  const firstPrompt = steps.find((step) => step.type === "user_prompt");
+  const tokens = part === void 0 ? {} : { inputTokens: null, outputTokens: null, cacheReadTokens: null, cacheCreationTokens: null };
+  return FlatbreadTraceSchema.parse({
+    ...trace,
+    ...part !== void 0 ? { title: titleFromPrompt(firstPrompt?.content ?? ""), source: { ...trace.source, part } } : {},
+    summary: `${part !== void 0 ? `From prompt ${part.fromPrompt} of ${part.prompts}: ` : ""}${plural2(steps.length, "step")}, ${plural2(toolCallCount, "tool call")}, ${filesPhrase}, ${errorsPhrase} over ${Math.round(durationSeconds)}s.`,
+    stats: { ...trace.stats, ...tokens, startedAt, endedAt, durationSeconds, toolCallCount, errorCount, filesChanged },
+    steps
+  });
+}
+
 // src/share.ts
 var spanKey = (match) => `${match.fieldPath}\0${match.start}\0${match.end}\0${match.original}`;
 function applyReview(trace, matches, keepIds, title) {
@@ -10920,7 +11145,7 @@ async function runShare(options) {
     target = path16.resolve(options.file);
     if (!fs17.existsSync(target) || !fs17.statSync(target).isFile()) {
       console.error(`file not found: ${target}`);
-      return { exitCode: 1, status: "not-found" };
+      return { exitCode: 1, status: "not-found", problem: `file not found: ${target}` };
     }
   } else {
     const harness = options.harness ?? "claude-code";
@@ -10943,7 +11168,7 @@ async function runShare(options) {
     console.error(`could not parse ${target}`);
     console.error(`  reason    ${parsed.reason}`);
     if (parsed.humanTest) console.error(`  next step HUMAN-TESTS.md section ${parsed.humanTest}`);
-    return { exitCode: 1, status: "not-found" };
+    return { exitCode: 1, status: "not-found", problem: `could not read ${target}: ${parsed.reason}` };
   }
   const cwd = parsed.trace.source.cwd;
   let lineage;
@@ -10958,15 +11183,44 @@ async function runShare(options) {
   } else {
     lineage = (options.readLineage ?? ((dir) => readGitLineage(dir)))(cwd);
   }
-  const lined = withLineage(parsed.trace, lineage, options.prUrl);
-  const trace = options.title !== void 0 ? FlatbreadTraceSchema.parse({ ...lined, title: options.title }) : lined;
+  const whole = withoutShareTurn(withLineage(parsed.trace, lineage, options.prUrl), { requestIsLast: options.requestIsLast === true });
+  const prompts = promptsOf(whole);
+  const redactedWhole = applyRedactions(whole, scanTrace(whole).matches, { keepIds: [] }).trace;
+  const shownPrompts = promptsOf(redactedWhole);
+  const shown = (refs) => refs.map((ref) => shownPrompts[ref.n - 1] ?? ref);
+  if (prompts.length === 0) {
+    const problem = "this session has no prompt before the share request, so there is nothing to share";
+    console.error(problem);
+    return { exitCode: 1, status: "empty", problem, candidates: [] };
+  }
+  let from = 1;
+  if (options.from !== void 0) {
+    const resolved = resolveFrom(prompts, options.from);
+    if ("problem" in resolved) {
+      console.error(`--from ${options.from}: ${resolved.problem}`);
+      for (const prompt2 of shown(resolved.candidates)) console.error(`  ${prompt2.n}  ${promptPreview(prompt2)}`);
+      return { exitCode: 1, status: "bad-from", problem: resolved.problem, candidates: shown(resolved.candidates) };
+    }
+    from = resolved.n;
+  }
   for (const note of parsed.notes) log(`note: ${note}`);
-  const scan = scanTrace(trace);
+  const views = /* @__PURE__ */ new Map();
+  const viewOf = (n) => {
+    const cached = views.get(n);
+    if (cached !== void 0) return cached;
+    const part = partFrom(whole, n);
+    const trace2 = options.title !== void 0 ? FlatbreadTraceSchema.parse({ ...part, title: options.title }) : part;
+    const scan2 = scanTrace(trace2);
+    const view = { trace: trace2, scan: scan2, previewTitle: applyRedactions(trace2, scan2.matches, { keepIds: [] }).trace.title };
+    views.set(n, view);
+    return view;
+  };
+  const { trace, scan, previewTitle } = viewOf(from);
   const byRule = /* @__PURE__ */ new Map();
   for (const match of scan.matches) byRule.set(match.rule, (byRule.get(match.rule) ?? 0) + 1);
   log("");
-  const previewTitle = applyRedactions(trace, scan.matches, { keepIds: [] }).trace.title;
   log(`  ${previewTitle}`);
+  if (from > 1) log(`  from prompt ${from} of ${prompts.length}`);
   log(`  ${trace.steps.length} steps, ${trace.stats.toolCallCount} tool calls`);
   log(`  scanned ${scan.fieldsScanned} string fields`);
   log(`  ${scan.matches.length} redaction ${scan.matches.length === 1 ? "match" : "matches"}`);
@@ -10974,94 +11228,121 @@ async function runShare(options) {
     log(`    ${String(count).padStart(4)}  ${rule} (${labelForRule(rule)})`);
   }
   log("");
-  let keepIds = [];
-  let visibility = "private";
-  let written;
   if (options.noReview) {
     log("--no-review: redacting every match, visibility stays private");
-  } else {
-    const reviewPublisher = options.publisher ?? (options.publish === true ? createPublisherForMachine() : createPublisher());
-    const session = await startReviewServer({
-      trace,
-      matches: scan.matches,
-      slots: scan.slots,
+    const applied = applyRedactions(trace, scan.matches, { keepIds: [] });
+    const draft = buildDraft(applied.trace, applied.report, "private");
+    writeDraft(options.outputPath, draft);
+    logDraft(draft, options.outputPath, log);
+    const persisted = await persistDraft(draft, options, log);
+    reportPersist(persisted, options, log);
+    return { exitCode: 0, status: "written", outputPath: options.outputPath, draft, ...persisted ? { persisted } : {} };
+  }
+  const reviewPublisher = options.publisher ?? (options.publish === true ? createPublisherForMachine() : createPublisher());
+  const publishTo = isPublisher(reviewPublisher) ? reviewPublisher.description : void 0;
+  const inputOf = (n) => {
+    const view = viewOf(n);
+    return {
+      trace: view.trace,
+      matches: view.scan.matches,
+      slots: view.scan.slots,
       sessionPath: target,
       draftPath: options.outputPath,
-      titleDraft: previewTitle,
-      keepsRun: options.persist !== false && (options.storeDir ?? resolveStoreDir()) !== null,
-      ...isPublisher(reviewPublisher) ? { publishTo: reviewPublisher.description } : {},
-      ...options.ports ? { ports: options.ports } : {},
-      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
-      onConfirm: (decision2) => {
-        const applied2 = applyReview(trace, scan.matches, decision2.keepIds, decision2.title);
-        const draft2 = buildDraft(applied2.trace, applied2.report, decision2.visibility);
-        writeDraft(options.outputPath, draft2);
-        written = draft2;
-        return options.outputPath;
-      }
-    });
-    if (!session) {
-      console.error(
-        `could not bind a review port on ${REVIEW_SERVER.host} (tried ${(options.ports ?? REVIEW_SERVER.ports).join(", ")}, then any port the OS would give)`
-      );
-      console.error("Loopback itself refused, so this machine needs a look; --no-review redacts everything without the page.");
-      return { exitCode: 1, status: "port-unavailable" };
-    }
-    log(`  review at ${session.url}`);
-    if (options.openBrowser) {
-      const opened = openInBrowser(session.url);
-      log(opened ? "  opening your browser\u2026" : `  could not open a browser - visit ${session.url}`);
-    }
-    log("  waiting for Confirm or Cancel\u2026");
-    const decision = await session.decision;
-    await session.close();
-    if (decision.action === "cancel") {
-      log("cancelled - nothing was written");
-      return { exitCode: 0, status: "cancelled", url: session.url };
-    }
-    if (decision.action === "timeout") {
-      log("timed out waiting for review - nothing was written");
-      return { exitCode: 1, status: "timeout", url: session.url };
-    }
-    if (written) {
-      log("");
-      log(`  visibility  ${written.trace.visibility}`);
-      log(`  redacted    ${written.redaction.redactedCount}`);
-      log(`  kept        ${written.redaction.keptCount}`);
-      log("");
-      log(`wrote ${options.outputPath}`);
-      const persisted2 = await persistDraft(written, options, log);
-      reportPersist(persisted2, options, log);
-      return {
-        exitCode: 0,
-        status: "written",
-        outputPath: options.outputPath,
-        draft: written,
-        url: session.url,
-        ...persisted2 ? { persisted: persisted2 } : {}
-      };
+      titleDraft: view.previewTitle,
+      ...publishTo !== void 0 ? { publishTo } : {},
+      ...options.foundBy !== void 0 ? { foundBy: options.foundBy } : {}
+    };
+  };
+  let written;
+  const session = await startReviewServer({
+    ...inputOf(from),
+    ...prompts.length > 1 ? { starts: { current: from, prompts: shownPrompts.map((prompt2) => ({ n: prompt2.n, preview: promptPreview(prompt2) })), inputOf } } : {},
+    ...options.ports ? { ports: options.ports } : {},
+    ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+    // EVERYTHING HAPPENS INSIDE THE CONFIRM, so the page it answers with is the receipt: the link,
+    // or why there is none, and the manage token. A share started by an agent has no terminal.
+    onConfirm: async (decision2) => {
+      const view = viewOf(decision2.from ?? from);
+      const applied = applyReview(view.trace, view.scan.matches, decision2.keepIds, decision2.title);
+      const draft = buildDraft(applied.trace, applied.report, decision2.visibility);
+      writeDraft(options.outputPath, draft);
+      const persisted = await persistDraft(draft, options, log);
+      written = { draft, ...persisted ? { persisted } : {} };
+      return doneReportOf(options.outputPath, persisted);
     }
-    keepIds = decision.keepIds;
-    visibility = decision.visibility;
-  }
-  const applied = applyRedactions(trace, scan.matches, { keepIds });
-  const draft = buildDraft(applied.trace, applied.report, visibility);
-  writeDraft(options.outputPath, draft);
-  log(`  visibility  ${draft.trace.visibility}`);
-  log(`  redacted    ${draft.redaction.redactedCount}`);
-  log(`  kept        ${draft.redaction.keptCount}`);
-  log("");
-  log(`wrote ${options.outputPath}`);
-  const persisted = await persistDraft(draft, options, log);
-  reportPersist(persisted, options, log);
+  });
+  if (!session) {
+    console.error(
+      `could not bind a review port on ${REVIEW_SERVER.host} (tried ${(options.ports ?? REVIEW_SERVER.ports).join(", ")}, then any port the OS would give)`
+    );
+    console.error("Loopback itself refused, so this machine needs a look; --no-review redacts everything without the page.");
+    return { exitCode: 1, status: "port-unavailable" };
+  }
+  log(`  review at ${session.url}`);
+  if (options.openBrowser) {
+    const opened = openInBrowser(session.url);
+    log(opened ? "  opening your browser\u2026" : `  could not open a browser - visit ${session.url}`);
+  }
+  log("  waiting for Confirm or Cancel\u2026");
+  options.onReviewReady?.({
+    url: session.url,
+    sessionPath: target,
+    steps: trace.steps.length,
+    matches: scan.matches.length,
+    prompts: prompts.length,
+    fromPrompt: from,
+    ...publishTo !== void 0 ? { publishTo } : {}
+  });
+  const decision = await session.decision;
+  await session.close();
+  if (decision.action === "cancel") {
+    log("cancelled - nothing was written");
+    return { exitCode: 0, status: "cancelled", url: session.url };
+  }
+  if (decision.action === "timeout") {
+    log("timed out waiting for review - nothing was written");
+    return { exitCode: 1, status: "timeout", url: session.url };
+  }
+  const done = written;
+  if (done === void 0) {
+    return { exitCode: 1, status: "cancelled", url: session.url };
+  }
+  logDraft(done.draft, options.outputPath, log);
+  reportPersist(done.persisted, options, log);
   return {
     exitCode: 0,
     status: "written",
     outputPath: options.outputPath,
-    draft,
-    ...persisted ? { persisted } : {}
+    draft: done.draft,
+    url: session.url,
+    ...done.persisted ? { persisted: done.persisted } : {}
   };
 }
+function promptPreview(prompt2) {
+  return titleFromPrompt(prompt2.text, "(empty prompt)");
+}
+function logDraft(draft, outputPath, log) {
+  log("");
+  log(`  visibility  ${draft.trace.visibility}`);
+  log(`  redacted    ${draft.redaction.redactedCount}`);
+  log(`  kept        ${draft.redaction.keptCount}`);
+  log("");
+  log(`wrote ${outputPath}`);
+}
+function doneReportOf(draftPath, persisted) {
+  if (persisted === void 0) return { draftPath, upload: { kind: "none", reason: "no record was kept, so nothing was uploaded" } };
+  const base = { draftPath, slug: persisted.slug, manageToken: persisted.manageToken };
+  if (persisted.publish?.ok === true) return { ...base, upload: { kind: "published", url: persisted.publish.url } };
+  if (persisted.publish !== void 0) return { ...base, upload: { kind: "failed", reason: publishFailureDetail(persisted.publish) } };
+  return { ...base, upload: { kind: "none", reason: skippedReason(persisted.publishSkipped) } };
+}
+function skippedReason(skipped) {
+  if (skipped === "not-signed-in") return "this machine is not signed in. Run `flatbread login`, then share again";
+  if (skipped === "wrong-origin") return "the saved sign-in was issued by a different site. Run `flatbread login` against this one";
+  if (skipped === "partial-env") return "FLATBREAD_API_URL is not set, so there is nowhere to send it";
+  if (skipped === "bad-url") return "FLATBREAD_API_URL is not an address this can send to";
+  return "this share was not asked to upload";
+}
 
 // src/view.ts
 import fs18 from "node:fs";
@@ -11236,7 +11517,7 @@ 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");
+  params.set("partial", "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);
@@ -11249,7 +11530,16 @@ async function searchRemote(query, options = {}) {
   const results = parsed.results;
   if (!Array.isArray(results)) return { ok: false, reason: "http", status: 200, detail: "the search answer had no results list" };
   if (!results.every(isHit)) return { ok: false, reason: "http", status: 200, detail: "a search result was not readable" };
-  return { ok: true, results, site: apiUrl };
+  const closest = parsed.closest ?? [];
+  if (!Array.isArray(closest) || !closest.every(isClosest)) {
+    return { ok: false, reason: "http", status: 200, detail: "a closest result was not readable" };
+  }
+  return { ok: true, results, closest, site: apiUrl };
+}
+function isClosest(value) {
+  if (!isHit(value)) return false;
+  const hit = value;
+  return typeof hit["matched"] === "number" && typeof hit["terms"] === "number";
 }
 function isHit(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -11274,16 +11564,141 @@ function describeReadFailure(failure, what) {
 // src/mcp.ts
 import readline3 from "node:readline";
 
-// src/bucket.ts
-import { createHash as createHash2 } from "node:crypto";
+// src/caller-session.ts
 import fs19 from "node:fs";
 import path18 from "node:path";
+var SESSION_ENV = [
+  { harness: "claude-code", variable: "CLAUDE_CODE_SESSION_ID", fileOf: (base, id) => base === `${id}.jsonl` },
+  { harness: "codex", variable: "CODEX_SESSION_ID", fileOf: (base, id) => base.endsWith(`-${id}.jsonl`) || base.endsWith(`-${id}.jsonl.zst`) }
+];
+var CODEX_ROLLOUTS_CHECKED = 40;
+function samePath(a, b) {
+  const [x, y] = [path18.resolve(a), path18.resolve(b)];
+  return process.platform === "win32" ? x.toLowerCase() === y.toLowerCase() : x === y;
+}
+function mtimeOf(file) {
+  try {
+    return fs19.statSync(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function ago(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1e3));
+  return seconds < 120 ? `${seconds} s ago` : `${Math.round(seconds / 60)} min ago`;
+}
+async function newestHere(harness, cwd, env) {
+  if (harness === "claude-code") return listSessionFiles(path18.join(getProjectsDir(env), encodeCwd(path18.resolve(cwd))))[0]?.filePath ?? null;
+  if (harness === "codex") {
+    for (const file of (adapterFor("codex").discover?.(env) ?? []).filter((f) => f.endsWith(".jsonl")).slice(0, CODEX_ROLLOUTS_CHECKED)) {
+      const meta = (await readFirstJsonLine(file))?.["payload"];
+      const recorded = typeof meta === "object" && meta !== null ? meta["cwd"] : void 0;
+      if (typeof recorded === "string" && samePath(recorded, cwd)) return file;
+    }
+  }
+  return null;
+}
+async function findCallerSession(options) {
+  const { env, cwd } = options;
+  const now = options.nowMs ?? Date.now();
+  const unmatched = [];
+  const named = [];
+  for (const { harness, variable, fileOf } of SESSION_ENV) {
+    if (options.harness !== void 0 && options.harness !== harness) continue;
+    const id = env[variable]?.trim() ?? "";
+    if (id.length === 0) continue;
+    const file = (adapterFor(harness).discover?.(env) ?? []).find((candidate) => fileOf(path18.basename(candidate), id));
+    if (file !== void 0) named.push({ file, harness, how: `named by ${variable}`, mtime: mtimeOf(file) });
+    else unmatched.push(`${variable}=${id} names no session file on this machine`);
+  }
+  const claimed = named.sort((a, b) => b.mtime - a.mtime)[0];
+  if (claimed !== void 0) return { file: claimed.file, harness: claimed.harness, how: claimed.how };
+  const harnesses = options.harness !== void 0 ? [options.harness] : ["claude-code", "codex"];
+  const here = [];
+  for (const harness of harnesses) {
+    const file = await newestHere(harness, cwd, env);
+    if (file !== null) here.push({ file, harness, mtime: mtimeOf(file) });
+  }
+  const newest = here.sort((a, b) => b.mtime - a.mtime)[0];
+  if (newest !== void 0) {
+    return { file: newest.file, harness: newest.harness, how: `the newest ${HARNESS_INFO[newest.harness].label} session in ${cwd}, written ${ago(now - newest.mtime)}` };
+  }
+  if (options.harness !== void 0 && options.harness !== "claude-code" && options.harness !== "codex") {
+    const file = adapterFor(options.harness).discover?.(env)[0];
+    if (file !== void 0) {
+      return { file, harness: options.harness, how: `the newest ${HARNESS_INFO[options.harness].label} session on this machine, written ${ago(now - mtimeOf(file))} (this harness records no folder to match)` };
+    }
+  }
+  const which = options.harness !== void 0 ? HARNESS_INFO[options.harness].label : "Claude Code or Codex";
+  return { problem: [`no ${which} session is recorded for ${cwd}`, ...unmatched].join("; ") };
+}
+
+// src/agent-share.ts
+var AGENT_REVIEW_TIMEOUT_MS = 30 * 6e4;
+function createAgentShare(context) {
+  let open = null;
+  const log = context.log ?? ((line) => process.stderr.write(`${line}
+`));
+  return async (request) => {
+    if (open !== null) return { ok: true, ...open, alreadyOpen: true };
+    const found = await (context.find ?? findCallerSession)({
+      env: context.env,
+      cwd: context.cwd,
+      ...request.harness !== void 0 ? { harness: request.harness } : {}
+    });
+    if ("problem" in found) return { ok: false, problem: found.problem };
+    let markReady = () => {
+    };
+    const ready = new Promise((resolve) => {
+      markReady = resolve;
+    });
+    const done = (context.share ?? runShare)({
+      file: found.file,
+      harness: found.harness,
+      requestIsLast: true,
+      foundBy: found.how,
+      ...request.from !== void 0 ? { from: request.from } : {},
+      publish: request.publish,
+      openBrowser: context.openBrowser ?? true,
+      outputPath: context.outputPath,
+      ...context.storeDir !== null ? { storeDir: context.storeDir } : {},
+      ...context.ports !== void 0 ? { ports: context.ports } : {},
+      timeoutMs: context.timeoutMs ?? AGENT_REVIEW_TIMEOUT_MS,
+      log,
+      onReviewReady: markReady
+    });
+    const first = await Promise.race([ready.then((r) => ({ ready: r })), done.then((result) => ({ result }))]);
+    if ("result" in first) {
+      const { result } = first;
+      return {
+        ok: false,
+        problem: result.problem ?? `the share stopped before its review opened (${result.status})`,
+        ...result.candidates !== void 0 ? { candidates: result.candidates } : {}
+      };
+    }
+    const entry = { ready: first.ready, foundBy: found.how, publish: request.publish };
+    open = entry;
+    const release = () => {
+      if (open === entry) open = null;
+    };
+    done.then(release, (error) => {
+      log(`flatbread share failed: ${error instanceof Error ? error.message : String(error)}`);
+      release();
+    });
+    return { ok: true, ...entry, alreadyOpen: false };
+  };
+}
+
+// src/bucket.ts
+import { createHash as createHash2 } from "node:crypto";
+import fs20 from "node:fs";
+import path19 from "node:path";
 var BUCKET_INDEX_VERSION = 1;
 var BUCKET_INDEX_FILE = "index.json";
 var CAPTURE_LOG_FILE = "capture.log";
 var COMMIT_SESSION_WINDOW_MS = 2 * 60 * 60 * 1e3;
 function bucketDir(env = process.env) {
-  return path18.join(flatbreadHome(env), "bucket");
+  return path19.join(flatbreadHome(env), "bucket");
 }
 function bucketSlug(harness, sessionKey) {
   return `local-${createHash2("sha256").update(`${harness}\0${sessionKey}`, "utf8").digest("hex").slice(0, 12)}`;
@@ -11298,18 +11713,18 @@ function rowOf(record) {
   };
 }
 function recordStems(dir) {
-  return fs19.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).filter((stem2) => SlugSchema.safeParse(stem2).success).sort();
+  return fs20.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).filter((stem2) => SlugSchema.safeParse(stem2).success).sort();
 }
 function writeAtomic(file, body) {
-  fs19.mkdirSync(path18.dirname(file), { recursive: true });
+  fs20.mkdirSync(path19.dirname(file), { recursive: true });
   const temp = `${file}.${process.pid}.tmp`;
-  fs19.writeFileSync(temp, body, "utf8");
-  fs19.renameSync(temp, file);
+  fs20.writeFileSync(temp, body, "utf8");
+  fs20.renameSync(temp, file);
 }
 var newestFirst = (rows) => [...rows].sort((a, b) => a.capturedAt < b.capturedAt ? 1 : a.capturedAt > b.capturedAt ? -1 : a.summary.slug < b.summary.slug ? -1 : 1);
 function readIndex(dir) {
   try {
-    const parsed = JSON.parse(fs19.readFileSync(path18.join(dir, BUCKET_INDEX_FILE), "utf8"));
+    const parsed = JSON.parse(fs20.readFileSync(path19.join(dir, BUCKET_INDEX_FILE), "utf8"));
     if (typeof parsed !== "object" || parsed === null) return null;
     const { version, rows } = parsed;
     if (version !== BUCKET_INDEX_VERSION || !Array.isArray(rows)) return null;
@@ -11328,10 +11743,10 @@ function readIndex(dir) {
   }
 }
 function writeIndex(dir, rows) {
-  writeAtomic(path18.join(dir, BUCKET_INDEX_FILE), JSON.stringify({ version: BUCKET_INDEX_VERSION, rows: newestFirst(rows) }, null, 2) + "\n");
+  writeAtomic(path19.join(dir, BUCKET_INDEX_FILE), JSON.stringify({ version: BUCKET_INDEX_VERSION, rows: newestFirst(rows) }, null, 2) + "\n");
 }
 function readBucket(dir) {
-  if (!fs19.existsSync(dir)) return { rows: [], rebuilt: false, unreadable: 0 };
+  if (!fs20.existsSync(dir)) return { rows: [], rebuilt: false, unreadable: 0 };
   const stems = recordStems(dir);
   const indexed = readIndex(dir);
   if (indexed !== null && JSON.stringify(indexed.map((row) => row.summary.slug).sort()) === JSON.stringify(stems)) {
@@ -11348,17 +11763,18 @@ function readBucket(dir) {
 function readBucketRecord(dir, slug) {
   if (!SlugSchema.safeParse(slug).success) return null;
   try {
-    const parsed = TraceRecordSchema.safeParse(JSON.parse(fs19.readFileSync(path18.join(dir, `${slug}.json`), "utf8")));
+    const parsed = TraceRecordSchema.safeParse(JSON.parse(fs20.readFileSync(path19.join(dir, `${slug}.json`), "utf8")));
     return parsed.success ? parsed.data : null;
   } catch {
     return null;
   }
 }
 function matchesQuery(summary, query) {
+  return matchesFilters(summary, query) && matchesSearch(summary, query.query ?? "");
+}
+function matchesFilters(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 ?? "");
+  return query.category === void 0 || summary.category === query.category;
 }
 async function captureToBucket(options) {
   const dir = options.dir ?? bucketDir(options.env);
@@ -11377,9 +11793,9 @@ async function captureToBucket(options) {
   const trace = withLineage(parsed.trace, lineage);
   const scan = scanTrace(trace);
   const applied = applyRedactions(trace, scan.matches, { keepIds: [] });
-  const sessionKey = trace.source.sessionId.length > 0 ? trace.source.sessionId : path18.resolve(options.file);
+  const sessionKey = trace.source.sessionId.length > 0 ? trace.source.sessionId : path19.resolve(options.file);
   const slug = bucketSlug(parsed.harness, sessionKey);
-  const recordPath = path18.join(dir, `${slug}.json`);
+  const recordPath = path19.join(dir, `${slug}.json`);
   const previous = readBucketRecord(dir, slug);
   const commit = applied.trace.source.commitNamed === true ? applied.trace.source.headCommitSha : void 0;
   const draft = ShareDraftSchema.parse({
@@ -11401,7 +11817,7 @@ async function captureToBucket(options) {
 }
 function sessionForRepo(repo, options = {}) {
   const projects = getProjectsDir(options.env ?? process.env);
-  const folder = path18.join(projects, encodeCwd(path18.resolve(repo)));
+  const folder = path19.join(projects, encodeCwd(path19.resolve(repo)));
   const newest = listSessionFiles(folder)[0];
   if (newest === void 0) return { problem: `no Claude Code session recorded for ${repo}` };
   const age = (options.nowMs ?? Date.now()) - newest.mtimeMs;
@@ -11413,8 +11829,8 @@ function sessionForRepo(repo, options = {}) {
 }
 function logCapture(dir, line, now = (/* @__PURE__ */ new Date()).toISOString()) {
   try {
-    fs19.mkdirSync(dir, { recursive: true });
-    fs19.appendFileSync(path18.join(dir, CAPTURE_LOG_FILE), `${now} ${line.replace(/[\r\n]+/g, " ")}
+    fs20.mkdirSync(dir, { recursive: true });
+    fs20.appendFileSync(path19.join(dir, CAPTURE_LOG_FILE), `${now} ${line.replace(/[\r\n]+/g, " ")}
 `, "utf8");
   } catch {
   }
@@ -11422,13 +11838,14 @@ 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";
-function defaultMcpDeps(storeDir2, bucketDir2) {
+var MCP_SERVER_VERSION = "0.7.0";
+function defaultMcpDeps(storeDir2, bucketDir2, shareOutputPath) {
   return {
     storeDir: storeDir2,
     bucketDir: bucketDir2,
     search: (query) => searchRemote(query, { client: "mcp" }),
-    capsule: (ref) => fetchCapsule(ref, { client: "mcp" })
+    capsule: (ref) => fetchCapsule(ref, { client: "mcp" }),
+    ...shareOutputPath !== void 0 ? { share: createAgentShare({ env: process.env, cwd: process.cwd(), outputPath: shareOutputPath, storeDir: storeDir2 }) } : {}
   };
 }
 var MCP_TOOLS = [
@@ -11439,10 +11856,9 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Words that must all appear in the run's title or ID" },
+        query: { type: "string", description: "Two to four words from the task or the error. Runs with every word in their title or ID come first; when none has them all, the closest are listed, marked with how many words they share" },
         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
     }
@@ -11457,6 +11873,20 @@ var MCP_TOOLS = [
       required: ["slug"],
       additionalProperties: false
     }
+  },
+  {
+    name: "flatbread_share",
+    title: "Share this run",
+    description: `Share the session you are in now as a Flatbread run. Call it when the user says "share this run", "flatbread share", "share to flatbread" or anything like it. It finds this session, leaves the share request out, opens a review page in the user's browser with every secret redacted by default, and returns at once: nothing is kept or uploaded until the user presses Confirm there. For only part of a long session, pass from: the number of the user's prompt to start at, or words from that prompt.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "string", description: 'Start at this prompt: its number ("3"), or words from it. Leave out for the whole session' },
+        publish: { type: "boolean", description: "Upload on Confirm when this machine is signed in to flatbread.io. Default true; false keeps it on this machine" },
+        harness: { type: "string", enum: [...HARNESS_IDS], description: "Which agent you are, only when you are not Claude Code or Codex" }
+      },
+      additionalProperties: false
+    }
   }
 ];
 function text(body, isError = false) {
@@ -11489,10 +11919,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) {
@@ -11506,6 +11933,8 @@ async function searchEverywhere(query, deps, options = {}) {
   const out = [];
   const local = localRecords(deps);
   const localHits = local.records.map((record) => summarize(record)).filter((summary) => matchesQuery(summary, query));
+  let found = localHits.length;
+  const nearby = [];
   if (deps.storeDir !== null) {
     out.push(`This machine (${runs(localHits.length)}):`);
     for (const hit of localHits) out.push(hitLine(hit));
@@ -11516,9 +11945,23 @@ async function searchEverywhere(query, deps, options = {}) {
     const { harness, sessionId } = record.trace.source;
     if (sessionId.length > 0 && localHits.some((hit) => hit.slug === record.slug)) seen.add(bucketSlug(harness, sessionId));
   }
+  const nearSeen = /* @__PURE__ */ new Set();
+  const localNear = local.records.filter((record) => matchesFilters(summarize(record), query));
+  for (const { row, matched, terms } of closestByTerms(localNear, (record) => rowSearchText(summarize(record)), query.query ?? "")) {
+    nearby.push({ line: `${hitLine(summarize(row))} \xB7 ${matched} of ${terms} words`, matched });
+    nearSeen.add(row.slug);
+    const { harness, sessionId } = row.trace.source;
+    if (sessionId.length > 0) nearSeen.add(bucketSlug(harness, sessionId));
+  }
   if (deps.bucketDir !== null) {
     const bucket = readBucket(deps.bucketDir);
     const captured = bucket.rows.filter((row) => !seen.has(row.summary.slug) && matchesQuery(row.summary, query));
+    found += captured.length;
+    const bucketNear = bucket.rows.filter((row) => !nearSeen.has(row.summary.slug) && matchesFilters(row.summary, query));
+    for (const { row, matched, terms } of closestByTerms(bucketNear, (row2) => rowSearchText(row2.summary), query.query ?? "")) {
+      nearby.push({ line: `${capturedLine(row)} \xB7 ${matched} of ${terms} words`, matched });
+      nearSeen.add(row.summary.slug);
+    }
     if (out.length > 0) out.push("");
     out.push(`Captured on this machine, not shared (${runs(captured.length)}):`);
     for (const row of captured) {
@@ -11527,21 +11970,31 @@ async function searchEverywhere(query, deps, options = {}) {
     }
     if (bucket.unreadable > 0) out.push(`(${bucket.unreadable} captured run file${bucket.unreadable === 1 ? "" : "s"} could not be read)`);
   }
+  let siteSearched = false;
   if (options.remote === false) {
     if (out.length > 0) out.push("");
     out.push("The site was not searched: --local");
-    return { lines: out, siteSearched: false };
-  }
-  const remote = await deps.search(query);
-  if (out.length > 0) out.push("");
-  if (remote.ok) {
-    const fresh = remote.results.filter((hit) => !seen.has(hit.slug));
-    out.push(`${remote.site} (${runs(fresh.length)}):`);
-    for (const hit of fresh) out.push(hitLine(hit));
   } else {
-    out.push(`The site was not searched: ${describeReadFailure(remote, "search")}`);
+    const remote = await deps.search(query);
+    if (out.length > 0) out.push("");
+    if (remote.ok) {
+      siteSearched = true;
+      const fresh = remote.results.filter((hit) => !seen.has(hit.slug));
+      found += fresh.length;
+      out.push(`${remote.site} (${runs(fresh.length)}):`);
+      for (const hit of fresh) out.push(hitLine(hit));
+      for (const hit of (remote.closest ?? []).filter((hit2) => !seen.has(hit2.slug) && !nearSeen.has(hit2.slug))) {
+        nearby.push({ line: `${hitLine(hit)} \xB7 ${hit.matched} of ${hit.terms} words`, matched: hit.matched });
+      }
+    } else {
+      out.push(`The site was not searched: ${describeReadFailure(remote, "search")}`);
+    }
+  }
+  if (found === 0 && nearby.length > 0) {
+    out.push("", `No run has every word of "${query.query ?? ""}". Closest, by words in common:`);
+    for (const hit of [...nearby].sort((a, b) => b.matched - a.matched).slice(0, CLOSEST_LIMIT)) out.push(hit.line);
   }
-  return { lines: out, siteSearched: remote.ok };
+  return { lines: out, siteSearched };
 }
 async function searchTool(args, deps) {
   const query = readQuery(args);
@@ -11559,6 +12012,50 @@ async function readCapsule(ref, deps) {
   const remote = await deps.capsule(ref);
   return remote.ok ? { ok: true, capsule: remote.capsule, from: "site" } : remote;
 }
+function readShareRequest(args) {
+  const from = args["from"];
+  const publish = args["publish"];
+  const harness = args["harness"];
+  if (from !== void 0 && typeof from !== "string" && !(typeof from === "number" && Number.isInteger(from))) {
+    return "from must be a prompt number or words from that prompt";
+  }
+  if (publish !== void 0 && typeof publish !== "boolean") return "publish must be true or false";
+  if (harness !== void 0 && (typeof harness !== "string" || !HARNESS_IDS.includes(harness))) {
+    return `harness must be one of ${HARNESS_IDS.join(", ")}`;
+  }
+  return {
+    ...from !== void 0 && String(from).trim().length > 0 ? { from: String(from) } : {},
+    publish: publish !== false,
+    ...harness !== void 0 ? { harness } : {}
+  };
+}
+function shareLines(start) {
+  const { ready } = start;
+  const matches = `${ready.matches} redaction match${ready.matches === 1 ? "" : "es"}`;
+  return [
+    start.alreadyOpen ? `A review is already open in the user's browser, so no new one was started: ${ready.url}` : `Review open in the user's browser: ${ready.url}`,
+    `Session: ${ready.sessionPath} (found as ${start.foundBy})`,
+    ready.fromPrompt > 1 ? `Shares prompt ${ready.fromPrompt} of ${ready.prompts} to the end` : `Shares the whole session: ${ready.prompts} prompt${ready.prompts === 1 ? "" : "s"}`,
+    `${ready.steps} steps, ${matches}, each redacted unless the user keeps it`,
+    ready.publishTo !== void 0 ? `Confirm uploads it to ${ready.publishTo} at the visibility the user picks there` : start.publish ? "Confirm keeps it on this machine only: this machine is not signed in, so nothing is uploaded (`flatbread login` signs it in)" : "Confirm keeps it on this machine only (publish: false)",
+    "",
+    "Nothing is kept or uploaded until the user presses Confirm on that page, which then shows the link and the manage token. Tell the user to review it there; do not wait for it."
+  ];
+}
+async function shareTool(args, deps) {
+  if (deps.share === void 0) return text("flatbread_share is not available in this server: run `flatbread share` in a terminal", true);
+  const request = readShareRequest(args);
+  if (typeof request === "string") return text(request, true);
+  const start = await deps.share(request);
+  if (start.ok) return text(shareLines(start).join("\n"));
+  const lines2 = [`Nothing was shared: ${start.problem}.`];
+  if (start.candidates !== void 0 && start.candidates.length > 0) {
+    lines2.push("", "This session's prompts, redacted:");
+    for (const prompt2 of start.candidates) lines2.push(`${prompt2.n}. ${titleFromPrompt(prompt2.text, "(empty prompt)")}`);
+    lines2.push("", "Ask the user which prompt to start at, then call flatbread_share again with from set to its number.");
+  }
+  return text(lines2.join("\n"), true);
+}
 async function capsuleTool(args, deps) {
   const raw = args["slug"];
   if (typeof raw !== "string") return text("slug must be a run ID or a /r/<id> link", true);
@@ -11590,7 +12087,7 @@ async function handleMcpMessage(message, deps) {
           protocolVersion,
           capabilities: { tools: { listChanged: false } },
           serverInfo: { name: "flatbread", version: MCP_SERVER_VERSION },
-          instructions: "Flatbread holds recorded coding-agent runs. Before a task someone may have done before, or after an error you have not seen, call flatbread_search_traces, then flatbread_get_capsule on a promising run and read its blockers before repeating them."
+          instructions: "Flatbread holds recorded coding-agent runs. Before a task someone may have done before, or after an error you have not seen, call flatbread_search_traces, then flatbread_get_capsule on a promising run and read its blockers before repeating them. When the user asks to share this run, call flatbread_share."
         }
       };
     }
@@ -11604,6 +12101,7 @@ async function handleMcpMessage(message, deps) {
       try {
         if (name === "flatbread_search_traces") return { jsonrpc: "2.0", id, result: await searchTool(toolArgs, deps) };
         if (name === "flatbread_get_capsule") return { jsonrpc: "2.0", id, result: await capsuleTool(toolArgs, deps) };
+        if (name === "flatbread_share") return { jsonrpc: "2.0", id, result: await shareTool(toolArgs, deps) };
       } catch (error) {
         return { jsonrpc: "2.0", id, result: text(`flatbread failed: ${error instanceof Error ? error.message : String(error)}`, true) };
       }
@@ -11641,14 +12139,18 @@ async function runMcpServer(deps, io) {
   return 0;
 }
 
+// src/setup.ts
+import fs26 from "node:fs";
+import path25 from "node:path";
+
 // src/claude-mcp.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import os8 from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 var MCP_SERVER_NAME = "flatbread";
 function claudeUserConfigPath(env = process.env) {
   const dir = env["CLAUDE_CONFIG_DIR"]?.trim();
-  return path19.join(dir ? dir : os8.homedir(), ".claude.json");
+  return path20.join(dir ? dir : os8.homedir(), ".claude.json");
 }
 function mcpEntryFor(execPath, entryPath) {
   return { type: "stdio", command: execPath, args: [entryPath, "mcp"] };
@@ -11663,7 +12165,7 @@ var BOM = "\uFEFF";
 function readConfig(file) {
   let raw;
   try {
-    raw = fs20.readFileSync(file, "utf8");
+    raw = fs21.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return { root: {}, raw: null };
     return { problem: error.message };
@@ -11690,28 +12192,38 @@ function serializeLike(raw, root) {
 function write(file, read2, next) {
   if (read2.raw !== null) {
     try {
-      fs20.accessSync(file, fs20.constants.W_OK);
+      fs21.accessSync(file, fs21.constants.W_OK);
     } 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 (fs21.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);
+    if (!fs21.existsSync(backup)) fs21.copyFileSync(file, backup);
   }
-  const mode = read2.raw !== null ? fs20.statSync(file).mode & 511 : 384;
-  fs20.mkdirSync(path19.dirname(file), { recursive: true });
+  const mode = read2.raw !== null ? fs21.statSync(file).mode & 511 : 384;
+  fs21.mkdirSync(path20.dirname(file), { recursive: true });
   const temp = `${file}.flatbread-${process.pid}.tmp`;
-  fs20.writeFileSync(temp, next, { encoding: "utf8", mode });
-  fs20.renameSync(temp, file);
+  fs21.writeFileSync(temp, next, { encoding: "utf8", mode });
+  fs21.renameSync(temp, file);
   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;
@@ -11738,16 +12250,16 @@ function registerClaudeMcp(options) {
     }
     log(`  mcp          ${file}: removed the ${MCP_SERVER_NAME} server`);
     const backup = `${file}.flatbread.bak`;
-    if (fs20.existsSync(backup)) log(`               ${backup} is the copy setup took before its first write; delete it when you like`);
+    if (fs21.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 +12273,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/codex-mcp.ts
+import fs22 from "node:fs";
+import path21 from "node:path";
+var BOM2 = "\uFEFF";
+var OWNED_KEYS = /* @__PURE__ */ new Set(["type", "command", "args"]);
+function codexConfigPath(codexHome2) {
+  return path21.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 {
+      fs22.accessSync(file, fs22.constants.W_OK);
+    } catch {
+      return `${file} is read-only, so it was left as it was`;
+    }
+    if (fs22.readFileSync(file, "utf8") !== raw) return `${file} changed while setup ran; run setup again`;
+    const backup = `${file}.flatbread.bak`;
+    if (!fs22.existsSync(backup)) fs22.copyFileSync(file, backup);
+  }
+  const mode = raw !== null ? fs22.statSync(file).mode & 511 : 384;
+  fs22.mkdirSync(path21.dirname(file), { recursive: true });
+  const temp = `${file}.flatbread-${process.pid}.tmp`;
+  fs22.writeFileSync(temp, next, { encoding: "utf8", mode });
+  fs22.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 = fs22.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 fs21 from "node:fs";
-import path20 from "node:path";
+import fs23 from "node:fs";
+import path22 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 +12677,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: path22.resolve(top), dir: path22.resolve(top, common, "hooks"), ...machineHooksPath !== void 0 ? { machineHooksPath } : {} };
 }
 var read = (file) => {
   try {
-    return fs21.readFileSync(file, "utf8");
+    return fs23.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 = path22.join(dir, "post-commit");
+  const chained = path22.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);
+    fs23.mkdirSync(dir, { recursive: true });
+    if (current !== null && !isOurs(current)) fs23.renameSync(hook, chained);
+    fs23.writeFileSync(hook, script, { encoding: "utf8", mode: 493 });
+    fs23.chmodSync(hook, 493);
     return { code: 0, lines: lines2 };
   };
   if (current === null) return write2([`post-commit  ${hook} (new)`]);
@@ -11838,7 +12703,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 (fs23.existsSync(chained)) {
     return {
       code: 1,
       lines: [
@@ -11854,10 +12719,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 = path22.join(dir, "post-commit");
+  const chained = path22.join(dir, CHAINED_HOOK);
   const current = read(hook);
-  const hasChained = fs21.existsSync(chained);
+  const hasChained = fs23.existsSync(chained);
   const done = (lines2, act) => {
     if (options.dryRun === true) return { code: 0, lines: [...lines2, "--dry-run: nothing was written"] };
     act();
@@ -11875,17 +12740,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) fs23.rmSync(hook);
+      fs23.renameSync(chained, hook);
     });
   }
-  return done([`post-commit  ${hook}`, "removed the flatbread hook"], () => fs21.rmSync(hook));
+  return done([`post-commit  ${hook}`, "removed the flatbread hook"], () => fs23.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 fs24 from "node:fs";
+import path23 from "node:path";
 var HOOK_EVENTS = ["Stop", "SessionEnd"];
 var OFFER_AFTER_STOPS = 2;
 var MAX_TRACKED_SESSIONS = 50;
@@ -11895,14 +12760,14 @@ function emptyHookState() {
   return { version: HOOK_STATE_VERSION, sessions: {} };
 }
 function hookStatePath(env = process.env) {
-  return path21.join(flatbreadHome(env), "hook-state.json");
+  return path23.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 (!fs24.existsSync(file)) return { ok: true, state: emptyHookState(), present: false };
   let raw;
   try {
-    raw = fs22.readFileSync(file, "utf8");
+    raw = fs24.readFileSync(file, "utf8");
   } catch (error) {
     return { ok: false, reason: "unreadable", detail: error.message };
   }
@@ -11945,9 +12810,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 });
+  fs24.mkdirSync(dir, { recursive: true, mode: 448 });
   const file = hookStatePath(env);
-  fs22.writeFileSync(file, JSON.stringify(pruneHookState(state), null, 2) + "\n", {
+  fs24.writeFileSync(file, JSON.stringify(pruneHookState(state), null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
   });
@@ -12093,7 +12958,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) => fs24.existsSync(filePath));
   const execPath = io.execPath ?? process.execPath;
   const entryPath = io.entryPath ?? process.argv[1] ?? "";
   try {
@@ -12250,10 +13115,10 @@ function removeHookConfig(settings) {
   return { settings: root, removed };
 }
 function readSettingsFile(file) {
-  if (!fs22.existsSync(file)) return { present: false, file };
+  if (!fs24.existsSync(file)) return { present: false, file };
   let raw;
   try {
-    raw = fs22.readFileSync(file, "utf8");
+    raw = fs24.readFileSync(file, "utf8");
   } catch (error) {
     return { present: true, file, unreadable: error.message };
   }
@@ -12265,10 +13130,10 @@ function readSettingsFile(file) {
   }
 }
 function writeSettingsFile(file, settings) {
-  fs22.mkdirSync(path21.dirname(file), { recursive: true });
+  fs24.mkdirSync(path23.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);
+  fs24.writeFileSync(temp, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  fs24.renameSync(temp, file);
 }
 function handlersFor(execPath, entryPath, capture = false) {
   return {
@@ -12426,8 +13291,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: path23.join(cwd, ".claude", "settings.json") },
+    { label: "local", file: path23.join(cwd, ".claude", "settings.local.json") }
   ];
 }
 function installedEventsIn(parsed, exists) {
@@ -12457,7 +13322,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) => fs24.existsSync(filePath));
   const candidates = options.settingsPath === void 0 ? settingsCandidates(env, cwd) : [{ label: "settings", file: options.settingsPath }];
   log("");
   log("flatbread hook");
@@ -12578,21 +13443,27 @@ function probeHandler(handler, run = spawnSync2) {
 }
 
 // src/skill.ts
-import fs23 from "node:fs";
-import path22 from "node:path";
+import fs25 from "node:fs";
+import path24 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.";
+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. Also when the user says "share this run", "flatbread share" or "share to flatbread".`;
 var BODY = `Search Flatbread once before your first edit in a coding task, even one that looks small and well-defined. A small task is exactly the one someone has already done, and the search costs one call. Then search again whenever a command, a test or a build fails, with the exact error line as the query.
 
 ## How
 
-1. Call \`flatbread_search_traces\` with two to four specific words from the task or the error (all of them must appear in a run's title). Try a second wording before deciding nothing is there.
+1. Call \`flatbread_search_traces\` with two to four specific words from the task or the error. Runs with every word come first; when none has them all, the closest are listed with how many words they share - open one only if its title is the same job. Try a second wording before deciding nothing is there.
 2. If a hit looks like the same job, call \`flatbread_get_capsule\` with its run ID. The capsule is that run's own record: what was asked, how the person steered it, each blocker and the fix, what the tests said, the diff.
 3. Use what it says. A blocker listed under "do not repeat" is a dead end someone already paid for: do not walk into it again.
 
 If the tools are not connected in this session, the same search runs in the shell: \`flatbread search <words>\` and \`flatbread pull <run id>\`.
 
+## When the user asks to share this run
+
+"Share this run", "flatbread share", "share to flatbread", "save this run": call \`flatbread_share\`. Do not open a terminal or look for the session yourself - the tool finds this session, leaves the share request out, and opens a review page in the user's browser. If the user wants only part of the session ("share it from where I asked about the retry"), pass \`from\` with that prompt's number or words from it; if the tool lists the prompts instead, ask the user which one. Then tell the user the page is open, in one line: nothing is kept or uploaded until they press Confirm there, and the page shows the link. Do not wait for it.
+
+Without the tool connected, the shell does the same with the person at the terminal: \`flatbread share\` (\`--from <n|words>\` for a part).
+
 ## Saying what you used
 
 When a capsule changed what you did, say so in one line at the start of your reply, with the run ID: "Flatbread: <run id> hit this before - <what it said>." Say nothing about searches that found nothing useful.
@@ -12617,28 +13488,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 fs25.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() || path24.join(home, ".claude");
+  const targets = [
+    { file: path24.join(claudeDir, "skills", SKILL_NAME, "SKILL.md") },
+    { file: path24.join(home, ".agents", "skills", SKILL_NAME, "SKILL.md") }
+  ];
+  const gemini = path24.join(home, ".gemini");
+  if (["antigravity", "antigravity-cli", "config"].some((dir) => isDir(path24.join(gemini, dir)))) {
+    const plugin = path24.join(gemini, "config", "plugins", SKILL_NAME);
+    targets.push({
+      file: path24.join(plugin, "skills", SKILL_NAME, "SKILL.md"),
+      companion: { file: path24.join(plugin, "plugin.json"), text: ANTIGRAVITY_PLUGIN_MANIFEST }
+    });
+  }
+  const opencode = path24.join(env["XDG_CONFIG_HOME"]?.trim() || path24.join(home, ".config"), "opencode");
+  if (isDir(opencode)) targets.push({ file: path24.join(opencode, "skills", SKILL_NAME, "SKILL.md") });
+  return targets;
+}
+function removeIfEmpty(dir) {
+  try {
+    fs25.rmdirSync(dir);
+  } catch {
+  }
 }
 function readOrNull(file) {
   try {
-    return fs23.readFileSync(file, "utf8");
+    return fs25.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 +13555,12 @@ function installSkill(options) {
         options.log(`  skill        would remove ${file}`);
         continue;
       }
-      fs23.rmSync(file);
-      try {
-        fs23.rmdirSync(path22.dirname(file));
-      } catch {
+      fs25.rmSync(file);
+      removeIfEmpty(path24.dirname(file));
+      if (companion !== void 0) {
+        removeIfEmpty(path24.dirname(path24.dirname(file)));
+        if (readOrNull(companion.file) === companion.text) fs25.rmSync(companion.file);
+        removeIfEmpty(path24.dirname(companion.file));
       }
       options.log(`  skill        removed ${file}`);
       continue;
@@ -12671,14 +13573,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);
+    fs25.mkdirSync(path24.dirname(file), { recursive: true });
+    if (companion !== void 0 && readOrNull(companion.file) === null) fs25.writeFileSync(companion.file, companion.text);
+    fs25.writeFileSync(file, text2);
     options.log(`  skill        ${current === null ? "wrote" : "updated"} ${file}`);
   }
   return code;
 }
 
 // src/setup.ts
+function isDir2(dir) {
+  try {
+    return fs26.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() || path25.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 = path25.join(home, ".cursor");
+  if (!isDir2(cursorHome)) log(`  skipped      not installed here (no ${cursorHome})`);
+  else {
+    code = Math.max(code, registerMcpJson({
+      file: path25.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 = path25.join(home, ".gemini");
+  if (!["antigravity", "antigravity-cli", "config"].some((dir) => isDir2(path25.join(gemini, dir)))) {
+    log(`  skipped      not installed here (no ${path25.join(gemini, "antigravity")})`);
+  } else {
+    code = Math.max(code, registerMcpJson({
+      file: path25.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 +13666,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 +13928,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 = path26.resolve(path26.dirname(fileURLToPath2(import.meta.url)), "..");
+var SOURCE_CHECKOUT = fs27.existsSync(path26.join(PACKAGE_ROOT, "src", "index.ts"));
+var TMP_DIR = process.env["FLATBREAD_TMP_DIR"]?.trim() || (SOURCE_CHECKOUT ? path26.join(PACKAGE_ROOT, ".tmp") : path26.join(os9.homedir(), ".flatbread"));
+var OUTPUT_PATH = path26.join(TMP_DIR, "last-parse.json");
+var SHARE_OUTPUT_PATH = path26.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 : path26.join(TMP_DIR, DEFAULT_STORE_DIRNAME));
 }
 var USAGE = `flatbread - registry of AI agent runs
 
@@ -12993,8 +13947,9 @@ Usage:
   flatbread pull <id|url>               Print a run's Context Capsule: a run this machine shared or
                                         captured is read here, anything else from the site
   flatbread pull <id|url> --out <file>  Write it to a file instead
-  flatbread mcp                         MCP server on stdio: flatbread_search_traces and
-                                        flatbread_get_capsule, for your coding agent
+  flatbread mcp                         MCP server on stdio for your coding agent:
+                                        flatbread_search_traces, flatbread_get_capsule, and
+                                        flatbread_share ("share this run" in the chat)
   flatbread search <words>              Find runs: this machine's shared and captured ones, then
                                         the site (the same answer the MCP server gives)
   flatbread setup                       Auto-capture: the Claude Code hook, plus a chained git
@@ -13030,13 +13985,14 @@ Options for share:
                                         opens with it and can still change it
   --commit [sha]                        Bind the run to a commit (bare --commit = HEAD) and record
                                         whether the working tree was clean against it
+  --from <n|words>                      Share only the part from that prompt to the end: its
+                                        number, or words from it. The review page can change it
   --no-review                           Redact every match, skip the browser (non-interactive)
   --no-open                             Start the review server but do not launch a browser
   -h, --help                            Show this message
 
 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 +14000,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,13 +14023,14 @@ 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 ${path26.relative(process.cwd(), OUTPUT_PATH) || OUTPUT_PATH}
+  Share drafts are written to ${path26.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
-  FLATBREAD_API_TOKEN yourself. pull and mcp only read: public runs, your own when you
-  are signed in, and a private run through its share link. The review UI listens on
+  Nothing is uploaded unless you pass --publish, set FLATBREAD_API_URL and
+  FLATBREAD_API_TOKEN yourself, or press Confirm on a review your agent opened with
+  flatbread_share. pull and search only read: public runs, your own when you are signed
+  in, and a private run through its share link. The review UI listens on
   127.0.0.1 only, on 4321-4325 or, when all five are busy, a port the OS picks.
   setup registers the MCP server in ~/.claude.json, for every project. By hand instead:
     claude mcp add --scope user flatbread -- flatbread mcp
@@ -13105,10 +14062,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 = path26.resolve(value);
       i += 1;
     } else if (arg !== void 0 && arg.startsWith("--out=")) {
-      args.out = path23.resolve(arg.slice("--out=".length));
+      args.out = path26.resolve(arg.slice("--out=".length));
     } else if (arg === "--harness") {
       const value = argv[i + 1];
       if (value === void 0 || value.startsWith("--")) {
@@ -13229,12 +14186,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 = path26.resolve(args.file);
+    if (!fs27.existsSync(target)) {
       console.error(`file not found: ${target}`);
       return 1;
     }
-    if (!fs24.statSync(target).isFile()) {
+    if (!fs27.statSync(target).isFile()) {
       console.error(`not a file: ${target}`);
       return 1;
     }
@@ -13265,8 +14222,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");
+    fs27.mkdirSync(path26.dirname(args.out), { recursive: true });
+    fs27.writeFileSync(args.out, JSON.stringify(trace, null, 2) + "\n", "utf8");
   }
   report({ ...result, trace }, args.out);
   return 0;
@@ -13330,8 +14287,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 = path26.resolve(args.file);
+    if (!fs27.existsSync(resolved)) {
       console.error(`file not found: ${resolved}`);
       return 1;
     }
@@ -13399,6 +14356,12 @@ function parseShareArgv(argv) {
       }
     } else if (arg !== void 0 && arg.startsWith("--commit=")) {
       args.commit = checkCommitRev(arg.slice("--commit=".length));
+    } else if (arg === "--from" || arg !== void 0 && arg.startsWith("--from=")) {
+      const value = arg === "--from" ? argv[i += 1] : arg.slice("--from=".length);
+      if (value === void 0 || value.startsWith("--") || value.trim().length === 0) {
+        throw new Error('--from needs a prompt number or words from that prompt, e.g. --from 3 or --from "retry helper"');
+      }
+      args.from = value;
     } else if (arg === "--file") {
       const value = argv[i + 1];
       if (value === void 0 || value.startsWith("--")) {
@@ -13765,9 +14728,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 = path26.resolve(args.out);
+  fs27.mkdirSync(path26.dirname(target), { recursive: true });
+  fs27.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 +14753,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("--")) {
@@ -13962,7 +14923,7 @@ async function main(argv) {
       console.error(`mcp takes no options, got: ${rest.join(" ")}`);
       return 1;
     }
-    return runMcpServer(defaultMcpDeps(storeDir(), bucketDir()));
+    return runMcpServer(defaultMcpDeps(storeDir(), bucketDir(), SHARE_OUTPUT_PATH));
   }
   if (command === "pull") {
     let pullArgs;
@@ -13997,6 +14958,7 @@ async function main(argv) {
       ...shareArgs.prUrl !== void 0 ? { prUrl: shareArgs.prUrl } : {},
       ...shareArgs.title !== void 0 ? { title: shareArgs.title } : {},
       ...shareArgs.commit !== void 0 ? { commit: shareArgs.commit } : {},
+      ...shareArgs.from !== void 0 ? { from: shareArgs.from } : {},
       ...storeDir() !== null ? { storeDir: storeDir() } : {},
       openBrowser: shareArgs.open && !shareArgs.noReview,
       outputPath: SHARE_OUTPUT_PATH
@@ -14017,9 +14979,9 @@ var invokedDirectly = (() => {
   if (entry === void 0) return false;
   const real = (file) => {
     try {
-      return fs24.realpathSync(file);
+      return fs27.realpathSync(file);
     } catch {
-      return path23.resolve(file);
+      return path26.resolve(file);
     }
   };
   return real(entry) === real(fileURLToPath2(import.meta.url));