@paradow/ledge 0.28.0 → 0.29.0-snapshot.41306023381.1

package/README.md

@@ -53,6 +53,14 @@ icon comes only from its profile, so Ledge installs a `Ledge` profile as a fragm
 `~/.ledge/tui.sh`, which each `ledge tui` rewrites with its node and CLI. `ledge tui --here`, tmux, SSH and any other
 terminal keep the TUI where it was started.
 
+The TUI opens on a home with Ledge first: its conversation (decisions to settle with `1`-`9`, `@build` to write to an
+OpenRig agent), then `À toi` (what waits for you), `Projets · sessions seules` (sessions outside a rig, as before) and
+`Rigs` (OpenRig rigs and the OpenRig kernel). `2` opens a rig's room: its seats, their exchanges and a live, colour,
+read-only view of the chosen seat's terminal (`a` attaches to type in it). A session driven by OMP shows its thread
+drawn as a terminal instead. `+` launches a session, or a rig from a rig, the kernel or the Rigs tab (goal, plan, start;
+`ctrl+t` switches between the two). Seats are restarted, stopped and resumed through OpenRig, never killed from Ledge.
+`?` lists every key by screen.
+
 When a Claude it launched exits, Ledge appends a `custom-title` « name - topic » to its transcript, so `claude --resume` lists the conversation that way, unless the user named it (`claude -n`, `/rename`).
 
 `ledge setup` installs `ledge-daemon.service` as a systemd user unit, starts it and enables linger, so the daemon runs from WSL boot and restarts after a crash. Rerun it after a node upgrade or a repository move: the unit is rewritten and the service restarted. Useful commands:

package/dist/cli/{action-NQRSZEC5.js → action-MXRYKL5N.js}

@@ -8,11 +8,11 @@ import {
   resultLine,
   runClose,
   runOnClient
-} from "./chunk-CR3LGTZQ.js";
-import "./chunk-LG3XFIPV.js";
-import "./chunk-VMGACWNP.js";
-import "./chunk-VKRFHDRK.js";
-import "./chunk-HOOHS3MX.js";
+} from "./chunk-LQCWBJYE.js";
+import "./chunk-DEOQT7IM.js";
+import "./chunk-X6NV2IEM.js";
+import "./chunk-G6ESCKEX.js";
+import "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 export {
   CLOSE_USAGE,

package/dist/cli/ask-HIKSAHRR.js

@@ -0,0 +1,17 @@
+import {
+  ASK_USAGE,
+  askArgs,
+  askOnClient,
+  runAsk
+} from "./chunk-BP7NGWYD.js";
+import "./chunk-DEOQT7IM.js";
+import "./chunk-X6NV2IEM.js";
+import "./chunk-G6ESCKEX.js";
+import "./chunk-W724IVDC.js";
+import "./chunk-U67V476Y.js";
+export {
+  ASK_USAGE,
+  askArgs,
+  askOnClient,
+  runAsk
+};

package/dist/cli/{attach-KXOSFUHO.js → attach-J65WTS3H.js}

@@ -1,24 +1,19 @@
 import {
   attachEnv
-} from "./chunk-RYZ6FHYT.js";
-import "./chunk-OYDTU6AP.js";
-import "./chunk-OLLQBK6N.js";
-import "./chunk-QSRB3F5Y.js";
-import "./chunk-ZI47U5CQ.js";
-import "./chunk-JHFKBKSO.js";
-import "./chunk-LG3XFIPV.js";
+} from "./chunk-JFXRDHZR.js";
+import {
+  realTmux
+} from "./chunk-KBSXP63H.js";
+import "./chunk-G3ST5WKR.js";
+import "./chunk-DEOQT7IM.js";
 import {
   connect
-} from "./chunk-VMGACWNP.js";
+} from "./chunk-X6NV2IEM.js";
 import {
   PROTOCOL_PORT,
   backendOf
-} from "./chunk-VKRFHDRK.js";
-import {
-  realTmux
-} from "./chunk-NLL2EQJ2.js";
-import "./chunk-6IYPRUQG.js";
-import "./chunk-HOOHS3MX.js";
+} from "./chunk-G6ESCKEX.js";
+import "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 
 // src/cli/attach.ts

package/dist/cli/brain-XOGS4OPT.js

@@ -0,0 +1,20 @@
+import {
+  BRAIN_MS,
+  BRAIN_USAGE,
+  NOT_BRAIN_LINE,
+  brainOnClient,
+  runBrain
+} from "./chunk-NEYGPVEZ.js";
+import "./chunk-LQCWBJYE.js";
+import "./chunk-DEOQT7IM.js";
+import "./chunk-X6NV2IEM.js";
+import "./chunk-G6ESCKEX.js";
+import "./chunk-W724IVDC.js";
+import "./chunk-U67V476Y.js";
+export {
+  BRAIN_MS,
+  BRAIN_USAGE,
+  NOT_BRAIN_LINE,
+  brainOnClient,
+  runBrain
+};

package/dist/cli/{bridge-XCTXVWKH.js → bridge-YZL5NT7Q.js}

@@ -7,8 +7,8 @@ import {
   parseClientMessage,
   parseServerMessage,
   readDaemonToken
-} from "./chunk-VKRFHDRK.js";
-import "./chunk-HOOHS3MX.js";
+} from "./chunk-G6ESCKEX.js";
+import "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 
 // src/cli/bridge.ts

package/dist/cli/{chunk-3NQNWGDX.js → chunk-3U6TAEIO.js}

@@ -1,27 +1,25 @@
 import {
   connect
-} from "./chunk-VMGACWNP.js";
+} from "./chunk-X6NV2IEM.js";
 import {
   isArchived
-} from "./chunk-VKRFHDRK.js";
+} from "./chunk-G6ESCKEX.js";
 
 // src/cli/who.ts
 import { basename } from "path";
 function formatWho(sessions, self) {
   const live = sessions.filter((s) => s.state !== "exited" && !isArchived(s));
   if (live.length === 0) return "aucune autre session";
-  const roles = live.some((s) => s.role);
   const rows = live.map((s) => [
     s.id === self ? "*" : " ",
     s.name,
-    ...roles ? [s.role ? `@${s.role}` : "-"] : [],
     s.tool,
     s.state,
     `${s.repo ?? s.project}${s.worktree ? ` (${basename(s.cwd)})` : ""}`,
     s.branch ?? "-",
     `${s.topic ?? "-"}${s.source === "hook_only" ? " \xB7 lecture seule" : ""}`
   ]);
-  const head = [" ", "NOM", ...roles ? ["R\xD4LE"] : [], "OUTIL", "\xC9TAT", "PROJET", "BRANCHE", "SUJET"];
+  const head = [" ", "NOM", "OUTIL", "\xC9TAT", "PROJET", "BRANCHE", "SUJET"];
   const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
   return [head, ...rows].map((r) => r.map((c, i) => i === r.length - 1 ? c : c.padEnd(widths[i])).join(" ")).join("\n");
 }

package/dist/cli/chunk-66ZLZ2OW.js

@@ -0,0 +1,365 @@
+import {
+  PROJECT_COLORS,
+  RIG_NAME,
+  parseServerMessage
+} from "./chunk-G6ESCKEX.js";
+
+// src/imageInfo.ts
+var ok = (mime, width, height) => width > 0 && height > 0 ? { mime, width, height } : null;
+function jpeg(b) {
+  let i = 2;
+  while (i + 4 <= b.length) {
+    if (b[i] !== 255) {
+      i++;
+      continue;
+    }
+    const m = b[i + 1];
+    if (m === 255) {
+      i++;
+      continue;
+    }
+    if (m === 216 || m === 1 || m >= 208 && m <= 215) {
+      i += 2;
+      continue;
+    }
+    const len = b.readUInt16BE(i + 2);
+    if (m >= 192 && m <= 207 && m !== 196 && m !== 200 && m !== 204) return i + 9 <= b.length ? ok("image/jpeg", b.readUInt16BE(i + 7), b.readUInt16BE(i + 5)) : null;
+    i += 2 + len;
+  }
+  return null;
+}
+function webp(b) {
+  const kind = b.toString("latin1", 12, 16);
+  if (kind === "VP8X") return b.length >= 30 ? ok("image/webp", b.readUIntLE(24, 3) + 1, b.readUIntLE(27, 3) + 1) : null;
+  if (kind === "VP8L") {
+    if (b.length < 25 || b[20] !== 47) return null;
+    const bits = b.readUInt32LE(21);
+    return ok("image/webp", (bits & 16383) + 1, (bits >>> 14 & 16383) + 1);
+  }
+  if (kind === "VP8 ") return b.length >= 30 && b[23] === 157 && b[24] === 1 && b[25] === 42 ? ok("image/webp", b.readUInt16LE(26) & 16383, b.readUInt16LE(28) & 16383) : null;
+  return null;
+}
+function imageInfo(b) {
+  try {
+    if (b.length >= 24 && b.readUInt32BE(0) === 2303741511 && b.readUInt32BE(4) === 218765834 && b.toString("latin1", 12, 16) === "IHDR") return ok("image/png", b.readUInt32BE(16), b.readUInt32BE(20));
+    if (b.length >= 10 && (b.toString("latin1", 0, 6) === "GIF87a" || b.toString("latin1", 0, 6) === "GIF89a")) return ok("image/gif", b.readUInt16LE(6), b.readUInt16LE(8));
+    if (b.length >= 4 && b[0] === 255 && b[1] === 216) return jpeg(b);
+    if (b.length >= 16 && b.toString("latin1", 0, 4) === "RIFF" && b.toString("latin1", 8, 12) === "WEBP") return webp(b);
+  } catch {
+  }
+  return null;
+}
+
+// ../ui/src/rigs/model.ts
+var rigKey = (r) => `${r.machine}/${r.id}`;
+var COLOR_NAMES = Object.keys(PROJECT_COLORS);
+function rigColor(r) {
+  let sum = 0;
+  for (let i = 0; i < r.name.length; i++) sum += r.name.charCodeAt(i);
+  return COLOR_NAMES[sum % COLOR_NAMES.length];
+}
+function kernelSplit(rig) {
+  const hidden = [], shown = [];
+  for (const s of rig.seats) (s.name.startsWith("advisor") || s.runtime === "terminal" ? hidden : shown).push(s);
+  return { shown, hidden };
+}
+var workingCount = (rig) => rig.seats.filter((s) => s.state === "working").length;
+function rigPlace(rig, projects) {
+  if (rig.projectId) return { kind: "project", name: projects?.projects.find((p) => p.id === rig.projectId)?.name ?? rig.projectId };
+  if (rig.offProject) return { kind: "off", cwd: rig.cwd };
+  return { kind: "none" };
+}
+function isStandalone(s, rigs) {
+  if (s.brain) return false;
+  const r = s.rig;
+  if (!r) return true;
+  return !rigs.some((x) => x.machine === r.machine && x.seats.some((seat) => seat.sessionId === s.id && seat.state !== "stopped"));
+}
+var MENTION_RIG = /* @__PURE__ */ new Set(["running", "partial"]);
+var MENTION_DOWN = /* @__PURE__ */ new Set(["stopped", "crashed", "attention"]);
+function seatMentions(rigs, query) {
+  const live = rigs.filter((r) => r.machine === "local" && MENTION_RIG.has(r.lifecycle)).flatMap((rig) => rig.seats.filter((s) => !MENTION_DOWN.has(s.state)).map((seat) => ({ rig, seat })));
+  const holders = /* @__PURE__ */ new Map();
+  for (const { seat } of live) holders.set(seat.address, (holders.get(seat.address) ?? 0) + 1);
+  const q = query.toLowerCase();
+  return live.filter(({ rig, seat }) => !rig.kernel && seat.address.replace(/^@/, "").toLowerCase().startsWith(q)).sort((a, b) => a.seat.address.localeCompare(b.seat.address) || a.rig.name.localeCompare(b.rig.name)).map(({ rig, seat }) => {
+    const shared = (holders.get(seat.address) ?? 0) > 1;
+    const insert = shared ? `${seat.address}@${rig.name}` : seat.address;
+    return { key: `${rigKey(rig)}/${seat.ref}`, label: shared ? insert : `${seat.address} \xB7 ${rig.name}`, insert };
+  });
+}
+function ledgeLine(escalations, rigs, said) {
+  const open = escalations.filter((e) => e.intent === "decision" && (e.state === "pending" || e.state === "grace")).sort((a, b) => a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : 0);
+  const rigOf = (e) => {
+    const name = e?.rigId ? rigs.find((r) => r.machine === e.machine && r.id === e.rigId)?.name : void 0;
+    return name ? { rig: name } : {};
+  };
+  const pending = open.filter((e) => e.state === "pending");
+  if (pending.length) return { preview: { kind: "decision", count: pending.length, ...rigOf(pending[0]) }, at: pending[0].createdAt, unread: open.length };
+  const grace = open[0];
+  if (grace) return { preview: { kind: "grace", ...rigOf(grace) }, at: grace.createdAt, unread: open.length };
+  if (said) return { preview: { kind: "said", text: said.text }, at: said.at, unread: 0 };
+  return { preview: { kind: "calm", rigs: rigs.filter((r) => !r.kernel).length }, unread: 0 };
+}
+function shortCwd(cwd) {
+  const m = /^(\/home\/[^/]+|\/root)(?=\/|$)/.exec(cwd);
+  return m ? `~${cwd.slice(m[0].length)}` : cwd;
+}
+var RUNTIME_LABELS = { "claude-code": "Claude Code", codex: "Codex" };
+var runtimeLabel = (runtime) => RUNTIME_LABELS[runtime] ?? runtime;
+
+// ../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);
+    }
+  };
+}
+
+// ../ui/src/launch/rigModel.ts
+var STOP = /* @__PURE__ */ new Set(["le", "la", "les", "de", "des", "du", "un", "une", "et", "\xE0", "au", "pour", "sur", "apr\xE8s", "avant"]);
+var LONG_WORDS = ["jours", "dur\xE9e", "produit", "livrer", "plusieurs"];
+var LONG_GOAL = 160;
+var fold = (s) => s.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "");
+function slugOfGoal(goal) {
+  const words = goal.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w && !STOP.has(w)).map(fold).map((w) => w.replace(/[^a-z0-9]/g, "")).filter(Boolean);
+  const slug = words.slice(-2).join("-").slice(0, 40).replace(/-+$/, "");
+  return RIG_NAME.test(slug) ? slug : "rig";
+}
+function rigFormDefaults(p) {
+  const goal = p.wanted.goal ?? "";
+  const spec = p.wanted.spec ?? null;
+  const machine = p.machines.find((m) => m.id === p.wanted.machine)?.id ?? p.machines.find((m) => m.id === "local")?.id ?? p.machines[0]?.id ?? "local";
+  const project = p.projects.find((x) => x.id === p.wanted.project);
+  if (!project) return { goal, spec, machine, place: p.wanted.off ? { kind: "off", name: p.wanted.off, nameTouched: true } : { kind: "off", name: slugOfGoal(goal), nameTouched: false } };
+  const repo = project.repos.find((r) => r.machine === machine)?.path ?? null;
+  return { goal, spec, machine, place: { kind: "project", projectId: project.id, repo, branch: spec ? `feat/${spec}` : "", copy: true } };
+}
+function withGoal(f, goal) {
+  const place = f.place.kind === "off" && !f.place.nameTouched ? { ...f.place, name: slugOfGoal(goal) } : f.place;
+  return { ...f, goal, place };
+}
+function recommendSpec(goal, specs) {
+  const g = goal.toLowerCase();
+  const long = goal.length > LONG_GOAL || LONG_WORDS.some((w) => g.includes(w));
+  const spec = long ? "factory" : "starter";
+  return specs.some((s) => s.name === spec || s.id === spec) ? { spec, why: long ? "long" : "bounded" } : null;
+}
+function missingOf(f) {
+  const out = [];
+  if (!f.goal.trim()) out.push("goal");
+  if (!f.spec) out.push("spec");
+  if (f.place.kind === "project") {
+    if (!f.place.repo) out.push("repo");
+    const b = f.place.branch.trim();
+    if (!b || b.startsWith("-")) out.push("branch");
+  } else if (!RIG_NAME.test(f.place.name)) out.push("name");
+  return out;
+}
+function whereOf(f) {
+  const missing = missingOf(f);
+  if (f.place.kind === "project") {
+    if (missing.includes("repo") || missing.includes("branch") || !f.place.repo) return null;
+    return { kind: "project", projectId: f.place.projectId, repo: f.place.repo, branch: f.place.branch.trim(), copy: f.place.copy };
+  }
+  return missing.includes("name") ? null : { kind: "off-project", name: f.place.name };
+}
+var planRequired = (f) => f.place.kind === "project" && !f.place.copy;
+var primaryAction = (f) => planRequired(f) ? "plan" : "launch";
+function providers(seats) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of seats) counts.set(s.runtime, (counts.get(s.runtime) ?? 0) + 1);
+  return [...counts].map(([runtime, count]) => ({ runtime, count }));
+}
+function launchability(m, status) {
+  if (m.status !== "open") return { ok: false, why: "offline" };
+  if (!status) return { ok: false, why: "unreachable" };
+  switch (status.state) {
+    case "running":
+    case "stopped":
+    case "starting":
+      return { ok: true };
+    case "absent":
+      return status.install ? { ok: false, why: "absent", install: status.install } : { ok: false, why: "absent" };
+    case "unsupported":
+      return { ok: false, why: "unsupported" };
+    default:
+      return { ok: false, why: "unreachable" };
+  }
+}
+
+export {
+  imageInfo,
+  rigKey,
+  rigColor,
+  kernelSplit,
+  workingCount,
+  rigPlace,
+  isStandalone,
+  seatMentions,
+  ledgeLine,
+  shortCwd,
+  runtimeLabel,
+  DAEMON_PROTOCOL_PREFIX,
+  createTokenSource,
+  createDaemonClient,
+  slugOfGoal,
+  rigFormDefaults,
+  withGoal,
+  recommendSpec,
+  missingOf,
+  whereOf,
+  primaryAction,
+  providers,
+  launchability
+};

package/dist/cli/{chunk-JLUHY5AB.js → chunk-7XFJ5QCZ.js}

@@ -1,12 +1,12 @@
 import {
   CODEX_HOOK_VAR
-} from "./chunk-LG3XFIPV.js";
+} from "./chunk-DEOQT7IM.js";
 import {
   connect
-} from "./chunk-VMGACWNP.js";
+} from "./chunk-X6NV2IEM.js";
 import {
   BRIEF_MAX
-} from "./chunk-VKRFHDRK.js";
+} from "./chunk-G6ESCKEX.js";
 
 // src/cli/handover.ts
 import { randomUUID } from "crypto";
@@ -27,7 +27,7 @@ async function handoverOnClient(client, args, by, ms) {
     client.send(op.op === "show" ? { type: "handover.show", rid, by } : { type: "handover.brief", rid, by, text: op.text });
     const r = await client.next("handover.result", ms);
     if (r.reason !== void 0) return { line: `refus\xE9 : ${r.reason}`, code: 1 };
-    return op.op === "show" ? { line: r.text ?? "", code: 0 } : { line: "bilan re\xE7u : Ledge lance la session qui prend ta rel\xE8ve et lui passe tes t\xE2ches. Arr\xEAte-toi l\xE0.", code: 0 };
+    return op.op === "show" ? { line: r.text ?? "", code: 0 } : { line: "bilan re\xE7u : Ledge lance la session qui prend ta rel\xE8ve. Arr\xEAte-toi l\xE0.", code: 0 };
   } catch (e) {
     return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
   }

package/dist/cli/chunk-BP7NGWYD.js

@@ -0,0 +1,57 @@
+import {
+  CODEX_HOOK_VAR
+} from "./chunk-DEOQT7IM.js";
+import {
+  connect
+} from "./chunk-X6NV2IEM.js";
+import {
+  ASK_OPTIONS_MAX,
+  ASK_QUESTION_MAX
+} from "./chunk-G6ESCKEX.js";
+
+// src/cli/ask.ts
+import { randomUUID } from "crypto";
+var ASK_USAGE = `ledge ask "<question>" "<options, ta recommandation>"   une d\xE9cision pour l'utilisateur ; sa r\xE9ponse te r\xE9veille`;
+var ASK_MS = 4e3;
+function askArgs(args) {
+  const [question, options] = args;
+  return args.length === 2 && question.trim() && question.length <= ASK_QUESTION_MAX && options.length <= ASK_OPTIONS_MAX ? { question, options } : void 0;
+}
+async function askOnClient(client, args, by, ms) {
+  const parsed = askArgs(args);
+  if (!parsed) return { line: ASK_USAGE, code: 1 };
+  try {
+    client.send({ type: "ask.create", rid: randomUUID(), by, ...parsed });
+    const r = await client.next("ask.result", ms);
+    if (!r.ask) return { line: `refus\xE9 : ${r.reason ?? "raison inconnue"}`, code: 1 };
+    return { line: `d\xE9cision ${r.ask.id} pos\xE9e \xE0 l'utilisateur : sa r\xE9ponse te r\xE9veillera`, code: 0 };
+  } catch (e) {
+    return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
+  }
+}
+async function runAsk(args, opts = {}) {
+  if (!askArgs(args)) return { line: ASK_USAGE, code: 1 };
+  const env = opts.env ?? process.env;
+  const by = env[CODEX_HOOK_VAR] || env.LEDGE_SESSION;
+  if (!by) return { line: "ledge ask ne marche que dans une session lanc\xE9e par Ledge", code: 1 };
+  const deadline = Date.now() + (opts.timeoutMs ?? ASK_MS);
+  const left = () => Math.max(0, deadline - Date.now());
+  let client;
+  try {
+    client = await connect({ port: opts.port, timeoutMs: left() });
+  } catch {
+    return { line: "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)", code: 1 };
+  }
+  try {
+    return await askOnClient(client, args, by, left());
+  } finally {
+    await client.close();
+  }
+}
+
+export {
+  ASK_USAGE,
+  askArgs,
+  askOnClient,
+  runAsk
+};

package/dist/cli/{chunk-LG3XFIPV.js → chunk-DEOQT7IM.js}

@@ -3,10 +3,10 @@ import {
   SESSION_KEY_VAR,
   pickName,
   sessionKey
-} from "./chunk-VKRFHDRK.js";
+} from "./chunk-G6ESCKEX.js";
 import {
   paths
-} from "./chunk-HOOHS3MX.js";
+} from "./chunk-W724IVDC.js";
 
 // src/daemon/transcript.ts
 import { appendFileSync, closeSync, fstatSync, openSync, readFileSync, readSync, statSync } from "fs";
@@ -45,6 +45,23 @@ function tailLines(path, bytes = TAIL_BYTES) {
   }
 }
 var texts = (blocks, kind) => (Array.isArray(blocks) ? blocks : []).filter((b) => b?.type === kind && typeof b.text === "string").map((b) => b.text.trim()).filter(Boolean).join("\n\n");
+function agentThought(path) {
+  let latest;
+  for (const line of tailLines(path, 64 * 1024)) {
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.type === "assistant" && e.isSidechain !== true) latest = texts(e.message?.content, "thinking") || latest;
+    if (e.type === "event_msg" && (e.payload?.type === "item_completed" || e.payload?.type === "item_updated")) {
+      const item = e.payload.item;
+      if (item?.type === "AgentReasoning") latest = (typeof item.text === "string" ? item.text : typeof item.summary === "string" ? item.summary : texts(item.content, "Text")) || latest;
+    }
+  }
+  return latest?.replace(/\s+/g, " ").trim().slice(0, 80) || void 0;
+}
 function agentMessages(path, opts = {}) {
   const out = [];
   for (const line of tailLines(path, opts.bytes ?? TAIL_BYTES)) {
@@ -210,7 +227,7 @@ var PARENT_AGENT_VARS = [
 var PARENT_AGENT = new Set(PARENT_AGENT_VARS);
 function agentEnv(base, extra) {
   const env = {};
-  for (const [k, v] of Object.entries(base)) if (v !== void 0 && k !== "TMUX" && !k.startsWith("TMUX_") && !PARENT_AGENT.has(k) && k !== "LEDGE_ROLE" && k !== "LEDGE_TEAM") env[k] = v;
+  for (const [k, v] of Object.entries(base)) if (v !== void 0 && k !== "TMUX" && !k.startsWith("TMUX_") && !PARENT_AGENT.has(k)) env[k] = v;
   return { ...env, ...extra };
 }
 async function spawnSession(opts) {
@@ -229,7 +246,7 @@ async function spawnSession(opts) {
   const transcriptPath = agentSessionId ? claudeTranscriptPath(opts.cwd, agentSessionId, env) : void 0;
   const command = opts.recordExit ? ["sh", "-c", '"$@"; echo $? > "$0"', exitFile(id), ...agent] : agent;
   const key = sessionKey(id);
-  await opts.tmux.newSession({ name: tmuxSession, cwd: opts.cwd, env: agentEnv(env, { LEDGE_SESSION: id, ...key ? { [SESSION_KEY_VAR]: key } : {}, LEDGE_NAME: name, ...opts.role ? { LEDGE_ROLE: opts.role.id } : {}, ...opts.team ? { LEDGE_TEAM: opts.team } : {}, ...opts.tool === "codex" ? { [CODEX_ENV_VAR]: id } : {} }), unset: PARENT_AGENT_VARS, command });
+  await opts.tmux.newSession({ name: tmuxSession, cwd: opts.cwd, env: agentEnv(env, { LEDGE_SESSION: id, ...key ? { [SESSION_KEY_VAR]: key } : {}, LEDGE_NAME: name, ...opts.tool === "codex" ? { [CODEX_ENV_VAR]: id } : {} }), unset: PARENT_AGENT_VARS, command });
   const at = now();
   return {
     id,
@@ -246,14 +263,14 @@ async function spawnSession(opts) {
     source: "launcher",
     ...agentSessionId ? { agentSessionId } : {},
     ...transcriptPath ? { transcriptPath } : {},
-    ...opts.role ? { role: opts.role.id, roleLabel: opts.role.label } : {},
-    ...opts.team ? { team: opts.team } : {},
-    ...opts.autonomy && opts.autonomy !== "ask" ? { autonomy: opts.autonomy } : {}
+    ...opts.autonomy && opts.autonomy !== "ask" ? { autonomy: opts.autonomy } : {},
+    ...opts.brain ? { brain: true } : {}
   };
 }
 
 export {
   ledgeTitleRest,
+  agentThought,
   agentMessages,
   codexPlan,
   claudePlan,