@hydra-acp/cli 0.1.52 → 0.1.53

package/dist/cli.js

@@ -168,8 +168,77 @@ var init_service_token = __esm({
   }
 });
 
-// src/core/config.ts
+// src/core/json-store.ts
 import * as fs2 from "fs/promises";
+import * as fsSync from "fs";
+import { randomBytes } from "crypto";
+async function writeJsonAtomic(filePath, data, opts = {}) {
+  const pretty = opts.pretty ?? true;
+  const body = (pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data)) + "\n";
+  await writeFileAtomic(filePath, body, opts);
+}
+async function writeFileAtomic(filePath, body, opts = {}) {
+  const dir = dirname(filePath);
+  await fs2.mkdir(dir, { recursive: true });
+  const tmp = `${filePath}.tmp-${process.pid}-${randSuffix()}`;
+  try {
+    const writeOpts = {
+      encoding: "utf8"
+    };
+    if (opts.mode !== void 0) {
+      writeOpts.mode = opts.mode;
+    }
+    await fs2.writeFile(tmp, body, writeOpts);
+    await fs2.rename(tmp, filePath);
+  } catch (err) {
+    await fs2.unlink(tmp).catch(() => void 0);
+    throw err;
+  }
+  if (opts.mode !== void 0) {
+    try {
+      fsSync.chmodSync(filePath, opts.mode);
+    } catch {
+    }
+  }
+}
+async function readJsonSafe(filePath) {
+  let raw;
+  try {
+    raw = await fs2.readFile(filePath, "utf8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+  if (raw.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function dirname(p) {
+  const slash = p.lastIndexOf("/");
+  if (slash <= 0) {
+    return ".";
+  }
+  return p.slice(0, slash);
+}
+function randSuffix() {
+  return randomBytes(4).toString("hex");
+}
+var init_json_store = __esm({
+  "src/core/json-store.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/config.ts
+import * as fs3 from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { z } from "zod";
 function extensionList(config) {
@@ -185,17 +254,8 @@ function transformerList(config) {
   }));
 }
 async function readConfigFile() {
-  let raw;
-  try {
-    raw = await fs2.readFile(paths.config(), "utf8");
-  } catch (err) {
-    const e = err;
-    if (e.code === "ENOENT") {
-      return {};
-    }
-    throw err;
-  }
-  return JSON.parse(raw);
+  const parsed = await readJsonSafe(paths.config());
+  return parsed ?? {};
 }
 async function migrateLegacyAuthToken() {
   const raw = await readConfigFile();
@@ -206,7 +266,7 @@ async function migrateLegacyAuthToken() {
   }
   let tokenFileExists = false;
   try {
-    await fs2.access(paths.authToken());
+    await fs3.access(paths.authToken());
     tokenFileExists = true;
   } catch (err) {
     const e = err;
@@ -224,10 +284,7 @@ async function migrateLegacyAuthToken() {
   if (Object.keys(daemon).length === 0) {
     delete raw.daemon;
   }
-  await fs2.writeFile(paths.config(), JSON.stringify(raw, null, 2) + "\n", {
-    encoding: "utf8",
-    mode: 384
-  });
+  await writeJsonAtomic(paths.config(), raw, { mode: 384 });
   process.stderr.write(
     `hydra-acp: migrated auth token from ${paths.config()} to ${paths.authToken()}.
 `
@@ -255,6 +312,7 @@ var init_config = __esm({
     "use strict";
     init_paths();
     init_service_token();
+    init_json_store();
     REGISTRY_URL_DEFAULT = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
     TlsConfig = z.object({
       cert: z.string(),
@@ -343,7 +401,22 @@ var init_config = __esm({
       // shared across all sessions; it's append-only on disk, so long-lived
       // installs can grow past this — it's enforced at load time and per
       // append in memory.
-      promptHistoryMaxEntries: z.number().int().positive().default(2e3)
+      promptHistoryMaxEntries: z.number().int().positive().default(2e3),
+      // How edit-style tool calls (Edit, Write, str_replace) render in
+      // scrollback, *in addition to* the normal tool row inside the tools
+      // block.
+      //   "none" — nothing extra; the collapsed tool row is the only signal.
+      //   "edit" (default) — a one-line scrollback mark naming the file
+      //     that was touched, so the user can scroll back and see which
+      //     files moved without expanding the tools block. Suppressed on
+      //     tool-only turns (no agent prose) since the marks would only
+      //     duplicate the still-visible tool rows.
+      //   "diff" — same mark plus a syntax-highlighted unified diff body,
+      //     Claude Code's Update(file) look.
+      // The diff payload is extracted from the ACP wire (content[]
+      // type:"diff" entries, falling back to rawInput shapes), so any agent
+      // that emits one of those shapes gets the treatment.
+      showFileUpdates: z.enum(["none", "edit", "diff"]).default("edit")
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -398,7 +471,8 @@ var init_config = __esm({
         progressIndicator: true,
         defaultEnterAction: "amend",
         showThoughts: true,
-        promptHistoryMaxEntries: 2e3
+        promptHistoryMaxEntries: 2e3,
+        showFileUpdates: "edit"
       })
     });
   }
@@ -480,8 +554,6 @@ var init_remote_url = __esm({
 });
 
 // src/core/remotes-store.ts
-import * as fs3 from "fs/promises";
-import * as fsSync from "fs";
 function hostKey(host, port) {
   return `${host}:${port}`;
 }
@@ -504,21 +576,9 @@ function splitKey(key) {
   }
   return { host, port };
 }
-async function readFile4() {
-  let raw;
-  try {
-    raw = await fs3.readFile(paths.remotes(), "utf8");
-  } catch (err) {
-    const e = err;
-    if (e.code === "ENOENT") {
-      return { version: 1, entries: {} };
-    }
-    throw err;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
+async function readFile3() {
+  const parsed = await readJsonSafe(paths.remotes());
+  if (parsed === void 0) {
     return { version: 1, entries: {} };
   }
   return normalise(parsed);
@@ -549,32 +609,22 @@ function normalise(raw) {
   }
   return { version: 1, entries: out };
 }
-async function writeFile4(data) {
-  const dir = paths.home();
-  await fs3.mkdir(dir, { recursive: true });
-  const tmp = paths.remotes() + ".tmp";
-  await fs3.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", {
-    encoding: "utf8",
-    mode: 384
-  });
-  await fs3.rename(tmp, paths.remotes());
-  try {
-    fsSync.chmodSync(paths.remotes(), 384);
-  } catch {
-  }
+async function writeFile3(data) {
+  await writeJsonAtomic(paths.remotes(), data, { mode: 384 });
 }
 var RemotesStore;
 var init_remotes_store = __esm({
   "src/core/remotes-store.ts"() {
     "use strict";
     init_paths();
+    init_json_store();
     RemotesStore = class _RemotesStore {
       data;
       constructor(data) {
         this.data = data;
       }
       static async load() {
-        const data = await readFile4();
+        const data = await readFile3();
         const now = Date.now();
         const filtered = {};
         let dropped = false;
@@ -587,7 +637,7 @@ var init_remotes_store = __esm({
         }
         const final = { version: 1, entries: filtered };
         if (dropped) {
-          await writeFile4(final);
+          await writeFile3(final);
         }
         return new _RemotesStore(final);
       }
@@ -603,7 +653,7 @@ var init_remotes_store = __esm({
       }
       async set(host, port, credential) {
         this.data.entries[hostKey(host, port)] = credential;
-        await writeFile4(this.data);
+        await writeFile3(this.data);
       }
       async delete(host, port) {
         const key = hostKey(host, port);
@@ -611,7 +661,7 @@ var init_remotes_store = __esm({
           return false;
         }
         delete this.data.entries[key];
-        await writeFile4(this.data);
+        await writeFile3(this.data);
         return true;
       }
       list() {
@@ -1172,6 +1222,11 @@ var init_types = __esm({
       importedFromUpstreamSessionId: z3.string().optional(),
       // Set when this session was spawned as a child by a transformer.
       parentSessionId: z3.string().optional(),
+      // Local-fork breadcrumbs set by hydra-acp/fork_session. Distinct from
+      // the imported* family above: a fork is a local branch off another
+      // local session, an import is a cross-machine takeover.
+      forkedFromSessionId: z3.string().optional(),
+      forkedFromMessageId: z3.string().optional(),
       // clientInfo from the process that issued session/new. Lets list views
       // hide cat-style ancillary sessions by default while letting an
       // override flag surface them.
@@ -2386,6 +2441,8 @@ var init_session = __esm({
       agentCapabilities;
       agentArgs;
       parentSessionId;
+      forkedFromSessionId;
+      forkedFromMessageId;
       originatingClient;
       title;
       // Snapshot state delivered to attaching clients via the attach
@@ -2414,6 +2471,13 @@ var init_session = __esm({
       // enqueue) and leave the file out of sync with in-memory state.
       queueWriteChain = Promise.resolve();
       closed = false;
+      // Set true at the start of close() / markClosed before any await yields.
+      // drainQueue checks this between iterations and bails out, so a queued
+      // entry can't be promoted to currentEntry (with its prompt_received and
+      // synthesized turn_complete(interrupted)) while the session is tearing
+      // down. markClosed sweeps the remaining queue with the normal abandoned
+      // / cancelled handling.
+      closing = false;
       closeHandlers = [];
       titleHandlers = [];
       // Subscribers notified after every entry that's actually persisted to
@@ -2541,6 +2605,8 @@ var init_session = __esm({
         this.agentCapabilities = init.agentCapabilities;
         this.agentArgs = init.agentArgs;
         this.parentSessionId = init.parentSessionId;
+        this.forkedFromSessionId = init.forkedFromSessionId;
+        this.forkedFromMessageId = init.forkedFromMessageId;
         this.originatingClient = init.originatingClient;
         this.title = init.title;
         this.currentModel = init.currentModel;
@@ -3649,6 +3715,7 @@ var init_session = __esm({
         if (this.closed) {
           return;
         }
+        this.closing = true;
         this.logger?.info(
           `session ${this.sessionId} closing deleteRecord=${opts.deleteRecord ?? false} regenTitle=${opts.regenTitle ?? false}`
         );
@@ -4780,21 +4847,22 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         if (this.closed) {
           return;
         }
+        this.closing = true;
         this.closed = true;
         this.cancelIdleTimer();
         if (this.extensionCommandsUnsub) {
           this.extensionCommandsUnsub();
           this.extensionCommandsUnsub = void 0;
         }
-        if (this.currentEntry?.kind === "user") {
+        if (this.currentEntry?.kind === "user" && !this.recentlyTerminal.has(this.currentEntry.messageId)) {
           this.broadcastTurnComplete(
             this.currentEntry.clientId,
             { stopReason: "interrupted" },
             this.currentEntry.messageId,
             this.currentEntry.wasAmend
           );
-          this.currentEntry = void 0;
         }
+        this.currentEntry = void 0;
         const stranded = this.promptQueue;
         this.promptQueue = [];
         for (const entry of stranded) {
@@ -5123,6 +5191,9 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         await new Promise((r) => setImmediate(r));
         try {
           while (this.promptQueue.length > 0) {
+            if (this.closing) {
+              break;
+            }
             const next = this.promptQueue.shift();
             if (!next) {
               break;
@@ -5557,6 +5628,51 @@ function isExitPlanModeTool(name) {
   const normalised = name.toLowerCase().replace(/[_\s-]/g, "");
   return normalised === "exitplanmode";
 }
+function extractEditDiff(u) {
+  const content = u.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object") {
+        continue;
+      }
+      const b = block;
+      if (b.type !== "diff") {
+        continue;
+      }
+      const oldText = typeof b.oldText === "string" ? b.oldText : void 0;
+      const newText = typeof b.newText === "string" ? b.newText : void 0;
+      if (oldText === void 0 && newText === void 0) {
+        continue;
+      }
+      const path20 = typeof b.path === "string" ? b.path : void 0;
+      return {
+        ...path20 !== void 0 ? { path: path20 } : {},
+        oldText: oldText ?? "",
+        newText: newText ?? ""
+      };
+    }
+  }
+  const rawInput = u.rawInput;
+  if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
+    const r = rawInput;
+    const filePath = typeof r.file_path === "string" ? r.file_path : typeof r.path === "string" ? r.path : void 0;
+    if (typeof r.old_string === "string" && typeof r.new_string === "string") {
+      return {
+        ...filePath !== void 0 ? { path: filePath } : {},
+        oldText: r.old_string,
+        newText: r.new_string
+      };
+    }
+    if (typeof r.content === "string") {
+      return {
+        ...filePath !== void 0 ? { path: filePath } : {},
+        oldText: "",
+        newText: r.content
+      };
+    }
+  }
+  return null;
+}
 function readExitPlanMarkdown(u) {
   const rawInput = u.rawInput;
   if (!rawInput || typeof rawInput !== "object" || Array.isArray(rawInput)) {
@@ -5596,6 +5712,10 @@ function mapToolCall(u) {
   if (rawKind !== void 0) {
     event.rawKind = rawKind;
   }
+  const diff = extractEditDiff(u);
+  if (diff !== null) {
+    event.editDiff = diff;
+  }
   return event;
 }
 function mapToolCallUpdate(u) {
@@ -5606,7 +5726,8 @@ function mapToolCallUpdate(u) {
   const rawTitle = readString(u, "title");
   const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
   const status = readString(u, "status");
-  const meaningful = title !== void 0 || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
+  const diff = extractEditDiff(u);
+  const meaningful = title !== void 0 || diff !== null || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
   if (!meaningful) {
     return null;
   }
@@ -5629,6 +5750,9 @@ function mapToolCallUpdate(u) {
   if (status !== void 0) {
     event.status = status;
   }
+  if (diff !== null) {
+    event.editDiff = diff;
+  }
   if (status === "failed") {
     const errorText = extractToolFailureText(u);
     if (errorText !== null) {
@@ -5949,10 +6073,37 @@ async function listSessions(target, opts = {}, fetchImpl = fetch) {
     title: s.title,
     importedFromMachine: s.importedFromMachine,
     importedFromUpstreamSessionId: s.importedFromUpstreamSessionId,
+    forkedFromSessionId: s.forkedFromSessionId,
+    forkedFromMessageId: s.forkedFromMessageId,
     busy: s.busy,
     originatingClient: s.originatingClient
   }));
 }
+async function forkSession(target, id, opts = {}, fetchImpl = fetch) {
+  const response = await fetchImpl(
+    `${target.baseUrl}/v1/sessions/${id}/fork`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${target.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(opts)
+    }
+  );
+  if (!response.ok) {
+    let detail = "";
+    try {
+      const body = await response.json();
+      if (typeof body.error === "string") {
+        detail = `: ${body.error}`;
+      }
+    } catch {
+    }
+    throw new Error(`fork failed (HTTP ${response.status})${detail}`);
+  }
+  return await response.json();
+}
 async function killSession(target, id, fetchImpl = fetch) {
   const response = await fetchImpl(`${target.baseUrl}/v1/sessions/${id}/kill`, {
     method: "POST",
@@ -6584,13 +6735,25 @@ function applyInlineMarkup(text, opts) {
   s = s.replace(/`([^`]+)`/g, `${codeOpen}$1${codeReset}`);
   return s;
 }
+function headingInlineOptsFor(style) {
+  switch (style) {
+    case "heading-1":
+      return { codeOpen: "^C", boldReset: "^+^Y", codeReset: "^+^Y" };
+    case "heading-2":
+      return { codeOpen: "^Y", boldReset: "^+^C", codeReset: "^+^C" };
+    case "heading-3":
+    default:
+      return { codeOpen: "^C", boldReset: "^:^+", codeReset: "^:^+" };
+  }
+}
 function parseMarkdown(text, opts) {
   const {
     proseStyle,
     highlightCode,
     prefixStyle,
     firstPrefix = "  ",
-    inlineOpts
+    inlineOpts,
+    maxWidth
   } = opts;
   const out = [];
   const lines = text.split("\n");
@@ -6657,7 +6820,12 @@ function parseMarkdown(text, opts) {
       const level = heading[1].length;
       const headingText = heading[2] ?? "";
       const headingStyle = highlightCode ? level === 1 ? "heading-1" : level === 2 ? "heading-2" : "heading-3" : proseStyle;
-      line(headingText, headingStyle, nextPrefix());
+      const headingInlineOpts = highlightCode ? headingInlineOptsFor(headingStyle) : inlineOpts;
+      line(
+        applyInlineMarkup(headingText, headingInlineOpts),
+        headingStyle,
+        nextPrefix()
+      );
       continue;
     }
     const next = lines[i + 1];
@@ -6669,7 +6837,7 @@ function parseMarkdown(text, opts) {
         body.push(parseTableRow(lines[j]));
         j++;
       }
-      const tableLines = formatTable(header, body);
+      const tableLines = formatTable(header, body, maxWidth);
       for (const tl of tableLines) {
         if (prefixStyle !== void 0)
           tl.prefixStyle = prefixStyle;
@@ -6712,8 +6880,12 @@ function parseMarkdown(text, opts) {
     flushCode();
   return out;
 }
-function parseAgentMarkdown(text) {
-  return parseMarkdown(text, { proseStyle: "agent", highlightCode: true });
+function parseAgentMarkdown(text, opts) {
+  return parseMarkdown(text, {
+    proseStyle: "agent",
+    highlightCode: true,
+    maxWidth: opts?.maxWidth
+  });
 }
 function parseThoughtMarkdown(text) {
   return parseMarkdown(text, {
@@ -6744,45 +6916,238 @@ function isTableSeparatorLine(line) {
   }
   return cells.every((c) => /^:?-+:?$/.test(c));
 }
-function cellVisibleWidth(cell, asLiteral) {
-  if (asLiteral) {
-    return stringWidth(cell);
-  }
+function cellVisibleWidth(cell) {
   const visible = cell.replace(/\*\*(.+?)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1");
   return stringWidth(visible);
 }
-function formatTable(header, body) {
+function tokenizeCell(cell) {
+  const atoms = [];
+  let i = 0;
+  while (i < cell.length) {
+    const ch = cell[i];
+    if (ch === " " || ch === "	") {
+      let j2 = i;
+      while (j2 < cell.length && (cell[j2] === " " || cell[j2] === "	")) {
+        j2++;
+      }
+      const text = cell.slice(i, j2);
+      atoms.push({ text, isWS: true, width: stringWidth(text) });
+      i = j2;
+      continue;
+    }
+    let word = "";
+    let j = i;
+    while (j < cell.length) {
+      const c = cell[j];
+      if (c === " " || c === "	") {
+        break;
+      }
+      if (cell[j] === "*" && cell[j + 1] === "*") {
+        const close = cell.indexOf("**", j + 2);
+        if (close === -1) {
+          word += "**";
+          j += 2;
+        } else {
+          word += cell.slice(j, close + 2);
+          j = close + 2;
+        }
+        continue;
+      }
+      if (c === "`") {
+        const close = cell.indexOf("`", j + 1);
+        if (close === -1) {
+          word += "`";
+          j += 1;
+        } else {
+          word += cell.slice(j, close + 1);
+          j = close + 1;
+        }
+        continue;
+      }
+      word += c;
+      j += 1;
+    }
+    atoms.push({ text: word, isWS: false, width: cellVisibleWidth(word) });
+    i = j;
+  }
+  return atoms;
+}
+function hardBreak(text, width) {
+  const out = [];
+  let current = "";
+  let currentWidth = 0;
+  for (const ch of text) {
+    const w = stringWidth(ch);
+    if (currentWidth > 0 && currentWidth + w > width) {
+      out.push(current);
+      current = ch;
+      currentWidth = w;
+    } else {
+      current += ch;
+      currentWidth += w;
+    }
+  }
+  if (current.length > 0) {
+    out.push(current);
+  }
+  return out;
+}
+function wrapCellAtoms(atoms, width) {
+  if (width <= 0) {
+    return atoms.length === 0 ? [""] : [atoms.map((a) => a.text).join("")];
+  }
+  const lines = [];
+  let current = "";
+  let currentWidth = 0;
+  const flush = () => {
+    lines.push(current.replace(/[ \t]+$/, ""));
+    current = "";
+    currentWidth = 0;
+  };
+  for (const atom of atoms) {
+    if (atom.isWS) {
+      if (currentWidth === 0) {
+        continue;
+      }
+      current += atom.text;
+      currentWidth += atom.width;
+      continue;
+    }
+    if (atom.width > width) {
+      if (currentWidth > 0) {
+        flush();
+      }
+      const hasMarkup = atom.text.includes("**") || atom.text.includes("`");
+      if (hasMarkup) {
+        lines.push(atom.text);
+      } else {
+        const fragments = hardBreak(atom.text, width);
+        for (let k = 0; k < fragments.length - 1; k++) {
+          lines.push(fragments[k]);
+        }
+        const last = fragments[fragments.length - 1] ?? "";
+        current = last;
+        currentWidth = stringWidth(last);
+      }
+      continue;
+    }
+    if (currentWidth === 0) {
+      current = atom.text;
+      currentWidth = atom.width;
+      continue;
+    }
+    if (currentWidth + atom.width > width) {
+      flush();
+      current = atom.text;
+      currentWidth = atom.width;
+    } else {
+      current += atom.text;
+      currentWidth += atom.width;
+    }
+  }
+  if (current.length > 0 || lines.length === 0) {
+    flush();
+  }
+  return lines;
+}
+function distributeColumnWidths(natural, budget) {
+  const cols = natural.length;
+  const total = natural.reduce((a, b) => a + b, 0);
+  if (total <= budget) {
+    return natural.slice();
+  }
+  const widths = natural.map((n) => Math.min(n, TABLE_MIN_COL));
+  let used = widths.reduce((a, b) => a + b, 0);
+  if (used >= budget) {
+    return widths;
+  }
+  const remaining = budget - used;
+  const shrinkable = natural.map((n, i) => ({ i, slack: Math.max(0, n - widths[i]) })).filter((e) => e.slack > 0);
+  const shrinkableTotal = shrinkable.reduce((a, b) => a + b.slack, 0);
+  if (shrinkableTotal === 0) {
+    return widths;
+  }
+  for (const e of shrinkable) {
+    const add = Math.floor(remaining * e.slack / shrinkableTotal);
+    widths[e.i] = widths[e.i] + Math.min(add, e.slack);
+  }
+  used = widths.reduce((a, b) => a + b, 0);
+  let leftover = budget - used;
+  while (leftover > 0) {
+    let bestIdx = -1;
+    let bestDeficit = 0;
+    for (let i = 0; i < cols; i++) {
+      const deficit = natural[i] - widths[i];
+      if (deficit > bestDeficit) {
+        bestDeficit = deficit;
+        bestIdx = i;
+      }
+    }
+    if (bestIdx < 0) {
+      break;
+    }
+    widths[bestIdx] = widths[bestIdx] + 1;
+    leftover--;
+  }
+  return widths;
+}
+function formatTable(header, body, maxWidth) {
   const cols = header.length;
-  const widths = new Array(cols).fill(0);
+  const natural = new Array(cols).fill(0);
   for (let c = 0; c < cols; c++) {
-    widths[c] = cellVisibleWidth(header[c] ?? "", true);
+    natural[c] = cellVisibleWidth(header[c] ?? "");
   }
   for (const row of body) {
     for (let c = 0; c < cols; c++) {
       const cell = row[c] ?? "";
-      const w = cellVisibleWidth(cell, false);
-      if (w > widths[c]) {
-        widths[c] = w;
+      const w = cellVisibleWidth(cell);
+      if (w > natural[c]) {
+        natural[c] = w;
       }
     }
   }
-  const renderRow = (cells, style, applyMarkup) => {
-    const padded = [];
+  let widths = natural.slice();
+  if (maxWidth !== void 0) {
+    const budget = Math.max(
+      cols * TABLE_MIN_COL,
+      maxWidth - TABLE_PREFIX_WIDTH - (cols - 1) * TABLE_SEP_WIDTH
+    );
+    widths = distributeColumnWidths(natural, budget);
+  }
+  const renderRow = (cells, style, inlineOpts) => {
+    const wrapped = [];
+    let rowHeight = 1;
     for (let c = 0; c < cols; c++) {
       const cell = cells[c] ?? "";
       const w = widths[c];
-      const visible = cellVisibleWidth(cell, !applyMarkup);
-      const rendered = applyMarkup ? applyInlineMarkup(cell) : cell;
-      padded.push(rendered + " ".repeat(Math.max(0, w - visible)));
+      const lines = wrapCellAtoms(tokenizeCell(cell), w);
+      wrapped.push(lines);
+      if (lines.length > rowHeight) {
+        rowHeight = lines.length;
+      }
+    }
+    const out2 = [];
+    for (let r = 0; r < rowHeight; r++) {
+      const padded = [];
+      for (let c = 0; c < cols; c++) {
+        const cellLine = wrapped[c][r] ?? "";
+        const w = widths[c];
+        const visible = cellVisibleWidth(cellLine);
+        const rendered = applyInlineMarkup(cellLine, inlineOpts);
+        padded.push(rendered + " ".repeat(Math.max(0, w - visible)));
+      }
+      out2.push({
+        prefix: "  ",
+        body: padded.join(" \u2502 "),
+        bodyStyle: style
+      });
     }
-    return {
-      prefix: "  ",
-      body: padded.join(" \u2502 "),
-      bodyStyle: style
-    };
+    return out2;
   };
   const out = [];
-  out.push(renderRow(header, "heading-3", false));
+  out.push(
+    ...renderRow(header, "heading-3", headingInlineOptsFor("heading-3"))
+  );
   const rules = [];
   for (let c = 0; c < cols; c++) {
     rules.push("\u2500".repeat(widths[c]));
@@ -6793,7 +7158,7 @@ function formatTable(header, body) {
     bodyStyle: "dim"
   });
   for (const row of body) {
-    out.push(renderRow(row, "agent", true));
+    out.push(...renderRow(row, "agent"));
   }
   return out;
 }
@@ -6811,6 +7176,7 @@ function highlightFencedBlock(lang, lines) {
   } catch {
     return lines.map((body) => ({ body, ansi: false }));
   }
+  highlighted = highlighted.replace(/\x1b\[39m/g, "\x1B[37m");
   const out = highlighted.split("\n");
   if (out.length !== lines.length) {
     return lines.map((body) => ({ body, ansi: false }));
@@ -6875,6 +7241,97 @@ function formatToolLine2(state) {
   }
   return lines;
 }
+function formatEditDiffBlock(diff, mode) {
+  const lines = [];
+  if (diff.path) {
+    lines.push({
+      prefix: "  ",
+      body: `\u25B8 Edited ${sanitizeSingleLine(shortenHomePath(diff.path))}`,
+      bodyStyle: "dim"
+    });
+  }
+  if (mode === "edit") {
+    return lines;
+  }
+  const body = buildUnifiedDiff(diff);
+  if (body.length === 0) {
+    return lines;
+  }
+  const fenced = "```diff\n" + body + "\n```";
+  lines.push(...parseAgentMarkdown(fenced));
+  return lines;
+}
+function buildUnifiedDiff(diff) {
+  const oldLines = sanitizeWireText(diff.oldText).split("\n");
+  const newLines = sanitizeWireText(diff.newText).split("\n");
+  if (oldLines.length > 0 && oldLines[oldLines.length - 1] === "") {
+    oldLines.pop();
+  }
+  if (newLines.length > 0 && newLines[newLines.length - 1] === "") {
+    newLines.pop();
+  }
+  const ops = diffLines(oldLines, newLines);
+  const rendered = [];
+  for (let idx = 0; idx < ops.length; idx++) {
+    const op = ops[idx];
+    const wouldTruncate = rendered.length >= EDIT_DIFF_MAX_LINES - 1 && idx < ops.length - 1;
+    if (wouldTruncate) {
+      const remaining = ops.length - idx;
+      rendered.push(`\u2026 ${remaining} more line${remaining === 1 ? "" : "s"}`);
+      break;
+    }
+    if (op.op === "=") {
+      rendered.push(`  ${op.text}`);
+    } else if (op.op === "-") {
+      rendered.push(`- ${op.text}`);
+    } else {
+      rendered.push(`+ ${op.text}`);
+    }
+  }
+  return rendered.join("\n");
+}
+function diffLines(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => new Array(n + 1).fill(0)
+  );
+  for (let i2 = m - 1; i2 >= 0; i2--) {
+    for (let j2 = n - 1; j2 >= 0; j2--) {
+      if (a[i2] === b[j2]) {
+        dp[i2][j2] = dp[i2 + 1][j2 + 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+      }
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    if (a[i] === b[j]) {
+      out.push({ op: "=", text: a[i] });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      out.push({ op: "-", text: a[i] });
+      i++;
+    } else {
+      out.push({ op: "+", text: b[j] });
+      j++;
+    }
+  }
+  while (i < m) {
+    out.push({ op: "-", text: a[i] });
+    i++;
+  }
+  while (j < n) {
+    out.push({ op: "+", text: b[j] });
+    j++;
+  }
+  return out;
+}
 function toolStatusIcon(status) {
   switch (status) {
     case "completed":
@@ -7016,11 +7473,15 @@ function toolStatusStyle(status) {
       return "tool-status-pending";
   }
 }
-var highlightChalk, HIGHLIGHT_THEME;
+var TABLE_MIN_COL, TABLE_PREFIX_WIDTH, TABLE_SEP_WIDTH, highlightChalk, HIGHLIGHT_THEME, EDIT_DIFF_MAX_LINES;
 var init_format = __esm({
   "src/tui/format.ts"() {
     "use strict";
+    init_paths();
     init_render_update();
+    TABLE_MIN_COL = 6;
+    TABLE_PREFIX_WIDTH = 2;
+    TABLE_SEP_WIDTH = 3;
     highlightChalk = new chalk2.Instance({ level: 3 });
     HIGHLIGHT_THEME = {
       keyword: highlightChalk.blueBright,
@@ -7046,6 +7507,7 @@ var init_format = __esm({
       tag: highlightChalk.cyan,
       name: highlightChalk.cyanBright
     };
+    EDIT_DIFF_MAX_LINES = 40;
   }
 });
 
@@ -7140,10 +7602,17 @@ var init_update_check = __esm({
 });
 
 // src/tui/input.ts
-var InputDispatcher;
+function formatPasteToken(id, lineCount) {
+  return `[pasted #${id} +${lineCount} lines]`;
+}
+var PASTE_LINE_THRESHOLD, PASTE_TOKEN_RE, PASTE_TOKEN_LEFT_RE, PASTE_TOKEN_RIGHT_RE, InputDispatcher;
 var init_input = __esm({
   "src/tui/input.ts"() {
     "use strict";
+    PASTE_LINE_THRESHOLD = 10;
+    PASTE_TOKEN_RE = /\[pasted #(\d+) \+\d+ lines\]/g;
+    PASTE_TOKEN_LEFT_RE = /\[pasted #(\d+) \+\d+ lines\]$/;
+    PASTE_TOKEN_RIGHT_RE = /^\[pasted #(\d+) \+\d+ lines\]/;
     InputDispatcher = class {
       buffer = [""];
       row = 0;
@@ -7185,9 +7654,23 @@ var init_input = __esm({
       // queue slots (which may carry their own attachments — though we
       // don't surface that yet) shouldn't blend with the current draft's.
       savedAttachments = null;
+      // Map of paste id → original text for placeholder tokens currently in
+      // the buffer (or recoverable via history walks within this session).
+      // Persists across sends — never cleared by clearBuffer/setBuffer, so
+      // up-arrow recall of a placeholder can still reanimate on resubmit.
+      pastes = /* @__PURE__ */ new Map();
+      nextPasteId = 1;
+      collapsePastes;
       constructor(opts = {}) {
         this.history = [...opts.history ?? []];
         this.planMode = opts.planMode ?? false;
+        this.collapsePastes = opts.collapsePastes ?? true;
+      }
+      // Buffer text with paste placeholders expanded back to their original
+      // content. Used by callers that bypass the send/amend effects (e.g.
+      // picker.ts reads composer text directly).
+      expandedText() {
+        return this.expandPastes(this.bufferText());
       }
       state() {
         return {
@@ -7296,7 +7779,14 @@ var init_input = __esm({
           return [];
         }
         if (event.type === "paste") {
-          this.insertText(event.text);
+          const lineCount = event.text.split("\n").length;
+          if (this.collapsePastes && lineCount > PASTE_LINE_THRESHOLD) {
+            const id = this.nextPasteId++;
+            this.pastes.set(id, event.text);
+            this.insertText(formatPasteToken(id, lineCount));
+          } else {
+            this.insertText(event.text);
+          }
           return [];
         }
         if (event.type === "attachment-paths") {
@@ -7420,6 +7910,16 @@ var init_input = __esm({
       bufferText() {
         return this.buffer.join("\n");
       }
+      // Substitute every [pasted #N +M lines] token with its stored original
+      // text. Unknown ids (orphaned placeholders from outside this process)
+      // are left as the literal token string — the safe fallback.
+      expandPastes(text) {
+        return text.replace(PASTE_TOKEN_RE, (match, idStr) => {
+          const id = parseInt(idStr, 10);
+          const stored = this.pastes.get(id);
+          return stored !== void 0 ? stored : match;
+        });
+      }
       bufferIsEmpty() {
         return this.buffer.length === 1 && this.buffer[0] === "";
       }
@@ -7476,6 +7976,16 @@ var init_input = __esm({
       backspace() {
         if (this.col > 0) {
           const line = this.currentLine();
+          const before = line.slice(0, this.col);
+          const m = before.match(PASTE_TOKEN_LEFT_RE);
+          if (m !== null) {
+            this.pastes.delete(parseInt(m[1], 10));
+            this.setCurrentLine(
+              line.slice(0, this.col - m[0].length) + line.slice(this.col)
+            );
+            this.col -= m[0].length;
+            return;
+          }
           this.setCurrentLine(line.slice(0, this.col - 1) + line.slice(this.col));
           this.col -= 1;
           return;
@@ -7493,6 +8003,15 @@ var init_input = __esm({
       deleteForward() {
         const line = this.currentLine();
         if (this.col < line.length) {
+          const after = line.slice(this.col);
+          const m = after.match(PASTE_TOKEN_RIGHT_RE);
+          if (m !== null) {
+            this.pastes.delete(parseInt(m[1], 10));
+            this.setCurrentLine(
+              line.slice(0, this.col) + line.slice(this.col + m[0].length)
+            );
+            return;
+          }
           this.setCurrentLine(line.slice(0, this.col) + line.slice(this.col + 1));
           return;
         }
@@ -7567,6 +8086,15 @@ var init_input = __esm({
           this.backspace();
           return;
         }
+        const before = line.slice(0, this.col);
+        const m = before.match(PASTE_TOKEN_LEFT_RE);
+        if (m !== null) {
+          this.killBuffer = m[0];
+          const i2 = this.col - m[0].length;
+          this.setCurrentLine(line.slice(0, i2) + line.slice(this.col));
+          this.col = i2;
+          return;
+        }
         let i = this.col;
         while (i > 0 && /\s/.test(line[i - 1] ?? "")) {
           i -= 1;
@@ -7589,6 +8117,12 @@ var init_input = __esm({
       }
       moveLeft() {
         if (this.col > 0) {
+          const before = this.currentLine().slice(0, this.col);
+          const m = before.match(PASTE_TOKEN_LEFT_RE);
+          if (m !== null) {
+            this.col -= m[0].length;
+            return;
+          }
           this.col -= 1;
           return;
         }
@@ -7598,7 +8132,14 @@ var init_input = __esm({
         }
       }
       moveRight() {
-        if (this.col < this.currentLine().length) {
+        const line = this.currentLine();
+        if (this.col < line.length) {
+          const after = line.slice(this.col);
+          const m = after.match(PASTE_TOKEN_RIGHT_RE);
+          if (m !== null) {
+            this.col += m[0].length;
+            return;
+          }
           this.col += 1;
           return;
         }
@@ -7621,6 +8162,12 @@ var init_input = __esm({
         while (i > 0 && /\s/.test(line[i - 1] ?? "")) {
           i -= 1;
         }
+        const before = line.slice(0, i);
+        const m = before.match(PASTE_TOKEN_LEFT_RE);
+        if (m !== null) {
+          this.col = i - m[0].length;
+          return;
+        }
         while (i > 0 && !/\s/.test(line[i - 1] ?? "")) {
           i -= 1;
         }
@@ -7640,6 +8187,12 @@ var init_input = __esm({
         while (i < line.length && /\s/.test(line[i] ?? "")) {
           i += 1;
         }
+        const after = line.slice(i);
+        const m = after.match(PASTE_TOKEN_RIGHT_RE);
+        if (m !== null) {
+          this.col = i + m[0].length;
+          return;
+        }
         while (i < line.length && !/\s/.test(line[i] ?? "")) {
           i += 1;
         }
@@ -7890,7 +8443,8 @@ var init_input = __esm({
         this.col = (this.buffer[this.row] ?? "").length;
       }
       send() {
-        const text = this.bufferText();
+        const displayText = this.bufferText();
+        const text = this.expandPastes(displayText);
         if (this.queueIndex >= 0 && this.queueIndex < this.queue.length) {
           const index = this.queueIndex;
           const attachments2 = [...this.attachments];
@@ -7898,7 +8452,7 @@ var init_input = __esm({
           if (text.trim().length === 0) {
             return [{ type: "queue-remove", index }];
           }
-          return [{ type: "queue-edit", index, text, attachments: attachments2 }];
+          return [{ type: "queue-edit", index, text, displayText, attachments: attachments2 }];
         }
         if (text.trim().length === 0 && this.attachments.length === 0) {
           return [];
@@ -7906,7 +8460,7 @@ var init_input = __esm({
         const planMode = this.planMode;
         const attachments = [...this.attachments];
         this.clearBuffer();
-        return [{ type: "send", text, planMode, attachments }];
+        return [{ type: "send", text, displayText, planMode, attachments }];
       }
       // Shift+Enter (also Ctrl+Enter / ^S): amend the in-flight turn.
       // While editing a queued slot, this is the "drop and amend" chord:
@@ -7918,7 +8472,8 @@ var init_input = __esm({
       // whether to route the amend through amend_prompt or fall through to
       // a regular send when no turn is in flight.
       amend() {
-        const text = this.bufferText();
+        const displayText = this.bufferText();
+        const text = this.expandPastes(displayText);
         if (this.queueIndex >= 0 && this.queueIndex < this.queue.length) {
           const index = this.queueIndex;
           const planMode2 = this.planMode;
@@ -7930,7 +8485,7 @@ var init_input = __esm({
           }
           return [
             { type: "queue-remove", index },
-            { type: "amend", text, planMode: planMode2, attachments: attachments2 }
+            { type: "amend", text, displayText, planMode: planMode2, attachments: attachments2 }
           ];
         }
         if (text.trim().length === 0 && this.attachments.length === 0) {
@@ -7939,7 +8494,7 @@ var init_input = __esm({
         const planMode = this.planMode;
         const attachments = [...this.attachments];
         this.clearBuffer();
-        return [{ type: "amend", text, planMode, attachments }];
+        return [{ type: "amend", text, displayText, planMode, attachments }];
       }
       // Home: jump to the very start of the prompt buffer. If we're already
       // there, fall through to scrolling the scrollback to its top.
@@ -8248,6 +8803,9 @@ function writeBodyWithHighlight(termObj, text, style, term, activeCol = null, _a
     i = next + term.length;
   }
 }
+function bodyStyleUsesMarkup(style) {
+  return style === "agent" || style === "heading-1" || style === "heading-2" || style === "heading-3";
+}
 function writeStyled(term, text, style) {
   if (text.length === 0) {
     return;
@@ -8299,16 +8857,16 @@ function writeStyled(term, text, style) {
       term.dim.noFormat(text);
       return;
     case "code":
-      term.bgColorGrayscale.brightCyan.noFormat(28, text);
+      term.bgColorGrayscale.white.noFormat(28, text);
       return;
     case "heading-1":
-      term.bold.brightYellow.noFormat(text);
+      term.bold.brightYellow(text);
       return;
     case "heading-2":
-      term.bold.brightCyan.noFormat(text);
+      term.bold.brightCyan(text);
       return;
     case "heading-3":
-      term.bold.noFormat(text);
+      term.bold(text);
       return;
     case "search-highlight":
       term.bgBrightYellow.black.noFormat(text);
@@ -9343,6 +9901,14 @@ uncaught: ${err.stack ?? err.message}
           this.pasteActive = true;
         }
       }
+      // Current terminal column count. Markdown rendering (parseAgentMarkdown,
+      // tables in particular) consults this so a too-wide block lays out
+      // narrowly enough that the screen-layer wrap is a no-op. Returns 0 if the
+      // terminal hasn't reported a width yet, in which case callers should fall
+      // back to natural-width formatting.
+      width() {
+        return this.term.width || 0;
+      }
       appendLines(lines) {
         if (lines.length === 0) {
           return;
@@ -10880,7 +11446,7 @@ uncaught: ${err.stack ?? err.message}
         }
         const prefix = line.prefix ?? "";
         const room = Math.max(1, width - prefix.length);
-        const stripMarkup = line.bodyStyle === "agent";
+        const stripMarkup = bodyStyleUsesMarkup(line.bodyStyle);
         const chunks = line.ansi ? wrapAnsiBody(line.body, room) : wrap(line.body, room, { stripMarkup });
         const wrapped = [];
         let scanPos = 0;
@@ -10926,7 +11492,7 @@ uncaught: ${err.stack ?? err.message}
           writeStyled(this.term, line.prefix, line.prefixStyle ?? line.bodyStyle);
         }
         const remaining = Math.max(0, width - (line.prefix?.length ?? 0));
-        const stripMarkup = line.bodyStyle === "agent";
+        const stripMarkup = bodyStyleUsesMarkup(line.bodyStyle);
         const bodyText = line.ansi ? line.body : truncate(line.body, remaining, { stripMarkup });
         if (this.scrollbackHighlight !== null && !line.ansi) {
           writeBodyWithHighlight(
@@ -11466,7 +12032,10 @@ async function pickSession(term, opts) {
   let mode = "normal";
   let pendingAction = null;
   let findSubMode = "input";
-  let findComposer = new InputDispatcher({ history: [] });
+  let findComposer = new InputDispatcher({
+    history: [],
+    collapsePastes: false
+  });
   let findResults = [];
   let findTruncated = false;
   let findSelectedIdx = 0;
@@ -12214,7 +12783,10 @@ async function pickSession(term, opts) {
     };
     const focus = { push: pushLayer, pop: popLayer };
     exitFind = () => {
-      findComposer = new InputDispatcher({ history: [] });
+      findComposer = new InputDispatcher({
+        history: [],
+        collapsePastes: false
+      });
       findResults = [];
       findTruncated = false;
       findSelectedIdx = 0;
@@ -12699,7 +13271,7 @@ ${cells}`;
         }
         if (name === "ENTER" || name === "KP_ENTER") {
           cleanup();
-          const text = composer.state().buffer.join("\n");
+          const text = composer.expandedText();
           if (text.trim().length === 0) {
             resolve7({ kind: "new" });
           } else {
@@ -12867,12 +13439,35 @@ ${cells}`;
           resolve7(result);
           return;
         }
-        if ((name === "k" || name === "K") && selectedIdx > 0) {
+        if ((name === "f" || name === "F") && selectedIdx > 0) {
           const session = visible[selectedIdx - 1];
           if (!session) {
             return;
           }
-          pendingAction = {
+          cleanup();
+          const result = {
+            kind: "fork",
+            sourceSessionId: session.sessionId,
+            sourceCwd: session.cwd
+          };
+          if (session.agentId !== void 0) {
+            result.sourceAgentId = session.agentId;
+          }
+          if (session.importedFromMachine !== void 0) {
+            result.sourceImportedFromMachine = session.importedFromMachine;
+          }
+          if (session.upstreamSessionId !== void 0) {
+            result.sourceUpstreamSessionId = session.upstreamSessionId;
+          }
+          resolve7(result);
+          return;
+        }
+        if ((name === "k" || name === "K") && selectedIdx > 0) {
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            return;
+          }
+          pendingAction = {
             sessionId: session.sessionId,
             cwd: session.cwd,
             status: session.status
@@ -13111,7 +13706,7 @@ var init_picker = __esm({
 });
 
 // src/core/cwd.ts
-import * as fs20 from "fs/promises";
+import * as fs19 from "fs/promises";
 import * as path17 from "path";
 async function validateLocalCwd(input) {
   const trimmed = input.trim();
@@ -13121,7 +13716,7 @@ async function validateLocalCwd(input) {
   const resolved = path17.resolve(expandHome(trimmed));
   let stat5;
   try {
-    stat5 = await fs20.stat(resolved);
+    stat5 = await fs19.stat(resolved);
   } catch {
     return { ok: false, reason: `${resolved} does not exist` };
   }
@@ -13130,6 +13725,58 @@ async function validateLocalCwd(input) {
   }
   return { ok: true, path: resolved };
 }
+async function pickInitialLocalCwd(sessionCwd) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (p) => {
+    if (!seen.has(p)) {
+      seen.add(p);
+      candidates.push(p);
+    }
+  };
+  push(sessionCwd);
+  if (sessionCwd.startsWith("/Users/")) {
+    push("/home/" + sessionCwd.slice("/Users/".length));
+  } else if (sessionCwd.startsWith("/home/")) {
+    push("/Users/" + sessionCwd.slice("/home/".length));
+  }
+  for (const candidate of candidates) {
+    try {
+      const stat5 = await fs19.stat(candidate);
+      if (stat5.isDirectory()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function completeLocalPath(input) {
+  const lastSlash = input.lastIndexOf("/");
+  let prefix;
+  let basePrefix;
+  let dirForRead;
+  if (lastSlash === -1) {
+    prefix = "";
+    basePrefix = input;
+    dirForRead = ".";
+  } else {
+    prefix = input.slice(0, lastSlash + 1);
+    basePrefix = input.slice(lastSlash + 1);
+    dirForRead = lastSlash === 0 ? "/" : prefix;
+  }
+  const resolvedDir = path17.resolve(expandHome(dirForRead));
+  let entries;
+  try {
+    const list = await fs19.readdir(resolvedDir, { withFileTypes: true });
+    entries = list.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+  } catch {
+    return { prefix, basePrefix, matches: [] };
+  }
+  const showHidden = basePrefix.startsWith(".");
+  const matches = entries.filter((e) => e.name.startsWith(basePrefix)).filter((e) => showHidden || !e.name.startsWith(".")).map((e) => e.isDir ? `${e.name}/` : e.name).sort();
+  return { prefix, basePrefix, matches };
+}
 var init_cwd = __esm({
   "src/core/cwd.ts"() {
     "use strict";
@@ -13137,10 +13784,54 @@ var init_cwd = __esm({
   }
 });
 
+// src/tui/completion.ts
+function longestCommonPrefix(names) {
+  if (names.length === 0) {
+    return "";
+  }
+  let prefix = names[0] ?? "";
+  for (let i = 1; i < names.length; i++) {
+    const n = names[i] ?? "";
+    let j = 0;
+    while (j < prefix.length && j < n.length && prefix[j] === n[j]) {
+      j += 1;
+    }
+    prefix = prefix.slice(0, j);
+    if (prefix.length === 0) {
+      break;
+    }
+  }
+  return prefix;
+}
+function computeTabCompletion(args) {
+  const { matches, firstLine: firstLine3 } = args;
+  if (matches.length === 0) {
+    return null;
+  }
+  const space = firstLine3.indexOf(" ");
+  const typedPrefix = space === -1 ? firstLine3 : firstLine3.slice(0, space);
+  const tail = space === -1 ? "" : firstLine3.slice(space);
+  if (matches.length === 1) {
+    const name = matches[0] ?? "";
+    const suffix = tail.startsWith(" ") ? "" : " ";
+    return name + suffix + tail;
+  }
+  const commonPrefix = longestCommonPrefix(matches);
+  if (commonPrefix.length <= typedPrefix.length) {
+    return null;
+  }
+  return commonPrefix + tail;
+}
+var init_completion = __esm({
+  "src/tui/completion.ts"() {
+    "use strict";
+  }
+});
+
 // src/tui/import-cwd-prompt.ts
 import * as os6 from "os";
 async function promptForImportCwd(term, session, opts = {}) {
-  const defaultCwd = opts.defaultCwd ?? os6.homedir();
+  const defaultCwd = opts.defaultCwd ?? await pickInitialLocalCwd(session.cwd) ?? os6.homedir();
   resetTerminalModes();
   const shortId2 = stripHydraSessionPrefix(session.sessionId);
   const fromMachine = session.importedFromMachine ?? "another machine";
@@ -13180,11 +13871,11 @@ async function promptForImportCwd(term, session, opts = {}) {
     } else {
       term.moveTo(layout.contentX, layout.contentY + row);
       term.dim.noFormat(
-        " Enter accept \xB7 Esc back \xB7 ^U clear \xB7 ^W kill word"
+        " Enter accept \xB7 Tab complete \xB7 Esc back \xB7 ^U clear"
       );
     }
   };
-  const inputRow = () => 7;
+  const inputRow = () => 6;
   const paintInputRow = (rowOffset) => {
     if (!layout) {
       return;
@@ -13215,7 +13906,7 @@ async function promptForImportCwd(term, session, opts = {}) {
       term.red.noFormat(` ${truncate3(errorLine, layout.contentW - 2)}`);
     } else {
       term.dim.noFormat(
-        " Enter accept \xB7 Esc back \xB7 ^U clear \xB7 ^W kill word"
+        " Enter accept \xB7 Tab complete \xB7 Esc back \xB7 ^U clear"
       );
     }
   };
@@ -13271,6 +13962,32 @@ async function promptForImportCwd(term, session, opts = {}) {
         finish({ kind: "cancel" });
         return;
       }
+      if (name === "TAB") {
+        busy = true;
+        void completeLocalPath(buffer).then((result) => {
+          busy = false;
+          if (result.matches.length === 0) {
+            return;
+          }
+          let next;
+          if (result.matches.length === 1) {
+            next = result.prefix + result.matches[0];
+          } else {
+            const lcp = longestCommonPrefix(result.matches);
+            if (lcp.length <= result.basePrefix.length) {
+              return;
+            }
+            next = result.prefix + lcp;
+          }
+          if (next === buffer) {
+            return;
+          }
+          buffer = next;
+          errorLine = null;
+          repaintInput();
+        });
+        return;
+      }
       if (name === "BACKSPACE") {
         if (buffer.length > 0) {
           buffer = buffer.slice(0, -1);
@@ -13332,13 +14049,14 @@ var init_import_cwd_prompt = __esm({
     init_paths();
     init_session();
     init_cwd();
+    init_completion();
     init_prompt_utils();
   }
 });
 
 // src/tui/clipboard.ts
 import { spawn as nodeSpawn } from "child_process";
-import fs21 from "fs/promises";
+import fs20 from "fs/promises";
 import os7 from "os";
 import path18 from "path";
 async function readClipboard(envIn = {}) {
@@ -13379,7 +14097,7 @@ async function readMacOS(env) {
       return img;
     }
   } catch {
-    await fs21.unlink(tmpPath).catch(() => void 0);
+    await fs20.unlink(tmpPath).catch(() => void 0);
   }
   try {
     const buf = await runCapture(env.spawn, "pbpaste", []);
@@ -13494,9 +14212,9 @@ async function which(env, cmd) {
 }
 async function readFileAsAttachment(p, unlinkAfter) {
   try {
-    const buf = await fs21.readFile(p);
+    const buf = await fs20.readFile(p);
     if (unlinkAfter) {
-      await fs21.unlink(p).catch(() => void 0);
+      await fs20.unlink(p).catch(() => void 0);
     }
     if (buf.length === 0) {
       return { ok: false, reason: "no image on clipboard" };
@@ -13595,50 +14313,6 @@ var init_clipboard = __esm({
   }
 });
 
-// src/tui/completion.ts
-function longestCommonPrefix(names) {
-  if (names.length === 0) {
-    return "";
-  }
-  let prefix = names[0] ?? "";
-  for (let i = 1; i < names.length; i++) {
-    const n = names[i] ?? "";
-    let j = 0;
-    while (j < prefix.length && j < n.length && prefix[j] === n[j]) {
-      j += 1;
-    }
-    prefix = prefix.slice(0, j);
-    if (prefix.length === 0) {
-      break;
-    }
-  }
-  return prefix;
-}
-function computeTabCompletion(args) {
-  const { matches, firstLine: firstLine3 } = args;
-  if (matches.length === 0) {
-    return null;
-  }
-  const space = firstLine3.indexOf(" ");
-  const typedPrefix = space === -1 ? firstLine3 : firstLine3.slice(0, space);
-  const tail = space === -1 ? "" : firstLine3.slice(space);
-  if (matches.length === 1) {
-    const name = matches[0] ?? "";
-    const suffix = tail.startsWith(" ") ? "" : " ";
-    return name + suffix + tail;
-  }
-  const commonPrefix = longestCommonPrefix(matches);
-  if (commonPrefix.length <= typedPrefix.length) {
-    return null;
-  }
-  return commonPrefix + tail;
-}
-var init_completion = __esm({
-  "src/tui/completion.ts"() {
-    "use strict";
-  }
-});
-
 // src/tui/reconnect-state.ts
 function parseReattachResponse(result) {
   const out = {};
@@ -13664,6 +14338,21 @@ function parseReattachResponse(result) {
   }
   return out;
 }
+function shouldDriftSnap(args) {
+  return !args.replayDraining && args.pendingTurns > 0 && args.queueSize === 0 && !args.ownTurnInFlight && !args.hasInFlightHead;
+}
+function computeAttachReconcile(args) {
+  if (args.daemonTurnStartedAt !== void 0) {
+    const delta2 = args.pendingTurns === 0 ? 1 : 0;
+    return {
+      pendingTurnsDelta: delta2,
+      banner: "busy",
+      busySince: args.daemonTurnStartedAt
+    };
+  }
+  const delta = args.pendingTurns > 0 ? -args.pendingTurns : 0;
+  return { pendingTurnsDelta: delta, banner: "ready" };
+}
 var init_reconnect_state = __esm({
   "src/tui/reconnect-state.ts"() {
     "use strict";
@@ -13674,7 +14363,7 @@ var init_reconnect_state = __esm({
 import { appendFileSync, statSync, renameSync } from "fs";
 import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
-import fs22 from "fs/promises";
+import fs21 from "fs/promises";
 import path19 from "path";
 function isReadonlyForbiddenEffect(effect) {
   switch (effect.type) {
@@ -13800,6 +14489,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
   let bufferedEvents = [];
   let applyRenderEvent = null;
   let teardownStarted = false;
+  let replayDraining = false;
   const appendRender = (event) => {
     if (!event) {
       return;
@@ -14002,7 +14692,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         echo.flushed = true;
         appendRender({
           kind: "user-text",
-          text: echo.text,
+          text: echo.displayText,
           attachments: echo.attachments
         });
         currentTurnEcho = echo;
@@ -14266,23 +14956,26 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
   if (globalHistory.length > config.tui.promptHistoryMaxEntries) {
     globalHistory = globalHistory.slice(globalHistory.length - config.tui.promptHistoryMaxEntries);
   }
+  let displayHistory = [...history];
   const dispatcher = new InputDispatcher({
-    history: buildCombinedHistory(globalHistory, history)
+    history: buildCombinedHistory(globalHistory, displayHistory)
   });
   dispatcherRef = dispatcher;
   let livePeerHistoryRecording = false;
-  const recordHistoryEntry = (entry) => {
+  const recordHistoryEntry = (entry, displayEntry) => {
     const trimmed = entry.replace(/\n+$/, "");
     if (trimmed.length === 0) {
       return;
     }
+    const trimmedDisplay = (displayEntry ?? entry).replace(/\n+$/, "");
     const nextSession = appendEntry(history, trimmed);
     const sessionChanged = nextSession !== history;
     history = nextSession;
+    displayHistory = appendEntry(displayHistory, trimmedDisplay);
     const nextGlobal = appendEntry(globalHistory, trimmed, config.tui.promptHistoryMaxEntries);
     const globalChanged = nextGlobal !== globalHistory;
     globalHistory = nextGlobal;
-    dispatcher.setHistory(buildCombinedHistory(globalHistory, history));
+    dispatcher.setHistory(buildCombinedHistory(globalHistory, displayHistory));
     if (sessionChanged) {
       saveHistory(historyFile, history).catch(() => void 0);
     }
@@ -14692,6 +15385,31 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         resolvedChoice = { choice: choice2, sessions };
         break;
       }
+      if (choice2.kind === "fork") {
+        const decided2 = await runForkFlow(term, target, choice2, sessions);
+        if (decided2.kind === "cancel") {
+          screen.start({ skipFullscreen: true });
+          screen.resumeRepaint();
+          return;
+        }
+        if (decided2.kind === "back") {
+          continue;
+        }
+        const synthetic = {
+          kind: "attach",
+          sessionId: decided2.ctx.sessionId,
+          ...decided2.ctx.agentId ? { agentId: decided2.ctx.agentId } : {}
+        };
+        resolvedChoice = { choice: synthetic, sessions };
+        attachOverrides = {
+          readonly: false,
+          cwd: decided2.ctx.cwd
+        };
+        if (decided2.ctx.importAttachHint !== void 0) {
+          attachOverrides.importAttachHint = decided2.ctx.importAttachHint;
+        }
+        break;
+      }
       const chosen = sessions.find((s) => s.sessionId === choice2.sessionId);
       const isImportedFirstLaunch = chosen !== void 0 && !!chosen.importedFromMachine && !chosen.upstreamSessionId && choice2.readonly !== true;
       if (!isImportedFirstLaunch) {
@@ -14783,16 +15501,16 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     switch (effect.type) {
       case "send":
         if (config.tui.defaultEnterAction === "amend") {
-          amendPrompt(effect.text, effect.attachments);
+          amendPrompt(effect.text, effect.attachments, effect.displayText);
         } else {
-          enqueuePrompt(effect.text, effect.attachments);
+          enqueuePrompt(effect.text, effect.attachments, effect.displayText);
         }
         return;
       case "amend":
         if (config.tui.defaultEnterAction === "amend") {
-          enqueuePrompt(effect.text, effect.attachments);
+          enqueuePrompt(effect.text, effect.attachments, effect.displayText);
         } else {
-          amendPrompt(effect.text, effect.attachments);
+          amendPrompt(effect.text, effect.attachments, effect.displayText);
         }
         return;
       case "queue-edit": {
@@ -14946,7 +15664,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         continue;
       }
       try {
-        const buf = await fs22.readFile(token);
+        const buf = await fs21.readFile(token);
         if (buf.length > MAX_ATTACHMENT_BYTES) {
           screen.notify(
             `image too large (${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)})`
@@ -15044,22 +15762,22 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       refreshQueueDisplay();
     }
   }
-  const enqueuePrompt = (text, attachments) => {
+  const enqueuePrompt = (text, attachments, displayText) => {
     screen.scrollToBottom();
     if (handleBuiltinCommand(text)) {
       return;
     }
-    recordHistoryEntry(text);
-    void runPrompt(text, attachments);
+    recordHistoryEntry(text, displayText);
+    void runPrompt(text, attachments, displayText);
   };
-  const amendPrompt = (text, attachments) => {
+  const amendPrompt = (text, attachments, displayText) => {
     screen.scrollToBottom();
     if (handleBuiltinCommand(text)) {
       return;
     }
-    recordHistoryEntry(text);
+    recordHistoryEntry(text, displayText);
     if (!daemonSupportsAmend || currentHeadMessageId === void 0) {
-      void runPrompt(text, attachments);
+      void runPrompt(text, attachments, displayText);
       return;
     }
     const target2 = currentHeadMessageId;
@@ -15070,7 +15788,12 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     for (const a of attachments) {
       blocks.push({ type: "image", data: a.data, mimeType: a.mimeType });
     }
-    const echo = { text, attachments, flushed: false };
+    const echo = {
+      text,
+      displayText: displayText ?? text,
+      attachments,
+      flushed: false
+    };
     pendingEchoes.push(echo);
     const popEcho = () => {
       const idx = pendingEchoes.indexOf(echo);
@@ -15161,6 +15884,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         toolsBlockEndedAt = null;
         toolsBlockStopReason = null;
         toolsExpanded = false;
+        pendingEditMarks = [];
         screen.clearScrollback();
         return true;
       case "/demo-plan": {
@@ -15256,7 +15980,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         return false;
     }
   };
-  const runPrompt = async (text, attachments) => {
+  const runPrompt = async (text, attachments, displayText) => {
     const userBlocks = [];
     if (text.length > 0) {
       userBlocks.push({ type: "text", text });
@@ -15265,7 +15989,12 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       userBlocks.push({ type: "image", data: a.data, mimeType: a.mimeType });
     }
     adjustPendingTurns(1);
-    const echo = { text, attachments, flushed: false };
+    const echo = {
+      text,
+      displayText: displayText ?? text,
+      attachments,
+      flushed: false
+    };
     pendingEchoes.push(echo);
     let cancelled = false;
     turnInFlight = {
@@ -15351,7 +16080,11 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (agentKey === null) {
       return;
     }
-    const lines = parseAgentMarkdown(agentBuffer);
+    const w = screen.width();
+    const lines = parseAgentMarkdown(
+      agentBuffer,
+      w > 0 ? { maxWidth: w } : void 0
+    );
     if (lines.length === 0) {
       return;
     }
@@ -15460,7 +16193,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     toolsBlockStopReason = null;
     renderToolsBlock();
   };
-  const recordToolCall = (id, title, status, errorText) => {
+  const recordToolCall = (id, title, status, errorText, editDiff) => {
     const wasNew = !toolStates.has(id);
     const existing = toolStates.get(id);
     const state = existing ?? {
@@ -15480,6 +16213,9 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (errorText !== void 0) {
       state.errorText = errorText;
     }
+    if (editDiff !== void 0) {
+      state.editDiff = editDiff;
+    }
     toolStates.set(id, state);
     if (wasNew) {
       if (toolsBlockStartedAt === null) {
@@ -15490,6 +16226,45 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       toolCallOrder.push(id);
     }
   };
+  let pendingEditMarks = [];
+  const maybeRenderEditDiff = (toolCallId) => {
+    const mode = config.tui.showFileUpdates;
+    if (mode === "none") {
+      return;
+    }
+    const state = toolStates.get(toolCallId);
+    if (!state?.editDiff || state.status !== "completed") {
+      return;
+    }
+    if (mode === "diff") {
+      const lines = formatEditDiffBlock(state.editDiff, "diff");
+      if (lines.length > 0) {
+        screen.upsertLines(`editdiff:${toolCallId}`, lines);
+      }
+      return;
+    }
+    pendingEditMarks.push({ toolCallId, diff: state.editDiff });
+  };
+  const flushPendingEditMarks = () => {
+    if (pendingEditMarks.length === 0) {
+      return;
+    }
+    let lastPath = null;
+    for (const { toolCallId, diff } of pendingEditMarks) {
+      if (diff.path && diff.path === lastPath) {
+        continue;
+      }
+      const lines = formatEditDiffBlock(diff, "edit");
+      if (lines.length === 0) {
+        continue;
+      }
+      screen.upsertLines(`editdiff:${toolCallId}`, lines);
+      if (diff.path) {
+        lastPath = diff.path;
+      }
+    }
+    pendingEditMarks = [];
+  };
   applyRenderEvent = (event) => {
     if (event.kind === "available-commands") {
       agentCommands = event.commands;
@@ -15561,17 +16336,22 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       toolCallOrder.length = 0;
       toolsExpanded = false;
       toolsBlockEndedAt = null;
+      pendingEditMarks = [];
       startToolsBlock();
       screen.redraw();
       return;
     }
     if (event.kind === "agent-text") {
       closeThought();
+      flushPendingEditMarks();
       appendAgentText(event.text);
       return;
     }
     if (event.kind === "agent-thought") {
       closeAgentText();
+      if (viewPrefs.showThoughts) {
+        flushPendingEditMarks();
+      }
       appendThought(event.text);
       return;
     }
@@ -15596,8 +16376,15 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     if (event.kind === "tool-call") {
       closeAgentText();
       closeThought();
-      recordToolCall(event.toolCallId, event.title, event.status, void 0);
+      recordToolCall(
+        event.toolCallId,
+        event.title,
+        event.status,
+        void 0,
+        event.editDiff
+      );
       renderToolsBlock();
+      maybeRenderEditDiff(event.toolCallId);
       return;
     }
     if (event.kind === "plan") {
@@ -15617,12 +16404,14 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         event.toolCallId,
         event.title,
         event.status,
-        event.errorText
+        event.errorText,
+        event.editDiff
       );
       if (event.upstreamInterrupted) {
         upstreamInterruptedSeen = true;
       }
       renderToolsBlock();
+      maybeRenderEditDiff(event.toolCallId);
       return;
     }
     if (event.kind === "model-changed") {
@@ -15675,7 +16464,17 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
       toolsBlockStopReason = null;
       toolsExpanded = false;
       upstreamInterruptedSeen = false;
+      pendingEditMarks = [];
       screen.ensureSeparator();
+      if (shouldDriftSnap({
+        pendingTurns,
+        queueSize: queueCache.size,
+        ownTurnInFlight: turnInFlight !== null,
+        hasInFlightHead: currentHeadMessageId !== void 0,
+        replayDraining
+      })) {
+        adjustPendingTurns(-pendingTurns);
+      }
     }
   };
   const buffered = bufferedEvents;
@@ -15687,18 +16486,21 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     }
   }
   screen.pauseRepaint();
+  replayDraining = true;
   try {
     for (const event of buffered) {
       applyRenderEvent(event);
     }
   } finally {
+    replayDraining = false;
     screen.resumeRepaint();
   }
   if (replayedPromptTexts.length > 0) {
     const merged = mergeReplayedEntries(history, replayedPromptTexts);
     if (merged !== history) {
       history = merged;
-      dispatcher.setHistory(buildCombinedHistory(globalHistory, history));
+      displayHistory = mergeReplayedEntries(displayHistory, replayedPromptTexts);
+      dispatcher.setHistory(buildCombinedHistory(globalHistory, displayHistory));
       saveHistory(historyFile, history).catch(() => void 0);
     }
   }
@@ -15747,6 +16549,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
     toolsBlockEndedAt = null;
     toolsBlockStopReason = null;
     toolsExpanded = false;
+    pendingEditMarks = [];
   };
   onDisconnectHook = () => {
     screen.setBanner({ status: "disconnected", elapsedMs: void 0 });
@@ -15832,17 +16635,47 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs, picke
         }
       ]);
     } else {
-      for (const params of buffered2) {
-        handleSessionUpdate(params);
+      replayDraining = true;
+      try {
+        for (const params of buffered2) {
+          handleSessionUpdate(params);
+        }
+      } finally {
+        replayDraining = false;
       }
     }
-    if (fields && fields.turnStartedAt === void 0 && pendingTurns > 0) {
-      adjustPendingTurns(-pendingTurns);
+    if (fields) {
+      const reconcile = computeAttachReconcile({
+        daemonTurnStartedAt: fields.turnStartedAt,
+        pendingTurns
+      });
+      if (reconcile.pendingTurnsDelta !== 0) {
+        adjustPendingTurns(reconcile.pendingTurnsDelta);
+      }
+      if (reconcile.banner === "busy" && reconcile.busySince !== void 0) {
+        sessionBusySince = reconcile.busySince;
+        screen.setBanner({
+          status: "busy",
+          elapsedMs: Date.now() - reconcile.busySince
+        });
+        if (sessionElapsedTimer === null) {
+          sessionElapsedTimer = setInterval(() => {
+            if (sessionBusySince === null || screenRef === null) {
+              return;
+            }
+            screenRef.setBanner({ elapsedMs: Date.now() - sessionBusySince });
+            renderToolsBlock();
+          }, 1e3);
+        }
+      } else {
+        screen.setBanner({ status: "ready", elapsedMs: void 0 });
+      }
+    } else {
+      screen.setBanner({
+        status: pendingTurns > 0 ? "busy" : "ready",
+        elapsedMs: pendingTurns > 0 ? 0 : void 0
+      });
     }
-    screen.setBanner({
-      status: pendingTurns > 0 ? "busy" : "ready",
-      elapsedMs: pendingTurns > 0 ? 0 : void 0
-    });
   };
   conn.onClose((err) => {
     if (err) {
@@ -15906,6 +16739,16 @@ async function resolveSession(term, config, target, opts, pickerPrefs) {
       }
       return newCtx(opts, cwd, config);
     }
+    if (choice.kind === "fork") {
+      const decided = await runForkFlow(term, target, choice, sessions);
+      if (decided.kind === "cancel") {
+        return null;
+      }
+      if (decided.kind === "back") {
+        continue;
+      }
+      return decided.ctx;
+    }
     opts.readonly = choice.readonly === true;
     const chosen = sessions.find((s) => s.sessionId === choice.sessionId);
     const isImportedFirstLaunch = chosen !== void 0 && !!chosen.importedFromMachine && !chosen.upstreamSessionId && !opts.readonly;
@@ -15966,6 +16809,51 @@ async function runImportedFirstLaunchFlow(term, chosen, choice, opts) {
     };
   }
 }
+async function runForkFlow(term, target, choice, sessions) {
+  const source = sessions.find((s) => s.sessionId === choice.sourceSessionId);
+  const isForeignNeverLaunched = !!choice.sourceImportedFromMachine && !choice.sourceUpstreamSessionId;
+  let cwd = choice.sourceCwd;
+  if (isForeignNeverLaunched) {
+    if (!source) {
+      return { kind: "back" };
+    }
+    const cwdResult = await promptForImportCwd(term, source);
+    if (cwdResult.kind === "cancel") {
+      return { kind: "cancel" };
+    }
+    if (cwdResult.kind === "back") {
+      return { kind: "back" };
+    }
+    cwd = cwdResult.path;
+  }
+  let result;
+  try {
+    result = await forkSession(
+      target,
+      choice.sourceSessionId,
+      isForeignNeverLaunched ? { cwd } : {}
+    );
+  } catch (err) {
+    term.red(`
+fork failed: ${err.message}
+`);
+    return { kind: "cancel" };
+  }
+  return {
+    kind: "ctx",
+    ctx: {
+      sessionId: result.sessionId,
+      agentId: choice.sourceAgentId ?? "",
+      cwd,
+      // For foreign-never-launched forks, the daemon stamped the chosen
+      // cwd onto meta.json via the POST body, but the very first attach
+      // still goes through the import-reseed path (upstreamSessionId=""),
+      // and importAttachHint is what makes attachManagerHooks persist
+      // the local cwd over the bundle's recorded one.
+      ...isForeignNeverLaunched ? { importAttachHint: { agentId: choice.sourceAgentId ?? "", cwd } } : {}
+    }
+  };
+}
 function newCtx(opts, cwd, config) {
   return {
     sessionId: "__new__",
@@ -16174,7 +17062,7 @@ var init_tui = __esm({
 // src/cli.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, resolve as resolve6 } from "path";
+import { dirname as dirname7, resolve as resolve6 } from "path";
 
 // src/cli/parse-args.ts
 var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
@@ -16363,7 +17251,7 @@ import { setTimeout as sleep2 } from "timers/promises";
 import chalk from "chalk";
 
 // src/daemon/server.ts
-import * as fs17 from "fs";
+import * as fs16 from "fs";
 import * as fsp8 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -16384,6 +17272,7 @@ import createPinoRoll from "pino-roll";
 
 // src/core/registry.ts
 init_paths();
+init_json_store();
 import * as fs6 from "fs/promises";
 import * as path5 from "path";
 import { z as z2 } from "zod";
@@ -17024,54 +17913,26 @@ var Registry = class {
     return cached2;
   }
   async readDiskCache() {
-    let text;
-    try {
-      text = await fs6.readFile(paths.registryCache(), "utf8");
-    } catch (err) {
-      const e = err;
-      if (e.code === "ENOENT") {
-        return void 0;
-      }
-      throw err;
+    const parsed = await readJsonSafe(
+      paths.registryCache()
+    );
+    if (!parsed || typeof parsed.fetchedAt !== "number" || parsed.data === void 0) {
+      return void 0;
     }
     try {
-      const parsed = JSON.parse(text);
-      if (typeof parsed.fetchedAt !== "number" || parsed.data === void 0) {
-        return void 0;
-      }
       const data = RegistryDocument.parse(parsed.data);
       return { fetchedAt: parsed.fetchedAt, raw: parsed.data, data };
     } catch {
       return void 0;
     }
   }
-  // Atomic write: dump to a sibling temp path, then rename onto the
-  // target. POSIX rename is atomic within a filesystem, so readers
-  // either see the old file or the fully-written new file — never a
-  // truncated middle. This also makes simultaneous writers safe
-  // without a lock file: the loser of the rename race just gets its
-  // version replaced by the winner's.
   async writeDiskCache(cache) {
-    await fs6.mkdir(paths.home(), { recursive: true });
-    const final = paths.registryCache();
-    const tmp = `${final}.tmp-${process.pid}-${randSuffix()}`;
-    const body = JSON.stringify(
-      { fetchedAt: cache.fetchedAt, data: cache.raw },
-      null,
-      2
-    ) + "\n";
-    try {
-      await fs6.writeFile(tmp, body, "utf8");
-      await fs6.rename(tmp, final);
-    } catch (err) {
-      await fs6.unlink(tmp).catch(() => void 0);
-      throw err;
-    }
+    await writeJsonAtomic(paths.registryCache(), {
+      fetchedAt: cache.fetchedAt,
+      data: cache.raw
+    });
   }
 };
-function randSuffix() {
-  return Math.random().toString(36).slice(2, 10);
-}
 function npxPackageBasename(agent) {
   const pkg = agent.distribution.npx?.package;
   if (!pkg) {
@@ -17384,6 +18245,7 @@ init_session();
 
 // src/core/session-store.ts
 init_paths();
+init_json_store();
 import * as fs8 from "fs/promises";
 import * as path6 from "path";
 import { customAlphabet as customAlphabet2 } from "nanoid";
@@ -17469,6 +18331,12 @@ var SessionRecord = z4.object({
   // Set when this session was spawned as a child by a transformer via
   // hydra-acp/spawn_child_session. Points to the spawning session's id.
   parentSessionId: z4.string().optional(),
+  // Set when this session was created by hydra-acp/fork_session.
+  // forkedFromSessionId points to the local source session; forkedFromMessageId
+  // is the resolved forkAt — the messageId of the turn_complete the slice
+  // ended at. Kept so future UI can show "branched from turn N of session X".
+  forkedFromSessionId: z4.string().optional(),
+  forkedFromMessageId: z4.string().optional(),
   // clientInfo from the process that issued session/new. Picker and
   // `sessions list` use this to hide cat-style ancillary sessions by
   // default; carried in meta.json so cold sessions filter the same way.
@@ -17485,30 +18353,21 @@ function assertSafeId(id) {
 var SessionStore = class {
   async write(record) {
     assertSafeId(record.sessionId);
-    await fs8.mkdir(paths.sessionDir(record.sessionId), { recursive: true });
     const full = { version: 1, ...record };
-    await fs8.writeFile(
-      paths.sessionFile(record.sessionId),
-      JSON.stringify(full, null, 2) + "\n",
-      { encoding: "utf8", mode: 384 }
-    );
+    await writeJsonAtomic(paths.sessionFile(record.sessionId), full, {
+      mode: 384
+    });
   }
   async read(sessionId) {
     if (!SESSION_ID_PATTERN.test(sessionId)) {
       return void 0;
     }
-    let raw;
-    try {
-      raw = await fs8.readFile(paths.sessionFile(sessionId), "utf8");
-    } catch (err) {
-      const e = err;
-      if (e.code === "ENOENT") {
-        return void 0;
-      }
-      throw err;
+    const parsed = await readJsonSafe(paths.sessionFile(sessionId));
+    if (parsed === void 0) {
+      return void 0;
     }
     try {
-      return SessionRecord.parse(JSON.parse(raw));
+      return SessionRecord.parse(parsed);
     } catch {
       return void 0;
     }
@@ -17595,6 +18454,8 @@ function recordFromMemorySession(args) {
     agentModels: args.agentModels,
     pendingHistorySync: args.pendingHistorySync,
     parentSessionId: args.parentSessionId,
+    forkedFromSessionId: args.forkedFromSessionId,
+    forkedFromMessageId: args.forkedFromMessageId,
     originatingClient: args.originatingClient,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
@@ -17721,6 +18582,19 @@ var HistoryStore = class {
     }
     return out;
   }
+  // Wait for every pending append/rewrite/compact across all sessions to
+  // settle. Daemon shutdown calls this after closing sessions so the final
+  // turn_complete(interrupted) emitted by markClosed reaches disk before
+  // the process exits — without this, history-replay attaches after a
+  // restart see an unmatched prompt_received and leak pendingTurns on
+  // every client.
+  async flushAll() {
+    const pending = [...this.writeQueues.values()];
+    if (pending.length === 0) {
+      return;
+    }
+    await Promise.allSettled(pending);
+  }
   async delete(sessionId) {
     if (!SESSION_ID_PATTERN2.test(sessionId)) {
       return;
@@ -17756,11 +18630,96 @@ var HistoryStore = class {
     });
     return task$;
   }
-};
+};
+
+// src/core/session-manager.ts
+init_paths();
+init_history();
+
+// src/core/bundle.ts
+import { z as z5 } from "zod";
+var HistoryEntrySchema = z5.object({
+  method: z5.string(),
+  params: z5.unknown(),
+  recordedAt: z5.number()
+});
+var BundleSession = z5.object({
+  // The exporter's local id. Regenerated fresh on import (sessionId is
+  // the local namespace; lineageId is what survives across hops).
+  sessionId: z5.string(),
+  // Required on bundles — the export path backfills if the source
+  // record was written before lineageId existed.
+  lineageId: z5.string(),
+  // The exporter's agent-side session id at export time. Carried so
+  // importers can persist it as a breadcrumb (and, eventually, as the
+  // handle a "connect back to origin" feature would need). Omitted on
+  // bundles whose source record never bound to an agent (e.g. a
+  // re-export of an imported, not-yet-attached session).
+  upstreamSessionId: z5.string().optional(),
+  agentId: z5.string(),
+  cwd: z5.string(),
+  title: z5.string().optional(),
+  currentModel: z5.string().optional(),
+  currentMode: z5.string().optional(),
+  currentUsage: PersistedUsage.optional(),
+  agentCommands: z5.array(PersistedAgentCommand).optional(),
+  agentModes: z5.array(PersistedAgentMode).optional(),
+  createdAt: z5.string(),
+  updatedAt: z5.string()
+});
+var Bundle = z5.object({
+  version: z5.literal(1),
+  exportedAt: z5.string(),
+  exportedFrom: z5.object({
+    hydraVersion: z5.string(),
+    machine: z5.string(),
+    // Externally-reachable name (and optional ":port") for the exporting
+    // daemon, sourced from config.daemon.publicHost (or daemon.host when
+    // non-loopback). Carried so an importer can construct a hydra:// URL
+    // that dials back to the origin — e.g. over Tailscale. Omitted when
+    // the exporter has no routable address; never falls back to loopback.
+    hydraHost: z5.string().optional()
+  }),
+  session: BundleSession,
+  history: z5.array(HistoryEntrySchema),
+  promptHistory: z5.array(z5.string()).optional()
+});
+function encodeBundle(params) {
+  const bundle = {
+    version: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    exportedFrom: {
+      hydraVersion: params.hydraVersion,
+      machine: params.machine,
+      ...params.hydraHost !== void 0 && params.hydraHost.length > 0 ? { hydraHost: params.hydraHost } : {}
+    },
+    session: {
+      sessionId: params.record.sessionId,
+      lineageId: params.record.lineageId,
+      ...params.record.upstreamSessionId ? { upstreamSessionId: params.record.upstreamSessionId } : {},
+      agentId: params.record.agentId,
+      cwd: params.record.cwd,
+      ...params.record.title !== void 0 ? { title: params.record.title } : {},
+      ...params.record.currentModel !== void 0 ? { currentModel: params.record.currentModel } : {},
+      ...params.record.currentMode !== void 0 ? { currentMode: params.record.currentMode } : {},
+      ...params.record.currentUsage !== void 0 ? { currentUsage: params.record.currentUsage } : {},
+      ...params.record.agentCommands !== void 0 ? { agentCommands: params.record.agentCommands } : {},
+      ...params.record.agentModes !== void 0 ? { agentModes: params.record.agentModes } : {},
+      createdAt: params.record.createdAt,
+      updatedAt: params.record.updatedAt
+    },
+    history: params.history
+  };
+  if (params.promptHistory !== void 0) {
+    bundle.promptHistory = params.promptHistory;
+  }
+  return bundle;
+}
+function decodeBundle(raw) {
+  return Bundle.parse(raw);
+}
 
 // src/core/session-manager.ts
-init_paths();
-init_history();
 init_types();
 init_hydra_version();
 init_queue_store();
@@ -18027,6 +18986,8 @@ var SessionManager = class {
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
       originatingClient: params.originatingClient,
+      forkedFromSessionId: params.forkedFromSessionId,
+      forkedFromMessageId: params.forkedFromMessageId,
       extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
@@ -18095,6 +19056,8 @@ var SessionManager = class {
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
       originatingClient: params.originatingClient,
+      forkedFromSessionId: params.forkedFromSessionId,
+      forkedFromMessageId: params.forkedFromMessageId,
       extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
@@ -18445,7 +19408,9 @@ var SessionManager = class {
       agentModels: record.agentModels,
       createdAt: record.createdAt,
       pendingHistorySync: record.pendingHistorySync,
-      originatingClient: record.originatingClient
+      originatingClient: record.originatingClient,
+      forkedFromSessionId: record.forkedFromSessionId,
+      forkedFromMessageId: record.forkedFromMessageId
     };
   }
   async clearPendingHistorySync(sessionId) {
@@ -18546,6 +19511,8 @@ var SessionManager = class {
         currentModel: session.currentModel,
         currentUsage: session.currentUsage,
         parentSessionId: session.parentSessionId,
+        forkedFromSessionId: session.forkedFromSessionId,
+        forkedFromMessageId: session.forkedFromMessageId,
         originatingClient: session.originatingClient,
         updatedAt: used,
         attachedClients: session.attachedCount,
@@ -18576,6 +19543,8 @@ var SessionManager = class {
         importedFromMachine: r.importedFromMachine,
         importedFromUpstreamSessionId: r.importedFromUpstreamSessionId,
         parentSessionId: r.parentSessionId,
+        forkedFromSessionId: r.forkedFromSessionId,
+        forkedFromMessageId: r.forkedFromMessageId,
         originatingClient: r.originatingClient,
         updatedAt: used,
         attachedClients: 0,
@@ -18663,10 +19632,114 @@ var SessionManager = class {
       replaced: false
     };
   }
-  // Write the imported bundle's history.jsonl, prompt-history (if
-  // present), and meta.json. upstreamSessionId is left empty as the
+  // Branch an existing local session into a new one that shares context
+  // up to the chosen turn boundary and diverges from there. Composes the
+  // import pipeline: synthesizes a Bundle from the source's record and
+  // sliced history, mints a fresh lineageId, then writes the new record
+  // via writeImportedRecord with forked* breadcrumbs instead of
+  // imported*. The fork carries upstreamSessionId="" so the first attach
+  // triggers seedFromImport — same wire shape as an imported session.
+  //
+  // forkAt defaults to the messageId of the source's most recent
+  // turn_complete; explicit forkAt must reference a session/update
+  // entry that's present in the source's history.jsonl. Cutting at a
+  // completed turn excludes any in-flight prompt by construction
+  // (history.jsonl is appended serially per session), so no locking
+  // against the live source is needed.
+  //
+  // agentId defaults to the source's agent. Overriding to a different
+  // agent scrubs agent-specific state from the fork (model, mode,
+  // usage, agent-emitted commands/modes/models) so the new agent boots
+  // clean — title and conversation transcript are agent-agnostic and
+  // are kept.
+  async forkSession(sourceSessionId, opts = {}) {
+    const sourceRecord = await this.store.read(sourceSessionId);
+    if (!sourceRecord) {
+      const err = new Error(`source session not found: ${sourceSessionId}`);
+      err.code = JsonRpcErrorCodes.SessionNotFound;
+      throw err;
+    }
+    const targetAgentId = opts.agentId ?? sourceRecord.agentId;
+    const crossAgent = targetAgentId !== sourceRecord.agentId;
+    if (crossAgent) {
+      const def = await this.registry.getAgent(targetAgentId);
+      if (!def) {
+        const err = new Error(
+          `agent ${targetAgentId} not found in registry`
+        );
+        err.code = JsonRpcErrorCodes.AgentNotInstalled;
+        throw err;
+      }
+    }
+    const sourceHistory = await this.histories.load(sourceSessionId).catch(() => []);
+    let cutoffIndex;
+    let forkedAt;
+    if (opts.forkAt !== void 0) {
+      cutoffIndex = findMessageIdIndex(sourceHistory, opts.forkAt);
+      if (cutoffIndex < 0) {
+        const err = new Error(
+          `forkAt messageId not found in source history: ${opts.forkAt}`
+        );
+        err.code = JsonRpcErrorCodes.InvalidParams;
+        throw err;
+      }
+      forkedAt = opts.forkAt;
+    } else {
+      const found = findLastTurnComplete(sourceHistory);
+      if (!found) {
+        const err = new Error(
+          `source session ${sourceSessionId} has no completed turns to fork from`
+        );
+        err.code = JsonRpcErrorCodes.InvalidParams;
+        throw err;
+      }
+      cutoffIndex = found.index;
+      forkedAt = found.messageId;
+    }
+    const slicedHistory = sourceHistory.slice(0, cutoffIndex + 1);
+    const promptHistory = await loadPromptHistorySafely(sourceSessionId);
+    const recordForBundle = {
+      ...sourceRecord,
+      lineageId: generateLineageId(),
+      agentId: targetAgentId,
+      ...crossAgent ? {
+        currentModel: void 0,
+        currentMode: void 0,
+        currentUsage: void 0,
+        agentCommands: void 0,
+        agentModes: void 0,
+        agentModels: void 0
+      } : {}
+    };
+    const bundle = encodeBundle({
+      record: recordForBundle,
+      history: slicedHistory,
+      promptHistory: promptHistory.length > 0 ? promptHistory : void 0,
+      hydraVersion: HYDRA_VERSION,
+      machine: os3.hostname()
+    });
+    const newId = `${HYDRA_SESSION_PREFIX}${generateRawSessionId()}`;
+    await this.writeImportedRecord({
+      sessionId: newId,
+      bundle,
+      cwd: opts.cwd,
+      forkedFromSessionId: sourceSessionId,
+      forkedFromMessageId: forkedAt
+    });
+    return {
+      sessionId: newId,
+      forkedFromSessionId: sourceSessionId,
+      forkedAt
+    };
+  }
+  // Write the imported (or forked) bundle's history.jsonl, prompt-history
+  // (if present), and meta.json. upstreamSessionId is left empty as the
   // marker that the first attach should bootstrap a fresh agent and
-  // run seedFromImport rather than calling session/load.
+  // run seedFromImport rather than calling session/load. When
+  // forkedFromSessionId is set, the record is marked as a local fork
+  // (forked* fields populated) instead of a cross-machine import
+  // (imported* fields populated) — both share the seed-on-first-attach
+  // wire shape but trace differently in list views.
   async writeImportedRecord(args) {
     await this.histories.rewrite(
       args.sessionId,
@@ -18683,14 +19756,20 @@ var SessionManager = class {
       ).catch(() => void 0);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const isFork = args.forkedFromSessionId !== void 0;
     await this.enqueueMetaWrite(args.sessionId, async () => {
       await this.store.write({
         sessionId: args.sessionId,
         lineageId: args.bundle.session.lineageId,
         upstreamSessionId: "",
-        importedFromSessionId: args.bundle.session.sessionId,
-        importedFromUpstreamSessionId: args.bundle.session.upstreamSessionId,
-        importedFromMachine: args.bundle.exportedFrom.machine,
+        ...isFork ? {
+          forkedFromSessionId: args.forkedFromSessionId,
+          forkedFromMessageId: args.forkedFromMessageId
+        } : {
+          importedFromSessionId: args.bundle.session.sessionId,
+          importedFromUpstreamSessionId: args.bundle.session.upstreamSessionId,
+          importedFromMachine: args.bundle.exportedFrom.machine
+        },
         agentId: args.bundle.session.agentId,
         cwd: args.cwd ?? args.bundle.session.cwd,
         title: args.bundle.session.title,
@@ -18824,6 +19903,14 @@ var SessionManager = class {
     }
     await Promise.allSettled(pending);
   }
+  // Wait for every pending history.jsonl write to settle. markClosed
+  // broadcasts turn_complete(interrupted) for the in-flight turn via a
+  // fire-and-forget store.append; without flushing, a SIGTERM can exit
+  // before that append hits disk, leaving an unmatched prompt_received
+  // in history that leaks pendingTurns on every client that replays it.
+  async flushHistoryWrites() {
+    await this.histories.flushAll();
+  }
   // Startup hook: scan persisted sessions for non-empty queue files,
   // apply the TTL, resurrect anything with surviving entries, and
   // replay them through the normal queue path. Called from the daemon
@@ -18922,6 +20009,8 @@ function mergeForPersistence(session, existing) {
     agentModes,
     agentModels,
     parentSessionId: session.parentSessionId ?? existing?.parentSessionId,
+    forkedFromSessionId: session.forkedFromSessionId ?? existing?.forkedFromSessionId,
+    forkedFromMessageId: session.forkedFromMessageId ?? existing?.forkedFromMessageId,
     originatingClient: session.originatingClient ?? existing?.originatingClient,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
@@ -19191,6 +20280,23 @@ function parseModesList(list) {
   }
   return out;
 }
+function findLastTurnComplete(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const entry = history[i];
+    if (!entry || entry.method !== "session/update") {
+      continue;
+    }
+    const update = entry.params?.update;
+    if (update?.sessionUpdate !== "turn_complete") {
+      continue;
+    }
+    if (typeof update.messageId !== "string" || update.messageId.length === 0) {
+      continue;
+    }
+    return { index: i, messageId: update.messageId };
+  }
+  return void 0;
+}
 async function loadPromptHistorySafely(sessionId) {
   try {
     const raw = await fs12.readFile(paths.tuiHistoryFile(sessionId), "utf8");
@@ -20322,9 +21428,9 @@ init_hydra_version();
 
 // src/core/session-tokens.ts
 init_paths();
-import * as fs15 from "fs/promises";
+init_json_store();
 import * as path12 from "path";
-import { createHash, randomBytes, timingSafeEqual } from "crypto";
+import { createHash, randomBytes as randomBytes2, timingSafeEqual } from "crypto";
 var TOKEN_PREFIX = "hydra_session_";
 var DEFAULT_TTL_SEC = 60 * 60 * 24 * 30;
 var ID_LENGTH = 12;
@@ -20337,7 +21443,7 @@ function sha256Hex(input) {
   return createHash("sha256").update(input).digest("hex");
 }
 function randomHex(bytes) {
-  return randomBytes(bytes).toString("hex");
+  return randomBytes2(bytes).toString("hex");
 }
 function generateId() {
   return randomHex(ID_LENGTH).slice(0, ID_LENGTH * 2);
@@ -20357,17 +21463,11 @@ var SessionTokenStore = class _SessionTokenStore {
   }
   static async load() {
     let records = [];
-    try {
-      const raw = await fs15.readFile(tokensFilePath(), "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed && Array.isArray(parsed.records)) {
-        records = parsed.records.filter(isRecord);
-      }
-    } catch (err) {
-      const e = err;
-      if (e.code !== "ENOENT") {
-        throw err;
-      }
+    const parsed = await readJsonSafe(
+      tokensFilePath()
+    );
+    if (parsed && Array.isArray(parsed.records)) {
+      records = parsed.records.filter(isRecord);
     }
     const store = new _SessionTokenStore(records);
     const removed = store.sweepExpired(/* @__PURE__ */ new Date());
@@ -20484,14 +21584,11 @@ var SessionTokenStore = class _SessionTokenStore {
       await this.writeInflight;
     }
     const records = Array.from(this.records.values());
-    const payload = JSON.stringify({ records }, null, 2) + "\n";
-    this.writeInflight = (async () => {
-      await fs15.mkdir(paths.home(), { recursive: true });
-      await fs15.writeFile(tokensFilePath(), payload, {
-        encoding: "utf8",
-        mode: 384
-      });
-    })();
+    this.writeInflight = writeJsonAtomic(
+      tokensFilePath(),
+      { records },
+      { mode: 384 }
+    );
     try {
       await this.writeInflight;
     } finally {
@@ -20661,89 +21758,6 @@ var AuthRateLimiter = class {
 init_config();
 import * as os4 from "os";
 
-// src/core/bundle.ts
-import { z as z5 } from "zod";
-var HistoryEntrySchema = z5.object({
-  method: z5.string(),
-  params: z5.unknown(),
-  recordedAt: z5.number()
-});
-var BundleSession = z5.object({
-  // The exporter's local id. Regenerated fresh on import (sessionId is
-  // the local namespace; lineageId is what survives across hops).
-  sessionId: z5.string(),
-  // Required on bundles — the export path backfills if the source
-  // record was written before lineageId existed.
-  lineageId: z5.string(),
-  // The exporter's agent-side session id at export time. Carried so
-  // importers can persist it as a breadcrumb (and, eventually, as the
-  // handle a "connect back to origin" feature would need). Omitted on
-  // bundles whose source record never bound to an agent (e.g. a
-  // re-export of an imported, not-yet-attached session).
-  upstreamSessionId: z5.string().optional(),
-  agentId: z5.string(),
-  cwd: z5.string(),
-  title: z5.string().optional(),
-  currentModel: z5.string().optional(),
-  currentMode: z5.string().optional(),
-  currentUsage: PersistedUsage.optional(),
-  agentCommands: z5.array(PersistedAgentCommand).optional(),
-  agentModes: z5.array(PersistedAgentMode).optional(),
-  createdAt: z5.string(),
-  updatedAt: z5.string()
-});
-var Bundle = z5.object({
-  version: z5.literal(1),
-  exportedAt: z5.string(),
-  exportedFrom: z5.object({
-    hydraVersion: z5.string(),
-    machine: z5.string(),
-    // Externally-reachable name (and optional ":port") for the exporting
-    // daemon, sourced from config.daemon.publicHost (or daemon.host when
-    // non-loopback). Carried so an importer can construct a hydra:// URL
-    // that dials back to the origin — e.g. over Tailscale. Omitted when
-    // the exporter has no routable address; never falls back to loopback.
-    hydraHost: z5.string().optional()
-  }),
-  session: BundleSession,
-  history: z5.array(HistoryEntrySchema),
-  promptHistory: z5.array(z5.string()).optional()
-});
-function encodeBundle(params) {
-  const bundle = {
-    version: 1,
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    exportedFrom: {
-      hydraVersion: params.hydraVersion,
-      machine: params.machine,
-      ...params.hydraHost !== void 0 && params.hydraHost.length > 0 ? { hydraHost: params.hydraHost } : {}
-    },
-    session: {
-      sessionId: params.record.sessionId,
-      lineageId: params.record.lineageId,
-      ...params.record.upstreamSessionId ? { upstreamSessionId: params.record.upstreamSessionId } : {},
-      agentId: params.record.agentId,
-      cwd: params.record.cwd,
-      ...params.record.title !== void 0 ? { title: params.record.title } : {},
-      ...params.record.currentModel !== void 0 ? { currentModel: params.record.currentModel } : {},
-      ...params.record.currentMode !== void 0 ? { currentMode: params.record.currentMode } : {},
-      ...params.record.currentUsage !== void 0 ? { currentUsage: params.record.currentUsage } : {},
-      ...params.record.agentCommands !== void 0 ? { agentCommands: params.record.agentCommands } : {},
-      ...params.record.agentModes !== void 0 ? { agentModes: params.record.agentModes } : {},
-      createdAt: params.record.createdAt,
-      updatedAt: params.record.updatedAt
-    },
-    history: params.history
-  };
-  if (params.promptHistory !== void 0) {
-    bundle.promptHistory = params.promptHistory;
-  }
-  return bundle;
-}
-function decodeBundle(raw) {
-  return Bundle.parse(raw);
-}
-
 // src/core/transcript.ts
 init_render_update();
 init_session();
@@ -21519,6 +22533,48 @@ function registerSessionRoutes(app, manager, defaults) {
     reply.header("Content-Type", "text/markdown; charset=utf-8");
     reply.code(200).send(bundleToMarkdown(bundle));
   });
+  app.post("/v1/sessions/:id/fork", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const body = request.body ?? {};
+    const opts = {};
+    if (body.forkAt !== void 0) {
+      if (typeof body.forkAt !== "string" || body.forkAt.length === 0) {
+        reply.code(400).send({ error: "forkAt must be a non-empty string" });
+        return;
+      }
+      opts.forkAt = body.forkAt;
+    }
+    if (body.cwd !== void 0) {
+      if (typeof body.cwd !== "string" || body.cwd.length === 0) {
+        reply.code(400).send({ error: "cwd must be a non-empty string" });
+        return;
+      }
+      opts.cwd = expandHome(body.cwd);
+    }
+    if (body.agentId !== void 0) {
+      if (typeof body.agentId !== "string" || body.agentId.length === 0) {
+        reply.code(400).send({ error: "agentId must be a non-empty string" });
+        return;
+      }
+      opts.agentId = body.agentId;
+    }
+    try {
+      const result = await manager.forkSession(id, opts);
+      reply.code(201).send(result);
+    } catch (err) {
+      const e = err;
+      if (e.code === JsonRpcErrorCodes.SessionNotFound) {
+        reply.code(404).send({ error: e.message });
+        return;
+      }
+      if (e.code === JsonRpcErrorCodes.InvalidParams || e.code === JsonRpcErrorCodes.AgentNotInstalled) {
+        reply.code(400).send({ error: e.message });
+        return;
+      }
+      reply.code(500).send({ error: e.message });
+    }
+  });
   app.post("/v1/sessions/import", async (request, reply) => {
     const body = request.body ?? {};
     if (body.bundle === void 0) {
@@ -21964,9 +23020,9 @@ import { z as z6 } from "zod";
 
 // src/core/password.ts
 init_paths();
-import * as fs16 from "fs/promises";
+import * as fs15 from "fs/promises";
 import * as path13 from "path";
-import { randomBytes as randomBytes2, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { randomBytes as randomBytes3, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { promisify } from "util";
 var scryptAsync = promisify(scrypt);
 function passwordHashPath() {
@@ -21982,7 +23038,7 @@ async function setPassword(plaintext) {
   if (typeof plaintext !== "string" || plaintext.length === 0) {
     throw new Error("password must be a non-empty string");
   }
-  const salt = randomBytes2(SALT_LEN);
+  const salt = randomBytes3(SALT_LEN);
   const key = await scryptAsync(plaintext, salt, KEY_LEN, {
     N: DEFAULT_N,
     r: DEFAULT_R,
@@ -21991,15 +23047,15 @@ async function setPassword(plaintext) {
   });
   const encoded = `scrypt$${DEFAULT_N}$${DEFAULT_R}$${DEFAULT_P}$${salt.toString("hex")}$${key.toString("hex")}
 `;
-  await fs16.mkdir(paths.home(), { recursive: true });
-  await fs16.writeFile(passwordHashPath(), encoded, {
+  await fs15.mkdir(paths.home(), { recursive: true });
+  await fs15.writeFile(passwordHashPath(), encoded, {
     encoding: "utf8",
     mode: 384
   });
 }
 async function hasPassword() {
   try {
-    const text = await fs16.readFile(passwordHashPath(), "utf8");
+    const text = await fs15.readFile(passwordHashPath(), "utf8");
     return text.trim().length > 0;
   } catch (err) {
     const e = err;
@@ -22015,7 +23071,7 @@ async function verifyPassword(plaintext) {
   }
   let line;
   try {
-    line = (await fs16.readFile(passwordHashPath(), "utf8")).trim();
+    line = (await fs15.readFile(passwordHashPath(), "utf8")).trim();
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -22142,7 +23198,7 @@ import { nanoid as nanoid2 } from "nanoid";
 import * as os5 from "os";
 import * as path14 from "path";
 init_hydra_version();
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, async (socket, request) => {
     const token = tokenFromUpgradeRequest({
@@ -22339,6 +23395,23 @@ function registerAcpWsEndpoint(app, deps) {
         });
         return { childSessionId: child.sessionId };
       });
+      connection.onRequest("hydra-acp/fork_session", async (raw) => {
+        const params = raw ?? {};
+        if (typeof params.sessionId !== "string") {
+          throw Object.assign(
+            new Error("fork_session requires sessionId"),
+            { code: JsonRpcErrorCodes.InvalidParams }
+          );
+        }
+        const forkAt = typeof params.forkAt === "string" ? params.forkAt : void 0;
+        const cwd = typeof params.cwd === "string" ? params.cwd : void 0;
+        const agentId = typeof params.agentId === "string" ? params.agentId : void 0;
+        return await deps.manager.forkSession(params.sessionId, {
+          ...forkAt !== void 0 ? { forkAt } : {},
+          ...cwd !== void 0 ? { cwd } : {},
+          ...agentId !== void 0 ? { agentId } : {}
+        });
+      });
       connection.onRequest("hydra-acp/await_child", async (raw) => {
         const params = raw ?? {};
         const childSessionId = typeof params.childSessionId === "string" ? params.childSessionId : void 0;
@@ -22413,7 +23486,7 @@ function registerAcpWsEndpoint(app, deps) {
       let stdinReservation;
       let augmentedMcpServers = params.mcpServers;
       if (hydraMeta.mcpStdin === true && deps.mcpTokenRegistry !== void 0 && deps.getDaemonOrigin !== void 0) {
-        stdinToken = randomBytes3(32).toString("hex");
+        stdinToken = randomBytes4(32).toString("hex");
         stdinReservation = deps.mcpTokenRegistry.reserve(stdinToken);
         const url = `${deps.getDaemonOrigin()}/mcp/hydra-acp-stdin`;
         const descriptor = {
@@ -22431,7 +23504,7 @@ function registerAcpWsEndpoint(app, deps) {
       if (deps.extensionMcp !== void 0 && deps.mcpTokenRegistry !== void 0 && deps.getDaemonOrigin !== void 0) {
         const extNames = deps.extensionMcp.list();
         if (extNames.length > 0) {
-          extMcpToken = randomBytes3(32).toString("hex");
+          extMcpToken = randomBytes4(32).toString("hex");
           extMcpReservation = deps.mcpTokenRegistry.reserve(extMcpToken);
           const origin = deps.getDaemonOrigin();
           const descriptors = extNames.map((name) => ({
@@ -23990,12 +25063,13 @@ async function startDaemon(config, serviceToken) {
     await transformers.stop();
     await manager.closeAll();
     await manager.flushMetaWrites();
+    await manager.flushHistoryWrites();
     setBinaryInstallLogger(null);
     setNpmInstallLogger(null);
     setAgentPruneLogger(null);
     await app.close();
     try {
-      fs17.unlinkSync(paths.pidFile());
+      fs16.unlinkSync(paths.pidFile());
     } catch {
     }
     try {
@@ -24045,7 +25119,7 @@ init_daemon_bootstrap();
 init_hydra_version();
 
 // src/cli/commands/log-tail.ts
-import * as fs18 from "fs";
+import * as fs17 from "fs";
 import * as fsp9 from "fs/promises";
 async function runLogTail(logPath, argv, notFoundMessage) {
   const opts = parseLogTailFlags(argv);
@@ -24069,7 +25143,7 @@ async function runLogTail(logPath, argv, notFoundMessage) {
   process.stdout.write(`-- following ${logPath} --
 `);
   let pending = false;
-  const watcher = fs18.watch(logPath, () => {
+  const watcher = fs17.watch(logPath, () => {
     if (pending) {
       return;
     }
@@ -24392,7 +25466,7 @@ init_remote_url();
 init_session();
 init_discovery();
 init_hydra_version();
-import * as fs19 from "fs/promises";
+import * as fs18 from "fs/promises";
 import * as path15 from "path";
 init_session_row();
 async function runSessionsList(opts = {}) {
@@ -24542,8 +25616,8 @@ async function runSessionsExport(id, outPath) {
     return;
   }
   const resolved = outPath === "." ? deriveFilenameFrom(response, id) : outPath;
-  await fs19.mkdir(path15.dirname(path15.resolve(resolved)), { recursive: true });
-  await fs19.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
+  await fs18.mkdir(path15.dirname(path15.resolve(resolved)), { recursive: true });
+  await fs18.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
   process.stdout.write(`Wrote ${resolved}
 `);
 }
@@ -24590,21 +25664,21 @@ async function runSessionsTranscript(idOrFile, outPath) {
     return;
   }
   const resolved = outPath === "." ? defaultName : outPath;
-  await fs19.mkdir(path15.dirname(path15.resolve(resolved)), { recursive: true });
-  await fs19.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
+  await fs18.mkdir(path15.dirname(path15.resolve(resolved)), { recursive: true });
+  await fs18.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
   process.stdout.write(`Wrote ${resolved}
 `);
 }
 async function readBundleFileIfExists(arg) {
   try {
-    const stat5 = await fs19.stat(arg);
+    const stat5 = await fs18.stat(arg);
     if (!stat5.isFile()) {
       return null;
     }
   } catch {
     return null;
   }
-  const text = await fs19.readFile(arg, "utf8");
+  const text = await fs18.readFile(arg, "utf8");
   try {
     return { raw: JSON.parse(text) };
   } catch (err) {
@@ -24633,7 +25707,7 @@ async function runSessionsImport(file, opts = {}) {
   if (opts.cwd !== void 0) {
     const resolved = path15.resolve(opts.cwd);
     try {
-      const stat5 = await fs19.stat(resolved);
+      const stat5 = await fs18.stat(resolved);
       if (!stat5.isDirectory()) {
         process.stderr.write(`--cwd ${resolved} is not a directory
 `);
@@ -24650,7 +25724,7 @@ async function runSessionsImport(file, opts = {}) {
   if (file === "-") {
     body = await readStdin();
   } else {
-    body = await fs19.readFile(file, "utf8");
+    body = await fs18.readFile(file, "utf8");
   }
   let bundle;
   try {
@@ -26676,14 +27750,15 @@ function renderLine(line, mode) {
 }
 var ANSI_BOLD = "\x1B[1m";
 var ANSI_CODE = "\x1B[96m";
+var ANSI_BRIGHT_YELLOW = "\x1B[93m";
 var ANSI_RESET = "\x1B[0m";
 var CARET_SENTINEL = "\0";
 function translateMarkup(text, mode) {
   let s = text.replace(/\^\^/g, CARET_SENTINEL);
   if (mode === "ansi") {
-    s = s.replace(/\^\+/g, ANSI_BOLD).replace(/\^C/g, ANSI_CODE).replace(/\^:/g, ANSI_RESET);
+    s = s.replace(/\^\+/g, ANSI_BOLD).replace(/\^C/g, ANSI_CODE).replace(/\^Y/g, ANSI_BRIGHT_YELLOW).replace(/\^:/g, ANSI_RESET);
   }
-  s = s.replace(/\^[+\-:CcK]/g, "");
+  s = s.replace(/\^[+\-:CcKY]/g, "");
   s = s.replace(/\x00/g, "^");
   return s;
 }
@@ -27730,7 +28805,7 @@ async function resolveSessionFlagOrExit(input, opts) {
 }
 function readVersion() {
   try {
-    const here = dirname6(fileURLToPath2(import.meta.url));
+    const here = dirname7(fileURLToPath2(import.meta.url));
     const pkg = JSON.parse(
       readFileSync2(resolve6(here, "../package.json"), "utf8")
     );