@paradow/ledge 0.0.0-stage → 0.3.0

package/dist/cli/daemon-CGOAUCUO.js

@@ -0,0 +1,1893 @@
+import {
+  reduce
+} from "./chunk-ZPF5I3LS.js";
+import {
+  LEDGE_VERSION
+} from "./chunk-QYQIJW5G.js";
+import {
+  SERVICE
+} from "./chunk-XDRYMOVF.js";
+import {
+  realTmux,
+  run,
+  runFile
+} from "./chunk-7ICDC2LK.js";
+import {
+  log,
+  spawnSession
+} from "./chunk-OUIDBDIH.js";
+import {
+  ensureLedgeDir,
+  paths
+} from "./chunk-6ZTCETRG.js";
+import {
+  DOCUMENT_MAX_BYTES,
+  PROTOCOL_PORT,
+  RecentSchema,
+  SessionSchema,
+  parseClientMessage,
+  pickName
+} from "./chunk-6GMDFIGB.js";
+
+// src/daemon/index.ts
+import { writeFile as writeFile4, rm as rm3 } from "fs/promises";
+
+// src/daemon/store.ts
+import { readFile, writeFile, rename, mkdir } from "fs/promises";
+import { dirname } from "path";
+var MAX_RECENTS = 12;
+var Store = class {
+  sessions = /* @__PURE__ */ new Map();
+  recentList = [];
+  listeners = /* @__PURE__ */ new Set();
+  timer = null;
+  saving = Promise.resolve();
+  journalPath;
+  constructor(opts = {}) {
+    this.journalPath = opts.journalPath ?? paths().journal;
+  }
+  async load() {
+    let raw;
+    try {
+      raw = await readFile(this.journalPath, "utf8");
+    } catch {
+      return;
+    }
+    if (!raw.trim()) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      log(`journal unreadable, starting empty: ${e.message}`);
+      return;
+    }
+    const list = parsed?.sessions;
+    if (!Array.isArray(list)) {
+      log("journal unreadable, starting empty: no sessions array");
+      return;
+    }
+    for (const item of list) {
+      const r = SessionSchema.safeParse(item);
+      if (r.success) this.sessions.set(r.data.id, r.data);
+      else log(`journal entry dropped: ${r.error.issues[0]?.message ?? "invalid"}`);
+    }
+    const recents = parsed?.recents;
+    if (Array.isArray(recents)) {
+      for (const item of recents) {
+        const r = RecentSchema.safeParse(item);
+        if (r.success) this.recentList.push(r.data);
+      }
+      this.recentList = this.recentList.slice(0, MAX_RECENTS);
+    }
+  }
+  all() {
+    return [...this.sessions.values()];
+  }
+  get(id) {
+    return this.sessions.get(id);
+  }
+  /** The folders of past sessions, most recent first. */
+  recents() {
+    return [...this.recentList];
+  }
+  upsert(session) {
+    this.sessions.set(session.id, session);
+    this.emit({ type: "updated", session });
+  }
+  /** Records a session's folder as the most recent one (one entry per folder, `MAX_RECENTS` kept). */
+  touchRecent(cwd, project, at) {
+    this.recentList = [{ cwd, project, lastAt: at }, ...this.recentList.filter((r) => r.cwd !== cwd)].slice(0, MAX_RECENTS);
+    this.emit({ type: "recents", recents: this.recents() });
+  }
+  /** Facts no event carries (the session's repository): the changed fields only, nothing emitted when they are equal. */
+  patch(id, fields) {
+    const cur = this.sessions.get(id);
+    if (!cur) return;
+    if (Object.keys(fields).every((k) => cur[k] === fields[k])) return;
+    this.upsert({ ...cur, ...fields });
+  }
+  apply(id, event) {
+    const cur = this.sessions.get(id);
+    if (!cur) return void 0;
+    const next = reduce(cur, event);
+    if (next === cur) return cur;
+    this.sessions.set(id, next);
+    this.emit({ type: "updated", session: next });
+    return next;
+  }
+  remove(id) {
+    if (!this.sessions.delete(id)) return;
+    this.emit({ type: "removed", id });
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  save() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const run3 = this.saving.then(() => this.write());
+    this.saving = run3.catch(() => void 0);
+    return run3;
+  }
+  async write() {
+    await mkdir(dirname(this.journalPath), { recursive: true });
+    const tmp = `${this.journalPath}.tmp`;
+    await writeFile(tmp, JSON.stringify({ savedAt: (/* @__PURE__ */ new Date()).toISOString(), sessions: this.all(), recents: this.recentList }, null, 2));
+    await rename(tmp, this.journalPath);
+  }
+  emit(c) {
+    for (const l of this.listeners) {
+      try {
+        l(c);
+      } catch (e) {
+        log(`listener failed: ${e.message}`);
+      }
+    }
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.save().catch((e) => log(`journal save failed: ${e.message}`));
+    }, 200);
+  }
+};
+
+// src/daemon/server.ts
+import { basename as basename3 } from "path";
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/adapters/claude.ts
+var OPTION = /^\s*(?:❯\s*)?(\d+)\.\s+(\S.*?)\s*$/;
+var FOOTER = /^\s*(?:(?:Enter to select\b.*)?Esc to cancel\b|ctrl\+g to edit\b)/;
+var PLAN_FOOTER = /^\s*ctrl\+g to edit\b/;
+var REVIEW_QUESTION = /^\s*Ready to submit your answers\?$/;
+var RULE = /^─{10,}$/;
+var DASHED = /^╌{10,}$/;
+var FOOTER_SLACK = 2;
+var isBlank = (l) => l.trim() === "";
+var isRule = (l) => RULE.test(l.trim()) || DASHED.test(l.trim());
+function footerIndex(lines) {
+  let nonBlank = 0;
+  for (let i = lines.length - 1; i >= 0 && nonBlank <= FOOTER_SLACK; i--) {
+    if (isBlank(lines[i])) continue;
+    if (FOOTER.test(lines[i])) return i;
+    nonBlank++;
+  }
+  return -1;
+}
+function reviewEnd(lines) {
+  let last = lines.length - 1;
+  while (last >= 0 && isBlank(lines[last])) last--;
+  if (last < 1 || lines[last].match(OPTION)?.[1] !== "2" || lines[last - 1].match(OPTION)?.[1] !== "1") return -1;
+  let q = last - 2;
+  while (q >= 0 && isBlank(lines[q])) q--;
+  return q >= 0 && REVIEW_QUESTION.test(lines[q]) ? last + 1 : -1;
+}
+function dialogEnd(lines) {
+  const footer = footerIndex(lines);
+  return footer >= 0 ? footer : reviewEnd(lines);
+}
+function optionsBetween(lines, from, footer) {
+  const options = [];
+  for (let i = from; i < footer; i++) {
+    const m = lines[i].match(OPTION);
+    if (m && Number(m[1]) === options.length + 1) options.push(m[2].replace(/\s+✔$/, ""));
+  }
+  return options;
+}
+function parseDialog(pane) {
+  const lines = pane.split("\n").map((l) => l.replace(/\s+$/, ""));
+  const footer = dialogEnd(lines);
+  if (footer < 0) return null;
+  let first = -1;
+  for (let i = footer - 1; i >= 0; i--) {
+    const m = lines[i].match(OPTION);
+    if (m && m[1] === "1") {
+      first = i;
+      break;
+    }
+  }
+  if (first < 0) return null;
+  const options = optionsBetween(lines, first, footer);
+  let q = first - 1;
+  while (q >= 0 && isBlank(lines[q])) q--;
+  const questionLines = [];
+  while (q >= 0 && !isBlank(lines[q]) && !isRule(lines[q]) && questionLines.length < 3) questionLines.unshift(lines[q--].trim());
+  if (questionLines.length === 0) return null;
+  let top = q;
+  while (top >= 0 && !RULE.test(lines[top].trim())) top--;
+  if (top < 0) return null;
+  return {
+    kind: /Enter to select/.test(lines[footer] ?? "") || REVIEW_QUESTION.test(questionLines.join(" ")) ? "question" : PLAN_FOOTER.test(lines[footer] ?? "") ? "plan" : "permission",
+    title: lines.slice(top + 1, q + 1),
+    question: questionLines.join(" "),
+    options
+  };
+}
+function permissionText(header, question) {
+  const nonBlank = header.filter((l) => !isBlank(l));
+  const titleAndNext = nonBlank.slice(0, 2).filter((l) => !DASHED.test(l.trim())).map((l) => l.trim()).join(" ");
+  if (/\bfile$/i.test(nonBlank[0]?.trim() ?? "")) return titleAndNext || question;
+  const d1 = header.findIndex((l) => DASHED.test(l.trim()));
+  const d2 = d1 < 0 ? -1 : header.findIndex((l, i) => i > d1 && DASHED.test(l.trim()));
+  if (d2 > d1 + 1) {
+    const body = header.slice(d1 + 1, d2).map((l) => l.trim()).filter(Boolean).join("\n");
+    if (body) return body;
+  }
+  return titleAndNext || question;
+}
+var TRUST_FOOTER = /^\s*Enter to confirm\b.*Esc to cancel\b/;
+var TRUST_OPTION = /\btrust this folder\b/i;
+function parseTrust(pane) {
+  const lines = pane.split("\n").map((l) => l.replace(/\s+$/, ""));
+  let footer = lines.length - 1;
+  while (footer >= 0 && isBlank(lines[footer])) footer--;
+  if (footer < 0 || !TRUST_FOOTER.test(lines[footer])) return null;
+  let o = footer - 1;
+  while (o >= 0 && isBlank(lines[o])) o--;
+  const block = [];
+  while (o >= 0 && !isBlank(lines[o])) block.unshift(lines[o--]);
+  const options = block.map((l) => l.trim().replace(/^❯\s*/, ""));
+  const trust = options.findIndex((l) => TRUST_OPTION.test(l));
+  const selected = block.findIndex((l) => l.trim().startsWith("\u276F"));
+  if (trust < 0 || selected < 0) return null;
+  const at = lines.findIndex((l) => /^\s*Accessing workspace:/.test(l));
+  const path = at < 0 ? "" : lines.slice(at + 1, footer).find((l) => !isBlank(l))?.trim() ?? "";
+  return { path, options, selected, trust };
+}
+function detectPrompt(pane) {
+  const t = parseTrust(pane);
+  if (t) return { kind: "permission", text: `Trust this folder? ${t.path}`.trim(), options: t.options };
+  const d = parseDialog(pane);
+  if (!d) return null;
+  if (d.kind === "question") return { kind: "question", text: d.question, options: d.options };
+  if (d.kind === "plan") return { kind: "plan", text: d.question, options: d.options };
+  return { kind: "permission", text: permissionText(d.title, d.question), options: d.options };
+}
+function promptStillVisible(lastLines2) {
+  const lines = lastLines2.split("\n").map((l) => l.replace(/\s+$/, ""));
+  if (lines.some((l) => TRUST_FOOTER.test(l)) && lines.some((l) => TRUST_OPTION.test(l))) return true;
+  const footer = dialogEnd(lines);
+  return footer > 0 && lines.slice(0, footer).some((l) => OPTION.test(l));
+}
+var squash = (t) => t.replace(/\s+/g, " ").trim();
+function promptGone(pane, pending) {
+  if (pending.kind !== "question" || !squash(pending.text)) return !promptStillVisible(pane.replace(/\s+$/, "").split("\n").slice(-5).join("\n"));
+  const m = detectPrompt(pane);
+  if (!m || m.kind !== "question") return true;
+  const shown = squash(m.text);
+  const asked = squash(pending.text);
+  return !(shown === asked || asked.startsWith(shown) || shown.startsWith(asked));
+}
+var STATUS_SLACK = 3;
+var INPUT_MAX = 12;
+var isInputRule = (l) => /^─{10,}$/.test(l.trim());
+var isInputTop = (l) => /^─{10,}(?: \S.* ─+)?$/.test(l.trim());
+function inputBox(lines) {
+  let end = lines.length;
+  while (end > 0 && isBlank(lines[end - 1])) end--;
+  let bottom = -1;
+  let below = 0;
+  for (let i = end - 1; i >= 0 && below <= STATUS_SLACK; i--) {
+    if (isInputRule(lines[i])) {
+      bottom = i;
+      break;
+    }
+    if (!isBlank(lines[i])) below++;
+  }
+  if (bottom < 0) return null;
+  for (let top = bottom - 1; top >= 0 && bottom - top <= INPUT_MAX + 1; top--) {
+    if (!isInputTop(lines[top])) continue;
+    return lines[top + 1].trimStart().startsWith("\u276F") ? { top, bottom } : null;
+  }
+  return null;
+}
+var TITLE_RULE = /^─{10,} (\S.*?) ─+$/;
+function paneTitle(pane) {
+  const lines = pane.split("\n").map((l) => l.replace(/\s+$/, ""));
+  const box = inputBox(lines);
+  const m = box ? TITLE_RULE.exec(lines[box.top].trim()) : null;
+  return m ? m[1] : null;
+}
+function previewLines(pane) {
+  const lines = pane.split("\n").map((l) => l.replace(/\s+$/, ""));
+  const box = inputBox(lines);
+  return box ? lines.slice(0, box.top) : lines;
+}
+var BUSY = /\besc to interrupt\b/;
+function atRest(pane) {
+  const lines = pane.split("\n").map((l) => l.replace(/\s+$/, ""));
+  if (dialogEnd(lines) >= 0 || parseTrust(pane)) return false;
+  const box = inputBox(lines);
+  return !!box && !lines.slice(box.bottom + 1).some((l) => BUSY.test(l));
+}
+var digit = (n) => [{ text: String(n) }];
+function optionNumber(text, pending) {
+  return pending?.kind === "question" && /^[1-9]$/.test(text) ? Number(text) : null;
+}
+var PLAN_ACCEPT = /\bmanually approve\b/i;
+var claudeAdapter = {
+  tool: "claude",
+  detectPrompt,
+  promptStillVisible,
+  promptGone,
+  previewLines,
+  atRest,
+  paneTitle,
+  keysFor(decision, pending, pane) {
+    if (decision === "deny") return [{ keys: ["Escape"] }];
+    const t = pane ? parseTrust(pane) : null;
+    if (t) {
+      const step = t.trust > t.selected ? "Down" : "Up";
+      return [{ keys: [...Array(Math.abs(t.trust - t.selected)).fill(step), "Enter"] }];
+    }
+    const d = pane ? parseDialog(pane) : null;
+    if (pending.kind === "plan" && d?.kind === "plan") {
+      const i = d.options.findIndex((o) => PLAN_ACCEPT.test(o));
+      return digit(i < 0 ? 1 : i + 1);
+    }
+    return digit(1);
+  },
+  replyPlan(text, pending) {
+    const flat = text.replace(/\s*[\r\n]+\s*/g, " ").trim();
+    const n = optionNumber(flat, pending);
+    if (n !== null) return digit(n);
+    return [{ text: flat }, { keys: ["Enter"] }];
+  },
+  interruptKeys: () => ["Escape"]
+};
+
+// src/adapters/codex.ts
+var APPROVAL_FOOTER = /^\s*Press enter to confirm or esc to cancel\s*$/;
+var QUESTION_FOOTER = /\benter to submit\b/;
+var SELECT_FOOTER = /^\s*enter select · esc back\s*$/;
+var CONFIRM_FOOTER = /^\s*enter confirm · esc skip\s*$/;
+var FOOTERS = [APPROVAL_FOOTER, QUESTION_FOOTER, SELECT_FOOTER, CONFIRM_FOOTER];
+var OPTION2 = /^\s*(?:›\s*)?(\d+)\.\s+(\S.*)$/;
+var HEADER_SPAN = 25;
+var isBlank2 = (l) => l.trim() === "";
+var isFooter = (l) => FOOTERS.some((f) => f.test(l));
+var split = (pane) => pane.split("\n").map((l) => l.replace(/\s+$/, ""));
+function lastLine(lines) {
+  let i = lines.length - 1;
+  while (i >= 0 && isBlank2(lines[i])) i--;
+  return i;
+}
+var label = (text) => text.split(/\s{2,}/)[0].replace(/\s+\([a-z]+\)$/, "").trim();
+function parseDialog2(pane) {
+  const lines = split(pane);
+  const footer = lastLine(lines);
+  if (footer < 0 || !isFooter(lines[footer])) return null;
+  let end = footer - 1;
+  while (end >= 0 && isBlank2(lines[end])) end--;
+  let start = end;
+  while (start > 0 && !isBlank2(lines[start - 1])) start--;
+  const raw = [];
+  for (let i = start; i <= end; i++) {
+    const m = lines[i].match(OPTION2);
+    if (m && Number(m[1]) === raw.length + 1) raw.push(m[2]);
+    else if (raw.length > 0) raw[raw.length - 1] += ` ${lines[i].trim()}`;
+    else return null;
+  }
+  if (raw.length === 0) return null;
+  const header = [];
+  for (let i = start - 1; i >= 0 && start - i <= HEADER_SPAN; i--) {
+    const l = lines[i];
+    if (!isBlank2(l) && !/^\s/.test(l)) break;
+    header.unshift(l);
+  }
+  const f = lines[footer];
+  const kind = APPROVAL_FOOTER.test(f) ? "approval" : QUESTION_FOOTER.test(f) ? "question" : SELECT_FOOTER.test(f) ? "plan" : "confirm";
+  if (kind === "plan" && !header.some((l) => /^\s*Implement this plan\?\s*$/.test(l))) return null;
+  return { kind, header, options: raw.map(label) };
+}
+function run2(header, from) {
+  const out = [];
+  for (let i = from; i < header.length && !isBlank2(header[i]); i++) out.push(header[i].trim());
+  return out;
+}
+function approvalText(header) {
+  const cmd = header.findIndex((l) => /^\s*\$\s/.test(l));
+  if (cmd >= 0) return run2(header, cmd).join(" ").replace(/^\$\s+/, "");
+  const dest = header.findIndex((l) => /^\s*Destination:\s*$/.test(l));
+  if (dest >= 0) {
+    const path = run2(header, dest + 1).join("");
+    if (path) return `Edit ${path}`;
+  }
+  return header.map((l) => l.trim()).find((l) => /^Would you like to\b/.test(l)) ?? "approval";
+}
+function questionText(header) {
+  const out = [];
+  for (let i = header.length - 1; i >= 0; i--) {
+    const l = header[i].trim();
+    if (!l) {
+      if (out.length) break;
+      continue;
+    }
+    if (/^Questions? \d+\/\d+\b/.test(l)) break;
+    out.unshift(l);
+    if (out.length === 3) break;
+  }
+  return out.join(" ");
+}
+function confirmText(header) {
+  const lines = header.map((l) => l.trim()).filter(Boolean);
+  if (lines[0] === "Hooks need review") return `Trust the new Codex hooks? ${lines[1] ?? ""}`.trim();
+  return lines[0] ?? "confirm";
+}
+function detectPrompt2(pane) {
+  const d = parseDialog2(pane);
+  if (!d) return null;
+  if (d.kind === "question") return { kind: "question", text: questionText(d.header), options: d.options };
+  if (d.kind === "plan") return { kind: "plan", text: "Implement this plan?", options: d.options };
+  if (d.kind === "confirm") return { kind: "permission", text: confirmText(d.header), options: d.options };
+  return { kind: "permission", text: approvalText(d.header), options: d.options };
+}
+function promptStillVisible2(lastLines2) {
+  const lines = split(lastLines2);
+  const i = lastLine(lines);
+  return i >= 0 && isFooter(lines[i]) && lines.slice(0, i).some((l) => OPTION2.test(l));
+}
+var BELOW_INPUT = 10;
+var BUSY2 = /\besc to interrupt\b/;
+var BUSY_SPAN = 6;
+function inputLine(lines) {
+  let below = 0;
+  for (let i = lastLine(lines); i >= 0 && below <= BELOW_INPUT; i--) {
+    if (/^›(?:\s|$)/.test(lines[i])) return i;
+    if (isBlank2(lines[i])) continue;
+    if (!/^\s/.test(lines[i])) return -1;
+    below++;
+  }
+  return -1;
+}
+function previewLines2(pane) {
+  const lines = split(pane);
+  if (parseDialog2(pane)) return lines;
+  const input = inputLine(lines);
+  return input < 0 ? lines : lines.slice(0, input);
+}
+function atRest2(pane) {
+  const lines = split(pane);
+  const last = lastLine(lines);
+  if (last < 0 || isFooter(lines[last])) return false;
+  const input = inputLine(lines);
+  return input >= 0 && !lines.slice(Math.max(0, input - BUSY_SPAN), input).some((l) => BUSY2.test(l));
+}
+var digit2 = (n) => [{ text: String(n) }];
+function optionNumber2(options, re) {
+  const i = options.findIndex((o) => re.test(o));
+  return i < 0 ? null : i + 1;
+}
+var REPLY_ENTER_DELAY_MS = 300;
+var codexAdapter = {
+  tool: "codex",
+  detectPrompt: detectPrompt2,
+  promptStillVisible: promptStillVisible2,
+  previewLines: previewLines2,
+  atRest: atRest2,
+  keysFor(decision, pending, pane) {
+    const d = pane ? parseDialog2(pane) : null;
+    if (decision === "deny") {
+      const no = d?.kind === "plan" ? optionNumber2(d.options, /^No\b/) : null;
+      return no ? digit2(no) : [{ keys: ["Escape"] }];
+    }
+    if (d?.kind === "confirm") {
+      const trust = optionNumber2(d.options, /^Trust all\b|^Yes\b/i);
+      if (!trust) throw new Error("no trust option in this dialog, answer in the terminal");
+      return [{ text: String(trust) }, { keys: ["Enter"] }];
+    }
+    if (d?.kind === "plan" || pending.kind === "plan") {
+      return digit2((d && (optionNumber2(d.options, /^Yes, implement this plan$/) ?? optionNumber2(d.options, /^Yes\b/))) ?? 1);
+    }
+    if (pending.kind === "question") return digit2(1);
+    return [{ text: "y" }];
+  },
+  replyPlan(text, pending) {
+    const flat = text.replace(/\s*[\r\n]+\s*/g, " ").trim();
+    if (pending?.kind === "question" && /^[1-9]$/.test(flat)) return digit2(Number(flat));
+    return [{ text: flat }, { waitMs: REPLY_ENTER_DELAY_MS }, { keys: ["Enter"] }];
+  },
+  // Esc interrupts the turn; Ctrl+C clears the draft and a second one quits Codex.
+  interruptKeys: () => ["Escape"]
+};
+
+// src/adapters/cursor.ts
+var rtrim = (l) => l.replace(/\s+$/, "");
+var isBlank3 = (l) => l.trim() === "";
+var toLines = (pane) => pane.split("\n").map(rtrim);
+function lastNonBlank(lines) {
+  let i = lines.length - 1;
+  while (i >= 0 && isBlank3(lines[i])) i--;
+  return i;
+}
+var DIALOG_FOOTER = /\(esc or n\)$/;
+var DIALOG_ACCEPT = /\(y\)$/;
+var RULE2 = /^─{10,}$/;
+var DIALOG_MAX = 40;
+function parseDialog3(lines) {
+  const end = lastNonBlank(lines);
+  if (end < 0 || !DIALOG_FOOTER.test(lines[end])) return null;
+  let rule = end - 1;
+  while (rule >= 0 && end - rule <= DIALOG_MAX && !RULE2.test(lines[rule].trim())) rule--;
+  if (rule < 0 || !RULE2.test(lines[rule].trim())) return null;
+  const body = lines.slice(rule + 1, end + 1).map((l) => l.trim());
+  if (!body.some((l) => DIALOG_ACCEPT.test(l))) return null;
+  const q = body.findIndex((l) => l.endsWith("?") && !/\((y|tab|shift\+tab)\)$/.test(l));
+  if (q < 0) return null;
+  const subject = body.slice(0, q).filter(Boolean).join(" ");
+  return { question: body[q], subject };
+}
+function dialogText(d) {
+  const cmd = d.subject.match(/^\$\s+(.+?)\s+in\s+\S+$/);
+  if (cmd) return cmd[1];
+  return d.subject ? `${d.question} ${d.subject}` : d.question;
+}
+var TRUST_TITLE = /Workspace Trust Required/;
+var TRUST_OPTION2 = /\[a\] Trust this workspace/;
+var TRUST_FOOTER2 = /Use arrow keys to navigate, Enter to select, or press the key shown/;
+var boxed = (l) => l.trim().replace(/^│/, "").replace(/│$/, "").trim();
+function parseTrust2(lines) {
+  const end = lastNonBlank(lines);
+  if (end < 0 || !lines[end].trim().startsWith("\u2570")) return null;
+  let top = end - 1;
+  while (top >= 0 && !lines[top].trim().startsWith("\u256D")) top--;
+  if (top < 0) return null;
+  const box = lines.slice(top + 1, end).map(boxed);
+  if (!box.some((l) => TRUST_TITLE.test(l)) || !box.some((l) => TRUST_OPTION2.test(l)) || !box.some((l) => TRUST_FOOTER2.test(l))) return null;
+  const ask = box.findIndex((l) => /^Do you trust\b/.test(l));
+  const opt = box.findIndex((l) => TRUST_OPTION2.test(l));
+  const path = ask < 0 ? "" : box.slice(ask + 1, opt).filter(Boolean).join("");
+  return { path };
+}
+function squareBox(lines) {
+  const end = lastNonBlank(lines);
+  if (end < 0 || !lines[end].trim().startsWith("\u2514")) return null;
+  let top = end - 1;
+  while (top >= 0 && !lines[top].trim().startsWith("\u250C")) top--;
+  return lines.slice(top + 1, end).map(boxed);
+}
+var QUESTION_FOOTER2 = /Space select\b.*\bEsc to skip\b/;
+var CHOICE = /^(›\s*)?\[([ x])\]\s+(.*)$/;
+var OTHER = /^Other:/;
+function parseQuestion(lines) {
+  const box = squareBox(lines);
+  if (!box || !box.some((l) => QUESTION_FOOTER2.test(l))) return null;
+  const choices = box.map((l) => l.match(CHOICE)).filter((m) => !!m && !OTHER.test(m[3]));
+  if (!choices.length) return null;
+  const first = box.findIndex((l) => CHOICE.test(l));
+  const question = box.slice(0, first).reverse().find((l) => /^\d+\.\s/.test(l))?.replace(/^\d+\.\s+/, "") ?? "";
+  return { question, options: choices.map((m) => m[3].trim()), cursor: choices.findIndex((m) => !!m[1]), checked: choices.map((m) => m[2] === "x") };
+}
+var PLAN_ASK = /^Ready to build\?$/;
+var PLAN_OPTION = /^(?:→\s*)?\d+\.\s+(.+?)\s+\([^)]*\)$/;
+var REVISE = /Describe how to revise the plan\b/;
+function parsePlan(lines) {
+  const box = squareBox(lines);
+  if (!box) return null;
+  const ask = box.findIndex((l) => PLAN_ASK.test(l));
+  if (ask < 0) return null;
+  const options = box.slice(ask + 1).map((l) => l.match(PLAN_OPTION)?.[1]).filter((o) => !!o);
+  if (!options.length) return null;
+  const head = box.findIndex((l) => l === "Suggested Plan");
+  const title = head < 0 ? "" : box.slice(head + 1).find((l) => l !== "") ?? "";
+  return { title: title || "Ready to build?", options };
+}
+var TELL_INSTEAD = /Tell the agent what to do instead\b/;
+var INPUT = /^\s{1,3}→ /;
+var BUSY3 = /\bctrl\+c to stop\b/;
+var STATUS_SLACK2 = 6;
+function inputLine2(lines) {
+  let below = 0;
+  for (let i = lastNonBlank(lines); i >= 0 && below <= STATUS_SLACK2; i--) {
+    if (INPUT.test(lines[i])) return i;
+    if (!isBlank3(lines[i])) below++;
+  }
+  return -1;
+}
+function detectPrompt3(pane) {
+  const lines = toLines(pane);
+  const t = parseTrust2(lines);
+  if (t) return { kind: "permission", text: `Trust this folder? ${t.path}`.trim(), options: ["Trust this workspace", "Quit"] };
+  const q = parseQuestion(lines);
+  if (q) return { kind: "question", text: q.question, options: q.options };
+  const plan = parsePlan(lines);
+  if (plan) return { kind: "plan", text: plan.title, options: plan.options };
+  const d = parseDialog3(lines);
+  return d ? { kind: "permission", text: dialogText(d) } : null;
+}
+var anyDialog = (lines) => !!(parseDialog3(lines) || parseTrust2(lines) || parseQuestion(lines) || parsePlan(lines));
+function promptStillVisible3(lastLines2) {
+  const lines = toLines(lastLines2);
+  const end = lastNonBlank(lines);
+  if (end >= 0 && lines[end].trim().startsWith("\u2570") && lines.some((l) => TRUST_FOOTER2.test(l))) return true;
+  if (lines.some((l) => TELL_INSTEAD.test(l))) return true;
+  if (end >= 0 && lines[end].trim().startsWith("\u2514") && lines.some((l) => QUESTION_FOOTER2.test(l) || /\(p or Esc\)\s*│?$/.test(l))) return true;
+  return end >= 0 && DIALOG_FOOTER.test(lines[end]) && lines.some((l) => DIALOG_ACCEPT.test(l.trim()));
+}
+var compact = (s) => s.replace(/\s+/g, "");
+var typed = (text) => (lastLines2) => {
+  const lines = toLines(lastLines2);
+  const want = compact(`\u2192 ${text}`);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (INPUT.test(lines[i]) && compact(lines.slice(i).join("")).startsWith(want)) return true;
+  }
+  return false;
+};
+var inSkipField = (lastLines2) => toLines(lastLines2).some((l) => TELL_INSTEAD.test(l));
+var inDialog = (lastLines2) => !inSkipField(lastLines2) && promptStillVisible3(lastLines2);
+function promptGone2(pane, pending) {
+  const lines = toLines(pane);
+  if (inSkipField(lines.slice(0, lastNonBlank(lines) + 1).slice(-5).join("\n"))) return false;
+  const m = detectPrompt3(pane);
+  return !m || m.kind !== pending.kind || m.text !== pending.text;
+}
+var onChoice = (i, what) => (lastLines2) => {
+  const q = parseQuestion(toLines(lastLines2));
+  return !!q && (what === "cursor" ? q.cursor === i : !!q.checked[i]);
+};
+function answerPlan(q, n) {
+  const i = n - 1;
+  if (i < 0 || i >= q.options.length) throw new Error(`the question has no option ${n}`);
+  const from = q.cursor < 0 ? 0 : q.cursor;
+  const moves = Array(Math.abs(i - from)).fill(i > from ? "Down" : "Up");
+  return [
+    ...moves.length ? [{ keys: moves }, { until: onChoice(i, "cursor") }] : [],
+    ...q.checked[i] ? [] : [{ text: " " }, { until: onChoice(i, "checked") }],
+    { keys: ["Enter"] }
+  ];
+}
+function previewLines3(pane) {
+  const lines = toLines(pane);
+  if (anyDialog(lines)) return lines;
+  const i = inputLine2(lines);
+  return i < 0 ? lines : lines.slice(0, i);
+}
+function atRest3(pane) {
+  const lines = toLines(pane);
+  if (anyDialog(lines)) return false;
+  const i = inputLine2(lines);
+  return i >= 0 && !TELL_INSTEAD.test(lines[i]) && !lines.slice(i).some((l) => BUSY3.test(l));
+}
+var cursorAdapter = {
+  tool: "cursor",
+  detectPrompt: detectPrompt3,
+  promptStillVisible: promptStillVisible3,
+  previewLines: previewLines3,
+  atRest: atRest3,
+  promptGone: promptGone2,
+  keysFor(decision, _pending, pane) {
+    const lines = pane ? toLines(pane) : [];
+    if (parseTrust2(lines)) return [{ text: decision === "accept" ? "a" : "q" }];
+    const q = parseQuestion(lines);
+    if (q) return decision === "accept" ? answerPlan(q, 1) : [{ keys: ["Escape"] }];
+    if (parsePlan(lines)) return decision === "accept" ? [{ text: "b" }] : [{ text: "p" }, { until: (p) => REVISE.test(p) }];
+    if (lines.some((l) => TELL_INSTEAD.test(l))) {
+      return decision === "accept" ? [{ keys: ["Escape"] }, { until: inDialog }, { text: "y" }] : [{ keys: ["Enter"] }];
+    }
+    return decision === "accept" ? [{ text: "y" }] : [{ text: "n" }, { until: inSkipField }, { keys: ["Enter"] }];
+  },
+  replyPlan(text, pending, pane) {
+    const q = pending?.kind === "question" && /^[1-9]$/.test(text.trim()) && pane ? parseQuestion(toLines(pane)) : null;
+    if (q) return answerPlan(q, Number(text.trim()));
+    const flat = text.replace(/\s*[\r\n]+\s*/g, " ").trim();
+    return [{ text: flat }, { until: typed(flat) }, { keys: ["Enter"] }];
+  },
+  // Ctrl-C aborts a running turn; at rest it only clears the input line, it never quits.
+  interruptKeys: () => ["C-c"]
+};
+
+// src/adapters/preview.ts
+var PREVIEW_LINES = 30;
+var PREVIEW_CAPTURE_LINES = 200;
+var isBlank4 = (l) => l.trim() === "";
+function tidyLines(lines) {
+  const out = [];
+  for (const raw of lines) {
+    const l = raw.replace(/\s+$/, "");
+    if (l === "" && (out.length === 0 || out[out.length - 1] === "")) continue;
+    out.push(l);
+  }
+  while (out.length > 0 && isBlank4(out[out.length - 1])) out.pop();
+  return out;
+}
+function buildPreview(pane, adapter) {
+  const lines = adapter?.previewLines ? adapter.previewLines(pane) : pane.split("\n");
+  const last = tidyLines(lines).slice(-PREVIEW_LINES);
+  while (last.length > 0 && last[0] === "") last.shift();
+  return last;
+}
+
+// src/adapters/index.ts
+function adapterFor(tool) {
+  if (tool === "claude") return claudeAdapter;
+  if (tool === "codex") return codexAdapter;
+  if (tool === "cursor") return cursorAdapter;
+  throw new Error(`adapter for ${tool} not implemented yet`);
+}
+
+// src/adapters/verify.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function verifyGone(capture, stillVisible, opts = {}) {
+  const attempts = opts.attempts ?? 3;
+  const interval = opts.intervalMs ?? 200;
+  for (let i = 0; i < attempts; i++) {
+    await sleep(interval);
+    const pane = await capture();
+    if (pane !== null && !stillVisible(pane)) return true;
+  }
+  return false;
+}
+
+// src/daemon/poller.ts
+import { createHash } from "crypto";
+
+// src/daemon/git.ts
+import { execFile } from "child_process";
+import { basename, dirname as dirname2, resolve } from "path";
+var execGit = (file, args, cwd) => new Promise((res) => {
+  execFile(file, args, { cwd, timeout: 3e3, maxBuffer: 1024 * 1024 }, (err, stdout) => res({ code: err ? 1 : 0, stdout: String(stdout) }));
+});
+async function gitInfo(cwd, exec = execGit) {
+  const r = await exec("git", ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir", "--abbrev-ref", "HEAD"], cwd);
+  if (r.code !== 0) return null;
+  const [toplevel = "", common = "", abbrev = ""] = r.stdout.split("\n").map((l) => l.trim());
+  if (!toplevel || !common || !abbrev) return null;
+  const worktree = resolve(common) !== resolve(toplevel, ".git");
+  const repoPath = worktree ? dirname2(resolve(common)) : resolve(toplevel);
+  let branch = abbrev;
+  if (abbrev === "HEAD") {
+    const sha = await exec("git", ["rev-parse", "--short", "HEAD"], cwd);
+    if (sha.code !== 0 || !sha.stdout.trim()) return null;
+    branch = sha.stdout.trim();
+  }
+  return { repo: basename(repoPath), repoPath, branch, worktree };
+}
+async function gitSummary(cwd, exec = execGit) {
+  const status = await exec("git", ["status", "--short", "--branch"], cwd);
+  if (status.code !== 0) return null;
+  const log2 = await exec("git", ["log", "--oneline", "-10"], cwd);
+  const diff = await exec("git", ["diff", "--stat"], cwd);
+  return [`# git status --short --branch`, status.stdout.trimEnd(), "", "# git log --oneline -10", log2.stdout.trimEnd(), "", "# git diff --stat", diff.stdout.trimEnd() || "(clean)"].join("\n");
+}
+
+// src/daemon/poller.ts
+var DETECT_LINES = 60;
+var REST_MS = 2e3;
+function startPoller(opts) {
+  const { store, tmux } = opts;
+  const adapterFor2 = opts.adapterFor ?? adapterFor;
+  const git = opts.gitInfo ?? gitInfo;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const deadCheckMs = opts.deadCheckMs ?? 5e3;
+  const retireMs = opts.retireMs ?? 10 * 60 * 1e3;
+  const hashes = /* @__PURE__ */ new Map();
+  const previews = /* @__PURE__ */ new Map();
+  const matches = /* @__PURE__ */ new Map();
+  const titles = /* @__PURE__ */ new Map();
+  const restSince = /* @__PURE__ */ new Map();
+  const gitSeen = /* @__PURE__ */ new Set();
+  const forget = (id) => {
+    hashes.delete(id);
+    matches.delete(id);
+    previews.delete(id);
+    restSince.delete(id);
+    titles.delete(id);
+    gitSeen.delete(id);
+  };
+  let lastDeadCheck = 0;
+  let running = false;
+  async function tick() {
+    if (running) return;
+    running = true;
+    try {
+      const t = Date.parse(now());
+      const deadCheck = t - lastDeadCheck >= deadCheckMs;
+      if (deadCheck) lastDeadCheck = t;
+      for (const id of previews.keys()) if (!store.get(id)) previews.delete(id);
+      for (const s of store.all()) {
+        try {
+          await pollOne(s, t, deadCheck);
+        } catch (e) {
+          log(`poll failed for ${s.id}: ${e.message}`);
+        }
+      }
+    } finally {
+      running = false;
+    }
+  }
+  async function pollOne(s, t, deadCheck) {
+    if (s.state === "exited") {
+      forget(s.id);
+      if (s.exitedAt && t - Date.parse(s.exitedAt) > retireMs) store.remove(s.id);
+      return;
+    }
+    if ((deadCheck || !gitSeen.has(s.id)) && s.cwd) {
+      gitSeen.add(s.id);
+      const g = await git(s.cwd);
+      if (g) store.patch(s.id, g);
+    }
+    if (!s.tmuxSession) return;
+    if (deadCheck && !await tmux.hasSession(s.tmuxSession)) {
+      store.apply(s.id, { name: "PaneGone", at: now(), source: "daemon" });
+      forget(s.id);
+      return;
+    }
+    const full = await tmux.capture(s.tmuxSession, PREVIEW_CAPTURE_LINES);
+    if (full === null) return;
+    const pane = full.split("\n").slice(-DETECT_LINES).join("\n");
+    const h = createHash("sha1").update(full).digest("hex");
+    const prev = hashes.get(s.id);
+    if (prev === h) {
+      const m2 = matches.get(s.id);
+      if (m2 && !store.get(s.id)?.pending) store.apply(s.id, { name: "PanePrompt", at: now(), source: "pane", kind: m2.kind, text: m2.text, options: m2.options });
+      rested(s.id, t);
+      return;
+    }
+    hashes.set(s.id, h);
+    if (prev !== void 0) store.apply(s.id, { name: "PaneChanged", at: now(), source: "pane" });
+    let adapter;
+    try {
+      adapter = adapterFor2(s.tool);
+    } catch {
+      adapter = null;
+    }
+    const lines = buildPreview(full, adapter);
+    const key = lines.join("\n");
+    if (previews.get(s.id) !== key) {
+      previews.set(s.id, key);
+      opts.broadcastPreview?.(s.id, lines);
+    }
+    if (!adapter) return;
+    const title = adapter.paneTitle?.(pane) ?? null;
+    if (title && title !== titles.get(s.id)) {
+      titles.set(s.id, title);
+      store.apply(s.id, { name: "PaneTitle", at: now(), source: "pane", text: title });
+    }
+    if (adapter.atRest?.(pane)) {
+      if (!restSince.has(s.id)) restSince.set(s.id, t);
+    } else restSince.delete(s.id);
+    const m = adapter.detectPrompt(pane);
+    if (!m) {
+      matches.delete(s.id);
+      rested(s.id, t);
+      return;
+    }
+    matches.set(s.id, m);
+    store.apply(s.id, { name: "PanePrompt", at: now(), source: "pane", kind: m.kind, text: m.text, options: m.options });
+  }
+  function rested(id, t) {
+    const since = restSince.get(id);
+    if (since !== void 0 && t - since >= REST_MS) store.apply(id, { name: "PaneIdle", at: now(), source: "pane" });
+  }
+  const timer = setInterval(() => {
+    void tick();
+  }, opts.intervalMs ?? 1e3);
+  return { stop: () => clearInterval(timer), tick };
+}
+
+// src/daemon/folders.ts
+import { mkdir as mkdir2, readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname3, isAbsolute, join, resolve as resolve2 } from "path";
+async function resolveFolder(input, home = homedir()) {
+  const raw = input.trim();
+  const expanded = raw === "~" ? home : raw.startsWith("~/") ? resolve2(home, raw.slice(2)) : raw;
+  if (!isAbsolute(expanded)) throw new Error(`not an absolute path: ${raw}`);
+  const path = resolve2(expanded);
+  let s;
+  try {
+    s = await stat(path);
+  } catch {
+    throw new Error(`no such folder: ${path}`);
+  }
+  if (!s.isDirectory()) throw new Error(`not a folder: ${path}`);
+  return path;
+}
+var byName = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+async function subfolders(path) {
+  const found = await Promise.all((await readdir(path, { withFileTypes: true })).map(async (d) => {
+    if (d.name.startsWith(".")) return null;
+    if (d.isDirectory()) return d.name;
+    if (!d.isSymbolicLink()) return null;
+    try {
+      return (await stat(join(path, d.name))).isDirectory() ? d.name : null;
+    } catch {
+      return null;
+    }
+  }));
+  return found.filter((n) => n !== null).sort(byName.compare);
+}
+async function listFolder(input, home = homedir()) {
+  const asked = input?.trim() ? input.trim() : "~";
+  try {
+    const path = await resolveFolder(asked, home);
+    const parent = dirname3(path);
+    return { type: "folder.listing", path, parent: parent === path ? null : parent, entries: await subfolders(path) };
+  } catch (e) {
+    return { type: "folder.listing", path: asked, parent: null, entries: [], error: e.message };
+  }
+}
+async function createFolder(parent, name, home = homedir()) {
+  const at = await listFolder(parent, home);
+  if (at.error) return at;
+  const clean = name.trim();
+  if (!clean || clean === "." || clean === ".." || /[/\0]/.test(clean)) return { ...at, error: `invalid folder name: ${name}` };
+  try {
+    await mkdir2(join(at.path, clean));
+  } catch (e) {
+    const code = e.code;
+    return { ...at, error: code === "EEXIST" ? `already exists: ${clean}` : `cannot create ${clean}: ${e.message}` };
+  }
+  return listFolder(join(at.path, clean), home);
+}
+
+// src/shell-path.ts
+import { execFile as execFile2 } from "child_process";
+function envCommand(shell) {
+  return [shell, "-l", "-c", "env -0"];
+}
+var SHELL_LOCAL = /* @__PURE__ */ new Set(["PWD", "OLDPWD", "SHLVL", "_"]);
+function parseEnv(out) {
+  const env = {};
+  for (const entry of out.split("\0")) {
+    const eq = entry.indexOf("=");
+    if (eq <= 0) continue;
+    const key = entry.slice(0, eq);
+    if (!SHELL_LOCAL.has(key)) env[key] = entry.slice(eq + 1);
+  }
+  return env;
+}
+function loginShellEnv(opts = {}) {
+  const shell = opts.shell ?? process.env.SHELL;
+  if (!shell) return Promise.resolve({});
+  const [bin, ...args] = (opts.command ?? envCommand)(shell);
+  return new Promise((resolve5) => {
+    execFile2(bin, args, { timeout: opts.timeoutMs ?? 5e3, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+      const env = err ? {} : parseEnv(String(stdout));
+      if (env.PATH) return resolve5(env);
+      log(`login shell environment unavailable (${shell}: ${err ? err.message.split("\n")[0] : "printed no PATH"}), launching with the daemon's`);
+      resolve5({});
+    });
+  });
+}
+
+// src/chat/service.ts
+import { randomUUID } from "crypto";
+import { mkdir as mkdir4, readFile as readFile2, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname4, join as join3 } from "path";
+
+// src/chat/context.ts
+import { mkdir as mkdir3, rm, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join2, resolve as resolve3 } from "path";
+var STATE = {
+  starting: "starting",
+  working: "working",
+  waiting_permission: "waiting for the user's approval",
+  waiting_input: "asking the user a question",
+  idle: "idle, waiting for instructions",
+  error: "in error",
+  exited: "exited"
+};
+async function writeContext(dir, input) {
+  await rm(dir, { recursive: true, force: true });
+  await mkdir3(dir, { recursive: true });
+  const steps = /* @__PURE__ */ new Map();
+  const lines = [`# Ledge sessions at ${input.now}`, "", "Each session below lists the files that describe it, in this folder.", ""];
+  for (const s of input.sessions) {
+    lines.push(
+      `## ${s.name} (${s.tool}) \u2014 ${STATE[s.state]}`,
+      `- id: ${s.id}`,
+      `- topic: ${s.topic ?? "(none yet)"}`,
+      `- folder: ${s.cwd}`,
+      `- repository: ${s.repo ?? s.project}${s.branch ? `, branch ${s.branch}${s.worktree ? " (linked worktree)" : ""}` : ""}`,
+      `- started: ${s.startedAt}, last activity: ${s.lastActivityAt}`
+    );
+    if (s.pending) lines.push(`- pending ${s.pending.kind}: ${s.pending.text}`);
+    const live = s.helpers.filter((h) => h.state !== "exited");
+    if (live.length) lines.push(`- subagents: ${live.map((h) => h.task || h.kind).join("; ")}`);
+    const pane = await input.capture(s).catch(() => null);
+    if (pane?.length) {
+      const f = `pane-${s.id}.txt`;
+      await writeFile2(join2(dir, f), pane.join("\n"));
+      steps.set(f, { kind: "pane", id: s.id, name: s.name });
+      lines.push(`- terminal, last lines: ${f}`);
+    }
+    if (s.lastReply?.text.trim()) {
+      const f = `reply-${s.id}.md`;
+      await writeFile2(join2(dir, f), s.lastReply.text);
+      steps.set(f, { kind: "reply", id: s.id, name: s.name });
+      lines.push(`- last reply (${s.lastReply.at}): ${f}`);
+    }
+    const g = await input.git(s.cwd).catch(() => null);
+    if (g) {
+      const f = `git-${s.id}.txt`;
+      await writeFile2(join2(dir, f), g);
+      steps.set(f, { kind: "git", id: s.id, name: s.name });
+      lines.push(`- git status, log and diff stat: ${f}`);
+    }
+    lines.push("");
+  }
+  await writeFile2(join2(dir, "sessions.md"), lines.join("\n"));
+  steps.set("sessions.md", { kind: "sessions" });
+  const repoPaths = [...new Set(input.sessions.map((s) => s.repoPath ?? s.cwd).filter((p) => p && !coversHome(p)).map((p) => resolve3(p)))];
+  return { dir, steps, repoPaths };
+}
+function coversHome(path) {
+  const p = resolve3(path);
+  const home = resolve3(homedir2());
+  return p === home || home.startsWith(p.endsWith("/") ? p : `${p}/`);
+}
+function stepFor(path, ctx) {
+  const abs = resolve3(path);
+  if (abs.startsWith(`${resolve3(ctx.dir)}/`)) return ctx.steps.get(basename2(abs)) ?? null;
+  const repo = ctx.repoPaths.find((r) => abs.startsWith(`${resolve3(r)}/`));
+  return repo ? { kind: "repo", name: basename2(repo), path: abs.slice(resolve3(repo).length + 1) } : { kind: "repo", path: abs };
+}
+
+// src/chat/claude.ts
+import { spawn as nodeSpawn2 } from "child_process";
+
+// src/chat/run.ts
+import { spawn as nodeSpawn } from "child_process";
+function runJsonl(file, args, o, parse, onEvent, spawnImpl = nodeSpawn) {
+  const child = spawnImpl(file, args, { cwd: o.cwd, env: o.env, stdio: ["pipe", "pipe", "pipe"] });
+  let buf = "";
+  let stderr = "";
+  const feed = (line) => {
+    for (const e of parse(line)) onEvent(e);
+  };
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buf += chunk;
+    let i;
+    while ((i = buf.indexOf("\n")) >= 0) {
+      feed(buf.slice(0, i));
+      buf = buf.slice(i + 1);
+    }
+  });
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (c) => {
+    stderr = (stderr + c).slice(-2e3);
+  });
+  const done = new Promise((res) => {
+    child.on("error", (e) => {
+      stderr = `${stderr}${e.message}`.slice(-2e3);
+      res({ code: null, stderr });
+    });
+    child.on("close", (code) => {
+      if (buf.trim()) feed(buf);
+      res({ code, stderr });
+    });
+  });
+  child.stdin.on("error", () => {
+  });
+  child.stdin.end(o.question);
+  return { done, kill: () => {
+    child.kill("SIGTERM");
+  } };
+}
+
+// src/chat/claude.ts
+var PERSONA = `Tu es Ledge, le compagnon qui veille sur les sessions d'agents (Claude Code, Codex, Cursor Agent) de l'utilisateur. Tu lis, tu ne touches \xE0 rien : pas de commande, pas d'\xE9criture, jamais d'instruction envoy\xE9e \xE0 une session.
+Tes sources : le dossier courant contient sessions.md (toutes les sessions, leur \xE9tat et le nom de leurs fichiers), pane-<id>.txt (les derni\xE8res lignes du terminal d'une session), reply-<id>.md (sa derni\xE8re r\xE9ponse) et git-<id>.txt (status, log et diff --stat de son dossier). Les d\xE9p\xF4ts eux-m\xEAmes sont lisibles (Read, Grep, Glob) pour aller plus loin.
+Commence toujours par lire sessions.md. Ne lis que ce que la question demande.
+R\xE9ponds dans la langue de la question, en 3 \xE0 10 lignes, en Markdown simple : paragraphes courts, listes \xE0 puces, \`code\` pour les commandes, fichiers et branches. Nomme chaque bot par son pr\xE9nom en gras (**Nova**) la premi\xE8re fois. Dis d'o\xF9 vient chaque fait et de quand il date quand cela compte. Si une information manque, dis-le au lieu de supposer. Tu ne proposes jamais d'agir \xE0 la place de l'utilisateur ; tu peux lui dire quel bot ouvrir.`;
+function claudeArgs(o) {
+  return [
+    "-p",
+    "--restricted",
+    "--tools",
+    "Read,Grep,Glob",
+    "--permission-mode",
+    "dontAsk",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--include-partial-messages",
+    "--max-turns",
+    String(o.maxTurns ?? 16),
+    "--append-system-prompt",
+    PERSONA,
+    ...o.addDirs.flatMap((d) => ["--add-dir", d]),
+    ...o.resume ? ["--resume", o.sessionId] : ["--session-id", o.sessionId]
+  ];
+}
+var obj = (v) => v && typeof v === "object" ? v : {};
+var str = (v) => typeof v === "string" ? v : void 0;
+function parseLine(line) {
+  let m;
+  try {
+    m = obj(JSON.parse(line));
+  } catch {
+    return [];
+  }
+  if (m.type === "system" && m.subtype === "init" && str(m.session_id)) return [{ type: "init", sessionId: str(m.session_id) }];
+  if (m.type === "stream_event") {
+    const ev = obj(m.event);
+    const d = obj(ev.delta);
+    return ev.type === "content_block_delta" && d.type === "text_delta" && str(d.text) !== void 0 ? [{ type: "delta", text: str(d.text) }] : [];
+  }
+  if (m.type === "assistant") {
+    const content = obj(m.message).content;
+    return (Array.isArray(content) ? content : []).map(obj).filter((b) => b.type === "tool_use").map((b) => {
+      const i = obj(b.input);
+      const path = str(i.file_path) ?? str(i.path);
+      return { type: "tool", tool: String(b.name ?? ""), ...path ? { path } : {} };
+    });
+  }
+  if (m.type === "result") return [{ type: "result", text: str(m.result) ?? "", isError: m.is_error === true || m.subtype !== void 0 && m.subtype !== "success" }];
+  return [];
+}
+function runClaude(o, onEvent, spawnImpl = nodeSpawn2) {
+  const [file = "claude", ...pre] = o.bin ?? ["claude"];
+  return runJsonl(file, [...pre, ...claudeArgs(o)], { cwd: o.cwd, env: o.env, question: o.question }, parseLine, onEvent, spawnImpl);
+}
+
+// src/chat/codex.ts
+import { spawn as nodeSpawn3 } from "child_process";
+function codexArgs(o) {
+  const flags = ["--sandbox", "read-only", "--json", "--skip-git-repo-check", "--ignore-user-config", "-C", o.cwd, "-c", 'sandbox_permissions=["disk-full-read-access"]', "-"];
+  return o.resume ? ["exec", "resume", o.sessionId, ...flags] : ["exec", ...flags];
+}
+var obj2 = (v) => v && typeof v === "object" ? v : {};
+var str2 = (v) => typeof v === "string" ? v : void 0;
+var pathIn = (s) => s.match(/(\/\S+)/)?.[1];
+function parseCodexLine(line) {
+  let m;
+  try {
+    m = obj2(JSON.parse(line));
+  } catch {
+    return [];
+  }
+  if (m.type === "thread.started" && str2(m.thread_id)) return [{ type: "init", sessionId: str2(m.thread_id) }];
+  const item = obj2(m.item);
+  if (m.type === "item.started" || m.type === "item.completed") {
+    if (item.type === "agent_message" && str2(item.text)) {
+      const text = str2(item.text);
+      return [{ type: "delta", text }, { type: "result", text, isError: false }];
+    }
+    const command = str2(item.command);
+    const path = command ? pathIn(command) : str2(item.path) ?? str2(obj2(item.changes).path);
+    if (item.type && item.type !== "agent_message") return [{ type: "tool", tool: String(item.type), ...path ? { path } : {} }];
+  }
+  if (m.type === "turn.failed" || m.type === "error") {
+    const err = obj2(m.error);
+    return [{ type: "result", text: str2(err.message) ?? str2(m.message) ?? "", isError: true }];
+  }
+  return [];
+}
+function runCodex(o, onEvent, spawnImpl = nodeSpawn3) {
+  const [file = "codex", ...pre] = o.bin ?? ["codex"];
+  return runJsonl(file, [...pre, ...codexArgs(o)], { cwd: o.cwd, env: o.env, question: `${PERSONA}
+
+${o.question}` }, parseCodexLine, onEvent, spawnImpl);
+}
+
+// src/chat/cursor.ts
+import { spawn as nodeSpawn4 } from "child_process";
+function cursorArgs(o) {
+  return [
+    "-p",
+    "--mode",
+    "ask",
+    "--output-format",
+    "stream-json",
+    "--stream-partial-output",
+    "--sandbox",
+    "enabled",
+    "--trust",
+    "--workspace",
+    o.cwd,
+    ...o.addDirs.flatMap((d) => ["--add-dir", d]),
+    ...o.resume ? ["--resume", o.sessionId] : []
+  ];
+}
+var obj3 = (v) => v && typeof v === "object" ? v : {};
+var str3 = (v) => typeof v === "string" ? v : void 0;
+function parseCursorLine(line) {
+  const known = parseLine(line);
+  if (known.length) return known;
+  let m;
+  try {
+    m = obj3(JSON.parse(line));
+  } catch {
+    return [];
+  }
+  if (m.type === "tool_call") {
+    const call = obj3(m.tool_call);
+    const read = obj3(call.readToolCall);
+    const args = obj3(read.args ?? call.args);
+    const path = str3(args.path) ?? str3(args.file_path);
+    return [{ type: "tool", tool: read.args ? "Read" : String(call.name ?? "tool"), ...path ? { path } : {} }];
+  }
+  if (m.type === "assistant") {
+    const content = obj3(m.message).content;
+    return (Array.isArray(content) ? content : []).map(obj3).filter((b) => b.type === "text" && str3(b.text)).map((b) => ({ type: "delta", text: str3(b.text) }));
+  }
+  return [];
+}
+function runCursor(o, onEvent, spawnImpl = nodeSpawn4) {
+  const [file = "cursor-agent", ...pre] = o.bin ?? ["cursor-agent"];
+  return runJsonl(file, [...pre, ...cursorArgs(o)], { cwd: o.cwd, env: o.env, question: `${PERSONA}
+
+${o.question}` }, parseCursorLine, onEvent, spawnImpl);
+}
+
+// src/chat/service.ts
+var TOOL_LABEL = { claude: "Claude Code", codex: "Codex", cursor: "Cursor Agent" };
+var runTool = (tool, o, onEvent, spawn) => tool === "codex" ? runCodex(o, onEvent, spawn) : tool === "cursor" ? runCursor(o, onEvent, spawn) : runClaude(o, onEvent, spawn);
+var ONE_AT_A_TIME = "one question at a time: wait for the answer";
+var HISTORY_MAX = 50;
+var PANE_LINES = 40;
+var sameStep = (a, b) => a.kind === b.kind && a.id === b.id && a.path === b.path;
+function createChat(deps) {
+  const now = deps.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const today = deps.today ?? (() => now().slice(0, 10));
+  const uuid = deps.uuid ?? randomUUID;
+  const dayFile = join3(deps.home, "chat.json");
+  let turns = [];
+  let turnsDay = "";
+  let busy = false;
+  let freshNext = false;
+  let current = null;
+  const CANCELLED = { ok: false, message: "cancelled", resumed: false };
+  function rollDay() {
+    const day = today();
+    if (turnsDay !== day) {
+      turns = [];
+      turnsDay = day;
+    }
+  }
+  async function daySession(fresh, tool) {
+    const day = today();
+    if (!fresh && !freshNext) {
+      try {
+        const saved = JSON.parse(await readFile2(dayFile, "utf8"));
+        if (saved.day === day && saved.sessionId && (saved.tool ?? "claude") === tool) return { sessionId: saved.sessionId, resume: true };
+      } catch {
+      }
+    }
+    const sessionId = uuid();
+    await mkdir4(dirname4(dayFile), { recursive: true });
+    await writeFile3(dayFile, JSON.stringify({ day, sessionId, tool }));
+    freshNext = false;
+    return { sessionId, resume: false };
+  }
+  const capture = async (s) => {
+    if (!s.tmuxSession) return null;
+    const p = await deps.tmux.capture(s.tmuxSession, PANE_LINES);
+    return p === null ? null : p.split("\n");
+  };
+  const contextDir = join3(deps.home, "chat", "context");
+  async function attempt(turn, emit, fresh, mine, tool) {
+    try {
+      return await run3(turn, emit, fresh, mine, tool);
+    } finally {
+      mine.handle = null;
+      await rm2(contextDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+  async function run3(turn, emit, fresh, mine, tool) {
+    const ctx = await writeContext(contextDir, { sessions: deps.store.all(), now: now(), capture, git: (cwd) => gitSummary(cwd) });
+    if (mine.cancelled) return CANCELLED;
+    const { sessionId, resume } = await daySession(fresh, tool);
+    const label2 = TOOL_LABEL[tool];
+    const env = { ...await deps.env(), LEDGE_CHAT: "1" };
+    delete env.LEDGE_SESSION;
+    delete env.LEDGE_NAME;
+    delete env.ANTHROPIC_API_KEY;
+    if (mine.cancelled) return CANCELLED;
+    let answer = "";
+    let resultError = null;
+    const handle = runTool(tool, { question: turn.question, cwd: ctx.dir, addDirs: ctx.repoPaths, sessionId, resume, env, bin: deps.bins?.[tool] ?? deps.bin }, (e) => {
+      if (e.type === "tool") {
+        const step = e.path ? stepFor(e.path, ctx) : null;
+        if (step && !turn.steps.some((s) => sameStep(s, step))) {
+          turn.steps.push(step);
+          emit({ type: "chat.step", qid: turn.qid, step });
+        }
+      } else if (e.type === "delta") {
+        answer += e.text;
+        emit({ type: "chat.delta", qid: turn.qid, text: e.text });
+      } else if (e.type === "result") {
+        if (e.text) answer = e.text;
+        if (e.isError) resultError = e.text || `${label2} reported an error`;
+      }
+    }, deps.spawn);
+    mine.handle = handle;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      log(`chat ${turn.qid}: timed out`);
+      timedOut = true;
+      handle.kill();
+    }, deps.timeoutMs ?? 18e4);
+    const r = await handle.done;
+    clearTimeout(timer);
+    if (mine.cancelled) return CANCELLED;
+    if (timedOut) return { ok: false, message: `${label2} did not answer within 3 minutes`, resumed: false };
+    if (r.code !== 0) return { ok: false, message: r.code === null ? `${label2} could not start: ${r.stderr.trim() || "not found in PATH"}` : r.stderr.trim() || `${label2} exited with code ${r.code}`, resumed: resume };
+    if (resultError) return { ok: false, message: resultError, resumed: false };
+    turn.answer = answer;
+    turn.answeredAt = now();
+    emit({ type: "chat.done", qid: turn.qid, text: answer, at: turn.answeredAt });
+    return { ok: true };
+  }
+  return {
+    history: () => turns,
+    cancel(qid) {
+      if (current?.qid === qid) {
+        current.cancelled = true;
+        current.handle?.kill();
+      }
+    },
+    async reset(emit) {
+      if (busy) {
+        log("chat reset ignored: a question is running");
+        return;
+      }
+      freshNext = true;
+      turns = [];
+      turnsDay = today();
+      emit({ type: "chat.history", turns });
+      await rm2(dayFile, { force: true }).catch((e) => log(`chat reset: day file not removed: ${e.message}`));
+    },
+    async ask(qid, text, emit, tool = "claude") {
+      if (busy) return emit({ type: "chat.error", qid, message: ONE_AT_A_TIME });
+      busy = true;
+      const mine = current = { qid, handle: null, cancelled: false };
+      const turn = { qid, question: text, askedAt: now(), steps: [] };
+      try {
+        rollDay();
+        turns = [...turns, turn].slice(-HISTORY_MAX);
+        emit({ type: "chat.history", turns });
+        let r = await attempt(turn, emit, false, mine, tool);
+        if (!r.ok && r.resumed && !mine.cancelled) {
+          log(`chat ${qid}: resume failed (${r.message}), starting a new day session`);
+          turn.steps.length = 0;
+          r = await attempt(turn, emit, true, mine, tool);
+        }
+        if (!r.ok) {
+          turn.error = r.message;
+          emit({ type: "chat.error", qid, message: r.message });
+        }
+      } catch (e) {
+        log(`chat ${qid} failed: ${e.message}`);
+        turn.error = e.message;
+        emit({ type: "chat.error", qid, message: turn.error });
+      } finally {
+        busy = false;
+        current = null;
+      }
+    }
+  };
+}
+
+// src/daemon/documents.ts
+import { constants } from "fs";
+import { open, realpath } from "fs/promises";
+import { isAbsolute as isAbsolute2, dirname as dirname5, extname, resolve as resolve4 } from "path";
+var markdown = (path) => /^\.(?:md|markdown)$/i.test(extname(path));
+var failure = (request, code) => ({
+  type: "document.error",
+  requestId: request.requestId,
+  path: request.path,
+  code
+});
+var errorCode = (e) => {
+  const code = e.code;
+  return code === "ENOENT" ? "not_found" : code === "EACCES" || code === "EPERM" ? "permission_denied" : code === "EISDIR" || code === "ENXIO" ? "not_file" : "read_failed";
+};
+async function readDocument(request, context) {
+  const source = request.path;
+  if (/^(?:file:|[a-zA-Z]:[\\/]|\\\\)/.test(source) || source.includes("\0")) return failure(request, "unsupported_path");
+  if (request.basePath && (!isAbsolute2(request.basePath) || !markdown(request.basePath))) return failure(request, "unsupported_path");
+  const expanded = source === "~" ? context.home : source.startsWith("~/") ? resolve4(context.home, source.slice(2)) : source;
+  const base = request.basePath ? dirname5(request.basePath) : context.cwd;
+  if (!isAbsolute2(expanded) && !base) return failure(request, "ambiguous_path");
+  const path = resolve4(base ?? context.home, expanded);
+  if (!markdown(path)) return failure(request, "unsupported_type");
+  let file;
+  try {
+    file = await open(path, constants.O_RDONLY | constants.O_NONBLOCK);
+    const stat2 = await file.stat();
+    if (!stat2.isFile()) return failure(request, "not_file");
+    if (stat2.size > DOCUMENT_MAX_BYTES) return failure(request, "too_large");
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    const parts = [];
+    let bytes = 0;
+    while (bytes <= DOCUMENT_MAX_BYTES) {
+      const { bytesRead } = await file.read(chunk, 0, Math.min(chunk.length, DOCUMENT_MAX_BYTES + 1 - bytes), null);
+      if (!bytesRead) break;
+      parts.push(Buffer.from(chunk.subarray(0, bytesRead)));
+      bytes += bytesRead;
+    }
+    if (bytes > DOCUMENT_MAX_BYTES) return failure(request, "too_large");
+    let text;
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(parts, bytes));
+    } catch {
+      return failure(request, "invalid_utf8");
+    }
+    return {
+      type: "document.content",
+      requestId: request.requestId,
+      path: await realpath(path),
+      text,
+      bytes,
+      modifiedAt: stat2.mtime.toISOString()
+    };
+  } catch (e) {
+    return failure(request, errorCode(e));
+  } finally {
+    await file?.close();
+  }
+}
+
+// src/daemon/server.ts
+var CONTINUE_ARGS = { claude: ["--continue"], codex: ["resume", "--last"], cursor: ["--continue"] };
+function launchArgs(msg) {
+  const prompt = msg.prompt?.trim();
+  return [...msg.continue ? CONTINUE_ARGS[msg.tool] : [], ...prompt ? [prompt] : []];
+}
+var ALLOWED_ORIGINS = [
+  "tauri://localhost",
+  "http://tauri.localhost",
+  "https://tauri.localhost",
+  "http://localhost:1420",
+  "http://127.0.0.1:1420"
+];
+function originAllowed(origin) {
+  return origin === void 0 || ALLOWED_ORIGINS.includes(origin);
+}
+function logDroppedRequest(id, ev, before, after) {
+  if (ev.name !== "PermissionRequest" || !after || after.pending !== before?.pending) return;
+  const held = before?.pending;
+  if (held && !held.helperId && !ev.helperId) return;
+  const who = ev.helperId ? `helper ${ev.helperId}` : "main thread";
+  const why = after.state === "exited" ? "the session has exited" : held ? `${held.helperId ? `helper ${held.helperId}` : "the main thread"} already holds the pending request` : "nothing was set";
+  log(`${who} permission for ${ev.tool ?? "a tool"} on ${id} not routed: ${why}`);
+}
+async function startServer(opts) {
+  const { store, tmux } = opts;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const launcher = opts.launcher ?? [process.execPath, process.argv[1] ?? "ledge"];
+  const agentEnv = opts.agentEnv ?? (async () => ({ ...process.env, ...await loginShellEnv() }));
+  const chat = opts.chat ?? createChat({ store, tmux, home: paths().dir, env: agentEnv, bin: opts.claudeBin, now });
+  const wss = new WebSocketServer({
+    host: opts.host ?? "127.0.0.1",
+    port: opts.port ?? PROTOCOL_PORT,
+    verifyClient: ({ req }) => {
+      const ok = originAllowed(req.headers.origin);
+      if (!ok) log(`refused a connection from origin ${String(req.headers.origin)}`);
+      return ok;
+    }
+  });
+  await new Promise((res, rej) => {
+    wss.once("listening", res);
+    wss.once("error", rej);
+  });
+  const port = wss.address().port;
+  const send = (ws, msg) => {
+    if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(msg));
+  };
+  const broadcast = (msg) => {
+    for (const c of wss.clients) send(c, msg);
+  };
+  const previews = /* @__PURE__ */ new Map();
+  const titles = /* @__PURE__ */ new Map();
+  const unsubscribe = store.onChange((c) => {
+    if (c.type === "recents") return broadcast({ type: "recents", recents: c.recents });
+    if (c.type === "updated" && c.session.tmuxSession && titles.get(c.session.id) !== c.session.title) {
+      titles.set(c.session.id, c.session.title);
+      tmux.setOption(c.session.tmuxSession, "@ledge_title", c.session.title).catch((e) => log(`tab title not set for ${c.session.id}: ${e.message}`));
+    }
+    if (c.type === "removed") {
+      previews.delete(c.id);
+      titles.delete(c.id);
+    }
+    broadcast(c.type === "updated" ? { type: "session.updated", session: c.session } : { type: "session.removed", id: c.id });
+  });
+  const sendSnapshot = (ws) => {
+    send(ws, { type: "snapshot", sessions: store.all(), recents: store.recents(), launcher, ...opts.daemon ? { daemon: opts.daemon } : {} });
+    for (const [id, lines] of previews) if (store.get(id)) send(ws, { type: "session.preview", id, lines });
+    send(ws, { type: "chat.history", turns: chat.history() });
+  };
+  const preview = (id, lines) => {
+    if (!store.get(id)) return;
+    previews.set(id, lines);
+    broadcast({ type: "session.preview", id, lines });
+  };
+  const UNTIL_MS = opts.untilMs ?? 1500;
+  const UNTIL_POLL_MS = 50;
+  const UNTIL_LINES = 30;
+  async function runPlan(s, plan) {
+    if (!s.tmuxSession) throw new Error("session has no terminal (started without ledge)");
+    for (const step of plan) {
+      if ("text" in step) await tmux.sendText(s.tmuxSession, step.text);
+      else if ("waitMs" in step) await new Promise((r) => setTimeout(r, step.waitMs));
+      else if ("keys" in step) await tmux.sendKeys(s.tmuxSession, step.keys);
+      else {
+        const end = Date.now() + UNTIL_MS;
+        for (; ; ) {
+          const pane = await tmux.capture(s.tmuxSession, UNTIL_LINES);
+          if (pane !== null && step.until(pane)) break;
+          if (Date.now() >= end) throw new Error(NOT_TAKEN);
+          await new Promise((r) => setTimeout(r, UNTIL_POLL_MS));
+        }
+      }
+    }
+  }
+  const inFlight = /* @__PURE__ */ new Set();
+  async function injectAndVerify(id, planFor, requirePrompt) {
+    const s = store.get(id);
+    if (!s) throw new Error(`unknown session ${id}`);
+    if (inFlight.has(id)) throw new Error("a decision is already in progress");
+    inFlight.add(id);
+    try {
+      const adapter = adapterFor(s.tool);
+      let before = null;
+      if (requirePrompt) {
+        before = s.tmuxSession ? await tmux.capture(s.tmuxSession, DETECT_LINES) : null;
+        if (before === null || !adapter.promptStillVisible(before.split("\n").slice(-5).join("\n"))) throw new Error(NO_PROMPT);
+      }
+      const plan = typeof planFor === "function" ? planFor(before ?? "") : planFor;
+      const decided = s.pending;
+      const stillTheSame = () => {
+        const cur = store.get(id)?.pending;
+        return cur === decided || !!cur && !!decided && cur.kind === decided.kind && cur.text === decided.text;
+      };
+      try {
+        await runPlan(s, plan);
+      } catch (e) {
+        store.apply(id, { name: "InjectFailed", at: now(), source: "daemon", text: e.message });
+        throw e;
+      }
+      const gone = decided && adapter.promptGone ? await verifyGone(() => tmux.capture(s.tmuxSession, DETECT_LINES), (p) => !adapter.promptGone(p, decided), opts.verify) : await verifyGone(() => tmux.capture(s.tmuxSession, 5), (p) => adapter.promptStillVisible(p), opts.verify);
+      if (!stillTheSame()) return;
+      if (gone) {
+        store.apply(id, { name: "Decided", at: now(), source: "daemon" });
+        return;
+      }
+      store.apply(id, { name: "InjectFailed", at: now(), source: "daemon", text: NOT_TAKEN });
+      throw new Error(NOT_TAKEN);
+    } finally {
+      inFlight.delete(id);
+    }
+  }
+  const READ_ONLY = "session started without ledge, read only";
+  const NO_PROMPT = "no prompt visible in the terminal, open the tab";
+  const NOT_TAKEN = "the terminal did not take it";
+  const FREE_TEXT = "free-text answers are not supported yet, answer in the terminal";
+  async function handle(ws, msg) {
+    switch (msg.type) {
+      case "document.read": {
+        const session = msg.sessionId ? store.get(msg.sessionId) : void 0;
+        if (msg.sessionId && !session) return send(ws, { type: "document.error", requestId: msg.requestId, path: msg.path, code: "session_missing" });
+        return send(ws, await readDocument(msg, { cwd: session?.cwd, home: opts.home ?? process.env.HOME ?? "" }));
+      }
+      case "snapshot.request":
+        return sendSnapshot(ws);
+      case "session.register": {
+        let incoming = msg.session;
+        const existing = store.get(incoming.id);
+        const others = store.all().filter((o) => o.id !== incoming.id);
+        if (others.some((o) => o.state !== "exited" && o.name === incoming.name)) {
+          const old = incoming.name;
+          const name = pickName(others.map((o) => o.name));
+          const title = incoming.title.startsWith(`${old} \xB7`) ? `${name}${incoming.title.slice(old.length)}` : incoming.title;
+          incoming = { ...incoming, name, title };
+        }
+        if (existing && existing.source === "hook_only") {
+          store.upsert({
+            ...existing,
+            ...incoming,
+            state: existing.state,
+            pending: existing.pending,
+            lastActivityAt: existing.lastActivityAt,
+            lastHookAt: existing.lastHookAt,
+            exitCode: existing.exitCode,
+            exitedAt: existing.exitedAt,
+            source: "launcher"
+          });
+        } else store.upsert(incoming);
+        if (incoming.cwd) store.touchRecent(incoming.cwd, incoming.project, incoming.startedAt);
+        return;
+      }
+      case "session.launch": {
+        const cwd = await resolveFolder(msg.cwd, opts.home);
+        const live = store.all();
+        const env = await agentEnv();
+        const session = await spawnSession({ tool: msg.tool, args: launchArgs(msg), name: msg.name, cwd, tmux, now, env, taken: { names: live.filter((s) => s.state !== "exited").map((s) => s.name), ids: live.map((s) => s.id) } });
+        store.upsert(session);
+        store.touchRecent(session.cwd, session.project, session.startedAt);
+        log(`launched ${session.name} (${session.tool}) in ${session.cwd} as ${session.id}`);
+        return send(ws, { type: "session.launched", id: session.id });
+      }
+      case "folder.list":
+        return send(ws, await listFolder(msg.path, opts.home));
+      case "folder.create": {
+        const listing = await createFolder(msg.parent, msg.name, opts.home);
+        if (!listing.error) log(`created folder ${listing.path}`);
+        return send(ws, listing);
+      }
+      case "session.event": {
+        const before = store.get(msg.id);
+        if (!before) {
+          const taken = store.all().map((s) => s.name);
+          const cwd = msg.cwd ?? "";
+          const base = { id: msg.id, name: pickName(taken), tool: msg.agent ?? "claude", cwd, project: basename3(cwd) || "unknown", title: "untracked session", tmuxSession: null, state: "working", helpers: [], startedAt: msg.event.at, lastActivityAt: msg.event.at, source: "hook_only" };
+          store.upsert(reduce(base, msg.event));
+        } else store.apply(msg.id, msg.event);
+        logDroppedRequest(msg.id, msg.event, before, store.get(msg.id));
+        return;
+      }
+      case "session.rename": {
+        if (!store.get(msg.id)) return send(ws, { type: "error", id: msg.id, message: "unknown session" });
+        store.apply(msg.id, { name: "Renamed", at: now(), source: "daemon", text: msg.topic });
+        return;
+      }
+      case "session.unregister":
+        store.apply(msg.id, { name: "SessionEnd", at: now(), source: "hook", exitCode: msg.exitCode });
+        return;
+      case "session.decide": {
+        const s = store.get(msg.id);
+        if (!s) return send(ws, { type: "error", id: msg.id, message: "unknown session" });
+        if (s.source === "hook_only") return send(ws, { type: "error", id: msg.id, message: READ_ONLY });
+        if (!s.pending) return send(ws, { type: "error", id: msg.id, message: "nothing to decide" });
+        const pending = s.pending;
+        const adapter = adapterFor(s.tool);
+        return injectAndVerify(msg.id, (pane) => adapter.keysFor(msg.decision, pending, pane), true);
+      }
+      case "session.reply": {
+        const s = store.get(msg.id);
+        if (!s) return send(ws, { type: "error", id: msg.id, message: "unknown session" });
+        if (s.source === "hook_only") return send(ws, { type: "error", id: msg.id, message: READ_ONLY });
+        if (s.pending && s.pending.kind !== "question") return send(ws, { type: "error", id: msg.id, message: `a ${s.pending.kind} prompt takes accept or deny, not a reply` });
+        if (msg.text.trim() === "") return send(ws, { type: "error", id: msg.id, message: "empty reply" });
+        if (s.pending?.kind === "question" && !/^[1-9]$/.test(msg.text.trim())) return send(ws, { type: "error", id: msg.id, message: FREE_TEXT });
+        const pending = s.pending;
+        const adapter = adapterFor(s.tool);
+        return injectAndVerify(msg.id, (pane) => adapter.replyPlan(msg.text, pending, pane || void 0), !!pending);
+      }
+      case "session.interrupt": {
+        const s = store.get(msg.id);
+        if (s?.source === "hook_only") return send(ws, { type: "error", id: msg.id, message: READ_ONLY });
+        if (!s?.tmuxSession) return;
+        await tmux.sendKeys(s.tmuxSession, adapterFor(s.tool).interruptKeys());
+        return;
+      }
+      case "session.kill": {
+        const s = store.get(msg.id);
+        if (!s) return;
+        if (s.source === "hook_only") return send(ws, { type: "error", id: msg.id, message: READ_ONLY });
+        if (s.tmuxSession) await tmux.killSession(s.tmuxSession);
+        store.apply(msg.id, { name: "PaneGone", at: now(), source: "daemon" });
+        return;
+      }
+      case "session.dismiss": {
+        const s = store.get(msg.id);
+        if (!s) return send(ws, { type: "error", id: msg.id, message: "unknown session" });
+        if (s.state !== "exited" && s.source !== "hook_only") return send(ws, { type: "error", id: msg.id, message: "the session is still running, kill it first" });
+        store.remove(msg.id);
+        return;
+      }
+      // Broadcast: every overlay shows the same progress, and the one that asked may be the one that reconnects.
+      // A busy refusal goes to the asker only: it must not fail the flow the other overlays follow.
+      case "update.daemon":
+        if (!opts.updater) return send(ws, { type: "update.failed", version: msg.version, reason: "no-systemd" });
+        return opts.updater.update(msg.version, broadcast, (m) => send(ws, m));
+      case "chat.ask":
+        return chat.ask(msg.qid, msg.text, broadcast, msg.tool);
+      case "chat.cancel":
+        return chat.cancel(msg.qid);
+      case "chat.reset":
+        return chat.reset(broadcast);
+      case "session.focus":
+        return;
+    }
+  }
+  wss.on("connection", (ws) => {
+    ws.on("error", (e) => log(`socket error: ${e.message}`));
+    sendSnapshot(ws);
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = parseClientMessage(JSON.parse(String(data)));
+      } catch (e) {
+        log(`invalid message: ${e.message}`);
+        return send(ws, { type: "error", message: "invalid message" });
+      }
+      handle(ws, msg).catch((e) => {
+        if (msg.type === "document.read") return send(ws, { type: "document.error", requestId: msg.requestId, path: msg.path, code: "read_failed" });
+        log(`${msg.type} failed: ${e.message}`);
+        send(ws, { type: "error", id: "id" in msg ? msg.id : void 0, message: e.message });
+      });
+    });
+  });
+  return {
+    port,
+    broadcast,
+    preview,
+    close: () => new Promise((res) => {
+      unsubscribe();
+      for (const c of wss.clients) c.terminate();
+      wss.close(() => res());
+    })
+  };
+}
+
+// src/update/self.ts
+import { existsSync } from "fs";
+import { readFile as readFile4, realpath as realpath2 } from "fs/promises";
+import { dirname as dirname6, join as join4 } from "path";
+
+// src/update/guard.ts
+import { readFile as readFile3 } from "fs/promises";
+var inDaemonService = (cgroup) => cgroup.split("\n").some((l) => l.split("/").includes(SERVICE));
+async function tmuxServerAtRisk(opts = {}) {
+  const runTmux = opts.runTmux ?? run;
+  const readCgroup = opts.readCgroup ?? ((pid2) => readFile3(`/proc/${pid2}/cgroup`, "utf8"));
+  const r = await runTmux(["-L", opts.socket ?? "ledge", "list-sessions", "-F", "#{pid}"]);
+  if (r.code !== 0) return false;
+  const pid = r.stdout.split("\n").map((s) => s.trim()).find(Boolean);
+  if (!pid) return false;
+  try {
+    return inDaemonService(await readCgroup(pid));
+  } catch {
+    return true;
+  }
+}
+
+// src/update/self.ts
+function gitRoot(script, exists = existsSync) {
+  for (let dir = dirname6(script); ; dir = dirname6(dir)) {
+    if (exists(join4(dir, ".git"))) return dir;
+    if (dirname6(dir) === dir) return null;
+  }
+}
+function installKind(script, exists = existsSync) {
+  if (script.includes("/node_modules/@paradow/ledge/")) return "npm";
+  return gitRoot(script, exists) ? "git" : "unknown";
+}
+var underSystemd = (env, cgroup) => !!env.INVOCATION_ID && inDaemonService(cgroup);
+var manualCommand = (root) => `cd ${root} && git pull && pnpm install && pnpm --filter @paradow/ledge build && systemctl --user restart ${SERVICE.replace(/\.service$/, "")}`;
+async function daemonInfo() {
+  const script = await realpath2(process.argv[1] ?? "").catch(() => process.argv[1] ?? "");
+  const cgroup = await readFile4("/proc/self/cgroup", "utf8").catch(() => "");
+  const install = installKind(script);
+  const root = install === "git" ? gitRoot(script) : null;
+  return { version: LEDGE_VERSION, install, systemd: underSystemd(process.env, cgroup), ...root ? { manual: manualCommand(root) } : {} };
+}
+
+// src/update/run-update.ts
+import { dirname as dirname7, join as join5 } from "path";
+var PACKAGE = "@paradow/ledge";
+var NPM_TIMEOUT_MS = 3 * 6e4;
+var RESTART_COMMAND = "systemctl --user restart ledge-daemon";
+var npmCommand = (execPath, version) => ({ file: join5(dirname7(execPath), "npm"), args: ["i", "-g", `${PACKAGE}@${version}`] });
+var lastLines = (output, n = 3) => output.split("\n").map((l) => l.trimEnd()).filter(Boolean).slice(-n).join("\n");
+var npmEnv = (execPath, env) => ({ ...env, PATH: `${dirname7(execPath)}:${env.PATH ?? ""}` });
+function createDaemonUpdater(deps) {
+  let busy = false;
+  let restarting = false;
+  return {
+    running: () => busy,
+    /** `reply` reaches only the asking client: a busy refusal must not fail the flow other overlays are following. */
+    async update(version, send, reply = send) {
+      if (busy) return reply({ type: "update.failed", version, reason: "busy" });
+      const info = deps.info();
+      const cmd = npmCommand(deps.execPath ?? process.execPath, version);
+      const shown = `${cmd.file} ${cmd.args.join(" ")}`;
+      if (info.install !== "npm") return send({ type: "update.failed", version, reason: "git-install", ...info.manual ? { command: info.manual } : {} });
+      if (!info.systemd) return send({ type: "update.failed", version, reason: "no-systemd", command: shown });
+      busy = true;
+      try {
+        if (await deps.atRisk()) return send({ type: "update.failed", version, reason: "sessions-at-risk" });
+        send({ type: "update.progress", version, step: "installing" });
+        log(`update: ${shown}`);
+        const r = await deps.npm(cmd);
+        if (r.code !== 0) {
+          log(`update: npm failed (${r.code})
+${r.output}`);
+          return send({ type: "update.failed", version, reason: "npm-failed", detail: lastLines(r.output), command: shown });
+        }
+        send({ type: "update.progress", version, step: "restarting" });
+        await deps.save();
+        const code = await deps.restart();
+        if (code !== 0) {
+          log(`update: systemctl restart failed (${code})`);
+          return send({ type: "update.failed", version, reason: "no-systemd", command: RESTART_COMMAND });
+        }
+        restarting = true;
+      } catch (e) {
+        log(`update: ${e.stack ?? String(e)}`);
+        send({ type: "update.failed", version, reason: "npm-failed", detail: e instanceof Error ? e.message : String(e) });
+      } finally {
+        if (!restarting) busy = false;
+      }
+    }
+  };
+}
+function realUpdaterDeps(opts) {
+  return {
+    info: () => opts.info,
+    atRisk: () => tmuxServerAtRisk(),
+    npm: async (cmd) => {
+      const env = npmEnv(process.execPath, { ...process.env, ...await loginShellEnv() });
+      const r = await runFile(cmd.file, cmd.args, env, { timeoutMs: NPM_TIMEOUT_MS });
+      const output = `${r.stdout}
+${r.stderr}`;
+      return r.code === 124 ? { code: 124, output: `npm timed out after 3 minutes
+${output}` } : { code: r.code, output };
+    },
+    // --no-block: this systemctl runs inside the cgroup being stopped; the job must not depend on it staying alive.
+    restart: async () => (await runFile("systemctl", ["--user", "restart", "--no-block", SERVICE])).code,
+    save: opts.save
+  };
+}
+
+// src/daemon/index.ts
+async function startDaemon(opts = {}) {
+  await ensureLedgeDir();
+  const store = new Store();
+  await store.load();
+  const tmux = opts.tmux ?? realTmux(opts.tmuxSocket ?? "ledge");
+  let live = null;
+  try {
+    live = new Set(await tmux.listSessions());
+  } catch (e) {
+    log(`startup prune skipped, tmux unavailable: ${e.message}`);
+  }
+  if (live) for (const s of store.all()) {
+    if (s.tmuxSession && !live.has(s.tmuxSession)) store.remove(s.id);
+  }
+  const daemon = await daemonInfo();
+  const updater = createDaemonUpdater(realUpdaterDeps({ info: daemon, save: () => store.save() }));
+  const server = await startServer({ store, tmux, port: opts.port, daemon, updater });
+  const poller = startPoller({ store, tmux, broadcastPreview: server.preview });
+  await writeFile4(paths().pid, String(process.pid));
+  log(`daemon started on ${server.port} with ${store.all().length} sessions`);
+  let stopping = null;
+  const stop = () => stopping ??= (async () => {
+    process.off("SIGTERM", onSignal);
+    process.off("SIGINT", onSignal);
+    poller.stop();
+    await server.close();
+    await store.save();
+    await rm3(paths().pid, { force: true });
+    log("daemon stopped");
+  })();
+  const onSignal = () => {
+    stop().finally(() => process.exit(0));
+  };
+  process.once("SIGTERM", onSignal);
+  process.once("SIGINT", onSignal);
+  return { stop, port: server.port };
+}
+export {
+  startDaemon
+};