@paradow/ledge 0.16.1 → 0.17.0

package/dist/cli/tui-DWA2EDC2.js

@@ -0,0 +1,3561 @@
+import {
+  attachEnv
+} from "./chunk-36KJUV62.js";
+import "./chunk-VVK4I6B5.js";
+import "./chunk-VE4LGNXX.js";
+import {
+  ChatTurnSchema,
+  IslandPrefsSchema,
+  MachinesSchema,
+  NOTE_MAX,
+  NOTE_NOT_TYPED,
+  PROJECT_COLORS,
+  PROTOCOL_PORT,
+  ProjectsSchema,
+  backendOf,
+  isArchived,
+  offers,
+  parseServerMessage,
+  pendingKey,
+  pickName,
+  projectOf,
+  proposalRows,
+  readDaemonToken
+} from "./chunk-QD27W6W5.js";
+import "./chunk-LAUNHDTX.js";
+import "./chunk-JQZHXVIZ.js";
+import {
+  ledgeDir
+} from "./chunk-ELLXOV4Q.js";
+
+// src/tui/index.tsx
+import { render } from "ink";
+
+// ../fleet/src/token.ts
+import { useSyncExternalStore } from "react";
+var DAEMON_PROTOCOL_PREFIX = "ledge.";
+var READ_TIMEOUT_MS = 1e4;
+function createTokenSource(read) {
+  let cached = null, missing = false, inflight = null;
+  const fns = /* @__PURE__ */ new Set();
+  const setMissing = (m) => {
+    if (m !== missing) {
+      missing = m;
+      fns.forEach((f) => f(m));
+    }
+  };
+  const load = async () => {
+    let r, timer;
+    const unavailable = { kind: "unavailable" };
+    try {
+      const got = await Promise.race([read(), new Promise((res) => {
+        timer = setTimeout(() => res(unavailable), READ_TIMEOUT_MS);
+      })]);
+      r = got?.kind === "token" && typeof got.token === "string" || got?.kind === "absent" ? got : unavailable;
+    } catch {
+      r = unavailable;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (r.kind === "token") cached = r.token;
+    else if (r.kind === "absent") cached = null;
+    setMissing(r.kind === "absent");
+    return r;
+  };
+  return {
+    get(fresh) {
+      if (!fresh && cached !== null) return Promise.resolve({ kind: "token", token: cached });
+      inflight ??= load().finally(() => {
+        inflight = null;
+      });
+      return inflight;
+    },
+    missing: () => missing,
+    onMissing(fn) {
+      fns.add(fn);
+      return () => {
+        fns.delete(fn);
+      };
+    }
+  };
+}
+
+// ../fleet/src/client.ts
+function createDaemonClient(opts) {
+  const Ws = opts.WebSocketImpl ?? globalThis.WebSocket;
+  const min = opts.minBackoffMs ?? 2e3, max = opts.maxBackoffMs ?? 3e4, token = opts.token;
+  let ws = null, status = "connecting", backoff = min, timer = null, closed = false;
+  let failed = false;
+  let attempt = 0;
+  const msgFns = /* @__PURE__ */ new Set(), statusFns = /* @__PURE__ */ new Set();
+  const setStatus = (s) => {
+    if (s !== status) {
+      status = s;
+      statusFns.forEach((f) => f(s));
+    }
+  };
+  const schedule = () => {
+    if (closed) return;
+    timer = setTimeout(open, backoff);
+    backoff = Math.min(max, backoff * 2);
+  };
+  function open() {
+    if (closed) return;
+    setStatus(status === "open" ? "connecting" : status);
+    if (!token) {
+      dial(new Ws(opts.url));
+      return;
+    }
+    const mine = ++attempt;
+    void token.get(failed).then((r) => {
+      if (closed || mine !== attempt) return;
+      if (r.kind === "token") {
+        try {
+          dial(new Ws(opts.url, [DAEMON_PROTOCOL_PREFIX + r.token]));
+          return;
+        } catch {
+        }
+      }
+      failed = true;
+      setStatus("unreachable");
+      schedule();
+    });
+  }
+  function dial(sock) {
+    ws = sock;
+    let opened = false;
+    sock.onopen = () => {
+      if (ws !== sock) return;
+      opened = true;
+      setStatus("open");
+    };
+    sock.onmessage = (ev) => {
+      if (ws !== sock) return;
+      try {
+        const m = parseServerMessage(JSON.parse(String(ev.data)));
+        if (m.type === "snapshot") {
+          backoff = min;
+          failed = false;
+        }
+        msgFns.forEach((f) => f(m));
+      } catch {
+      }
+    };
+    sock.onerror = () => {
+    };
+    sock.onclose = () => {
+      if (ws !== sock) return;
+      ws = null;
+      if (!opened) failed = true;
+      setStatus("unreachable");
+      schedule();
+    };
+  }
+  return {
+    // An explicit connect (a « Reconnect ») says « connecting » at once, even after a drop: the automatic retries stay « unreachable ».
+    connect: () => {
+      closed = false;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      const old = ws;
+      ws = null;
+      old?.close();
+      setStatus("connecting");
+      open();
+    },
+    close: () => {
+      closed = true;
+      attempt++;
+      if (timer) clearTimeout(timer);
+      const old = ws;
+      ws = null;
+      old?.close();
+      setStatus("connecting");
+    },
+    send: (m) => {
+      if (ws && ws.readyState === 1) ws.send(JSON.stringify(m));
+    },
+    status: () => status,
+    onMessage: (f) => {
+      msgFns.add(f);
+      return () => msgFns.delete(f);
+    },
+    onStatus: (f) => {
+      statusFns.add(f);
+      return () => statusFns.delete(f);
+    }
+  };
+}
+
+// ../fleet/src/store.ts
+import { useSyncExternalStore as useSyncExternalStore2 } from "react";
+var ERRORS_KEPT = 20;
+var empty = () => ({ sessions: [], archived: [], byId: /* @__PURE__ */ new Map(), status: "connecting", previews: /* @__PURE__ */ new Map(), threads: /* @__PURE__ */ new Map(), lastError: null, errors: [], recents: [], launcher: null, lastLaunched: null, lastListing: null, chat: [], chatLive: null, daemon: null, snapshotSeq: 0, lastUpdate: null });
+var archivedOf = (m) => [...m.values()].filter(isArchived).sort((a, b) => (b.archivedAt ?? "").localeCompare(a.archivedAt ?? "") || a.id.localeCompare(b.id));
+var state = empty();
+var subs = /* @__PURE__ */ new Set();
+var emit = () => subs.forEach((f) => f());
+var sorted = (m) => [...m.values()].filter((s) => !isArchived(s)).sort((a, b) => a.startedAt.localeCompare(b.startedAt) || a.id.localeCompare(b.id));
+var daemonStore = {
+  getState: () => state,
+  subscribe(fn) {
+    subs.add(fn);
+    return () => {
+      subs.delete(fn);
+    };
+  },
+  setStatus(status) {
+    state = { ...state, status };
+    emit();
+  },
+  reset() {
+    state = empty();
+    emit();
+  },
+  /** The overlay lists its own question at once; the daemon's events fill it in. */
+  beginTurn(turn) {
+    state = { ...state, chat: [...state.chat.filter((t) => t.qid !== turn.qid), turn], chatLive: null };
+    emit();
+  },
+  apply(m) {
+    if (m.type === "chat.history") {
+      state = { ...state, chat: m.turns, chatLive: null };
+      emit();
+      return;
+    }
+    if (m.type === "chat.step" || m.type === "chat.delta" || m.type === "chat.done" || m.type === "chat.error") {
+      const chat = state.chat.map((t) => t.qid !== m.qid ? t : m.type === "chat.step" ? { ...t, steps: [...t.steps, m.step] } : m.type === "chat.done" ? { ...t, answer: m.text, answeredAt: m.at, ...m.proposal ? { proposal: m.proposal } : {}, ...m.proposals ? { proposals: m.proposals } : {}, ...m.relay ? { relay: m.relay } : {}, ...m.closes ? { closes: m.closes } : {}, ...m.projectProposal ? { projectProposal: m.projectProposal } : {} } : m.type === "chat.error" ? { ...t, error: m.message } : t);
+      const chatLive = m.type === "chat.delta" ? { qid: m.qid, text: (state.chatLive?.qid === m.qid ? state.chatLive.text : "") + m.text } : m.type === "chat.step" ? state.chatLive : null;
+      state = { ...state, chat, chatLive };
+      emit();
+      return;
+    }
+    if (m.type === "error") {
+      const e = { id: m.id, message: m.message, seq: (state.lastError?.seq ?? 0) + 1, ...m.request ? { request: m.request } : {}, ...m.code ? { code: m.code } : {} };
+      state = { ...state, lastError: e, errors: [...state.errors, e].slice(-ERRORS_KEPT) };
+      emit();
+      return;
+    }
+    if (m.type === "session.launched") {
+      state = { ...state, lastLaunched: { id: m.id, seq: (state.lastLaunched?.seq ?? 0) + 1 } };
+      emit();
+      return;
+    }
+    if (m.type === "folder.listing") {
+      const { type: _, ...l } = m;
+      state = { ...state, lastListing: { ...l, seq: (state.lastListing?.seq ?? 0) + 1 } };
+      emit();
+      return;
+    }
+    if (m.type === "update.progress" || m.type === "update.failed") {
+      state = { ...state, lastUpdate: { msg: m, seq: (state.lastUpdate?.seq ?? 0) + 1 } };
+      emit();
+      return;
+    }
+    if (m.type === "recents") {
+      state = { ...state, recents: m.recents };
+      emit();
+      return;
+    }
+    const byId = new Map(state.byId);
+    const previews = new Map(state.previews);
+    const threads = new Map(state.threads);
+    let { recents, launcher, daemon, snapshotSeq } = state;
+    switch (m.type) {
+      case "snapshot":
+        byId.clear();
+        for (const s of m.sessions) byId.set(s.id, s);
+        for (const id of previews.keys()) if (!byId.has(id)) previews.delete(id);
+        recents = m.recents ?? [];
+        launcher = m.launcher ?? null;
+        daemon = m.daemon ?? null;
+        snapshotSeq += 1;
+        for (const id of [...threads.keys()]) if (!byId.get(id)?.offline) threads.delete(id);
+        break;
+      case "session.updated":
+        byId.set(m.session.id, m.session);
+        break;
+      case "session.removed":
+        byId.delete(m.id);
+        previews.delete(m.id);
+        threads.delete(m.id);
+        break;
+      case "session.preview":
+        previews.set(m.id, m.lines);
+        break;
+      case "session.thread":
+        threads.set(m.id, m.items);
+        break;
+      case "session.thread.item": {
+        const cur = threads.get(m.id);
+        if (!cur) break;
+        const at = cur.findIndex((i) => i.id === m.item.id);
+        threads.set(m.id, at >= 0 ? cur.map((i, k) => k === at ? m.item : i) : [...cur, m.item]);
+        break;
+      }
+    }
+    state = { ...state, byId, previews, threads, sessions: sorted(byId), archived: archivedOf(byId), recents, launcher, daemon, snapshotSeq };
+    emit();
+  }
+};
+function attachClient(client) {
+  const a = client.onMessage((m) => daemonStore.apply(m));
+  const b = client.onStatus((s) => daemonStore.setStatus(s));
+  return () => {
+    a();
+    b();
+  };
+}
+var useDaemon = () => useSyncExternalStore2(daemonStore.subscribe, daemonStore.getState, daemonStore.getState);
+
+// ../fleet/src/machines.ts
+import { useSyncExternalStore as useSyncExternalStore3 } from "react";
+var LOCAL_MACHINE = { id: "local", label: "Local", url: "ws://127.0.0.1:47831" };
+function parseMachines(raw) {
+  const list = MachinesSchema.parse(Array.isArray(raw) ? raw.map((m) => {
+    const rest = { ...m ?? {} };
+    delete rest.url;
+    return rest;
+  }) : raw);
+  return list.map((m, i) => i === 0 ? { ...m, url: LOCAL_MACHINE.url } : m);
+}
+function machineUrl(machine, local) {
+  if (!machine.ssh) return local.url;
+  const url = new URL(local.url);
+  if (machine.ssh) url.pathname = `/ssh/${machine.ssh}`;
+  return url.toString();
+}
+function loadMachines(prefix = "ledge") {
+  try {
+    return parseMachines(JSON.parse(localStorage.getItem(`${prefix}.machines`) ?? "null"));
+  } catch {
+    return [LOCAL_MACHINE];
+  }
+}
+function probeMachine(url, ssh, opts = {}) {
+  const Ws = opts.WebSocketImpl ?? globalThis.WebSocket;
+  return new Promise((resolve) => {
+    let sock, error = "", done = false, opened = false;
+    const finish = (r) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (sock) {
+        sock.onclose = sock.onmessage = sock.onerror = null;
+        sock.close();
+      }
+      resolve(r);
+    };
+    const timer = setTimeout(() => finish({ ok: false, error: "SSH: no Ledge snapshot received." }), opts.timeoutMs ?? 75e3);
+    const start = (protocols) => {
+      if (done) return;
+      try {
+        const target2 = machineUrl({ id: "probe", label: ssh, ssh }, { ...LOCAL_MACHINE, url });
+        sock = protocols ? new Ws(target2, protocols) : new Ws(target2);
+      } catch (e) {
+        finish({ ok: false, error: protocols ? "The local Ledge daemon could not be reached." : e.message });
+        return;
+      }
+      sock.onmessage = (ev) => {
+        let m;
+        try {
+          m = parseServerMessage(JSON.parse(String(ev.data)));
+        } catch {
+          return;
+        }
+        if (m.type === "error") error = m.message;
+        else if (m.type === "snapshot") finish(m.sshAlias === ssh ? { ok: true, version: m.daemon?.version, sessions: m.sessions.length } : { ok: false, error: "Update the local Ledge daemon: SSH transport is unavailable" });
+      };
+      sock.onopen = () => {
+        opened = true;
+      };
+      sock.onerror = () => {
+      };
+      sock.onclose = () => {
+        if (!opened) void opts.token?.get(true);
+        finish({ ok: false, error: error || "The local Ledge daemon closed the connection." });
+      };
+    };
+    if (!opts.token) {
+      start();
+      return;
+    }
+    void opts.token.get(false).then((r) => {
+      if (r.kind === "token") start([DAEMON_PROTOCOL_PREFIX + r.token]);
+      else finish({ ok: false, error: r.kind === "absent" ? "The local Ledge daemon token is missing: start or update the daemon." : "The local Ledge daemon token could not be read." });
+    });
+  });
+}
+var qualify = (machine, id) => `${machine}:${encodeURIComponent(id)}`;
+function splitId(id) {
+  const at = id.indexOf(":");
+  if (at < 0) return null;
+  try {
+    return { machine: id.slice(0, at), id: decodeURIComponent(id.slice(at + 1)) };
+  } catch {
+    return null;
+  }
+}
+var quote = (s) => "'" + s.replaceAll("'", "'\\''") + "'";
+var wslArg = (s) => s !== "" && !/["\u0000-\u001f\u007f-\u009f]/.test(s) && !s.endsWith("\\");
+function terminalCommand(machine, rawId, opts = {}) {
+  if (!machine.launcher || !rawId) return null;
+  const command = [...machine.launcher, "attach", ...opts.readOnly ? ["--read-only"] : [], rawId];
+  const argv = machine.ssh ? ["ssh", "-t", "--", machine.ssh, command.map(quote).join(" ")] : command;
+  return argv.every(wslArg) ? argv : null;
+}
+function shellCommand(machine, dir) {
+  if (!wslArg(dir)) return null;
+  const go = `cd ${quote(dir)} 2>/dev/null || cd; exec`;
+  const argv = machine.ssh ? ["ssh", "-t", "--", machine.ssh, `${go} $SHELL -l`] : ["sh", "-c", `${go} $(getent passwd $(id -un) | cut -d: -f7) -l`];
+  return argv.every(wslArg) ? argv : null;
+}
+var EMPTY = [];
+var noopSubscribe = () => () => {
+};
+var emptySnapshot = () => EMPTY;
+function useMachines(client) {
+  return useSyncExternalStore3(client.fleet?.subscribe ?? noopSubscribe, client.fleet?.machines ?? emptySnapshot, emptySnapshot);
+}
+var nullSnapshot = () => null;
+function useProjects(client) {
+  return useSyncExternalStore3(client.fleet?.subscribe ?? noopSubscribe, client.fleet?.projects ?? nullSnapshot, nullSnapshot);
+}
+
+// ../fleet/src/changes.ts
+var liveHelpers = (session) => session.helpers.filter((h) => h.state !== "exited" && h.state !== "idle");
+var isPending = (s) => s.state === "waiting_permission" || s.state === "waiting_input";
+var sameRequest = (a, b) => !!a && !!b && a.kind === b.kind && a.text === b.text && a.helperId === b.helperId;
+var isBusy = (s) => s.state === "working" || s.state === "idle" && liveHelpers(s).length > 0;
+function changeOf(was, now) {
+  if (!was) return { kind: "joined", id: now.id };
+  if (now.state === "exited" && was.state !== "exited") {
+    const code = now.exitCode ?? null;
+    return code !== null && code !== 0 ? { kind: "failed", id: now.id } : { kind: "left", id: now.id, exitCode: code };
+  }
+  if (now.state === "error" && was.state !== "error") return { kind: "failed", id: now.id };
+  if (now.state === "idle" && isBusy(was) && !isBusy(now)) return { kind: "finished", id: now.id };
+  if (isPending(now) && !(isPending(was) && sameRequest(was.pending, now.pending))) return { kind: "asked", id: now.id, ask: now.state === "waiting_permission" ? "approval" : "question" };
+  return null;
+}
+
+// ../fleet/src/fleet.ts
+var toWire = (list) => list.map(({ id, label, ssh }) => ({ id, label, ...ssh ? { ssh } : {} }));
+var OPERATIONS = /* @__PURE__ */ new Set(["session.launch", "session.relay", "session.relay.cancel", "session.close"]);
+function createFleetClient(config, makeClient = createDaemonClient, opts = {}) {
+  const prefix = opts.prefix ?? "ledge";
+  const HISTORY_KEY = `${prefix}.fleet.history`, MACHINES_KEY = `${prefix}.machines`;
+  let configs = parseMachines(config), selected = configs[0].id, connected = false, configuring = false, state2 = [];
+  const peers = /* @__PURE__ */ new Map();
+  const machineMessages = /* @__PURE__ */ new Set();
+  const messages = /* @__PURE__ */ new Set(), statuses = /* @__PURE__ */ new Set(), listeners = /* @__PURE__ */ new Set();
+  const turns2 = /* @__PURE__ */ new Map(), bindings = /* @__PURE__ */ new Map();
+  const documents = /* @__PURE__ */ new Map();
+  const inspections = /* @__PURE__ */ new Map();
+  const listings = /* @__PURE__ */ new Map();
+  const scans = /* @__PURE__ */ new Map();
+  const modelLists = /* @__PURE__ */ new Map();
+  const operations = /* @__PURE__ */ new Map();
+  const closeRows = /* @__PURE__ */ new Map();
+  const endOperation = (machine) => {
+    closeRows.delete(machine);
+    return operations.delete(machine);
+  };
+  const unfound = /* @__PURE__ */ new Map();
+  const answerUnfoundInspections = (machine) => {
+    for (const [requestId, owner] of inspections) if (owner === machine) {
+      inspections.delete(requestId);
+      const repos = unfound.get(requestId) ?? [];
+      unfound.delete(requestId);
+      emit2({ type: "repos.info", requestId, repos });
+    }
+  };
+  const answerUnfoundListings = (machine, error) => {
+    for (const [requestId, l] of listings) if (l.machine === machine) {
+      listings.delete(requestId);
+      emit2({ type: "folder.listing", requestId, path: l.path, parent: null, entries: [], error });
+    }
+  };
+  const answerFailedScans = (machine, error) => {
+    for (const [requestId, owner] of scans) if (owner === machine) {
+      scans.delete(requestId);
+      emit2({ type: "repos.found", requestId, repos: [], truncated: false, error });
+    }
+  };
+  const answerFailedModels = (machine, error) => {
+    for (const [requestId, l] of modelLists) if (l.machine === machine) {
+      modelLists.delete(requestId);
+      emit2({ type: "models.listing", requestId, tool: l.tool, models: [], error });
+    }
+  };
+  let source = "local";
+  let projects = null;
+  let island;
+  let mobile;
+  let mobileError;
+  let routing = null, resetAt = "", lastStatus = "connecting";
+  const emit2 = (m) => messages.forEach((fn) => fn(m));
+  const day = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  let historyDay = day();
+  try {
+    const saved = JSON.parse(localStorage.getItem(HISTORY_KEY) ?? "null");
+    if (saved?.day === day()) {
+      for (const raw of (saved.turns ?? []).slice(-50)) {
+        const t = ChatTurnSchema.parse(raw);
+        if (!t.answeredAt && !t.error) t.error = "Connection interrupted";
+        turns2.set(t.qid, t);
+      }
+      for (const [qid, b] of saved.bindings ?? []) if (turns2.has(qid) && (opts.machinesFromDaemon || configs.some((c) => c.id === b.machine)) && typeof b.raw === "string") bindings.set(qid, b);
+      resetAt = typeof saved.resetAt === "string" ? saved.resetAt : "";
+    }
+  } catch {
+  }
+  function history() {
+    const list = [...turns2.values()].sort((a, b) => a.askedAt.localeCompare(b.askedAt)).slice(-50);
+    const kept = new Set(list.map((t) => t.qid));
+    for (const id of turns2.keys()) if (!kept.has(id)) {
+      turns2.delete(id);
+      bindings.delete(id);
+    }
+    try {
+      localStorage.setItem(HISTORY_KEY, JSON.stringify({ day: historyDay, turns: list, bindings: [...bindings], resetAt }));
+    } catch {
+    }
+    emit2({ type: "chat.history", turns: list });
+  }
+  const available = (p) => !!p && p.status === "open" && p.fresh && !!p.snapshot;
+  const status = () => [...peers.values()].some(available) ? "open" : [...peers.values()].some((p) => p.status === "connecting") ? "connecting" : "unreachable";
+  const stale = (p) => !!opts.keepStale && !!p && !available(p) && !!p.snapshot;
+  const session = (p, s) => ({ ...s, id: qualify(p.config.id, s.id), machineId: p.config.id, machineName: p.config.label, ...stale(p) ? { offline: true } : {} });
+  const stateSessions = (p) => (stale(p) ? p.snapshot.sessions.map((s) => ({ ...s, offline: true })) : p.snapshot?.sessions ?? []).filter((s) => !isArchived(s));
+  function refresh() {
+    state2 = configs.map((c) => {
+      const p = peers.get(c.id);
+      return { ...c, status: p.status, ready: available(p), recents: p.snapshot?.recents ?? [], sessions: stateSessions(p), launcher: p.snapshot?.launcher ?? null, version: p.snapshot?.daemon?.version, daemon: p.snapshot?.daemon, error: p.error };
+    });
+    const next2 = status();
+    if (next2 !== lastStatus) {
+      lastStatus = next2;
+      statuses.forEach((fn) => fn(next2));
+    }
+    listeners.forEach((fn) => fn());
+  }
+  function publish() {
+    if (configuring) return;
+    state2 = configs.map((c) => {
+      const p = peers.get(c.id);
+      return { ...c, status: p.status, ready: available(p), recents: p.snapshot?.recents ?? [], sessions: stateSessions(p), launcher: p.snapshot?.launcher ?? null, version: p.snapshot?.daemon?.version, daemon: p.snapshot?.daemon, error: p.error };
+    });
+    const primary = peers.get("local")?.snapshot;
+    emit2({ type: "snapshot", sessions: [...peers.values()].filter((p) => available(p) || stale(p)).flatMap((p) => p.snapshot.sessions.map((s) => session(p, s))), recents: available(peers.get(selected)) ? peers.get(selected).snapshot.recents : [], launcher: primary?.launcher, daemon: primary?.daemon });
+    for (const p of peers.values()) if (available(p) || stale(p)) for (const [id, lines] of p.previews) emit2({ type: "session.preview", id: qualify(p.config.id, id), lines });
+    const next2 = status();
+    if (next2 !== lastStatus) {
+      lastStatus = next2;
+      statuses.forEach((fn) => fn(next2));
+    }
+    listeners.forEach((fn) => fn());
+  }
+  function fail(qid, message) {
+    const t = turns2.get(qid);
+    if (t) turns2.set(qid, { ...t, error: message });
+    history();
+    emit2({ type: "chat.error", qid, message });
+  }
+  function globalQid(machine, raw) {
+    return [...bindings].find(([, b]) => b.machine === machine && b.raw === raw)?.[0] ?? qualify(machine, raw);
+  }
+  const launchedOn = (p, x) => ({ ...x, ...x.launchedId ? { launchedId: qualify(p.config.id, x.launchedId) } : {} });
+  function mappedTurn(p, raw) {
+    const qid = globalQid(p.config.id, raw.qid), old = turns2.get(qid);
+    bindings.set(qid, { machine: p.config.id, raw: raw.qid });
+    return {
+      ...raw,
+      qid,
+      question: old?.question ?? raw.question,
+      machineId: p.config.id,
+      machineName: p.config.label,
+      steps: raw.steps.map((s) => ({ ...s, ...s.id ? { id: qualify(p.config.id, s.id) } : {} })),
+      ...raw.proposal ? { proposal: launchedOn(p, raw.proposal) } : {},
+      ...raw.proposals ? { proposals: raw.proposals.map((x) => launchedOn(p, x)) } : {},
+      ...raw.relay ? { relay: { ...raw.relay, id: qualify(p.config.id, raw.relay.id) } } : {},
+      ...raw.closes ? { closes: raw.closes.map((c) => ({ ...c, id: qualify(p.config.id, c.id) })) } : {}
+    };
+  }
+  function apply(next2) {
+    configuring = true;
+    for (const [id, p] of peers) if (!next2.some((c) => c.id === id && c.url === p.config.url && c.ssh === p.config.ssh)) {
+      p.client.close();
+      p.off.forEach((off) => off());
+      peers.delete(id);
+    }
+    configs = next2;
+    for (const c of configs) {
+      const p = peers.get(c.id);
+      if (p) p.config = c;
+      else add(c);
+    }
+    if (!peers.has(selected)) selected = "local";
+    const gone = source === "daemon" ? [...bindings].filter(([, b]) => !configs.some((c) => c.id === b.machine)) : [];
+    for (const [qid] of gone) bindings.delete(qid);
+    configuring = false;
+    publish();
+    if (gone.length) history();
+  }
+  function receive(p, m) {
+    const machine = p.config.id;
+    if (m.type === "machines") {
+      if (machine !== "local" || !opts.machinesFromDaemon) return;
+      let next2;
+      try {
+        next2 = parseMachines(m.machines);
+      } catch {
+        return;
+      }
+      const mine = next2.length === 1 ? loadMachines(prefix) : [];
+      source = "daemon";
+      if (next2.length === 1 && mine.length > 1) {
+        p.client.send({ type: "machines.set", machines: toWire(mine) });
+        return;
+      }
+      try {
+        localStorage.removeItem(MACHINES_KEY);
+      } catch {
+      }
+      apply(next2);
+      return;
+    }
+    if (m.type === "projects") {
+      if (machine !== "local") return;
+      projects = m.projects;
+      listeners.forEach((fn) => fn());
+      return;
+    }
+    if (m.type === "island") {
+      if (machine !== "local") return;
+      island = m.prefs;
+      listeners.forEach((fn) => fn());
+      return;
+    }
+    if (m.type === "mobile") {
+      if (machine !== "local") return;
+      mobile = m.state;
+      mobileError = void 0;
+      listeners.forEach((fn) => fn());
+      return;
+    }
+    machineMessages.forEach((fn) => fn(machine, m));
+    if (m.type === "update.progress") p.restarting = m.step === "restarting";
+    if (m.type === "update.failed") p.restarting = false;
+    if (m.type === "snapshot") {
+      if (p.config.ssh && m.sshAlias !== p.config.ssh) {
+        p.error = "Update the local Ledge daemon: SSH transport is unavailable";
+        p.client.close();
+        publish();
+        return;
+      }
+      p.snapshot = m;
+      p.fresh = true;
+      p.error = void 0;
+      p.restarting = false;
+      p.previews.clear();
+      publish();
+      return;
+    }
+    if (m.type === "session.updated") {
+      if (p.snapshot) p.snapshot = { ...p.snapshot, sessions: [...p.snapshot.sessions.filter((s) => s.id !== m.session.id), m.session] };
+      if (available(p)) emit2({ type: "session.updated", session: session(p, m.session) });
+      refresh();
+      return;
+    }
+    if (m.type === "session.removed") {
+      if (p.snapshot) p.snapshot = { ...p.snapshot, sessions: p.snapshot.sessions.filter((s) => s.id !== m.id) };
+      p.previews.delete(m.id);
+      emit2({ ...m, id: qualify(machine, m.id) });
+      refresh();
+      return;
+    }
+    if (m.type === "recents") {
+      if (p.snapshot) p.snapshot = { ...p.snapshot, recents: m.recents };
+      if (machine === selected && available(p)) emit2(m);
+      refresh();
+      return;
+    }
+    if (m.type === "session.preview") {
+      p.previews.set(m.id, m.lines);
+      if (available(p)) emit2({ ...m, id: qualify(machine, m.id) });
+      return;
+    }
+    if (m.type === "session.thread" || m.type === "session.thread.item" || m.type === "session.queue.restored") {
+      if (available(p)) emit2({ ...m, id: qualify(machine, m.id) });
+      return;
+    }
+    if (m.type === "session.launched") {
+      if (!closeRows.has(machine)) operations.delete(machine);
+      emit2({ ...m, id: qualify(machine, m.id) });
+      return;
+    }
+    if (m.type === "session.closed") {
+      emit2({ ...m, qid: globalQid(machine, m.qid), id: qualify(machine, m.id) });
+      return;
+    }
+    if (m.type === "folder.listing") {
+      if (m.requestId !== void 0 && listings.has(m.requestId)) {
+        if (listings.get(m.requestId).machine === machine) {
+          listings.delete(m.requestId);
+          emit2(m);
+        }
+        return;
+      }
+      const creation = m.requestId === void 0 ? [...listings].find(([, l]) => l.machine === machine && l.created !== void 0 && (m.error === void 0 ? m.path === l.created : m.path === l.path)) : void 0;
+      if (creation) {
+        listings.delete(creation[0]);
+        emit2({ ...m, requestId: creation[0] });
+        return;
+      }
+      if (m.requestId === void 0 && machine === selected) emit2(m);
+      return;
+    }
+    if (m.type === "document.content" || m.type === "document.error") {
+      if (documents.get(m.requestId) === machine) {
+        documents.delete(m.requestId);
+        emit2(m);
+      }
+      return;
+    }
+    if (m.type === "repos.info") {
+      if (inspections.get(m.requestId) === machine) {
+        inspections.delete(m.requestId);
+        unfound.delete(m.requestId);
+        emit2(m);
+      }
+      return;
+    }
+    if (m.type === "repos.found") {
+      if (scans.get(m.requestId) === machine) {
+        scans.delete(m.requestId);
+        emit2(m);
+      }
+      return;
+    }
+    if (m.type === "models.listing") {
+      if (modelLists.get(m.requestId)?.machine === machine) {
+        modelLists.delete(m.requestId);
+        emit2(m);
+      }
+      return;
+    }
+    if (m.type === "chat.routed") {
+      if (routing?.qid !== m.qid || routing.coordinator !== machine) return;
+      const req = routing;
+      routing = null;
+      if (m.result.machineId === null) {
+        const old = turns2.get(m.qid);
+        turns2.set(m.qid, { ...old, answer: m.result.text, answeredAt: (/* @__PURE__ */ new Date()).toISOString(), choices: m.result.choices?.map((id) => ({ id, label: peers.get(id)?.config.label ?? id })) });
+        history();
+      } else {
+        const target2 = peers.get(m.result.machineId);
+        bindings.set(req.qid, { machine: m.result.machineId, raw: req.qid });
+        if (!available(target2)) {
+          fail(req.qid, `${target2?.config.label ?? m.result.machineId} is offline`);
+          return;
+        }
+        target2.client.send({ type: "chat.ask", qid: req.qid, text: m.result.text, tool: req.tool });
+      }
+      return;
+    }
+    if (m.type === "chat.history") {
+      if (m.turns.some((t) => t.qid === operations.get(machine) && t.relay && (t.relay.status || t.relay.error)) && !closeRows.has(machine)) endOperation(machine);
+      const close = closeRows.get(machine), closing = close && m.turns.find((t) => t.qid === close.qid);
+      if (close && closing?.closes && close.rows.every((r) => {
+        const c = closing.closes[r];
+        return !c || c.closedAt || c.error !== void 0 && c.error !== close.errors[r];
+      })) endOperation(machine);
+      for (const raw of m.turns) if (raw.askedAt >= resetAt && raw.askedAt.slice(0, 10) === historyDay) {
+        const t = mappedTurn(p, raw);
+        turns2.set(t.qid, t);
+      }
+      history();
+      return;
+    }
+    if (m.type === "chat.step" || m.type === "chat.delta" || m.type === "chat.done" || m.type === "chat.error") {
+      if (routing?.qid === m.qid && routing.coordinator === machine && m.type === "chat.error") {
+        routing = null;
+        fail(m.qid, m.message);
+        return;
+      }
+      const qid = globalQid(machine, m.qid), old = turns2.get(qid);
+      if (!old) return;
+      if (m.type === "chat.done") {
+        const raw = { ...old, qid: m.qid, answer: m.text, answeredAt: m.at, proposal: m.proposal, proposals: m.proposals, relay: m.relay, closes: m.closes, projectProposal: m.projectProposal };
+        const t = mappedTurn(p, { ...raw, steps: [] });
+        turns2.set(qid, { ...t, steps: old.steps });
+        history();
+      } else if (m.type === "chat.error") fail(qid, m.message);
+      else if (m.type === "chat.step") {
+        const step2 = { ...m.step, ...m.step.id ? { id: qualify(machine, m.step.id) } : {} };
+        turns2.set(qid, { ...old, steps: [...old.steps, step2] });
+        emit2({ ...m, qid, step: step2 });
+      } else emit2({ ...m, qid });
+      return;
+    }
+    if (m.type === "error") {
+      if (p.restarting) return;
+      if (m.request?.startsWith("mobile.")) {
+        if (machine === "local") {
+          mobileError = { request: m.request, message: m.message, ...m.code ? { code: m.code } : {} };
+          listeners.forEach((fn) => fn());
+        }
+        return;
+      }
+      if (!p.fresh) {
+        p.error = m.message;
+        publish();
+        return;
+      }
+      if (m.request === "repos.inspect") {
+        answerUnfoundInspections(machine);
+        return;
+      }
+      if (m.request === "repos.scan") {
+        answerFailedScans(machine, "outdated");
+        return;
+      }
+      if (m.request === "models.list") {
+        answerFailedModels(machine, "outdated");
+        return;
+      }
+      if ((m.request === "folder.list" || m.request === "folder.create") && [...listings.values()].some((l) => l.machine === machine)) {
+        answerUnfoundListings(machine, m.message || "not found");
+        return;
+      }
+      if (m.request !== void 0 && OPERATIONS.has(m.request)) endOperation(machine);
+      emit2({ ...m, ...m.id ? { id: qualify(machine, m.id) } : {}, message: configs.length > 1 ? `${p.config.label}: ${m.message}` : m.message });
+      return;
+    }
+    if (machine === "local") emit2(m);
+  }
+  function add(c) {
+    const client = makeClient({ url: machineUrl(c, configs[0]), token: opts.token });
+    const p = { config: c, client, status: "connecting", fresh: false, snapshot: null, previews: /* @__PURE__ */ new Map(), off: [] };
+    peers.set(c.id, p);
+    p.off.push(client.onMessage((m) => receive(p, m)), client.onStatus((s) => {
+      p.status = s;
+      if (s !== "open") {
+        p.fresh = false;
+        const op = operations.get(c.id), closing = closeRows.has(c.id);
+        if (endOperation(c.id)) emit2({ type: "error", message: `${c.label} is offline`, ...op === "launch" ? { request: "session.launch" } : closing ? { request: "session.close" } : {} });
+        answerUnfoundInspections(c.id);
+        answerUnfoundListings(c.id, "offline");
+        answerFailedScans(c.id, "offline");
+        answerFailedModels(c.id, "offline");
+        for (const [requestId, owner] of documents) if (owner === c.id) {
+          documents.delete(requestId);
+          emit2({ type: "document.error", requestId, path: "", code: "read_failed" });
+        }
+        if (routing?.coordinator === c.id) {
+          const qid = routing.qid;
+          routing = null;
+          fail(qid, `${c.label} is offline`);
+        }
+        for (const [qid, b] of bindings) {
+          const t = turns2.get(qid);
+          if (b.machine === c.id && t && !t.answeredAt && !t.error) fail(qid, `${c.label} is offline`);
+        }
+      }
+      publish();
+    }));
+    if (connected) client.connect();
+  }
+  for (const c of configs) add(c);
+  function inventory() {
+    return { machines: state2.map((m) => ({ id: m.id, label: m.label, online: m.ready, local: m.id === "local", sessions: m.sessions.slice(0, 500).map((s) => ({ id: s.id, name: s.name, project: s.repo ?? s.project, cwd: s.cwd, topic: s.topic, state: s.state, readOnly: s.source === "hook_only" })), folders: m.recents.slice(0, 100).map((r) => ({ project: r.project, cwd: r.cwd })) })), history: [...turns2.values()].slice(-30).map((t) => ({ question: t.question.slice(0, 2e4), answer: t.answer?.slice(0, 2e4), machineId: t.machineId })) };
+  }
+  const api = {
+    connect() {
+      connected = true;
+      peers.forEach((p) => p.client.connect());
+      publish();
+      history();
+    },
+    close() {
+      connected = false;
+      peers.forEach((p) => p.client.close());
+    },
+    status,
+    onMessage(fn) {
+      messages.add(fn);
+      return () => {
+        messages.delete(fn);
+      };
+    },
+    onStatus(fn) {
+      statuses.add(fn);
+      return () => {
+        statuses.delete(fn);
+      };
+    },
+    send(msg) {
+      if (msg.type === "chat.reset") {
+        if ([...turns2.values()].some((t) => !t.answeredAt && !t.error)) return;
+        turns2.clear();
+        bindings.clear();
+        resetAt = (/* @__PURE__ */ new Date()).toISOString();
+        peers.forEach((p) => {
+          if (available(p)) p.client.send(msg);
+        });
+        history();
+        return;
+      }
+      if (msg.type === "chat.ask") {
+        if (historyDay !== day()) {
+          turns2.clear();
+          bindings.clear();
+          historyDay = day();
+        }
+        if (routing || [...turns2.values()].some((t) => !t.answeredAt && !t.error)) {
+          emit2({ type: "chat.error", qid: msg.qid, message: "one question at a time" });
+          return;
+        }
+        const context = inventory();
+        turns2.set(msg.qid, { qid: msg.qid, question: msg.text, askedAt: (/* @__PURE__ */ new Date()).toISOString(), steps: [] });
+        history();
+        if (configs.length === 1) {
+          const p = peers.get("local");
+          if (!available(p)) return fail(msg.qid, "Local is offline");
+          bindings.set(msg.qid, { machine: "local", raw: msg.qid });
+          p.client.send(msg);
+          return;
+        }
+        const coordinator = [...peers.values()].find((p) => available(p) && p.snapshot?.daemon?.routing);
+        if (!coordinator) return fail(msg.qid, "Update a connected daemon to enable multi-machine chat");
+        routing = { qid: msg.qid, text: msg.text, tool: msg.tool, coordinator: coordinator.config.id };
+        coordinator.client.send({ type: "chat.route", qid: msg.qid, text: msg.text, tool: msg.tool, context });
+        return;
+      }
+      if (msg.type === "chat.cancel" && routing?.qid === msg.qid) {
+        peers.get(routing.coordinator)?.client.send(msg);
+        routing = null;
+        fail(msg.qid, "cancelled");
+        return;
+      }
+      let machine = selected;
+      let outgoing = msg;
+      if ("id" in msg) {
+        const origin = splitId(msg.id);
+        if (!origin) {
+          emit2({ type: "error", id: msg.id, message: "Unknown machine", request: msg.type });
+          return;
+        }
+        machine = origin.machine;
+        outgoing = { ...msg, id: origin.id };
+      }
+      if ("qid" in msg && msg.qid) {
+        const b = bindings.get(msg.qid);
+        if (!b) {
+          emit2({ type: "error", message: "Unknown conversation destination", request: msg.type });
+          return;
+        }
+        machine = b.machine;
+        outgoing = { ...outgoing, qid: b.raw };
+      }
+      if (msg.type === "document.read") {
+        if (configs.length > 1 && !msg.machineId && !msg.sessionId) {
+          emit2({ type: "document.error", requestId: msg.requestId, path: msg.path, code: "read_failed" });
+          return;
+        }
+        if (msg.machineId) machine = msg.machineId;
+        const origin = msg.sessionId ? splitId(msg.sessionId) : null;
+        if (origin) {
+          machine = origin.machine;
+          outgoing = { ...msg, sessionId: origin.id };
+        }
+        documents.set(msg.requestId, machine);
+      }
+      if (msg.type === "session.launch" && msg.machineId) {
+        machine = msg.machineId;
+        const { machineId: _m, ...rest } = msg;
+        outgoing = rest;
+      }
+      if (msg.type === "repos.inspect") {
+        machine = msg.machineId ?? "local";
+        const { machineId: _m, ...rest } = msg;
+        outgoing = rest;
+        const none = msg.paths.map((path) => ({ path, exists: false, branch: null }));
+        if (!available(peers.get(machine))) {
+          emit2({ type: "repos.info", requestId: msg.requestId, repos: none });
+          return;
+        }
+        inspections.set(msg.requestId, machine);
+        unfound.set(msg.requestId, none);
+      }
+      if (msg.type === "repos.scan") {
+        machine = msg.machineId ?? "local";
+        const { machineId: _m, ...rest } = msg;
+        outgoing = rest;
+        if (!available(peers.get(machine))) {
+          emit2({ type: "repos.found", requestId: msg.requestId, repos: [], truncated: false, error: "offline" });
+          return;
+        }
+        scans.set(msg.requestId, machine);
+      }
+      if (msg.type === "models.list") {
+        machine = msg.machineId ?? "local";
+        const { machineId: _m, ...rest } = msg;
+        outgoing = rest;
+        if (!available(peers.get(machine))) {
+          emit2({ type: "models.listing", requestId: msg.requestId, tool: msg.tool, models: [], error: "offline" });
+          return;
+        }
+        modelLists.set(msg.requestId, { machine, tool: msg.tool });
+      }
+      if (msg.type === "folder.list") {
+        if (msg.machineId) machine = msg.machineId;
+        else if (msg.requestId !== void 0) machine = "local";
+        const { machineId: _m, ...rest } = msg;
+        outgoing = rest;
+        if (msg.requestId !== void 0) {
+          if (!available(peers.get(machine))) {
+            emit2({ type: "folder.listing", requestId: msg.requestId, path: msg.path || "~", parent: null, entries: [], error: "offline" });
+            return;
+          }
+          listings.set(msg.requestId, { machine, path: msg.path || "~" });
+        }
+      }
+      if (msg.type === "folder.create") {
+        if (msg.machineId) machine = msg.machineId;
+        else if (msg.requestId !== void 0) machine = "local";
+        const { machineId: _m, ...rest } = msg;
+        outgoing = rest;
+        if (msg.requestId !== void 0) {
+          if (!available(peers.get(machine))) {
+            emit2({ type: "folder.listing", requestId: msg.requestId, path: msg.parent, parent: null, entries: [], error: "offline" });
+            return;
+          }
+          listings.set(msg.requestId, { machine, path: msg.parent, created: `${msg.parent === "/" ? "" : msg.parent}/${msg.name.trim()}` });
+        }
+      }
+      if (msg.type === "update.daemon") machine = "local";
+      if (msg.type === "snapshot.request") {
+        publish();
+        history();
+        return;
+      }
+      const target2 = peers.get(machine);
+      if (!available(target2)) {
+        if (msg.type === "document.read") {
+          documents.delete(msg.requestId);
+          emit2({ type: "document.error", requestId: msg.requestId, path: msg.path, code: "read_failed" });
+        } else emit2({ type: "error", ..."id" in msg ? { id: msg.id } : {}, message: `${target2?.config.label ?? machine} is offline`, request: msg.type });
+        return;
+      }
+      if (outgoing.type === "session.launch" || outgoing.type === "session.relay" || outgoing.type === "session.relay.cancel") {
+        closeRows.delete(machine);
+        operations.set(machine, outgoing.qid ?? "launch");
+      }
+      if (outgoing.type === "session.close") {
+        const all = turns2.get(msg.type === "session.close" ? msg.qid : "")?.closes ?? [];
+        if (all.length) {
+          closeRows.set(machine, { qid: outgoing.qid, rows: outgoing.rows ?? all.map((_, i) => i), errors: all.map((c) => c.error) });
+          operations.set(machine, outgoing.qid);
+        }
+      }
+      target2.client.send(outgoing);
+    },
+    fleet: {
+      primary: peers.get("local").client,
+      subscribe(fn) {
+        listeners.add(fn);
+        return () => {
+          listeners.delete(fn);
+        };
+      },
+      machines: () => state2,
+      selected: () => selected,
+      select(id) {
+        if (!peers.has(id)) return;
+        selected = id;
+        publish();
+      },
+      configure(raw) {
+        const next2 = parseMachines(raw);
+        if (source === "daemon") {
+          const local = peers.get("local").client;
+          if (local.status() !== "open") throw Object.assign(new Error("The local daemon is not connected"), { name: "DaemonOffline" });
+          local.send({ type: "machines.set", machines: toWire(next2) });
+          return;
+        }
+        localStorage.setItem(MACHINES_KEY, JSON.stringify(next2));
+        apply(next2);
+      },
+      machinesSource: () => source,
+      probe: (ssh) => probeMachine(configs[0].url, ssh, { token: opts.token }),
+      // The last try's error is forgotten: the machine is « connecting » until its next answer (a snapshot, or an error again).
+      retry(id) {
+        const p = peers.get(id);
+        if (!p || !connected) return;
+        p.error = void 0;
+        p.client.connect();
+        publish();
+      },
+      terminal(id, opts2) {
+        const origin = splitId(id);
+        const m = state2.find((x) => x.id === origin?.machine);
+        return origin && m ? terminalCommand(m, origin.id, opts2) : null;
+      },
+      shell(id) {
+        const origin = splitId(id);
+        const m = state2.find((x) => x.id === origin?.machine);
+        const s = m?.sessions.find((x) => x.id === origin?.id);
+        return m && s ? shellCommand(m, s.workdir ?? s.cwd) : null;
+      },
+      turnMachine(qid) {
+        return state2.find((m) => m.id === bindings.get(qid)?.machine);
+      },
+      documentMachine(id) {
+        return splitId(id)?.machine;
+      },
+      localSnapshot: () => peers.get("local")?.snapshot ?? null,
+      sendTo(machine, msg) {
+        const p = peers.get(machine);
+        if (!available(p)) return false;
+        p.client.send(msg);
+        return true;
+      },
+      onMachineMessage(fn) {
+        machineMessages.add(fn);
+        return () => {
+          machineMessages.delete(fn);
+        };
+      },
+      projects: () => projects,
+      setProjects(next2) {
+        const valid = ProjectsSchema.parse(next2);
+        const local = peers.get("local").client;
+        if (local.status() !== "open") throw Object.assign(new Error("The local daemon is not connected"), { name: "DaemonOffline" });
+        if (projects === null) throw Object.assign(new Error("Update the local Ledge daemon: it does not know projects"), { name: "DaemonOutdated" });
+        local.send({ type: "projects.set", projects: valid });
+      },
+      island: () => island,
+      setIsland(next2) {
+        const valid = IslandPrefsSchema.parse(next2);
+        const local = peers.get("local").client;
+        if (local.status() !== "open") throw Object.assign(new Error("The local daemon is not connected"), { name: "DaemonOffline" });
+        if (island === void 0) throw Object.assign(new Error("Update the local Ledge daemon: it does not know the island settings"), { name: "DaemonOutdated" });
+        local.send({ type: "island.set", prefs: valid });
+      },
+      mobile: () => mobile,
+      mobileError: () => mobileError,
+      sendMobile(msg) {
+        const local = peers.get("local").client;
+        if (local.status() !== "open") throw Object.assign(new Error("The local daemon is not connected"), { name: "DaemonOffline" });
+        if (mobile === void 0) throw Object.assign(new Error("Update the local Ledge daemon: it does not know mobile access"), { name: "DaemonOutdated" });
+        if (mobileError) {
+          mobileError = void 0;
+          listeners.forEach((fn) => fn());
+        }
+        local.send(msg);
+      }
+    }
+  };
+  publish();
+  return api;
+}
+
+// ../fleet/src/proposals.ts
+var COLORS = Object.keys(PROJECT_COLORS);
+
+// src/tui/App.tsx
+import { useCallback, useEffect as useEffect9, useMemo as useMemo6, useRef as useRef8, useState as useState8 } from "react";
+import { useApp, useInput as useInput5, useStdout } from "ink";
+
+// src/tui/actions.ts
+import { useEffect as useEffect2, useMemo, useRef as useRef2 } from "react";
+
+// ../fleet/src/decisions.ts
+import { useEffect, useRef, useState } from "react";
+function requestKey(s) {
+  const p = s.pending;
+  return p ? `${p.kind}
+${p.text}
+${p.helperId ?? ""}` : null;
+}
+var UNCONFIRMED_MS = 8e3;
+var FLASH_MS = 1800;
+function markOf(s) {
+  return JSON.stringify([s.state, s.lastActivityAt, s.lastReply ?? null, requestKey(s)]);
+}
+function useDecisions(o) {
+  const { sessions, errors } = o;
+  const live = useRef(/* @__PURE__ */ new Map());
+  const [inFlight, setInFlight] = useState(() => /* @__PURE__ */ new Set());
+  const [landed, setLanded] = useState(null);
+  const latest = useRef({ o });
+  latest.current = { o };
+  const seen = useRef(errors.at(-1)?.seq ?? 0);
+  const forget = (id) => {
+    const x = live.current.get(id);
+    if (!x) return null;
+    clearTimeout(x.timer);
+    live.current.delete(id);
+    setInFlight(new Set(live.current.keys()));
+    return x;
+  };
+  const settled = useRef(/* @__PURE__ */ new Map());
+  const unsettle = (id) => {
+    const x = settled.current.get(id);
+    if (x) {
+      clearTimeout(x.timer);
+      settled.current.delete(id);
+    }
+    return x;
+  };
+  useEffect(() => {
+    const byId = new Map(sessions.map((s) => [s.id, s]));
+    for (const [id, x] of [...live.current]) {
+      const s = byId.get(id);
+      if (!s) forget(id);
+      else if (!s.offline && (x.message === "session.reply" ? markOf(s) !== x.mark : requestKey(s) !== x.pending)) {
+        forget(id);
+        setLanded({ id });
+        if (x.message === "session.reply" || x.text !== void 0) {
+          unsettle(id);
+          settled.current.set(id, { ...x, timer: setTimeout(() => settled.current.delete(id), UNCONFIRMED_MS) });
+        }
+      }
+    }
+    for (const id of [...settled.current.keys()]) if (!byId.has(id)) unsettle(id);
+  }, [sessions]);
+  useEffect(() => {
+    const last = errors.at(-1)?.seq ?? 0;
+    if (last < seen.current) seen.current = 0;
+    for (const e of errors) {
+      if (e.seq <= seen.current) continue;
+      seen.current = e.seq;
+      if (e.id === void 0 || !e.request) continue;
+      const matches = (x2) => !!x2 && e.request === x2.message && e.seq > x2.errorSeq;
+      const inFlightNow = live.current.get(e.id);
+      const done = settled.current.get(e.id);
+      const x = matches(inFlightNow) ? forget(e.id) : matches(done) && (done.message === "session.reply" || e.code === NOTE_NOT_TYPED) ? unsettle(e.id) : null;
+      if (!x) continue;
+      const { o: cur } = latest.current, tr = cur.copy;
+      cur.notify(e.code === NOTE_NOT_TYPED ? tr.noteNotTyped : x.message === "session.decide" ? tr.failed(x.name, e.message) : tr.replyFailed(x.name, e.message));
+      if (x.text !== void 0) x.onRefused?.(x.text);
+    }
+  }, [errors]);
+  useEffect(() => {
+    if (!landed) return;
+    const timer = setTimeout(() => setLanded(null), FLASH_MS);
+    return () => clearTimeout(timer);
+  }, [landed]);
+  useEffect(() => () => {
+    for (const x of [...live.current.values(), ...settled.current.values()]) clearTimeout(x.timer);
+    live.current.clear();
+    settled.current.clear();
+  }, []);
+  const send = (s, message, payload, extra = {}) => {
+    const { name, id } = s;
+    if (message === "session.reply") unsettle(id);
+    const timer = setTimeout(() => {
+      const x = forget(id);
+      if (!x) return;
+      const { o: cur } = latest.current, tr = cur.copy;
+      cur.notify(message === "session.decide" ? tr.unconfirmed(name) : tr.replyUnconfirmed(name));
+    }, UNCONFIRMED_MS);
+    live.current.set(id, { message, pending: requestKey(s), mark: markOf(s), errorSeq: latest.current.o.errors.at(-1)?.seq ?? 0, name, timer, ...extra });
+    setInFlight(new Set(live.current.keys()));
+    latest.current.o.client.send(payload);
+    return true;
+  };
+  return {
+    busy: (id) => inFlight.has(id),
+    landed: landed?.id ?? null,
+    decide(s, decision, note, onRefused) {
+      const p = s.pending;
+      if (s.offline || s.source === "hook_only" || !p || p.kind === "question" || live.current.has(s.id)) return false;
+      if (decision === "always" && !offers(s.tool, p.kind, "always")) return false;
+      if (note) {
+        if (decision !== "deny" || note.length > NOTE_MAX || !offers(s.tool, p.kind, "note")) return false;
+      }
+      const payload = { type: "session.decide", id: s.id, decision, ...note ? { note } : {}, expect: { kind: p.kind, text: p.text, key: pendingKey(p) } };
+      return send(s, "session.decide", payload, note ? { text: note, onRefused } : {});
+    },
+    answer(s, answers, cancel) {
+      const p = s.pending;
+      if (s.offline || s.source === "hook_only" || !p?.questions || !p.requestId || live.current.has(s.id)) return false;
+      return send(s, "session.answer", { type: "session.answer", id: s.id, requestId: p.requestId, answers: [...answers], ...cancel ? { cancel: true } : {} });
+    },
+    reply(s, text, onRefused, how) {
+      if (s.offline || s.source === "hook_only" || !text.trim() || live.current.has(s.id) || s.pending && s.pending.kind !== "question") return false;
+      return send(s, "session.reply", { type: "session.reply", id: s.id, text, ...how?.steer ? { steer: true } : {} }, { text, onRefused });
+    }
+  };
+}
+
+// src/tui/model/pending.ts
+var isFreeRow = (label) => /^Type something\.?$/.test(label);
+function answerFor(s, key) {
+  const p = s.pending;
+  const digit = /^[1-9]$/.test(key) ? Number(key) : null;
+  if (key !== "y" && key !== "n" && key !== "A" && digit === null) return null;
+  if (s.offline) return { kind: "refused", why: "offline" };
+  if (s.source === "hook_only") return { kind: "refused", why: "readOnly" };
+  if (!p) return { kind: "refused", why: "notNow" };
+  if (p.kind !== "question") {
+    if (key === "y") return { kind: "decide", decision: "accept" };
+    if (key === "n") return { kind: "decide", decision: "deny" };
+    if (key === "A") return offers(s.tool, p.kind, "always") ? { kind: "decide", decision: "always" } : { kind: "refused", why: "noAlways" };
+    return { kind: "refused", why: "notNow" };
+  }
+  if (digit === null) return { kind: "refused", why: "notNow" };
+  const q = p.questions?.length === 1 ? p.questions[0] : void 0;
+  if (q) {
+    const option2 = q.options[digit - 1];
+    return option2 && !q.multi ? { kind: "select", questionId: q.id, label: option2.label, n: digit } : { kind: "refused", why: "notNow" };
+  }
+  const option = p.options?.[digit - 1];
+  return option !== void 0 && !isFreeRow(option) ? { kind: "option", n: digit } : { kind: "refused", why: "notNow" };
+}
+function choices(p) {
+  const q = p.questions?.length === 1 ? p.questions[0] : void 0;
+  const labels = q ? q.options.map((o) => o.label) : p.options ?? [];
+  return labels.map((label, i) => ({ n: i + 1, label })).filter((c) => !isFreeRow(c.label));
+}
+
+// src/tui/actions.ts
+function useActions(o) {
+  const { t, toast } = o;
+  const decisions = useDecisions({ client: o.client, sessions: o.sessions, errors: o.errors, notify: (text) => toast({ text, tone: "error" }), copy: t.decisions });
+  const onLand = useRef2(/* @__PURE__ */ new Map());
+  useEffect2(() => {
+    const id = decisions.landed;
+    if (!id) return;
+    const text = onLand.current.get(id);
+    if (text) {
+      onLand.current.delete(id);
+      toast({ text, tone: "ok" });
+    }
+  }, [decisions.landed]);
+  return useMemo(() => ({
+    key(s, key) {
+      const a = answerFor(s, key);
+      if (!a) return false;
+      if (a.kind === "refused") {
+        toast({ text: t.toast[a.why](s.name), tone: "info" });
+        return true;
+      }
+      if (decisions.busy(s.id)) {
+        toast({ text: t.toast.busy(s.name), tone: "info" });
+        return true;
+      }
+      const sent = a.kind === "decide" ? decisions.decide(s, a.decision) : a.kind === "option" ? decisions.reply(s, String(a.n)) : decisions.answer(s, [{ id: a.questionId, selected: [a.label] }]);
+      if (sent) onLand.current.set(s.id, a.kind === "decide" ? t.toast[a.decision](s.name) : t.toast.option(s.name, a.n));
+      else toast({ text: t.toast.notNow(s.name), tone: "info" });
+      return true;
+    },
+    denyWithNote(s, note, onRefused) {
+      if (decisions.decide(s, "deny", note, onRefused)) onLand.current.set(s.id, t.toast.deny(s.name));
+      else {
+        onRefused(note);
+        toast({ text: t.toast.noNote(s.name), tone: "info" });
+      }
+    },
+    reply(s, text, onRefused) {
+      const sent = decisions.reply(s, text, onRefused);
+      if (sent) onLand.current.set(s.id, t.toast.reply(s.name));
+      else toast({ text: s.offline ? t.toast.offline(s.name) : s.source === "hook_only" ? t.toast.readOnly(s.name) : t.toast.busy(s.name), tone: "info" });
+      return sent;
+    },
+    interrupt(s) {
+      if (s.offline) {
+        toast({ text: t.toast.offline(s.name), tone: "info" });
+        return;
+      }
+      if (s.source === "hook_only") {
+        toast({ text: t.toast.readOnly(s.name), tone: "info" });
+        return;
+      }
+      o.client.send({ type: "session.interrupt", id: s.id });
+      toast({ text: t.toast.interrupted(s.name), tone: "info" });
+    },
+    busy: (id) => decisions.busy(id)
+  }), [decisions, t, toast, o.client]);
+}
+
+// src/tui/attach.ts
+import { spawn } from "child_process";
+function attachCommand(fleet, s) {
+  if (s.offline) return { why: "offline" };
+  if (backendOf(s) === "omp-rpc") return { why: "omp" };
+  if (!s.tmuxSession) return { why: "none" };
+  const argv = fleet.terminal(s.id);
+  return argv && argv.length > 0 ? { argv } : { why: "none" };
+}
+function runAttached(argv, env = process.env) {
+  return new Promise((resolve) => {
+    const child = spawn(argv[0], argv.slice(1), { stdio: "inherit", env: attachEnv(env) });
+    child.on("error", () => resolve(127));
+    child.on("exit", (code) => resolve(code ?? 1));
+  });
+}
+
+// src/tui/context.tsx
+import { createContext, useContext, useEffect as useEffect3, useRef as useRef3 } from "react";
+var SCREENS = ["overview", "session", "ask", "launch", "settings"];
+var TuiContext = createContext(null);
+var useTui = () => {
+  const tui = useContext(TuiContext);
+  if (!tui) throw new Error("useTui outside the TUI");
+  return tui;
+};
+function useScreenKeys(handler) {
+  const { keys } = useTui();
+  const latest = useRef3(handler);
+  latest.current = handler;
+  useEffect3(() => {
+    const fn = (i, k) => latest.current(i, k);
+    keys.current = fn;
+    return () => {
+      if (keys.current === fn) keys.current = null;
+    };
+  }, [keys]);
+}
+function useEditing(on) {
+  const { setEditing } = useTui();
+  useEffect3(() => {
+    setEditing(on);
+    return () => setEditing(false);
+  }, [on, setEditing]);
+}
+
+// src/tui/i18n/lang.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+
+// src/tui/i18n/fr.ts
+var plural = (n, one, many) => n > 1 ? many : one;
+var fr = {
+  lang: { fr: "Fran\xE7ais", en: "English" },
+  state: { approval: "Votre accord", question: "Une question", starting: "D\xE9marrage", idle: "Disponible", working: "Au travail", done: "Termin\xE9e", error: "Erreur", readonly: "Lecture seule" },
+  time: {
+    now: "\xE0 l\u2019instant",
+    s: (n) => `${n} s`,
+    min: (n) => `${n} min`,
+    h: (n) => `${n} h`,
+    d: (n) => `${n} j`
+  },
+  tabs: { overview: "Vue d\u2019ensemble", session: "Session", ask: "Demander \xE0 Ledge", launch: "Nouvelle session", settings: "R\xE9glages" },
+  bar: {
+    sessions: (n) => `${n} ${plural(n, "session", "sessions")}`,
+    machines: (n) => `${n} ${plural(n, "machine", "machines")}`,
+    waiting: (n) => `${n} t\u2019${plural(n, "attend", "attendent")}`,
+    connecting: "connexion au daemon\u2026",
+    unreachable: "daemon injoignable, nouvel essai\u2026",
+    tokenMissing: "pas de jeton : lancez une session avec `ledge claude` ou `ledge daemon`"
+  },
+  keys: {
+    navigate: "naviguer",
+    open: "ouvrir",
+    answer: "r\xE9pondre",
+    attach: "attacher (tmux)",
+    ask: "demander \xE0 Ledge",
+    launch: "nouvelle session",
+    settings: "r\xE9glages",
+    help: "aide",
+    quit: "quitter",
+    back: "retour",
+    write: "\xE9crire",
+    diffs: "diffs",
+    terminal: "terminal",
+    model: "mod\xE8le",
+    interrupt: "interrompre",
+    next: "suivante en attente",
+    unfold: "d\xE9plier",
+    send: "envoyer / lancer",
+    nextCard: "carte suivante",
+    newChat: "nouvelle conversation",
+    stopAnswer: "arr\xEAter la r\xE9ponse",
+    nextField: "champ suivant",
+    choose: "choisir",
+    tick: "cocher",
+    start: "lancer",
+    cancel: "annuler",
+    change: "changer",
+    scroll: "d\xE9filer",
+    space: "espace",
+    redraw: "autre nom"
+  },
+  overview: {
+    yours: (n) => `\xC0 toi \xB7 ${n}`,
+    projects: "Projets",
+    exchanges: "\xC9changes",
+    terminal: (name) => `Terminal \xB7 ${name}`,
+    nobodyWaits: "Personne ne t\u2019attend.",
+    noSession: "Aucune session. + pour en lancer une.",
+    noPreview: "Pas d\u2019aper\xE7u.",
+    noExchange: "Aucun \xE9change.",
+    sessions: (n) => `${n} ${plural(n, "session", "sessions")}`,
+    outside: "Hors projet",
+    offline: "hors ligne",
+    readOnly: "lecture seule",
+    wantsToRun: "Veut ex\xE9cuter :",
+    asks: "Demande :",
+    plan: "Propose un plan :",
+    diff: "Veut modifier :",
+    allow: "Autoriser",
+    deny: "Refuser",
+    always: "Toujours",
+    denyWithNote: "Refuser en expliquant"
+  },
+  session: {
+    you: "Vous",
+    unfold: "d\xE9plier",
+    fold: "replier",
+    actions: (n) => `${n} ${plural(n, "action", "actions")}`,
+    files: (n) => `${n} ${plural(n, "fichier modifi\xE9", "fichiers modifi\xE9s")}`,
+    since: (label, t) => `${label} \xB7 depuis ${t}`,
+    wantsTo: (name) => `${name} veut ex\xE9cuter :`,
+    sentTo: "envoy\xE9 \xE0",
+    receivedFrom: "re\xE7u de",
+    sent: { sending: "envoi\u2026", delivered: "remis", read: "lu", failed: "\xE9chec" },
+    helperWorking: (n) => `au travail \xB7 ${n} ${plural(n, "action", "actions")}`,
+    helperDone: "termin\xE9",
+    replyTo: (name) => `R\xE9pondre \xE0 ${name}\u2026`,
+    noteFor: (name) => `Expliquer le refus \xE0 ${name}\u2026`,
+    loading: "Chargement du fil\u2026",
+    empty: "Rien encore dans ce fil.",
+    noSession: "Choisissez une session dans la vue d\u2019ensemble.",
+    model: (m) => `mod\xE8le : ${m}`,
+    defaultModel: "par d\xE9faut",
+    notice: "Ledge"
+  },
+  ask: {
+    title: (s, m) => `Ledge \xB7 voit ${s} ${plural(s, "session", "sessions")}, ${m} ${plural(m, "machine", "machines")}`,
+    question: "Question",
+    read: "lu",
+    reading: "Ledge lit\u2026",
+    you: "vous",
+    empty: "Posez une question : qui a besoin de moi, o\xF9 en est une session, que lancer\u2026",
+    launchCard: "Nouvelle session",
+    relayCard: (name) => `Relayer \xE0 ${name}`,
+    closeCard: "Fermer des sessions",
+    launch: "Lancer la session",
+    relay: "Envoyer",
+    cancelRelay: "Retirer de la file",
+    close: "Fermer",
+    ignore: "Ignorer",
+    nothingWithoutYou: "Ledge ne lance rien sans toi.",
+    folder: "Dossier",
+    agent: "Agent",
+    instruction: "Instruction",
+    launched: "lanc\xE9e",
+    queued: "en file",
+    sentAt: "envoy\xE9e",
+    closed: "ferm\xE9e",
+    offline: "Le daemon local est hors ligne : la question attendra.",
+    steps: { sessions: "les sessions", pane: (n) => `le terminal de ${n}`, reply: (n) => `la r\xE9ponse de ${n}`, git: (n) => `l\u2019\xE9tat git de ${n}`, repo: (p) => p }
+  },
+  launch: {
+    title: "Nouvelle session",
+    preview: "Aper\xE7u",
+    instruction: "Instruction",
+    agent: "Agent",
+    model: "Mod\xE8le",
+    effort: "Effort",
+    project: "Projet",
+    machine: "Machine",
+    repos: "D\xE9p\xF4ts",
+    folder: "Dossier",
+    name: "Nom",
+    none: "aucun",
+    defaultModel: "par d\xE9faut",
+    loading: "chargement\u2026",
+    drawn: "(tir\xE9 au sort \xB7 ctrl+r pour un autre)",
+    folderHint: "chemin sur la machine (~ accept\xE9)",
+    joins: (name, table) => `${name} rejoindra ${table}`,
+    launch: "Lancer",
+    cancel: "Annuler",
+    thenAttach: "puis a pour s\u2019attacher \xE0 son terminal",
+    missing: { prompt: "\xC9crivez une instruction.", machine: "Aucune machine en ligne.", repos: "Choisissez un d\xE9p\xF4t ou un dossier." },
+    launching: "Lancement\u2026",
+    launched: (name) => `\u2713 ${name} est lanc\xE9e`
+  },
+  settings: { title: "R\xE9glages", language: "Langue", saved: "R\xE9glage enregistr\xE9.", saveFailed: (m) => `R\xE9glage appliqu\xE9, mais non enregistr\xE9 : ${m}` },
+  help: {
+    title: "Aide",
+    global: "Partout",
+    overview: "Vue d\u2019ensemble",
+    session: "Session",
+    ask: "Demander \xE0 Ledge",
+    launch: "Nouvelle session",
+    settings: "R\xE9glages",
+    screens: "changer d\u2019\xE9cran"
+  },
+  toast: {
+    accept: (n) => `\u2713 ${n} : autoris\xE9`,
+    deny: (n) => `\u2713 ${n} : refus\xE9`,
+    always: (n) => `\u2713 ${n} : toujours autoris\xE9`,
+    option: (n, k) => `\u2713 ${n} : option ${k} envoy\xE9e`,
+    reply: (n) => `\u2713 R\xE9ponse envoy\xE9e \xE0 ${n}`,
+    interrupted: (n) => `${n} : interruption demand\xE9e`,
+    model: (n, m) => `${n} : mod\xE8le ${m}`,
+    notNow: (n) => `Rien \xE0 r\xE9pondre pour ${n}.`,
+    offline: (n) => `${n} est hors ligne.`,
+    readOnly: (n) => `${n} est en lecture seule : r\xE9pondez dans son terminal.`,
+    busy: (n) => `Un envoi pour ${n} est d\xE9j\xE0 en cours.`,
+    noAlways: (n) => `${n} ne propose pas \xAB toujours \xBB ici.`,
+    noNote: (n) => `${n} ne prend pas de note ici.`,
+    noTerminalOmp: (n) => `${n} est pilot\xE9 par Ledge via le protocole d\u2019OMP : pas de terminal \xE0 attacher.`,
+    noTerminal: (n) => `Pas de terminal pour ${n}.`,
+    attachFailed: (code) => `tmux s\u2019est arr\xEAt\xE9 avec le code ${code}.`,
+    modelSwitch: "Ce daemon ne change pas le mod\xE8le d\u2019une session en cours."
+  },
+  decisions: {
+    failed: (name, message) => `D\xE9cision non transmise \xE0 ${name} : ${message}`,
+    unconfirmed: (name) => `Ledge n\u2019a pas vu la d\xE9cision pour ${name} aboutir. Ouvrez la session pour v\xE9rifier.`,
+    replyFailed: (name, message) => `R\xE9ponse non transmise \xE0 ${name} : ${message}`,
+    replyUnconfirmed: (name) => `Ledge n\u2019a pas vu la r\xE9ponse \xE0 ${name} aboutir. V\xE9rifiez le fil.`,
+    noteNotTyped: "Refus\xE9, mais la note n\u2019a pas pu \xEAtre tap\xE9e."
+  },
+  notify: {
+    approval: (n, text) => `${n} attend ton accord : ${text}`,
+    question: (n, text) => `${n} a une question : ${text}`,
+    title: (n) => n > 0 ? `ledge \xB7 ${n} t\u2019${plural(n, "attend", "attendent")}` : "ledge"
+  },
+  cli: { notTty: "ledge tui: needs a terminal (stdin and stdout must be a TTY)" }
+};
+
+// src/tui/i18n/en.ts
+var plural2 = (n, one, many) => n > 1 ? many : one;
+var en = {
+  lang: { fr: "Fran\xE7ais", en: "English" },
+  state: { approval: "Needs you", question: "A question", starting: "Starting", idle: "Available", working: "Working", done: "Finished", error: "Error", readonly: "Read-only" },
+  time: { now: "just now", s: (n) => `${n}s`, min: (n) => `${n} min`, h: (n) => `${n} h`, d: (n) => `${n} d` },
+  tabs: { overview: "Overview", session: "Session", ask: "Ask Ledge", launch: "New session", settings: "Settings" },
+  bar: {
+    sessions: (n) => `${n} ${plural2(n, "session", "sessions")}`,
+    machines: (n) => `${n} ${plural2(n, "machine", "machines")}`,
+    waiting: (n) => `${n} waiting for you`,
+    connecting: "connecting to the daemon\u2026",
+    unreachable: "daemon unreachable, retrying\u2026",
+    tokenMissing: "no token: start a session with `ledge claude` or run `ledge daemon`"
+  },
+  keys: {
+    navigate: "move",
+    open: "open",
+    answer: "answer",
+    attach: "attach (tmux)",
+    ask: "ask Ledge",
+    launch: "new session",
+    settings: "settings",
+    help: "help",
+    quit: "quit",
+    back: "back",
+    write: "write",
+    diffs: "diffs",
+    terminal: "terminal",
+    model: "model",
+    interrupt: "interrupt",
+    next: "next waiting",
+    unfold: "unfold",
+    send: "send / launch",
+    nextCard: "next card",
+    newChat: "new conversation",
+    stopAnswer: "stop the answer",
+    nextField: "next field",
+    choose: "choose",
+    tick: "tick",
+    start: "launch",
+    cancel: "cancel",
+    change: "change",
+    scroll: "scroll",
+    space: "space",
+    redraw: "another name"
+  },
+  overview: {
+    yours: (n) => `Yours \xB7 ${n}`,
+    projects: "Projects",
+    exchanges: "Messages",
+    terminal: (name) => `Terminal \xB7 ${name}`,
+    nobodyWaits: "Nobody is waiting for you.",
+    noSession: "No session. Press + to start one.",
+    noPreview: "No preview.",
+    noExchange: "No message yet.",
+    sessions: (n) => `${n} ${plural2(n, "session", "sessions")}`,
+    outside: "No project",
+    offline: "offline",
+    readOnly: "read-only",
+    wantsToRun: "Wants to run:",
+    asks: "Asks:",
+    plan: "Proposes a plan:",
+    diff: "Wants to edit:",
+    allow: "Allow",
+    deny: "Deny",
+    always: "Always",
+    denyWithNote: "Deny with a note"
+  },
+  session: {
+    you: "You",
+    unfold: "unfold",
+    fold: "fold",
+    actions: (n) => `${n} ${plural2(n, "action", "actions")}`,
+    files: (n) => `${n} ${plural2(n, "file changed", "files changed")}`,
+    since: (label, t) => `${label} \xB7 for ${t}`,
+    wantsTo: (name) => `${name} wants to run:`,
+    sentTo: "sent to",
+    receivedFrom: "from",
+    sent: { sending: "sending\u2026", delivered: "delivered", read: "read", failed: "failed" },
+    helperWorking: (n) => `working \xB7 ${n} ${plural2(n, "action", "actions")}`,
+    helperDone: "done",
+    replyTo: (name) => `Reply to ${name}\u2026`,
+    noteFor: (name) => `Tell ${name} why\u2026`,
+    loading: "Loading the thread\u2026",
+    empty: "Nothing in this thread yet.",
+    noSession: "Pick a session in the overview.",
+    model: (m) => `model: ${m}`,
+    defaultModel: "default",
+    notice: "Ledge"
+  },
+  ask: {
+    title: (s, m) => `Ledge \xB7 sees ${s} ${plural2(s, "session", "sessions")}, ${m} ${plural2(m, "machine", "machines")}`,
+    question: "Question",
+    read: "read",
+    reading: "Ledge is reading\u2026",
+    you: "you",
+    empty: "Ask anything: who needs me, how a session is doing, what to start\u2026",
+    launchCard: "New session",
+    relayCard: (name) => `Relay to ${name}`,
+    closeCard: "Close sessions",
+    launch: "Launch the session",
+    relay: "Send",
+    cancelRelay: "Take it back",
+    close: "Close",
+    ignore: "Ignore",
+    nothingWithoutYou: "Ledge starts nothing without you.",
+    folder: "Folder",
+    agent: "Agent",
+    instruction: "Instruction",
+    launched: "launched",
+    queued: "queued",
+    sentAt: "sent",
+    closed: "closed",
+    offline: "The local daemon is offline: the question will wait.",
+    steps: { sessions: "the sessions", pane: (n) => `${n}'s terminal`, reply: (n) => `${n}'s reply`, git: (n) => `${n}'s git state`, repo: (p) => p }
+  },
+  launch: {
+    title: "New session",
+    preview: "Preview",
+    instruction: "Instruction",
+    agent: "Agent",
+    model: "Model",
+    effort: "Effort",
+    project: "Project",
+    machine: "Machine",
+    repos: "Repositories",
+    folder: "Folder",
+    name: "Name",
+    none: "none",
+    defaultModel: "default",
+    loading: "loading\u2026",
+    drawn: "(drawn at random \xB7 ctrl+r for another)",
+    folderHint: "path on the machine (~ allowed)",
+    joins: (name, table) => `${name} will join ${table}`,
+    launch: "Launch",
+    cancel: "Cancel",
+    thenAttach: "then a to attach to its terminal",
+    missing: { prompt: "Write an instruction.", machine: "No machine online.", repos: "Pick a repository or a folder." },
+    launching: "Launching\u2026",
+    launched: (name) => `\u2713 ${name} is started`
+  },
+  settings: { title: "Settings", language: "Language", saved: "Setting saved.", saveFailed: (m) => `Setting applied, but not saved: ${m}` },
+  help: { title: "Help", global: "Everywhere", overview: "Overview", session: "Session", ask: "Ask Ledge", launch: "New session", settings: "Settings", screens: "switch screen" },
+  toast: {
+    accept: (n) => `\u2713 ${n}: allowed`,
+    deny: (n) => `\u2713 ${n}: denied`,
+    always: (n) => `\u2713 ${n}: always allowed`,
+    option: (n, k) => `\u2713 ${n}: option ${k} sent`,
+    reply: (n) => `\u2713 Reply sent to ${n}`,
+    interrupted: (n) => `${n}: interrupt asked`,
+    model: (n, m) => `${n}: model ${m}`,
+    notNow: (n) => `Nothing to answer for ${n}.`,
+    offline: (n) => `${n} is offline.`,
+    readOnly: (n) => `${n} is read-only: answer in its terminal.`,
+    busy: (n) => `A send for ${n} is already in flight.`,
+    noAlways: (n) => `${n} does not offer \u201Calways\u201D here.`,
+    noNote: (n) => `${n} takes no note here.`,
+    noTerminalOmp: (n) => `${n} is driven by Ledge over OMP's protocol: there is no terminal to attach to.`,
+    noTerminal: (n) => `No terminal for ${n}.`,
+    attachFailed: (code) => `tmux stopped with code ${code}.`,
+    modelSwitch: "This daemon cannot change a running session\u2019s model."
+  },
+  decisions: {
+    failed: (name, message) => `Could not send the decision to ${name}: ${message}`,
+    unconfirmed: (name) => `Ledge did not see the decision for ${name} land. Open the session to check.`,
+    replyFailed: (name, message) => `Could not send the reply to ${name}: ${message}`,
+    replyUnconfirmed: (name) => `Ledge did not see the reply to ${name} land. Check the thread.`,
+    noteNotTyped: "Refused, but the note could not be typed."
+  },
+  notify: {
+    approval: (n, text) => `${n} needs your approval: ${text}`,
+    question: (n, text) => `${n} has a question: ${text}`,
+    title: (n) => n > 0 ? `ledge \xB7 ${n} waiting` : "ledge"
+  },
+  cli: { notTty: "ledge tui: needs a terminal (stdin and stdout must be a TTY)" }
+};
+
+// src/tui/i18n/lang.tsx
+import { jsx } from "react/jsx-runtime";
+var LANGS = ["fr", "en"];
+var MESSAGES = { fr, en };
+var I18nContext = createContext2({ lang: "fr", t: fr });
+function I18nProvider({ lang, children }) {
+  return /* @__PURE__ */ jsx(I18nContext.Provider, { value: { lang, t: MESSAGES[lang] }, children });
+}
+
+// src/tui/model/overview.ts
+var listed = (sessions) => sessions.filter((s) => s.state !== "exited");
+var machineOf = (s) => s.machineId ?? splitId(s.id)?.machine ?? "local";
+function overview(sessions, projects) {
+  const live = listed(sessions);
+  const yours = live.filter(isPending).sort((a, b) => a.lastActivityAt.localeCompare(b.lastActivityAt) || a.id.localeCompare(b.id));
+  const nodes = /* @__PURE__ */ new Map();
+  const known2 = new Map((projects?.projects ?? []).map((p) => [p.id, p]));
+  for (const p of projects?.projects ?? []) nodes.set(`p:${p.id}`, { key: `p:${p.id}`, label: p.name, color: p.color, branches: [], count: 0 });
+  for (const s of live) {
+    const pid = projects ? projectOf({ machineId: machineOf(s), cwd: s.cwd }, projects) : null;
+    const key = pid && known2.has(pid) ? `p:${pid}` : `r:${machineOf(s)}:${s.repoPath ?? s.cwd}`;
+    let node = nodes.get(key);
+    if (!node) {
+      node = { key, label: s.repo ?? s.project, branches: [], count: 0 };
+      nodes.set(key, node);
+    }
+    const branch = s.branch ?? "-";
+    let row = node.branches.find((b) => b.branch === branch);
+    if (!row) {
+      row = { branch, sessions: [] };
+      node.branches.push(row);
+    }
+    row.sessions.push(s);
+    node.count += 1;
+  }
+  const tree = [...nodes.values()].filter((n) => n.count > 0);
+  const order = tree.flatMap((n) => n.branches.flatMap((b) => b.sessions.map((s) => s.id)));
+  return { yours, tree, order, machines: new Set(live.map(machineOf)).size };
+}
+var helperCount = (s) => liveHelpers(s).length;
+function keepSelection(order, selected, previous = []) {
+  if (selected && order.includes(selected)) return selected;
+  if (selected) {
+    const at = previous.indexOf(selected);
+    for (let i = at; i >= 0 && at >= 0; i--) if (order.includes(previous[i])) return previous[i];
+  }
+  return order[0] ?? null;
+}
+function step(order, selected, by) {
+  if (order.length === 0) return null;
+  const at = selected ? order.indexOf(selected) : -1;
+  return order[(at + by + order.length) % order.length];
+}
+function nextWaiting(yours, selected) {
+  if (yours.length === 0) return null;
+  const at = yours.findIndex((s) => s.id === selected);
+  return yours[(at + 1) % yours.length].id;
+}
+function exchanges(sessions, max) {
+  const byId = new Map(sessions.map((s) => [s.id, s]));
+  return sessions.flatMap((s) => {
+    const m = s.lastMessage;
+    if (!m) return [];
+    const peer = m.peer ? byId.get(m.peer) ?? sessions.find((x) => splitId(x.id)?.id === m.peer) : void 0;
+    return [{ at: m.at, from: s.name, to: peer?.name ?? m.to, summary: m.summary }];
+  }).sort((a, b) => b.at.localeCompare(a.at)).slice(0, max);
+}
+
+// src/tui/model/time.ts
+function ago(iso, now, t) {
+  const s = Math.max(0, Math.floor((now - Date.parse(iso)) / 1e3));
+  if (s < 5) return t.now;
+  if (s < 60) return t.s(s);
+  const m = Math.floor(s / 60);
+  if (m < 60) return t.min(m);
+  const h = Math.floor(m / 60);
+  return h < 24 ? t.h(h) : t.d(Math.floor(h / 24));
+}
+var clock = (iso) => {
+  const d = new Date(iso);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+};
+var oneLine = (s) => s.replace(/\*\*|__|`/g, "").replace(/\s*\n\s*/g, " ").trim();
+
+// src/tui/notify.ts
+var NOTIFY_MODES = ["bell", "osc9", "off"];
+function asked(was, now, t) {
+  const out = [];
+  for (const s of now) {
+    const prev = was.get(s.id);
+    if (!prev) continue;
+    const c = changeOf(prev, s);
+    if (c?.kind !== "asked") continue;
+    const text = oneLine(s.pending?.text ?? "").slice(0, 120);
+    out.push(c.ask === "approval" ? t.approval(s.name, text) : t.question(s.name, text));
+  }
+  return out;
+}
+function notification(text, mode, env) {
+  if (mode === "off") return "";
+  if (mode === "bell") return "\x07";
+  const safe = text.replace(/[\u0000-\u001f\u007f]/g, " ");
+  const osc = `\x1B]9;${safe}\x07`;
+  return env.TMUX ? `\x1BPtmux;${osc.replaceAll("\x1B", "\x1B\x1B")}\x1B\\` : osc;
+}
+var title = (text) => `\x1B]0;${text.replace(/[\u0000-\u001f\u007f]/g, " ")}\x07`;
+
+// src/tui/screens/Overview.tsx
+import { useMemo as useMemo2 } from "react";
+import { Box as Box6, Text as Text6, useWindowSize as useWindowSize2 } from "ink";
+
+// ../ui/src/bots/poseFor.ts
+var FROM_SESSION = {
+  starting: "starting",
+  working: "working",
+  waiting_input: "question",
+  waiting_permission: "approval",
+  idle: "idle",
+  exited: "done",
+  error: "error"
+};
+function botState(session) {
+  if (session.state === "idle" && liveHelpers(session).length > 0) return "working";
+  return FROM_SESSION[session.state];
+}
+
+// src/tui/model/labels.ts
+var TOOL_NAME = { claude: "Claude Code", codex: "Codex", cursor: "Cursor Agent", omp: "OMP" };
+var modelLabel = (s, fallback) => [s.model ?? (s.effort ? fallback : ""), s.effort ?? ""].filter(Boolean).join(" \xB7 ") || fallback;
+var machineLabel = (s) => s.machineName ?? splitId(s.id)?.machine ?? "Local";
+var paneName = (s) => s.tmuxSession ?? `ledge-${splitId(s.id)?.id ?? s.id}`;
+function fit(s, n) {
+  const cps = [...s];
+  if (n <= 0) return "";
+  return cps.length > n ? `${cps.slice(0, Math.max(0, n - 1)).join("")}\u2026` : s + " ".repeat(n - cps.length);
+}
+
+// src/tui/theme.ts
+var C = {
+  fg: "#e6e0dc",
+  dim: "#8f8681",
+  faint: "#5f5854",
+  line: "#3a3532",
+  sel: "#2b2725",
+  coral: "#f07a62",
+  blue: "#7fb2ec",
+  red: "#f0806e",
+  yellow: "#e6c46a",
+  green: "#86cf9d",
+  violet: "#b9a2f0"
+};
+var STATE_COLOR = {
+  approval: C.red,
+  question: C.yellow,
+  working: C.blue,
+  starting: C.blue,
+  idle: C.green,
+  done: C.faint,
+  error: C.red,
+  readonly: C.dim
+};
+var projectColor = (color) => color ? PROJECT_COLORS[color] : C.dim;
+
+// src/tui/ui/Frame.tsx
+import { Box as Box2, Text as Text2, useWindowSize } from "ink";
+
+// src/tui/ui/KeyBar.tsx
+import { Box, Text } from "ink";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function KeyBar({ keys }) {
+  return /* @__PURE__ */ jsx2(Box, { paddingX: 1, columnGap: 2, flexWrap: "wrap", height: 1, overflow: "hidden", children: keys.map(([k, label]) => /* @__PURE__ */ jsxs(Text, { wrap: "truncate", children: [
+    /* @__PURE__ */ jsxs(Text, { color: C.fg, backgroundColor: "#2c2926", children: [
+      " ",
+      k,
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+      " ",
+      label
+    ] })
+  ] }, k)) });
+}
+
+// src/tui/ui/Frame.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function Frame({ crumb, keys, children }) {
+  const { d, machines, t, g, lastToast } = useTui();
+  const { rows, columns } = useWindowSize();
+  const live = listed(d.sessions);
+  const waiting = live.filter(isPending).length;
+  const status = d.status === "open" ? null : d.status === "connecting" ? t.bar.connecting : t.bar.unreachable;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", height: rows, width: columns, children: [
+    /* @__PURE__ */ jsxs2(Box2, { paddingX: 1, justifyContent: "space-between", height: 1, backgroundColor: "#1f1d1b", children: [
+      /* @__PURE__ */ jsxs2(Text2, { wrap: "truncate", children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: C.coral, children: [
+          g.logo,
+          " ledge"
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { color: C.dim, children: [
+          "  ",
+          t.bar.sessions(live.length),
+          " \xB7 ",
+          t.bar.machines(Math.max(1, machines.length))
+        ] }),
+        waiting > 0 ? /* @__PURE__ */ jsxs2(Text2, { color: C.red, children: [
+          " \xB7 ",
+          t.bar.waiting(waiting)
+        ] }) : null,
+        status ? /* @__PURE__ */ jsxs2(Text2, { color: C.yellow, children: [
+          "  ",
+          status
+        ] }) : null
+      ] }),
+      /* @__PURE__ */ jsx3(Text2, { wrap: "truncate", color: C.dim, children: crumb })
+    ] }),
+    /* @__PURE__ */ jsx3(Box2, { flexGrow: 1, flexDirection: "column", overflow: "hidden", children }),
+    lastToast ? /* @__PURE__ */ jsx3(Box2, { paddingX: 1, height: 1, children: /* @__PURE__ */ jsx3(Text2, { wrap: "truncate", color: lastToast.tone === "error" ? C.red : lastToast.tone === "ok" ? C.green : C.yellow, children: lastToast.text }) }) : null,
+    /* @__PURE__ */ jsx3(KeyBar, { keys })
+  ] });
+}
+
+// src/tui/ui/SessionCard.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function Button({ label, k, primary, off }) {
+  return /* @__PURE__ */ jsxs3(Text3, { children: [
+    /* @__PURE__ */ jsxs3(Text3, { color: off ? C.faint : primary ? C.fg : C.fg, backgroundColor: off ? void 0 : primary ? "#3a201b" : "#2c2926", children: [
+      " ",
+      label,
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { color: C.dim, backgroundColor: off ? void 0 : primary ? "#3a201b" : "#2c2926", children: [
+      k,
+      " "
+    ] })
+  ] });
+}
+function SessionCard({ s, note }) {
+  const { t, g } = useTui();
+  const state2 = botState(s);
+  const helpers = liveHelpers(s);
+  const p = s.pending;
+  const canAct = !s.offline && s.source !== "hook_only";
+  const verb = !p ? "" : p.kind === "question" ? t.overview.asks : p.kind === "plan" ? t.overview.plan : p.kind === "diff" ? t.overview.diff : t.overview.wantsToRun;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate", children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: STATE_COLOR[state2], children: [
+        g[state2],
+        " ",
+        t.state[state2]
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { color: C.dim, children: [
+        "  ",
+        TOOL_NAME[s.tool],
+        " \xB7 ",
+        modelLabel(s, t.session.defaultModel),
+        " \xB7 ",
+        machineLabel(s),
+        s.branch ? ` \xB7 ${g.branch} ${s.branch}` : ""
+      ] }),
+      s.offline ? /* @__PURE__ */ jsxs3(Text3, { color: C.yellow, children: [
+        "  ",
+        t.overview.offline
+      ] }) : s.source === "hook_only" ? /* @__PURE__ */ jsxs3(Text3, { color: C.faint, children: [
+        "  ",
+        t.overview.readOnly
+      ] }) : null
+    ] }),
+    helpers.length > 0 ? /* @__PURE__ */ jsxs3(Text3, { color: C.violet, wrap: "truncate", children: [
+      "  ",
+      helpers.map((h) => `${g.helper} ${h.kind} \xB7 ${oneLine(h.task)}`).join("   ")
+    ] }) : null,
+    p ? /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate", children: [
+        /* @__PURE__ */ jsx4(Text3, { color: STATE_COLOR[state2], children: verb }),
+        " ",
+        /* @__PURE__ */ jsx4(Text3, { color: C.fg, bold: true, children: oneLine(p.text) }),
+        p.tool ? /* @__PURE__ */ jsxs3(Text3, { color: C.faint, children: [
+          "  ",
+          p.tool
+        ] }) : null
+      ] }),
+      /* @__PURE__ */ jsx4(Box3, { marginTop: 1, columnGap: 2, flexWrap: "wrap", children: p.kind === "question" ? choices(p).slice(0, 9).map((c, i) => /* @__PURE__ */ jsx4(Button, { label: `${c.n} \xB7 ${c.label}`, k: String(c.n), primary: i === 0, off: !canAct }, c.n)) : /* @__PURE__ */ jsxs3(Fragment, { children: [
+        /* @__PURE__ */ jsx4(Button, { label: t.overview.allow, k: "y", primary: true, off: !canAct }),
+        /* @__PURE__ */ jsx4(Button, { label: t.overview.deny, k: "n", off: !canAct }),
+        offers(s.tool, p.kind, "always") ? /* @__PURE__ */ jsx4(Button, { label: t.overview.always, k: "A", off: !canAct }) : null,
+        note && offers(s.tool, p.kind, "note") ? /* @__PURE__ */ jsx4(Button, { label: t.overview.denyWithNote, k: "r", off: !canAct }) : null
+      ] }) })
+    ] }) : s.lastReply && state2 === "idle" ? /* @__PURE__ */ jsxs3(Text3, { color: C.dim, wrap: "truncate", children: [
+      "  ",
+      oneLine(s.lastReply.text)
+    ] }) : null
+  ] });
+}
+
+// src/tui/ui/Tail.tsx
+import { useRef as useRef4 } from "react";
+import { Box as Box4, Text as Text4, useBoxMetrics } from "ink";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function Tail({ lines, color, empty: empty2, emptyColor }) {
+  const ref = useRef4(null);
+  const { height } = useBoxMetrics(ref);
+  let end = lines.length;
+  while (end > 0 && !lines[end - 1].trim()) end--;
+  const shown = end === 0 ? [] : lines.slice(0, end).slice(-Math.max(1, height));
+  return /* @__PURE__ */ jsx5(Box4, { ref, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: shown.length === 0 ? /* @__PURE__ */ jsx5(Text4, { color: emptyColor, children: empty2 }) : shown.map((l, i) => /* @__PURE__ */ jsx5(Text4, { color, wrap: "truncate", children: l || " " }, i)) });
+}
+
+// src/tui/ui/TitledBox.tsx
+import { useRef as useRef5 } from "react";
+import { Box as Box5, Text as Text5, useBoxMetrics as useBoxMetrics2 } from "ink";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function TitledBox({ title: title2, color = C.line, titleColor = C.dim, children, flexGrow, height, width, flexShrink }) {
+  const ref = useRef5(null);
+  const { width: w } = useBoxMetrics2(ref);
+  const label = ` ${title2.toUpperCase()} `;
+  const room = Math.max(0, w - 3);
+  const shown = [...label].length > room ? `${[...label].slice(0, Math.max(0, room - 2)).join("")}\u2026 ` : label;
+  const rest = Math.max(0, w - 3 - [...shown].length);
+  return /* @__PURE__ */ jsxs4(Box5, { ref, flexDirection: "column", flexGrow, flexShrink, height, width, overflow: "hidden", children: [
+    /* @__PURE__ */ jsxs4(Text5, { wrap: "truncate", children: [
+      /* @__PURE__ */ jsx6(Text5, { color, children: "\u256D\u2500" }),
+      /* @__PURE__ */ jsx6(Text5, { color: titleColor, children: w > 0 ? shown : "" }),
+      /* @__PURE__ */ jsxs4(Text5, { color, children: [
+        "\u2500".repeat(rest),
+        "\u256E"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx6(Box5, { flexDirection: "column", borderStyle: "round", borderTop: false, borderColor: color, paddingX: 1, flexGrow: 1, overflow: "hidden", children })
+  ] });
+}
+
+// src/tui/screens/Overview.tsx
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var WIDE = 100;
+function windowed(rows, selectedKey, height) {
+  if (rows.length <= height) return [...rows];
+  const at = Math.max(0, rows.findIndex((r) => r.key === selectedKey));
+  const start = Math.min(Math.max(0, at - Math.floor(height / 2)), rows.length - height);
+  return rows.slice(start, start + height);
+}
+function Overview() {
+  const tui = useTui();
+  const { d, projects, t, g, now, selected, select, actions, go, attach } = tui;
+  const { columns, rows: height } = useWindowSize2();
+  const wide = columns >= WIDE;
+  const left = wide ? Math.min(64, Math.max(44, Math.floor(columns * 0.42))) : columns;
+  const view = useMemo2(() => overview(d.sessions, projects), [d.sessions, projects]);
+  const sel = selected?.id ?? null;
+  useScreenKeys((input, key) => {
+    if (input === "j" || key.downArrow) {
+      select(step(view.order, sel, 1));
+      return true;
+    }
+    if (input === "k" || key.upArrow) {
+      select(step(view.order, sel, -1));
+      return true;
+    }
+    if (key.tab) {
+      const next2 = nextWaiting(view.yours, sel);
+      if (next2) select(next2);
+      return true;
+    }
+    if (key.return) {
+      if (selected) go("session");
+      return true;
+    }
+    if (!selected) return false;
+    if (input === "a") {
+      attach(selected);
+      return true;
+    }
+    if (input === "r" && selected.pending) {
+      go("session");
+      return true;
+    }
+    if (/^[1-9]$/.test(input) && selected.pending?.kind !== "question") return false;
+    if (input === "y" || input === "n" || input === "A" || /^[1-9]$/.test(input)) return actions.key(selected, input);
+    if (input === "i" && selected.state === "working") {
+      actions.interrupt(selected);
+      return true;
+    }
+    return false;
+  });
+  const tree = view.tree.flatMap((n) => [
+    { kind: "project", key: n.key, label: n.label, color: projectColor(n.color), count: n.count },
+    ...n.branches.flatMap((b) => [{ kind: "branch", key: `${n.key}|${b.branch}`, branch: b.branch }, ...b.sessions.map((s) => ({ kind: "session", key: s.id, s }))])
+  ]);
+  const yoursHeight = Math.max(1, Math.min(view.yours.length, 6));
+  const treeHeight = Math.max(3, height - 3 - (yoursHeight + 2) - 3);
+  const inner = left - 4, nameW = 7;
+  const stateW = Math.max(...Object.values(t.state).map((x) => x.length)) + 1;
+  const topicW = Math.max(6, inner - 6 - nameW - stateW - 3);
+  const askW = Math.max(6, inner - 2 - nameW - 9 - 7);
+  const yoursBox = /* @__PURE__ */ jsx7(TitledBox, { title: t.overview.yours(view.yours.length), color: view.yours.length ? C.red : C.line, titleColor: view.yours.length ? C.red : C.dim, height: yoursHeight + 2, children: view.yours.length === 0 ? /* @__PURE__ */ jsx7(Text6, { color: C.faint, children: t.overview.nobodyWaits }) : view.yours.slice(0, yoursHeight).map((s) => {
+    const st = botState(s);
+    return /* @__PURE__ */ jsxs5(Text6, { wrap: "truncate", backgroundColor: s.id === sel ? C.sel : void 0, children: [
+      /* @__PURE__ */ jsxs5(Text6, { color: STATE_COLOR[st], children: [
+        g[st],
+        " "
+      ] }),
+      /* @__PURE__ */ jsx7(Text6, { color: C.fg, bold: true, children: fit(s.name, nameW) }),
+      /* @__PURE__ */ jsx7(Text6, { color: C.dim, children: fit(s.repo ?? s.project, 9) }),
+      /* @__PURE__ */ jsx7(Text6, { color: STATE_COLOR[st], children: fit(oneLine(s.pending?.text ?? ""), askW) }),
+      /* @__PURE__ */ jsxs5(Text6, { color: C.faint, children: [
+        " ",
+        ago(s.lastActivityAt, now, t.time)
+      ] })
+    ] }, s.id);
+  }) });
+  const treeBox = /* @__PURE__ */ jsx7(TitledBox, { title: t.overview.projects, flexGrow: 1, children: tree.length === 0 ? /* @__PURE__ */ jsx7(Text6, { color: C.faint, children: t.overview.noSession }) : windowed(tree, sel, treeHeight).map((r) => r.kind === "project" ? /* @__PURE__ */ jsxs5(Text6, { wrap: "truncate", children: [
+    /* @__PURE__ */ jsx7(Text6, { color: r.color, children: g.project }),
+    " ",
+    /* @__PURE__ */ jsx7(Text6, { color: C.fg, bold: true, children: r.label }),
+    " ",
+    /* @__PURE__ */ jsx7(Text6, { color: C.faint, children: t.overview.sessions(r.count) })
+  ] }, r.key) : r.kind === "branch" ? /* @__PURE__ */ jsxs5(Text6, { wrap: "truncate", color: C.faint, children: [
+    "  ",
+    g.branch,
+    " ",
+    r.branch
+  ] }, r.key) : /* @__PURE__ */ jsx7(SessionRow, { s: r.s, on: r.s.id === sel, nameW, topicW, stateW }, r.key)) });
+  const keys = [
+    ["j k", t.keys.navigate],
+    ["\u21B5", t.keys.open],
+    ...view.yours.length ? [["tab", t.keys.next], ["y n", t.keys.answer]] : [],
+    ["a", t.keys.attach],
+    ["/", t.keys.ask],
+    ["+", t.keys.launch],
+    [",", t.keys.settings],
+    ["?", t.keys.help],
+    ["q", t.keys.quit]
+  ];
+  return /* @__PURE__ */ jsx7(Frame, { crumb: tui.machines.map((m) => `${m.label} ${m.ready ? g.machine : "\u25CB"}`).join("  "), keys, children: /* @__PURE__ */ jsxs5(Box6, { flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", width: left, flexShrink: 0, children: [
+      yoursBox,
+      treeBox
+    ] }),
+    wide ? /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", flexGrow: 1, children: [
+      selected ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+        /* @__PURE__ */ jsx7(TitledBox, { title: `${selected.name} \xB7 ${oneLine(selected.topic ?? selected.title)}`, color: isPending(selected) ? C.red : C.line, titleColor: isPending(selected) ? C.red : C.dim, children: /* @__PURE__ */ jsx7(SessionCard, { s: selected, note: true }) }),
+        /* @__PURE__ */ jsx7(TitledBox, { title: t.overview.terminal(paneName(selected)), flexGrow: 1, children: /* @__PURE__ */ jsx7(Tail, { lines: d.previews.get(selected.id) ?? [], color: C.dim, empty: t.overview.noPreview, emptyColor: C.faint }) })
+      ] }) : /* @__PURE__ */ jsx7(TitledBox, { title: t.tabs.session, flexGrow: 1, children: /* @__PURE__ */ jsx7(Text6, { color: C.faint, children: t.session.noSession }) }),
+      /* @__PURE__ */ jsx7(TitledBox, { title: t.overview.exchanges, height: 5, children: (() => {
+        const list = exchanges(d.sessions, 3);
+        return list.length === 0 ? /* @__PURE__ */ jsx7(Text6, { color: C.faint, children: t.overview.noExchange }) : list.map((x, i) => /* @__PURE__ */ jsxs5(Text6, { wrap: "truncate", children: [
+          /* @__PURE__ */ jsx7(Text6, { color: C.faint, children: clock(x.at) }),
+          " ",
+          /* @__PURE__ */ jsx7(Text6, { color: C.fg, children: x.from }),
+          " ",
+          /* @__PURE__ */ jsx7(Text6, { color: C.violet, children: g.arrow }),
+          " ",
+          /* @__PURE__ */ jsx7(Text6, { color: C.fg, children: x.to }),
+          "  ",
+          /* @__PURE__ */ jsx7(Text6, { color: C.dim, children: oneLine(x.summary) })
+        ] }, i));
+      })() })
+    ] }) : null
+  ] }) });
+}
+function SessionRow({ s, on, nameW, topicW, stateW }) {
+  const { t, g } = useTui();
+  const st = botState(s);
+  const n = helperCount(s);
+  return /* @__PURE__ */ jsxs5(Text6, { wrap: "truncate", backgroundColor: on ? C.sel : void 0, children: [
+    /* @__PURE__ */ jsx7(Text6, { color: on ? C.coral : C.faint, children: on ? "\u258C" : " " }),
+    /* @__PURE__ */ jsx7(Text6, { children: "  " }),
+    /* @__PURE__ */ jsxs5(Text6, { color: s.offline ? C.faint : STATE_COLOR[st], children: [
+      g[st],
+      " "
+    ] }),
+    /* @__PURE__ */ jsx7(Text6, { color: s.offline ? C.dim : C.fg, bold: true, children: fit(s.name, nameW) }),
+    /* @__PURE__ */ jsxs5(Text6, { color: C.dim, children: [
+      fit(oneLine(s.topic ?? s.title), topicW),
+      " "
+    ] }),
+    /* @__PURE__ */ jsx7(Text6, { color: s.offline ? C.faint : STATE_COLOR[st], children: fit(s.offline ? t.overview.offline : t.state[st], stateW).trimEnd() }),
+    n > 0 ? /* @__PURE__ */ jsxs5(Text6, { color: C.violet, children: [
+      " +",
+      n
+    ] }) : null,
+    s.machineName && s.machineId !== "local" ? /* @__PURE__ */ jsxs5(Text6, { color: C.faint, children: [
+      " \xB7 ",
+      machineLabel(s)
+    ] }) : null
+  ] });
+}
+
+// src/tui/screens/Session.tsx
+import { useEffect as useEffect6, useMemo as useMemo3, useState as useState4 } from "react";
+import { Box as Box9, Text as Text10, useWindowSize as useWindowSize3 } from "ink";
+
+// ../ui/src/thread/turns.ts
+var byTime = (a, b) => a.at < b.at ? -1 : a.at > b.at ? 1 : 0;
+function withoutEcho(items, reply) {
+  if (!reply) return items;
+  let last = -1;
+  items.forEach((it, i) => {
+    if (it.kind === "message") last = i;
+  });
+  const echo = items[last];
+  return echo?.kind === "message" && echo.text.trim() === reply.text.trim() ? items.filter((_, i) => i !== last) : items;
+}
+function turns(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const it of items) {
+    if (it.helperId) continue;
+    const t = map.get(it.turn) ?? { n: it.turn, items: [] };
+    t.items.push(it);
+    if (it.kind === "prompt") t.prompt = it;
+    if (it.kind === "reply") t.reply = it;
+    map.set(it.turn, t);
+  }
+  return [...map.values()].sort((a, b) => a.n - b.n).map((t) => ({ ...t, items: withoutEcho([...t.items].sort(byTime), t.reply) }));
+}
+
+// ../ui/src/thread/tools.ts
+var TARGET_MAX = 40;
+var looksLikePath = (s) => !/\s/.test(s) && s.includes("/");
+function cut(s, max = TARGET_MAX) {
+  if (s.length <= max) return s;
+  const head = s.slice(0, max - 1);
+  const space = head.lastIndexOf(" ");
+  return `${(space > max / 2 ? head.slice(0, space) : head).trimEnd()}\u2026`;
+}
+function shortPath(path) {
+  const parts = path.split("/").filter(Boolean);
+  const two = parts.slice(-2).join("/");
+  return two.length <= TARGET_MAX ? two : cut(parts.at(-1) ?? two);
+}
+function rawTarget(item) {
+  let s = item.label.trim();
+  const prefix = `${item.tool} \xB7 `;
+  if (s.startsWith(prefix)) s = s.slice(prefix.length);
+  if (s === item.tool) return "";
+  if (s.startsWith("{")) {
+    try {
+      const o = JSON.parse(s);
+      const v = ["pattern", "query", "url", "file_path", "path", "command", "description", "prompt"].map((k) => o[k]).find((x) => typeof x === "string" && x);
+      if (typeof v === "string") s = v;
+    } catch {
+    }
+  }
+  return (s.split("\n")[0] ?? "").trim();
+}
+function target(item) {
+  const raw = rawTarget(item);
+  return looksLikePath(raw) ? shortPath(raw) : cut(raw);
+}
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+
+// src/tui/model/thread.ts
+var DIFF_MAX = 30;
+function wrap(text, width) {
+  const out = [];
+  const w = Math.max(10, width);
+  for (const raw of text.replace(/\r/g, "").split("\n")) {
+    let rest = [...raw];
+    if (rest.length === 0) {
+      out.push("");
+      continue;
+    }
+    while (rest.length > w) {
+      const head = rest.slice(0, w);
+      const space = head.lastIndexOf(" ");
+      const at = space > 0 ? space : w;
+      out.push(rest.slice(0, at).join("").trimEnd());
+      rest = [...rest.slice(at).join("").trimStart()];
+    }
+    out.push(rest.join(""));
+  }
+  return out;
+}
+function diffCount(diff) {
+  let add = 0, del = 0;
+  for (const l of (diff ?? "").split("\n")) {
+    if (l.startsWith("+++") || l.startsWith("---")) continue;
+    if (l.startsWith("+")) add++;
+    else if (l.startsWith("-")) del++;
+  }
+  return { add, del };
+}
+var seconds = (ms) => `${(ms / 1e3).toFixed(ms < 1e4 ? 1 : 0)} s`;
+function toolLines(it, o) {
+  const status = it.status === "success" ? { g: o.g.ok, c: C.green } : it.status === "failed" ? { g: o.g.fail, c: C.red } : it.status === "running" ? { g: o.ascii ? o.g.live : SPINNER[Math.floor(o.now / 1e3) % SPINNER.length], c: C.blue } : { g: "\xB7", c: C.faint };
+  const counts = it.files.reduce((a, f) => {
+    const n = diffCount(f.diff);
+    return { add: a.add + n.add, del: a.del + n.del };
+  }, { add: 0, del: 0 });
+  const took = it.durationMs !== void 0 ? seconds(it.durationMs) : it.status === "running" ? seconds(Math.max(0, o.now - Date.parse(it.at))) : "";
+  const line = [{ text: "  " }, { text: status.g, color: status.c }, { text: ` ${it.tool.padEnd(6)} `, color: C.dim }, { text: target(it), color: C.fg }];
+  if (counts.add || counts.del) line.push({ text: "  " }, { text: `+${counts.add}`, color: C.green }, { text: " " }, { text: `\u2212${counts.del}`, color: C.red });
+  if (took) line.push({ text: `  ${took}`, color: C.faint });
+  const out = [line];
+  if (it.status === "failed" && it.error) out.push([{ text: `      ${oneLine(it.error).slice(0, 200)}`, color: C.red }]);
+  if (o.diffs) for (const f of it.files) {
+    const lines = (f.diff ?? "").split("\n").filter((l) => l && !l.startsWith("+++") && !l.startsWith("---"));
+    for (const l of lines.slice(0, DIFF_MAX)) out.push([{ text: `      ${o.g.bar} `, color: C.faint }, { text: l, color: l.startsWith("+") ? C.green : l.startsWith("-") ? C.red : C.faint }]);
+    if (lines.length > DIFF_MAX) out.push([{ text: `      ${o.g.bar} ${o.g.ellipsis} ${lines.length - DIFF_MAX}`, color: C.faint }]);
+  }
+  return out;
+}
+function itemLines(it, o) {
+  const { t, g, width } = o;
+  const body = (text, color) => wrap(text, width - 2).map((l) => [{ text: `  ${l}`, color }]);
+  switch (it.kind) {
+    case "prompt":
+      return [[{ text: t.session.you, color: C.coral, bold: true }, { text: `  ${clock(it.at)}`, color: C.faint }], ...body(it.text, C.fg)];
+    case "message":
+      return body(it.text, C.dim);
+    case "reply":
+      return body(it.text, C.fg);
+    case "tool":
+      return toolLines(it, o);
+    case "permission": {
+      const d = it.decision ? ` ${g.arrow} ${it.decision}` : "";
+      return [[{ text: "  " }, { text: g.approval, color: C.red }, { text: ` ${it.tool.padEnd(6)} `, color: C.dim }, { text: oneLine(it.text), color: C.fg }, { text: d, color: C.faint }]];
+    }
+    case "helper":
+      return [[{ text: `  ${g.helper} `, color: C.violet }, { text: it.agentType ?? "", color: C.dim }, { text: ` ${oneLine(it.task)}`, color: C.violet }, { text: `  ${it.state === "working" ? t.state.working : t.session.helperDone}`, color: C.faint }]];
+    case "sent":
+      return [[{ text: `  ${g.message} `, color: C.violet }, { text: `${t.session.sentTo} `, color: C.dim }, { text: it.to, color: C.fg, bold: true }, { text: `  \xAB ${oneLine(it.summary ?? it.text)} \xBB`, color: C.dim }, { text: `  ${t.session.sent[it.status]}`, color: it.status === "failed" ? C.red : C.green }]];
+    case "received":
+      return [[{ text: `  ${g.message} `, color: C.violet }, { text: `${t.session.receivedFrom} `, color: C.dim }, { text: it.from, color: C.fg, bold: true }, { text: `  \xAB ${oneLine(it.text)} \xBB`, color: C.dim }]];
+    case "notice":
+      return [[{ text: `  \xB7 ${oneLine(it.summary ?? it.text)}`, color: C.faint }]];
+  }
+}
+function foldedLine(turn, o) {
+  const tools = turn.items.filter((i) => i.kind === "tool");
+  const files = new Set(tools.flatMap((i) => i.status === "success" ? i.files.map((f) => f.path) : []));
+  const parts = [turn.prompt ? oneLine(turn.prompt.text) : "", o.t.session.actions(tools.length), ...files.size ? [o.t.session.files(files.size)] : [], ...turn.reply ? [oneLine(turn.reply.text)] : []].filter(Boolean);
+  return [{ text: `${o.g.folded} ${clock(turn.prompt?.at ?? turn.items[0]?.at ?? (/* @__PURE__ */ new Date(0)).toISOString())}  `, color: C.faint }, { text: parts.join(" \xB7 "), color: C.faint }];
+}
+function threadLines(items, o) {
+  const all = turns(items);
+  const out = [];
+  all.forEach((turn, i) => {
+    const last = i === all.length - 1;
+    if (!last && !o.unfolded) {
+      out.push(foldedLine(turn, o));
+      return;
+    }
+    if (out.length) out.push([{ text: "" }]);
+    for (const it of turn.items) out.push(...itemLines(it, o));
+  });
+  return out;
+}
+
+// src/tui/ui/ModelPicker.tsx
+import { useState as useState3 } from "react";
+import { Box as Box7, Text as Text7, useInput } from "ink";
+
+// ../fleet/src/models.ts
+import { useEffect as useEffect4, useState as useState2 } from "react";
+var IDLE = { status: "idle", models: [] };
+var LOADING = { status: "loading", models: [] };
+var known = /* @__PURE__ */ new Map();
+var next = 0;
+function useModels(client, machine, tool) {
+  const key = machine === null || tool === null ? null : `${machine}|${tool}`;
+  const [answer, setAnswer] = useState2(null);
+  useEffect4(() => {
+    if (key === null || machine === null || tool === null || known.has(key)) return;
+    const requestId = `models-${++next}`;
+    const off = client.onMessage((m) => {
+      if (m.type !== "models.listing" || m.requestId !== requestId) return;
+      const state2 = { status: "ready", models: m.models, ...m.error ? { error: m.error } : {} };
+      if (!m.error) known.set(key, state2);
+      setAnswer({ key, state: state2 });
+    });
+    client.send({ type: "models.list", requestId, tool, machineId: machine });
+    return off;
+  }, [client, key, machine, tool]);
+  if (key === null) return IDLE;
+  return known.get(key) ?? (answer && answer.key === key ? answer.state : LOADING);
+}
+
+// src/tui/ui/ModelPicker.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function ModelPicker({ machine, tool, current, onPick, onCancel }) {
+  const { client, t, g } = useTui();
+  useEditing(true);
+  const models = useModels(client, machine, tool);
+  const rows = [{ id: null, label: t.launch.defaultModel, efforts: [], defaultEffort: void 0 }, ...models.models.map((m) => ({ id: m.id, label: m.label, efforts: m.efforts ?? [], defaultEffort: m.defaultEffort }))];
+  const [at, setAt] = useState3(() => Math.max(0, rows.findIndex((r) => r.id === current.model)));
+  const [effort, setEffort] = useState3(current.effort);
+  const row = rows[Math.min(at, rows.length - 1)];
+  useInput((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setAt((i) => (i - 1 + rows.length) % rows.length);
+      setEffort(null);
+      return;
+    }
+    if (key.downArrow || input === "j") {
+      setAt((i) => (i + 1) % rows.length);
+      setEffort(null);
+      return;
+    }
+    if ((key.leftArrow || key.rightArrow) && row.efforts.length) {
+      const cur = Math.max(0, row.efforts.indexOf(effort ?? row.defaultEffort ?? row.efforts[0]));
+      setEffort(row.efforts[(cur + (key.rightArrow ? 1 : -1) + row.efforts.length) % row.efforts.length]);
+      return;
+    }
+    if (key.return) onPick({ model: row.id, effort: row.efforts.length ? effort ?? null : null });
+  });
+  if (models.status !== "ready") return /* @__PURE__ */ jsx8(Text7, { color: C.faint, children: t.launch.loading });
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+    models.error ? /* @__PURE__ */ jsx8(Text7, { color: C.yellow, children: models.error }) : null,
+    rows.map((r, i) => /* @__PURE__ */ jsxs6(Text7, { wrap: "truncate", backgroundColor: i === at ? C.sel : void 0, children: [
+      /* @__PURE__ */ jsxs6(Text7, { color: i === at ? C.coral : C.faint, children: [
+        i === at ? g.cursor : " ",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx8(Text7, { color: C.fg, children: r.label }),
+      i === at && r.efforts.length ? /* @__PURE__ */ jsxs6(Text7, { color: C.dim, children: [
+        "   ",
+        r.efforts.map((e) => e === (effort ?? r.defaultEffort) ? `${g.prev} ${e} ${g.next}` : e).join("  ")
+      ] }) : null
+    ] }, r.id ?? "-"))
+  ] });
+}
+
+// src/tui/ui/Lines.tsx
+import { useEffect as useEffect5, useRef as useRef6 } from "react";
+import { Box as Box8, Text as Text8, useBoxMetrics as useBoxMetrics3 } from "ink";
+import { jsx as jsx9 } from "react/jsx-runtime";
+function Lines({ lines, up = 0, onHeight }) {
+  const ref = useRef6(null);
+  const { height } = useBoxMetrics3(ref);
+  useEffect5(() => {
+    if (height > 0) onHeight?.(height);
+  }, [height, onHeight]);
+  const h = Math.max(1, height);
+  const back = Math.min(up, Math.max(0, lines.length - h));
+  const shown = lines.slice(Math.max(0, lines.length - h - back), lines.length - back);
+  return /* @__PURE__ */ jsx9(Box8, { ref, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: shown.map((l, i) => /* @__PURE__ */ jsx9(Text8, { wrap: "truncate", children: l.map((x, k) => /* @__PURE__ */ jsx9(Text8, { color: x.color, bold: x.bold, children: x.text || (k === 0 ? " " : "") }, k)) }, i)) });
+}
+
+// src/tui/ui/TextInput.tsx
+import { Text as Text9, useInput as useInput2 } from "ink";
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+function TextInput({ value, onChange, onSubmit, onEscape, placeholder, active, mask }) {
+  useInput2((input, key) => {
+    if (key.return) {
+      onSubmit?.(value);
+      return;
+    }
+    if (key.escape) {
+      onEscape?.();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      onChange([...value].slice(0, -1).join(""));
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      onChange("");
+      return;
+    }
+    if (key.ctrl || key.meta || key.tab || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.pageUp || key.pageDown) return;
+    if (input) onChange(value + input.replace(/\r\n?/g, "\n"));
+  }, { isActive: active });
+  const shown = mask ? "\u2022".repeat(value.length) : value.replace(/\n/g, "\u23CE");
+  if (!shown && !active) return /* @__PURE__ */ jsx10(Text9, { color: C.faint, wrap: "truncate", children: placeholder ?? "" });
+  return /* @__PURE__ */ jsxs7(Text9, { wrap: "truncate-start", children: [
+    shown ? /* @__PURE__ */ jsx10(Text9, { color: C.fg, children: shown }) : null,
+    active ? /* @__PURE__ */ jsx10(Text9, { inverse: true, children: " " }) : null,
+    !shown && placeholder ? /* @__PURE__ */ jsxs7(Text9, { color: C.faint, children: [
+      " ",
+      placeholder
+    ] }) : null
+  ] });
+}
+
+// src/tui/screens/Session.tsx
+import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+function SessionScreen() {
+  const tui = useTui();
+  const { selected: s, t } = tui;
+  if (!s) return /* @__PURE__ */ jsx11(Frame, { crumb: "", keys: [["esc", t.keys.back]], children: /* @__PURE__ */ jsx11(Text10, { color: C.faint, children: t.session.noSession }) });
+  return /* @__PURE__ */ jsx11(SessionView, { s }, s.id);
+}
+function SessionView({ s }) {
+  const { client, d, t, g, now, actions, attach, toast, machines } = useTui();
+  const { columns } = useWindowSize3();
+  const [mode, setMode] = useState4("read");
+  const [draft, setDraft] = useState4("");
+  const [diffs, setDiffs] = useState4(false);
+  const [unfolded, setUnfolded] = useState4(false);
+  const [terminal, setTerminal] = useState4(false);
+  const [up, setUp] = useState4(0);
+  useEditing(mode === "reply" || mode === "note");
+  const items = d.threads.get(s.id);
+  useEffect6(() => {
+    if (!items && !s.offline) client.send({ type: "session.thread", id: s.id });
+  }, [items === void 0, s.id, d.snapshotSeq]);
+  const width = Math.max(20, columns - 6);
+  const lines = useMemo3(() => items ? threadLines(items, { t, g, now, width, diffs, unfolded }) : [], [items, t, g, now, width, diffs, unfolded]);
+  const p = s.pending;
+  const [view, setView] = useState4(10);
+  const maxUp = Math.max(0, lines.length - view);
+  const machine = splitId(s.id)?.machine ?? "local";
+  const canSwitch = machines.find((m) => m.id === machine)?.daemon?.modelSwitch === true;
+  const send = (text) => {
+    if (!text.trim()) {
+      setMode("read");
+      return;
+    }
+    const back = (x) => {
+      setDraft(x);
+    };
+    if (mode === "note") actions.denyWithNote(s, text.trim(), back);
+    else if (!actions.reply(s, text, back)) return;
+    setDraft("");
+    setMode("read");
+  };
+  useScreenKeys((input, key) => {
+    if (mode === "model") return true;
+    if (mode !== "read") {
+      if (key.ctrl && input === "c") {
+        setMode("read");
+        return true;
+      }
+      return false;
+    }
+    if (key.pageUp) {
+      setUp((u) => Math.min(maxUp, u + view - 1));
+      return true;
+    }
+    if (key.pageDown) {
+      setUp((u) => Math.max(0, u - view + 1));
+      return true;
+    }
+    if (input === "k" || key.upArrow) {
+      setUp((u) => Math.min(maxUp, u + 1));
+      return true;
+    }
+    if (input === "j" || key.downArrow) {
+      setUp((u) => Math.max(0, u - 1));
+      return true;
+    }
+    if (input === "G" || key.end) {
+      setUp(0);
+      return true;
+    }
+    if (input === " ") {
+      setUnfolded((u) => !u);
+      return true;
+    }
+    if (input === "d") {
+      setDiffs((x) => !x);
+      return true;
+    }
+    if (input === "t") {
+      setTerminal((x) => !x);
+      return true;
+    }
+    if (input === "a") {
+      attach(s);
+      return true;
+    }
+    if (input === "i") {
+      actions.interrupt(s);
+      return true;
+    }
+    if (input === "m") {
+      if (!canSwitch) toast({ text: t.toast.modelSwitch, tone: "info" });
+      else setMode("model");
+      return true;
+    }
+    if (input === "r" || key.return) {
+      if (s.offline) {
+        toast({ text: t.toast.offline(s.name), tone: "info" });
+        return true;
+      }
+      if (s.source === "hook_only") {
+        toast({ text: t.toast.readOnly(s.name), tone: "info" });
+        return true;
+      }
+      const note = p && p.kind !== "question" && input === "r";
+      if (note && !offers(s.tool, p.kind, "note")) {
+        toast({ text: t.toast.noNote(s.name), tone: "info" });
+        return true;
+      }
+      if (p && p.kind !== "question" && !note) return true;
+      setMode(note ? "note" : "reply");
+      return true;
+    }
+    if (/^[1-9]$/.test(input) && p?.kind !== "question") return false;
+    if (input === "y" || input === "n" || input === "A" || /^[1-9]$/.test(input)) return actions.key(s, input);
+    return false;
+  });
+  const state2 = botState(s);
+  const title2 = `${s.name} \xB7 ${oneLine(s.topic ?? s.title)} \xB7 ${TOOL_NAME[s.tool]} \xB7 ${modelLabel(s, t.session.defaultModel)}`;
+  const keys = mode === "model" ? [["\u2191 \u2193", t.keys.choose], ["\u2190 \u2192", t.launch.effort], ["\u21B5", t.keys.choose], ["esc", t.keys.cancel]] : mode !== "read" ? [["\u21B5", t.keys.send], ["esc", t.keys.back]] : [["esc", t.keys.back], ...p ? [["y n A", t.keys.answer]] : [], ["r", t.keys.write], ["j k", t.keys.scroll], [t.keys.space, t.keys.unfold], ["d", t.keys.diffs], ["t", t.keys.terminal], ["a", t.keys.attach], ["m", t.keys.model], ["i", t.keys.interrupt]];
+  return /* @__PURE__ */ jsxs8(Frame, { crumb: `${s.repo ?? s.project}${s.branch ? ` \u203A ${g.branch} ${s.branch}` : ""} \u203A ${s.name} \xB7 ${machineLabel(s)}`, keys, children: [
+    /* @__PURE__ */ jsx11(TitledBox, { title: terminal ? t.overview.terminal(paneName(s)) : title2, flexGrow: 1, children: mode === "model" ? /* @__PURE__ */ jsx11(
+      ModelPicker,
+      {
+        machine,
+        tool: s.tool,
+        current: { model: s.model ?? null, effort: s.effort ?? null },
+        onCancel: () => setMode("read"),
+        onPick: (pick) => {
+          client.send({ type: "session.model", id: s.id, model: pick.model, effort: pick.effort });
+          toast({ text: t.toast.model(s.name, pick.model ?? t.session.defaultModel), tone: "ok" });
+          setMode("read");
+        }
+      }
+    ) : terminal ? /* @__PURE__ */ jsx11(Tail, { lines: d.previews.get(s.id) ?? [], color: C.dim, empty: t.overview.noPreview, emptyColor: C.faint }) : !items ? /* @__PURE__ */ jsx11(Text10, { color: C.faint, children: t.session.loading }) : lines.length === 0 ? /* @__PURE__ */ jsx11(Text10, { color: C.faint, children: t.session.empty }) : /* @__PURE__ */ jsx11(Lines, { lines, up, onHeight: setView }) }),
+    p ? /* @__PURE__ */ jsxs8(TitledBox, { title: t.session.since(t.state[state2], ago(s.lastActivityAt, now, t.time)), color: isPending(s) ? C.red : C.line, titleColor: STATE_COLOR[state2], children: [
+      /* @__PURE__ */ jsxs8(Text10, { wrap: "truncate", children: [
+        /* @__PURE__ */ jsx11(Text10, { color: C.fg, children: p.kind === "question" ? oneLine(p.text) : `${t.session.wantsTo(s.name)} ` }),
+        p.kind !== "question" ? /* @__PURE__ */ jsx11(Text10, { color: C.fg, bold: true, children: oneLine(p.text) }) : null,
+        p.tool ? /* @__PURE__ */ jsxs8(Text10, { color: C.faint, children: [
+          "   ",
+          p.tool
+        ] }) : null
+      ] }),
+      /* @__PURE__ */ jsx11(Box9, { marginTop: 1, columnGap: 2, flexWrap: "wrap", children: p.kind === "question" ? choices(p).slice(0, 9).map((c, i) => /* @__PURE__ */ jsx11(Button, { label: `${c.n} \xB7 ${c.label}`, k: String(c.n), primary: i === 0 }, c.n)) : /* @__PURE__ */ jsxs8(Fragment3, { children: [
+        /* @__PURE__ */ jsx11(Button, { label: t.overview.allow, k: "y", primary: true }),
+        /* @__PURE__ */ jsx11(Button, { label: t.overview.deny, k: "n" }),
+        offers(s.tool, p.kind, "always") ? /* @__PURE__ */ jsx11(Button, { label: t.overview.always, k: "A" }) : null,
+        offers(s.tool, p.kind, "note") ? /* @__PURE__ */ jsx11(Button, { label: t.overview.denyWithNote, k: "r" }) : null
+      ] }) })
+    ] }) : null,
+    /* @__PURE__ */ jsx11(TitledBox, { title: mode === "note" ? t.overview.denyWithNote : t.keys.write, color: mode === "read" ? C.line : C.coral, children: /* @__PURE__ */ jsxs8(Text10, { wrap: "truncate", children: [
+      /* @__PURE__ */ jsxs8(Text10, { color: C.coral, children: [
+        g.cursor,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx11(
+        TextInput,
+        {
+          value: draft,
+          onChange: setDraft,
+          onSubmit: send,
+          onEscape: () => setMode("read"),
+          active: mode === "reply" || mode === "note",
+          placeholder: mode === "note" ? t.session.noteFor(s.name) : t.session.replyTo(s.name)
+        }
+      )
+    ] }) })
+  ] });
+}
+
+// src/tui/screens/Ask.tsx
+import { randomUUID } from "crypto";
+import { useEffect as useEffect7, useMemo as useMemo4, useRef as useRef7, useState as useState5 } from "react";
+import { Box as Box10, Text as Text11, useInput as useInput3, useWindowSize as useWindowSize4 } from "ink";
+
+// src/tui/model/chat.ts
+function stepLabel(s, t) {
+  const name = s.name ?? s.id ?? "";
+  return s.kind === "sessions" ? t.sessions : s.kind === "repo" ? t.repo(s.path ?? "") : t[s.kind](name);
+}
+function chatLines(turns2, live, o) {
+  const { t, g, width } = o;
+  const out = [];
+  for (const turn of turns2) {
+    if (out.length) out.push([{ text: "" }]);
+    for (const l of wrap(turn.question, width - 2)) out.push([{ text: `${g.cursor} `, color: C.coral }, { text: l, color: C.fg, bold: true }]);
+    out.push([{ text: `  ${t.ask.you} \xB7 ${clock(turn.askedAt)}`, color: C.faint }]);
+    const steps = [...new Set(turn.steps.map((s) => stepLabel(s, t.ask.steps)))];
+    if (steps.length) out.push([{ text: `  ${t.ask.read} : ${steps.join(" \xB7 ")}`, color: C.faint }]);
+    const text = turn.answer ?? (live?.qid === turn.qid ? live.text : void 0);
+    if (turn.error) out.push([{ text: `  ${turn.error}`, color: C.red }]);
+    else if (text) {
+      out.push([{ text: "" }]);
+      for (const l of wrap(text, width - 2)) out.push([{ text: "  " }, { text: l, color: C.fg }]);
+    } else out.push([{ text: `  ${t.ask.reading}`, color: C.faint }]);
+  }
+  return out;
+}
+function openCards(turns2) {
+  const out = [];
+  for (const turn of [...turns2].reverse()) {
+    if (!turn.answeredAt) continue;
+    const launch = proposalRows(turn).map((p, i) => p.launchedId ? -1 : i).filter((i) => i >= 0);
+    if (launch.length) out.push({ kind: "launch", qid: turn.qid, rows: launch });
+    if (turn.relay && turn.relay.status !== "sent") out.push({ kind: "relay", qid: turn.qid });
+    const close = (turn.closes ?? []).map((c, i) => c.closedAt ? -1 : i).filter((i) => i >= 0);
+    if (close.length) out.push({ kind: "close", qid: turn.qid, rows: close });
+  }
+  return out;
+}
+
+// src/tui/screens/Ask.tsx
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+var CARD_MS = 2e4;
+function Ask() {
+  const { client, d, machines, t, g, toast, go } = useTui();
+  const { columns } = useWindowSize4();
+  const [draft, setDraft] = useState5("");
+  const [focus, setFocus] = useState5(-1);
+  const [busy, setBusy] = useState5(null);
+  useEditing(focus === -1);
+  const cards = useMemo4(() => openCards(d.chat), [d.chat]);
+  useEffect7(() => {
+    if (focus >= cards.length) setFocus(cards.length ? cards.length - 1 : -1);
+  }, [cards.length, focus]);
+  useEffect7(() => {
+    if (!busy) return;
+    const turn = d.chat.find((x) => x.qid === busy.qid);
+    if (turn !== busy.turn || (d.errors.at(-1)?.seq ?? 0) > busy.errorSeq) {
+      setBusy(null);
+      return;
+    }
+    const timer = setTimeout(() => setBusy(null), Math.max(0, busy.at + CARD_MS - Date.now()));
+    return () => clearTimeout(timer);
+  }, [busy, d.chat, d.errors]);
+  const local = machines.find((m) => m.id === "local");
+  const asking = d.chat.find((x) => !x.answeredAt && !x.error);
+  const ask = (text) => {
+    if (!text.trim()) return;
+    if (!local?.ready) {
+      toast({ text: t.ask.offline, tone: "info" });
+      return;
+    }
+    const qid = `q-${randomUUID()}`;
+    daemonStore.beginTurn({ qid, question: text.trim(), askedAt: (/* @__PURE__ */ new Date()).toISOString(), steps: [] });
+    client.send({ type: "chat.ask", qid, text: text.trim() });
+    setDraft("");
+  };
+  const act = (card) => {
+    if (busy) return;
+    const turn = d.chat.find((x) => x.qid === card.qid);
+    if (!turn) return;
+    setBusy({ qid: card.qid, turn, errorSeq: d.errors.at(-1)?.seq ?? 0, at: Date.now() });
+    if (card.kind === "launch") {
+      const first = proposalRows(turn)[card.rows[0]];
+      client.send({ type: "session.launch", tool: first.tool, cwd: first.cwd, ...first.prompt ? { prompt: first.prompt } : {}, qid: card.qid, rows: card.rows });
+    } else if (card.kind === "relay") client.send({ type: turn.relay?.status === "queued" ? "session.relay.cancel" : "session.relay", qid: card.qid });
+    else client.send({ type: "session.close", qid: card.qid, rows: card.rows });
+  };
+  const latest = useRef7({ asking, cards, focus });
+  latest.current = { asking, cards, focus };
+  useInput3((input, key) => {
+    if (key.ctrl && input === "n") {
+      client.send({ type: "chat.reset" });
+      return;
+    }
+    if (key.tab) {
+      const n = latest.current.cards.length;
+      setFocus((f) => n === 0 ? -1 : f + 1 >= n ? -1 : f + 1);
+    }
+  });
+  useScreenKeys((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (latest.current.asking) {
+        client.send({ type: "chat.cancel", qid: latest.current.asking.qid });
+        return true;
+      }
+      return false;
+    }
+    if (focus < 0) return false;
+    if (key.return) {
+      act(cards[focus]);
+      return true;
+    }
+    if (key.escape) {
+      setFocus(-1);
+      return true;
+    }
+    return false;
+  });
+  const sessions = listed(d.sessions).length;
+  const width = Math.max(20, columns - 6);
+  const lines = useMemo4(() => chatLines(d.chat, d.chatLive, { t, g, width }), [d.chat, d.chatLive, t, g, width]);
+  return /* @__PURE__ */ jsxs9(Frame, { crumb: `${t.tabs.ask}`, keys: [["\u21B5", t.keys.send], ["tab", t.keys.nextCard], ["ctrl+n", t.keys.newChat], ["ctrl+c", t.keys.stopAnswer], ["esc", t.keys.back]], children: [
+    /* @__PURE__ */ jsx12(TitledBox, { title: t.ask.title(sessions, Math.max(1, machines.length)), flexGrow: 1, children: lines.length === 0 ? /* @__PURE__ */ jsx12(Text11, { color: C.faint, children: t.ask.empty }) : /* @__PURE__ */ jsx12(Lines, { lines }) }),
+    cards.slice(0, 2).map((c, i) => /* @__PURE__ */ jsx12(CardBox, { card: c, turn: d.chat.find((x) => x.qid === c.qid), focused: i === focus, busy: busy?.qid === c.qid }, `${c.kind}:${c.qid}`)),
+    /* @__PURE__ */ jsx12(TitledBox, { title: t.ask.question, color: focus === -1 ? C.coral : C.line, children: /* @__PURE__ */ jsxs9(Text11, { wrap: "truncate", children: [
+      /* @__PURE__ */ jsxs9(Text11, { color: C.coral, children: [
+        g.cursor,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx12(TextInput, { value: draft, onChange: setDraft, onSubmit: ask, onEscape: () => {
+        if (!draft) go("overview");
+      }, active: focus === -1 })
+    ] }) })
+  ] });
+}
+function CardBox({ card, turn, focused, busy }) {
+  const { t, g } = useTui();
+  const color = focused ? C.coral : C.line;
+  if (card.kind === "launch") {
+    const rows = proposalRows(turn);
+    return /* @__PURE__ */ jsxs9(TitledBox, { title: t.ask.launchCard, color, titleColor: C.coral, children: [
+      card.rows.map((r) => {
+        const p = rows[r];
+        return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs9(Text11, { wrap: "truncate", children: [
+            /* @__PURE__ */ jsx12(Text11, { color: C.dim, children: t.ask.folder.padEnd(13) }),
+            /* @__PURE__ */ jsx12(Text11, { color: C.fg, children: p.project }),
+            " ",
+            /* @__PURE__ */ jsx12(Text11, { color: C.faint, children: p.cwd })
+          ] }),
+          /* @__PURE__ */ jsxs9(Text11, { wrap: "truncate", children: [
+            /* @__PURE__ */ jsx12(Text11, { color: C.dim, children: t.ask.agent.padEnd(13) }),
+            TOOL_NAME[p.tool]
+          ] }),
+          p.prompt ? /* @__PURE__ */ jsxs9(Text11, { wrap: "truncate", children: [
+            /* @__PURE__ */ jsx12(Text11, { color: C.dim, children: t.ask.instruction.padEnd(13) }),
+            oneLine(p.prompt)
+          ] }) : null,
+          p.error ? /* @__PURE__ */ jsx12(Text11, { color: C.red, wrap: "truncate", children: p.error }) : null
+        ] }, r);
+      }),
+      /* @__PURE__ */ jsxs9(Box10, { columnGap: 2, children: [
+        /* @__PURE__ */ jsx12(Button, { label: busy ? `${g.live} ${t.ask.launch}` : t.ask.launch, k: "\u21B5", primary: focused }),
+        /* @__PURE__ */ jsx12(Button, { label: t.ask.ignore, k: "esc" }),
+        /* @__PURE__ */ jsx12(Text11, { color: C.faint, children: t.ask.nothingWithoutYou })
+      ] })
+    ] });
+  }
+  if (card.kind === "relay") {
+    const r = turn.relay;
+    return /* @__PURE__ */ jsxs9(TitledBox, { title: t.ask.relayCard(r.name), color, titleColor: C.violet, children: [
+      /* @__PURE__ */ jsx12(Text11, { wrap: "truncate", color: C.fg, children: oneLine(r.text) }),
+      r.error ? /* @__PURE__ */ jsx12(Text11, { color: C.red, wrap: "truncate", children: r.error }) : null,
+      /* @__PURE__ */ jsxs9(Box10, { columnGap: 2, children: [
+        /* @__PURE__ */ jsx12(Button, { label: r.status === "queued" ? t.ask.cancelRelay : t.ask.relay, k: "\u21B5", primary: focused }),
+        r.status === "queued" ? /* @__PURE__ */ jsx12(Text11, { color: C.faint, children: t.ask.queued }) : null
+      ] })
+    ] });
+  }
+  const closes = turn.closes ?? [];
+  return /* @__PURE__ */ jsxs9(TitledBox, { title: t.ask.closeCard, color, titleColor: C.red, children: [
+    card.rows.map((r) => /* @__PURE__ */ jsxs9(Text11, { wrap: "truncate", children: [
+      /* @__PURE__ */ jsx12(Text11, { color: C.fg, children: closes[r].name }),
+      " ",
+      /* @__PURE__ */ jsx12(Text11, { color: C.faint, children: TOOL_NAME[closes[r].tool] }),
+      closes[r].error ? /* @__PURE__ */ jsxs9(Text11, { color: C.red, children: [
+        "  ",
+        closes[r].error
+      ] }) : null
+    ] }, r)),
+    /* @__PURE__ */ jsx12(Box10, { columnGap: 2, children: /* @__PURE__ */ jsx12(Button, { label: t.ask.close, k: "\u21B5", primary: focused }) })
+  ] });
+}
+
+// src/tui/screens/Launch.tsx
+import { useEffect as useEffect8, useMemo as useMemo5, useState as useState6 } from "react";
+import { Box as Box11, Text as Text12, useInput as useInput4 } from "ink";
+
+// ../fleet/src/launch.ts
+var MULTI_REPO_TOOLS = /* @__PURE__ */ new Set(["claude", "omp"]);
+var NO_PICK = { model: null, effort: null };
+var isUp = (m) => m.ready;
+var find = (projects, id) => projects.find((p) => p.id === id);
+var usable = (infos, path) => infos?.get(path)?.exists !== false;
+function reposOn(project, machine) {
+  return machine === null ? [] : project?.repos.filter((r) => r.machine === machine) ?? [];
+}
+function firstRepo(project, machine, infos) {
+  const r = reposOn(project, machine).find((r2) => usable(infos, r2.path));
+  return r ? [r.path] : [];
+}
+function launchDefaults(projects, machines, wanted, tool, infos) {
+  const project = (find(projects, wanted.project ?? null) ?? find(projects, wanted.filter ?? null) ?? projects[0])?.id ?? null;
+  const up = machines.filter(isUp);
+  const machine = (up.find((m) => m.id === "local") ?? up[0])?.id ?? null;
+  return { tool, prompt: "", project, machine, repos: firstRepo(find(projects, project), machine, infos), ...NO_PICK, approval: "always-ask" };
+}
+function withProject(f, projects, id, infos) {
+  return { ...f, project: id, repos: firstRepo(find(projects, id), f.machine, infos) };
+}
+function withMachine(f, projects, machine, infos) {
+  return { ...f, machine, repos: firstRepo(find(projects, f.project), machine, infos) };
+}
+function withTool(f, tool, pick = NO_PICK) {
+  return { ...f, tool, repos: MULTI_REPO_TOOLS.has(tool) ? f.repos : f.repos.slice(0, 1), model: pick.model, effort: pick.effort };
+}
+function withPick(f, pick) {
+  return { ...f, model: pick.model, effort: pick.effort };
+}
+function toggleRepo(f, path) {
+  if (!MULTI_REPO_TOOLS.has(f.tool)) return { ...f, repos: [path] };
+  return { ...f, repos: f.repos.includes(path) ? f.repos.filter((p) => p !== path) : [...f.repos, path] };
+}
+function missingOf(f, machines) {
+  if (!f.prompt.trim()) return "prompt";
+  if (f.machine === null || !machines.some((m) => m.id === f.machine && isUp(m))) return "machine";
+  if (f.repos.length === 0) return "repos";
+  return null;
+}
+function previewOf(f, sessions, projectIdOf) {
+  const machineOf2 = (s) => splitId(s.id)?.machine ?? s.machineId ?? "local";
+  const taken = sessions.filter((s) => s.state !== "exited" && machineOf2(s) === f.machine).map((s) => s.name);
+  const seated = f.project === null ? 0 : sessions.filter((s) => projectIdOf(s) === f.project).length;
+  return { name: pickName(taken), seat: seated + 1 };
+}
+function launchMessage(f, name) {
+  const [cwd = "", ...rest] = f.repos;
+  const { tool } = f;
+  return {
+    type: "session.launch",
+    tool,
+    cwd,
+    ...MULTI_REPO_TOOLS.has(tool) && rest.length ? { dirs: rest } : {},
+    name,
+    prompt: f.prompt.trim(),
+    ...f.model ? { model: f.model } : {},
+    ...f.effort ? { effort: f.effort } : {},
+    ...tool === "omp" && f.approval !== "always-ask" ? { approval: f.approval } : {},
+    ...f.machine ? { machineId: f.machine } : {}
+  };
+}
+
+// src/tui/screens/Launch.tsx
+import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+var FIELDS = ["prompt", "tool", "model", "effort", "project", "machine", "repos", "folder", "name"];
+var TEXT = /* @__PURE__ */ new Set(["prompt", "folder"]);
+var LAUNCH_MS = 2e4;
+var cycle = (list, cur, by) => list[((Math.max(0, list.indexOf(cur)) + by) % list.length + list.length) % list.length];
+function Launch() {
+  const { client, d, machines, projects, t, g, toast, go, select } = useTui();
+  const list = projects?.projects ?? [];
+  const [form, setForm] = useState6(() => launchDefaults(list, machines, {}, "claude"));
+  const [field, setField] = useState6("prompt");
+  const [folder, setFolder] = useState6("");
+  const [repoAt, setRepoAt] = useState6(0);
+  const [launching, setLaunching] = useState6(null);
+  useEditing(true);
+  useEffect8(() => {
+    if (form.machine === null) {
+      const up = machines.find((m) => m.ready);
+      if (up) setForm((f) => withMachine(f, list, up.id));
+    }
+  }, [machines]);
+  const machine = machines.find((m) => m.id === form.machine);
+  const tools = ["claude", "codex", "cursor", ...machine?.daemon?.omp ? ["omp"] : []];
+  const models = useModels(client, machine?.daemon?.models ? form.machine : null, form.tool);
+  const modelIds = [null, ...models.models.map((m) => m.id)];
+  const model = models.models.find((m) => m.id === form.model);
+  const efforts = [null, ...model?.efforts ?? []];
+  const project = list.find((p) => p.id === form.project);
+  const repoOptions = useMemo5(() => {
+    const own = reposOn(project, form.machine).map((r) => r.path);
+    return own.length ? own : (machine?.recents ?? []).slice(0, 6).map((r) => r.cwd);
+  }, [project, form.machine, machine?.recents]);
+  const withFolder = folder.trim() ? { ...form, repos: MULTI_REPO_TOOLS.has(form.tool) ? [folder.trim(), ...form.repos.filter((r) => r !== folder.trim())] : [folder.trim()] } : form;
+  const projectIdOf = (s) => projects ? projectOf(s, projects) : null;
+  const drawn = useMemo5(() => previewOf(withFolder, d.sessions, projectIdOf), [form.machine, form.project, d.sessions.length]);
+  const [name, setName] = useState6(null);
+  const shownName = name ?? drawn.name;
+  const missing = missingOf(withFolder, machines);
+  useEffect8(() => {
+    if (!launching) return;
+    if ((d.lastLaunched?.seq ?? 0) > launching.seq) {
+      select(d.lastLaunched.id);
+      toast({ text: t.launch.launched(launching.name), tone: "ok" });
+      setLaunching(null);
+      go("overview");
+      return;
+    }
+    const refused = d.errors.find((e) => e.seq > launching.errorSeq && e.id === void 0);
+    if (refused) {
+      toast({ text: refused.message, tone: "error" });
+      setLaunching(null);
+      return;
+    }
+    const timer = setTimeout(() => setLaunching(null), Math.max(0, launching.at + LAUNCH_MS - Date.now()));
+    return () => clearTimeout(timer);
+  }, [launching, d.lastLaunched, d.errors]);
+  const launch = () => {
+    if (launching) return;
+    if (missing) {
+      toast({ text: t.launch.missing[missing], tone: "info" });
+      setField(missing === "prompt" ? "prompt" : missing === "machine" ? "machine" : "repos");
+      return;
+    }
+    setLaunching({ seq: d.lastLaunched?.seq ?? 0, errorSeq: d.errors.at(-1)?.seq ?? 0, at: Date.now(), name: shownName });
+    client.send(launchMessage(withFolder, shownName));
+  };
+  useInput4((input, key) => {
+    if (key.escape) {
+      go("overview");
+      return;
+    }
+    if (key.ctrl && input === "s") {
+      launch();
+      return;
+    }
+    if (key.ctrl && input === "r") {
+      setName(pickName([...d.sessions.map((s) => s.name), shownName]));
+      return;
+    }
+    if (key.tab || key.downArrow || key.return && field !== "name") {
+      setField((f) => cycle(FIELDS, f, key.shift ? -1 : 1));
+      return;
+    }
+    if (key.upArrow) {
+      setField((f) => cycle(FIELDS, f, -1));
+      return;
+    }
+    if (key.return) {
+      launch();
+      return;
+    }
+    if (TEXT.has(field)) return;
+    const by = key.rightArrow || input === "l" ? 1 : key.leftArrow || input === "h" ? -1 : 0;
+    if (field === "repos") {
+      if (by) setRepoAt((i) => repoOptions.length ? (i + by + repoOptions.length) % repoOptions.length : 0);
+      else if (input === " " && repoOptions[repoAt]) setForm((f) => toggleRepo(f, repoOptions[repoAt]));
+      return;
+    }
+    if (!by) return;
+    if (field === "tool") setForm((f) => withTool(f, cycle(tools, f.tool, by)));
+    else if (field === "model") setForm((f) => withPick(f, { model: cycle(modelIds, f.model, by), effort: null }));
+    else if (field === "effort") setForm((f) => withPick(f, { model: f.model, effort: cycle(efforts, f.effort, by) }));
+    else if (field === "project") {
+      const ids = [...list.map((p) => p.id), null];
+      setForm((f) => {
+        const next2 = cycle(ids, f.project, by);
+        return next2 === null ? { ...f, project: null, repos: [] } : withProject(f, list, next2);
+      });
+      setRepoAt(0);
+    } else if (field === "machine") {
+      const up = machines.filter((m) => m.ready).map((m) => m.id);
+      if (up.length) setForm((f) => withMachine(f, list, cycle(up, f.machine ?? up[0], by)));
+      setRepoAt(0);
+    }
+  });
+  const row = (f, label, value) => /* @__PURE__ */ jsxs10(Box11, { backgroundColor: field === f ? C.sel : void 0, children: [
+    /* @__PURE__ */ jsx13(Text12, { color: field === f ? C.coral : C.faint, children: field === f ? "\u258C" : " " }),
+    /* @__PURE__ */ jsx13(Box11, { width: 14, flexShrink: 0, children: /* @__PURE__ */ jsx13(Text12, { color: C.dim, children: label }) }),
+    /* @__PURE__ */ jsx13(Box11, { flexGrow: 1, overflow: "hidden", children: value })
+  ] }, f);
+  const choice = (items, cur, label, color) => /* @__PURE__ */ jsx13(Text12, { wrap: "truncate", children: items.map((x, i) => /* @__PURE__ */ jsxs10(Text12, { children: [
+    x === cur ? /* @__PURE__ */ jsx13(Text12, { color: C.fg, bold: true, children: `${g.prev} ${label(x)} ${g.next}` }) : /* @__PURE__ */ jsx13(Text12, { color: color?.(x) ?? C.dim, children: label(x) }),
+    "   "
+  ] }, i)) });
+  return /* @__PURE__ */ jsxs10(Frame, { crumb: t.launch.title, keys: [["tab", t.keys.nextField], ["\u2190 \u2192", t.keys.choose], [t.keys.space, t.keys.tick], ["ctrl+s", t.keys.start], ["ctrl+r", t.keys.redraw], ["esc", t.keys.cancel]], children: [
+    /* @__PURE__ */ jsxs10(TitledBox, { title: t.launch.title, flexGrow: 1, children: [
+      row("prompt", t.launch.instruction, /* @__PURE__ */ jsx13(TextInput, { value: form.prompt, onChange: (v) => setForm((f) => ({ ...f, prompt: v })), active: field === "prompt" })),
+      /* @__PURE__ */ jsx13(Text12, { children: " " }),
+      row("tool", t.launch.agent, /* @__PURE__ */ jsx13(Text12, { wrap: "truncate", children: tools.map((x) => /* @__PURE__ */ jsxs10(Text12, { color: x === form.tool ? C.coral : C.dim, children: [
+        x === form.tool ? g.radioOn : g.radioOff,
+        " ",
+        TOOL_NAME[x],
+        "   "
+      ] }, x)) })),
+      row("model", t.launch.model, models.status === "loading" ? /* @__PURE__ */ jsx13(Text12, { color: C.faint, children: t.launch.loading }) : choice(modelIds, form.model, (x) => x === null ? t.launch.defaultModel : models.models.find((m) => m.id === x)?.label ?? x)),
+      row("effort", t.launch.effort, efforts.length > 1 ? choice(efforts, form.effort, (x) => x ?? t.launch.defaultModel) : /* @__PURE__ */ jsx13(Text12, { color: C.faint, children: t.launch.defaultModel })),
+      row("project", t.launch.project, choice([...list.map((p) => p.id), null], form.project, (x) => x === null ? t.launch.none : list.find((p) => p.id === x).name, (x) => projectColor(list.find((p) => p.id === x)?.color))),
+      row("machine", t.launch.machine, /* @__PURE__ */ jsx13(Text12, { wrap: "truncate", children: machines.map((m) => /* @__PURE__ */ jsxs10(Text12, { color: m.id === form.machine ? C.fg : C.dim, bold: m.id === form.machine, children: [
+        /* @__PURE__ */ jsx13(Text12, { color: m.ready ? C.green : C.faint, children: g.machine }),
+        " ",
+        m.label,
+        "    "
+      ] }, m.id)) })),
+      row("repos", t.launch.repos, repoOptions.length === 0 ? /* @__PURE__ */ jsx13(Text12, { color: C.faint, children: t.launch.none }) : /* @__PURE__ */ jsx13(Text12, { wrap: "truncate", children: repoOptions.map((r, i) => /* @__PURE__ */ jsxs10(Text12, { backgroundColor: field === "repos" && i === repoAt ? "#3a3532" : void 0, color: form.repos.includes(r) ? C.fg : C.dim, children: [
+        /* @__PURE__ */ jsx13(Text12, { color: form.repos.includes(r) ? C.green : C.faint, children: form.repos.includes(r) ? g.boxOn : g.boxOff }),
+        " ",
+        r.split("/").filter(Boolean).at(-1) ?? r,
+        " ",
+        /* @__PURE__ */ jsx13(Text12, { color: C.faint, children: r }),
+        "   "
+      ] }, r)) })),
+      row("folder", t.launch.folder, /* @__PURE__ */ jsx13(TextInput, { value: folder, onChange: setFolder, active: field === "folder", placeholder: t.launch.folderHint })),
+      row("name", t.launch.name, /* @__PURE__ */ jsxs10(Text12, { children: [
+        shownName,
+        " ",
+        /* @__PURE__ */ jsx13(Text12, { color: C.faint, children: t.launch.drawn })
+      ] }))
+    ] }),
+    /* @__PURE__ */ jsxs10(TitledBox, { title: t.launch.preview, color: C.coral, titleColor: C.coral, children: [
+      /* @__PURE__ */ jsxs10(Text12, { wrap: "truncate", children: [
+        /* @__PURE__ */ jsx13(Text12, { color: C.fg, bold: true, children: project ? t.launch.joins(shownName, project.name) : shownName }),
+        /* @__PURE__ */ jsxs10(Text12, { color: C.faint, children: [
+          " \xB7 ",
+          machine?.label ?? "-",
+          " \xB7 ",
+          TOOL_NAME[form.tool],
+          " \xB7 ",
+          form.model ?? t.launch.defaultModel,
+          form.effort ? ` \xB7 ${form.effort}` : ""
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs10(Box11, { marginTop: 1, columnGap: 2, children: [
+        /* @__PURE__ */ jsx13(Button, { label: launching ? t.launch.launching : t.launch.launch, k: "ctrl+s", primary: true }),
+        /* @__PURE__ */ jsx13(Button, { label: t.launch.cancel, k: "esc" }),
+        missing ? /* @__PURE__ */ jsx13(Text12, { color: C.yellow, children: t.launch.missing[missing] }) : /* @__PURE__ */ jsx13(Text12, { color: C.faint, children: t.launch.thenAttach })
+      ] })
+    ] })
+  ] });
+}
+
+// src/tui/screens/Settings.tsx
+import { useState as useState7 } from "react";
+import { Box as Box12, Text as Text13 } from "ink";
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+function Settings() {
+  const { t, g, lang, setLang } = useTui();
+  const rows = [{ id: "lang", label: t.settings.language }];
+  const [at, setAt] = useState7(0);
+  useScreenKeys((input, key) => {
+    if (key.upArrow || input === "k") {
+      setAt((i) => (i - 1 + rows.length) % rows.length);
+      return true;
+    }
+    if (key.downArrow || input === "j") {
+      setAt((i) => (i + 1) % rows.length);
+      return true;
+    }
+    const by = key.rightArrow || input === "l" || input === " " || key.return ? 1 : key.leftArrow || input === "h" ? -1 : 0;
+    if (!by) return false;
+    if (rows[at].id === "lang") setLang(LANGS[(LANGS.indexOf(lang) + by + LANGS.length) % LANGS.length]);
+    return true;
+  });
+  return /* @__PURE__ */ jsx14(Frame, { crumb: t.settings.title, keys: [["\u2191 \u2193", t.keys.navigate], ["\u2190 \u2192", t.keys.change], ["esc", t.keys.back]], children: /* @__PURE__ */ jsx14(TitledBox, { title: t.settings.title, flexGrow: 1, children: rows.map((r, i) => /* @__PURE__ */ jsxs11(Box12, { backgroundColor: i === at ? C.sel : void 0, children: [
+    /* @__PURE__ */ jsx14(Text13, { color: i === at ? C.coral : C.faint, children: i === at ? "\u258C" : " " }),
+    /* @__PURE__ */ jsx14(Box12, { width: 16, children: /* @__PURE__ */ jsx14(Text13, { color: C.dim, children: r.label }) }),
+    /* @__PURE__ */ jsx14(Text13, { children: LANGS.map((l) => /* @__PURE__ */ jsxs11(Text13, { color: l === lang ? C.fg : C.dim, bold: l === lang, children: [
+      l === lang ? `${g.radioOn} ` : `${g.radioOff} `,
+      t.lang[l],
+      "     "
+    ] }, l)) })
+  ] }, r.id)) }) });
+}
+
+// src/tui/screens/Help.tsx
+import { Box as Box13, Text as Text14 } from "ink";
+import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+function Help() {
+  const { t } = useTui();
+  const k = t.keys;
+  const groups = [
+    [t.help.global, [["1\u20265", t.help.screens], ["/", k.ask], ["+", k.launch], [",", k.settings], ["?", k.help], ["esc", k.back], ["q", k.quit]]],
+    [t.help.overview, [["j k \u2191 \u2193", k.navigate], ["tab", k.next], ["\u21B5", k.open], ["y n A", k.answer], ["1\u20269", k.answer], ["r", t.overview.denyWithNote], ["a", k.attach], ["i", k.interrupt]]],
+    [t.help.session, [["y n A 1\u20269", k.answer], ["r \u21B5", k.write], ["j k PgUp PgDn", k.scroll], [t.keys.space, k.unfold], ["d", k.diffs], ["t", k.terminal], ["a", k.attach], ["m", k.model], ["i", k.interrupt]]],
+    [t.help.ask, [["\u21B5", k.send], ["tab", k.nextCard], ["ctrl+n", k.newChat], ["ctrl+c", k.stopAnswer]]],
+    [t.help.launch, [["tab \u2191 \u2193", k.nextField], ["\u2190 \u2192", k.choose], [t.keys.space, k.tick], ["ctrl+r", t.keys.redraw], ["ctrl+s", k.start], ["esc", k.cancel]]],
+    [t.help.settings, [["\u2191 \u2193", k.navigate], ["\u2190 \u2192", k.change]]]
+  ];
+  return /* @__PURE__ */ jsx15(Frame, { crumb: t.help.title, keys: [["esc", k.back]], children: /* @__PURE__ */ jsx15(TitledBox, { title: t.help.title, flexGrow: 1, children: /* @__PURE__ */ jsx15(Box13, { flexWrap: "wrap", columnGap: 4, children: groups.map(([title2, keys]) => /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", width: 40, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx15(Text14, { color: C.coral, bold: true, children: title2 }),
+    keys.map(([key, label]) => /* @__PURE__ */ jsxs12(Text14, { wrap: "truncate", children: [
+      /* @__PURE__ */ jsx15(Text14, { color: C.fg, children: key.padEnd(16) }),
+      /* @__PURE__ */ jsx15(Text14, { color: C.dim, children: label })
+    ] }, key + label))
+  ] }, title2)) }) }) });
+}
+
+// src/tui/App.tsx
+import { jsx as jsx16 } from "react/jsx-runtime";
+var TOAST_MS = 5e3;
+function App(props) {
+  const [lang, setLangState] = useState8(props.lang);
+  return /* @__PURE__ */ jsx16(I18nProvider, { lang, children: /* @__PURE__ */ jsx16(Shell, { ...props, lang, setLang: setLangState }) });
+}
+function Shell({ client, lang, setLang: setLangState, saveLang, notify, glyphs, env, run }) {
+  const { exit, suspendTerminal } = useApp();
+  const { stdout } = useStdout();
+  const write = useCallback((seq) => {
+    if (seq) stdout.write(seq);
+  }, [stdout]);
+  const d = useDaemon();
+  const machines = useMachines(client);
+  const projects = useProjects(client);
+  const fleet = client.fleet;
+  const t = MESSAGES[lang];
+  const [screen, setScreen] = useState8("overview");
+  const [back, setBack] = useState8("overview");
+  const [selectedId, setSelectedId] = useState8(null);
+  const [lastToast, setToast] = useState8(null);
+  const [editing, setEditingState] = useState8(false);
+  const [now, setNow] = useState8(() => Date.now());
+  const keys = useRef8(null);
+  useEffect9(() => {
+    const timer = setInterval(() => setNow(Date.now()), 1e3);
+    return () => clearInterval(timer);
+  }, []);
+  useEffect9(() => {
+    if (!lastToast) return;
+    const timer = setTimeout(() => setToast(null), TOAST_MS);
+    return () => clearTimeout(timer);
+  }, [lastToast]);
+  const toast = useCallback((x) => setToast(x), []);
+  const setEditing = useCallback((on) => setEditingState(on), []);
+  const view = useMemo6(() => overview(d.sessions, projects), [d.sessions, projects]);
+  const order = useRef8([]);
+  useEffect9(() => {
+    setSelectedId((cur) => cur === null && view.yours[0] ? view.yours[0].id : keepSelection(view.order, cur, order.current));
+    order.current = view.order;
+  }, [view]);
+  const selected = (selectedId ? d.byId.get(selectedId) : void 0) ?? null;
+  const seen = useRef8(null);
+  useEffect9(() => {
+    if (seen.current) for (const text of asked(seen.current, d.sessions, t.notify)) write(notification(text, notify, env));
+    seen.current = d.byId;
+    write(title(t.notify.title(listed(d.sessions).filter(isPending).length)));
+  }, [d.byId]);
+  const actions = useActions({ client, sessions: d.sessions, errors: d.errors, t, toast });
+  const go = useCallback((next2) => {
+    setScreen((cur) => {
+      if (next2 === "help" || next2 === "settings") setBack(cur === "help" || cur === "settings" ? "overview" : cur);
+      return next2;
+    });
+  }, []);
+  const setLang = useCallback((next2) => {
+    setLangState(next2);
+    try {
+      saveLang(next2);
+      toast({ text: MESSAGES[next2].settings.saved, tone: "ok" });
+    } catch (e) {
+      toast({ text: MESSAGES[next2].settings.saveFailed(e.message), tone: "error" });
+    }
+  }, [saveLang, setLangState, toast]);
+  const attach = useCallback((s) => {
+    const cmd = attachCommand(fleet, s);
+    if ("why" in cmd) {
+      toast({ text: cmd.why === "offline" ? t.toast.offline(s.name) : cmd.why === "omp" ? t.toast.noTerminalOmp(s.name) : t.toast.noTerminal(s.name), tone: "info" });
+      return;
+    }
+    void suspendTerminal(async () => {
+      const code = await (run ?? runAttached)(cmd.argv);
+      if (code !== 0) toast({ text: t.toast.attachFailed(code), tone: "error" });
+    });
+  }, [fleet, suspendTerminal, run, t, toast]);
+  const tui = {
+    client,
+    fleet,
+    d,
+    machines,
+    projects,
+    t,
+    lang,
+    setLang,
+    g: glyphs,
+    now,
+    screen,
+    go,
+    selected,
+    select: setSelectedId,
+    toast,
+    lastToast,
+    actions,
+    setEditing,
+    attach,
+    keys
+  };
+  useInput5((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (keys.current?.(input, key)) return;
+      exit();
+      return;
+    }
+    if (editing) return;
+    if (keys.current?.(input, key)) return;
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (key.escape) {
+      go(screen === "help" || screen === "settings" ? back : "overview");
+      return;
+    }
+    if (input === "?") {
+      go("help");
+      return;
+    }
+    if (input === ",") {
+      go("settings");
+      return;
+    }
+    if (input === "/") {
+      go("ask");
+      return;
+    }
+    if (input === "+") {
+      go("launch");
+      return;
+    }
+    if (/^[1-5]$/.test(input)) {
+      go(SCREENS[Number(input) - 1]);
+      return;
+    }
+  });
+  const Body = { overview: Overview, session: SessionScreen, ask: Ask, launch: Launch, settings: Settings, help: Help }[screen];
+  return /* @__PURE__ */ jsx16(TuiContext.Provider, { value: tui, children: /* @__PURE__ */ jsx16(Body, {}) });
+}
+
+// src/tui/fleet.ts
+import WebSocket from "ws";
+async function readToken() {
+  try {
+    const token = readDaemonToken();
+    return token ? { kind: "token", token } : { kind: "absent" };
+  } catch {
+    return { kind: "unavailable" };
+  }
+}
+function createTuiFleet(opts = {}) {
+  const local = LOCAL_MACHINE.url, port = opts.port ?? PROTOCOL_PORT;
+  const backoff = { ...opts.minBackoffMs ? { minBackoffMs: opts.minBackoffMs } : {}, ...opts.maxBackoffMs ? { maxBackoffMs: opts.maxBackoffMs } : {} };
+  return createFleetClient(
+    [LOCAL_MACHINE],
+    (c) => createDaemonClient({ url: c.url.replace(local, `ws://127.0.0.1:${port}`), WebSocketImpl: WebSocket, token: c.token, ...backoff }),
+    { prefix: "tui", keepStale: true, machinesFromDaemon: true, ...opts.token === null ? {} : { token: opts.token ?? createTokenSource(readToken) } }
+  );
+}
+
+// src/tui/glyphs.ts
+var UNICODE = {
+  approval: "\u25C6",
+  question: "?",
+  working: "\u25CF",
+  idle: "\u25CB",
+  starting: "\u25CC",
+  done: "\xB7",
+  error: "\u2717",
+  readonly: "\u25CB",
+  branch: "\u2387",
+  helper: "\u21B3",
+  message: "\u2709",
+  arrow: "\u2192",
+  ok: "\u2713",
+  fail: "\u2717",
+  live: "\u25CC",
+  folded: "\u25B8",
+  unfolded: "\u25BE",
+  project: "\u25A0",
+  machine: "\u25CF",
+  logo: "\u25D6",
+  cursor: "\u276F",
+  radioOn: "\u25C9",
+  radioOff: "\u25CB",
+  boxOn: "\u2713",
+  boxOff: "\u2610",
+  prev: "\u25C2",
+  next: "\u25B8",
+  ellipsis: "\u2026",
+  bar: "\u2502"
+};
+var ASCII = {
+  approval: "!",
+  question: "?",
+  working: "*",
+  idle: "o",
+  starting: ".",
+  done: "-",
+  error: "x",
+  readonly: "o",
+  branch: "git:",
+  helper: ">",
+  message: "@",
+  arrow: "->",
+  ok: "v",
+  fail: "x",
+  live: "~",
+  folded: "+",
+  unfolded: "-",
+  project: "#",
+  machine: "*",
+  logo: "(",
+  cursor: ">",
+  radioOn: "(*)",
+  radioOff: "( )",
+  boxOn: "[x]",
+  boxOff: "[ ]",
+  prev: "<",
+  next: ">",
+  ellipsis: "...",
+  bar: "|"
+};
+function glyphsFor(env) {
+  if (env.LEDGE_TUI_ASCII === "1") return ASCII;
+  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "";
+  return locale && !/utf-?8/i.test(locale) && locale !== "C.UTF-8" ? ASCII : UNICODE;
+}
+
+// src/tui/settings.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+var SettingsSchema = z.object({ lang: z.enum(["fr", "en"]).optional() }).passthrough();
+var settingsPath = () => join(ledgeDir(), "tui.json");
+function defaultLang(env) {
+  const locale = env.LC_ALL || env.LC_MESSAGES || env.LANG || "";
+  return /^fr/i.test(locale) ? "fr" : "en";
+}
+function loadSettings() {
+  try {
+    return SettingsSchema.parse(JSON.parse(readFileSync(settingsPath(), "utf8")));
+  } catch {
+    return {};
+  }
+}
+function saveSettings(settings) {
+  const path = settingsPath(), tmp = `${path}.${process.pid}.tmp`;
+  mkdirSync(ledgeDir(), { recursive: true });
+  writeFileSync(tmp, `${JSON.stringify(settings, null, 2)}
+`, { mode: 384 });
+  renameSync(tmp, path);
+}
+
+// src/tui/index.tsx
+import { jsx as jsx17 } from "react/jsx-runtime";
+var TUI_USAGE = "ledge tui [--notify bell|osc9|off]";
+function tuiArgs(args) {
+  let notify = "bell";
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const value = a.startsWith("--notify=") ? a.slice("--notify=".length) : a === "--notify" ? args[++i] : void 0;
+    if (value === void 0 || !NOTIFY_MODES.includes(value)) return null;
+    notify = value;
+  }
+  return { notify };
+}
+async function runTui(args) {
+  const parsed = tuiArgs(args);
+  if (!parsed) {
+    console.error(`usage: ${TUI_USAGE}`);
+    return 2;
+  }
+  const settings = loadSettings();
+  const lang = settings.lang ?? defaultLang(process.env);
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.error(MESSAGES[lang].cli.notTty);
+    return 2;
+  }
+  const client = createTuiFleet();
+  const detach = attachClient(client);
+  client.connect();
+  const app = render(
+    /* @__PURE__ */ jsx17(App, { client, lang, saveLang: (next2) => saveSettings({ ...loadSettings(), lang: next2 }), notify: parsed.notify, glyphs: glyphsFor(process.env), env: process.env }),
+    { alternateScreen: true, exitOnCtrlC: false, maxFps: 30 }
+  );
+  const stop = () => app.unmount();
+  process.once("SIGTERM", stop);
+  process.once("SIGHUP", stop);
+  try {
+    await app.waitUntilExit();
+  } finally {
+    process.off("SIGTERM", stop);
+    process.off("SIGHUP", stop);
+    detach();
+    client.close();
+    process.stdout.write("\x1B]0;\x07");
+  }
+  return 0;
+}
+export {
+  TUI_USAGE,
+  runTui,
+  tuiArgs
+};