@paradow/ledge 0.16.1 → 0.18.0

package/dist/cli/{chunk-DBSCO3HI.js → chunk-KKNE7BFZ.js}

@@ -1,12 +1,50 @@
 import {
   ledgeTitleRest
-} from "./chunk-H36JD4E3.js";
+} from "./chunk-TRTS24PF.js";
 import {
   cleanTopic,
+  isArchived,
   sessionTitle
-} from "./chunk-Q5WWH7FG.js";
+} from "./chunk-HP3G2TYJ.js";
+
+// src/daemon/seat.ts
+function teammates(team, sessions) {
+  const byId = new Map(sessions.map((s) => [s.id, s]));
+  return team.seats.flatMap((seat) => {
+    const s = seat.sessionId ? byId.get(seat.sessionId) : void 0;
+    return s && s.state !== "exited" && !isArchived(s) ? [{ name: s.name, role: seat.role }] : [];
+  });
+}
+function seatContext(o) {
+  const id = o.role?.id ?? o.roleId;
+  const label = o.role?.label ?? o.roleLabel ?? id;
+  const lines = [];
+  if (id) lines.push(`Ton r\xF4le : ${label} (${id})${o.team ? `, dans l'\xE9quipe ${o.team.name}` : ""}.`);
+  if (o.role?.prompt.trim()) lines.push(o.role.prompt.trim());
+  if (o.team) {
+    const members = o.team.members.map((m) => `${m.name} (${m.role})`).join(", ") || "personne d'autre pour l'instant";
+    lines.push(
+      `Ton \xE9quipe : ${members}. \xC9cris-leur par leur r\xF4le : ledge send @build "\u2026", ledge task give @qa "\u2026".`,
+      `L'op\xE9rateur est Ledge : il t'a confi\xE9 ou te confiera ton travail par une <ledge-task>. Travaille en autonomie avec ton \xE9quipe ; ne t'arr\xEAte pour l'utilisateur que pour une d\xE9cision qui lui revient. Termine toujours une t\xE2che re\xE7ue (ledge task done <id> "<r\xE9sultat>", ou refuse) : c'est ainsi que Ledge et l'utilisateur savent o\xF9 en est l'\xE9quipe.`
+    );
+  }
+  return lines.join("\n");
+}
+function resolveRoleAddress(to, from, sessions, teams) {
+  if (!to.startsWith("@")) return { to };
+  const role = to.slice(1);
+  const team = teams.find((t) => t.state !== "dissolved" && t.seats.some((s) => s.sessionId === from));
+  if (!team) return { reason: `${to} n'existe que dans une \xE9quipe` };
+  const byId = new Map(sessions.map((s) => [s.id, s]));
+  const held = team.seats.filter((s) => s.role === role && s.sessionId).map((s) => byId.get(s.sessionId)).filter((s) => !!s && s.state !== "exited" && !isArchived(s));
+  if (held.length === 1) return { to: held[0].name };
+  if (held.length > 1) return { reason: `plusieurs sessions tiennent ${to} dans ${team.name} : ${held.map((s) => s.name).join(", ")}` };
+  const roles = teammates(team, sessions).map((m) => `@${m.role}`);
+  return { reason: `personne ne tient ${to} dans l'\xE9quipe ${team.name}${roles.length ? ` (r\xF4les tenus : ${roles.join(", ")})` : ""}` };
+}
 
 // src/daemon/crossSession.ts
+import { createHash } from "crypto";
 var FIRST_LINE = /^Another Claude session sent a message:\s*\n/;
 var BLOCK = /<cross-session-message\b([^>]*)>([\s\S]*?)(?:<\/cross-session-message>|(?=\n[ \t]*<cross-session-message\b)|$)/g;
 var ATTR = /([\w-]+)="([^"]*)"/g;
@@ -24,7 +62,7 @@ function crossSession(text) {
 }
 var LEDGE_CLOSE = "</ledge-message>";
 var LEDGE_BLOCK = /^<ledge-message\b([^>]*)>([\s\S]*?)(?:<\/ledge-message>|$)/;
-var messageNote = (from, to) => `(message de la session ${from}, pas de l'utilisateur ; pour r\xE9pondre : ${to === "codex" ? `ledge send ${from} "\u2026"` : `SendMessage vers ${from}`})`;
+var messageNote = (from, to) => `(message de la session ${from}, pas de l'utilisateur ; pour r\xE9pondre : ${to === "claude" ? `SendMessage vers ${from}` : `ledge send ${from} "\u2026"`})`;
 var NOTE_SENDER = /^\(message de la session (.+?), pas de l'utilisateur ; /;
 function stripNote(text) {
   const body = text.trimStart();
@@ -36,9 +74,20 @@ var ESCAPES = /\x1b(?:\[[0-?]*[ -/]*[@-~]|[\]PX^_][^\x07\x1b]*(?:\x07|\x1b\\)|[
 var CONTROLS = /[\x00-\x1f\x7f-\x9f]/g;
 var typable = (text, newline) => text.replace(ESCAPES, "").replace(/\r\n|\r|\n/g, newline).replace(CONTROLS, " ");
 var ledgeBody = (text) => typable(text.replaceAll("<", "\u2039"), " \u23CE ");
+var INLINE_MAX = 800;
+var INLINE_LINES = 8;
+var POINTER_HEAD = 200;
+var lineCount = (text) => text.split(/\r\n|\r|\n/).length;
+var mailId = (rid, length = 6) => `m${createHash("sha1").update(rid).digest("hex").slice(0, length)}`;
+var inline = (text) => text.length <= INLINE_MAX && lineCount(text) <= INLINE_LINES;
+var attr = (s) => typable(s, " ").replace(/["<>]/g, "").trim();
 function formatLedgeMessage(m) {
-  const from = typable(m.from, " ").replace(/["<>]/g, "").trim();
-  return `<ledge-message from="${from}" tool="${m.tool}">${messageNote(from, m.to)} ${ledgeBody(m.text)}${LEDGE_CLOSE}`;
+  const from = attr(m.from);
+  const open = `<ledge-message from="${from}" tool="${m.tool}"${m.id ? ` id="${attr(m.id)}"` : ""}>${messageNote(from, m.to)} `;
+  if (!m.id || inline(m.text)) return `${open}${ledgeBody(m.text)}${LEDGE_CLOSE}`;
+  const first = m.summary?.trim() || m.text.trim().split(/\r\n|\r|\n/)[0].trim();
+  const head = ledgeBody(first.length > POINTER_HEAD ? `${first.slice(0, POINTER_HEAD)}\u2026` : first);
+  return `${open}${head} \u2026 [message de ${m.text.length} caract\xE8res, ${lineCount(m.text)} lignes : lis-le en entier avec ledge read ${attr(m.id)}]${LEDGE_CLOSE}`;
 }
 function ledgeMessages(text) {
   const m = LEDGE_BLOCK.exec(text.trimStart());
@@ -46,8 +95,49 @@ function ledgeMessages(text) {
   const attrs = new Map([...m[1].matchAll(ATTR)].map((a) => [a[1], a[2]]));
   const from = attrs.get("from");
   const tool = attrs.get("tool");
+  const id = attrs.get("id");
   if (!from) return void 0;
-  return [{ from, ...tool ? { tool } : {}, text: stripNote(m[2]).text.trim() }];
+  return [{ from, ...tool ? { tool } : {}, ...id ? { id } : {}, text: stripNote(m[2]).text.trim() }];
+}
+var NOTICE_BLOCK = /^<ledge-notice\b([^>]*)>([\s\S]*?)(?:<\/ledge-notice>|$)/;
+var NOTICE_QUOTE = 80;
+var NOTICE_REASON = " \xBB) : ";
+function formatLedgeNotice(n) {
+  const to = attr(n.to);
+  const flat = typable(n.text, " ").trim();
+  const quote = ledgeBody(flat.length > NOTICE_QUOTE ? `${flat.slice(0, NOTICE_QUOTE)}\u2026` : flat);
+  return `<ledge-notice to="${to}">Ledge n'a pas pu remettre ton message \xE0 ${to} (\xAB ${quote}${NOTICE_REASON}${ledgeBody(n.reason)}</ledge-notice>`;
+}
+function formatTeamNotice(n) {
+  return `<ledge-notice team="${attr(n.team)}">${ledgeBody(n.text)}</ledge-notice>`;
+}
+var TEAM_NOTICE = /^<ledge-notice\b([^>]*\bteam="[^"]*"[^>]*)>([\s\S]*?)(?:<\/ledge-notice>|$)/;
+function ledgeTeamNotice(text) {
+  const m = TEAM_NOTICE.exec(text.trimStart());
+  if (!m) return void 0;
+  const team = new Map([...m[1].matchAll(ATTR)].map((a) => [a[1], a[2]])).get("team");
+  return team ? { team, text: m[2].trim() } : void 0;
+}
+var TASK_BLOCK = /^<ledge-task\b([^>]*)>([\s\S]*?)(?:<\/ledge-task>|$)/;
+function formatLedgeTask(t) {
+  return `<ledge-task id="${attr(t.id)}" from="${attr(t.from)}">${ledgeBody(t.text)}</ledge-task>`;
+}
+function ledgeTask(text) {
+  const m = TASK_BLOCK.exec(text.trimStart());
+  if (!m) return void 0;
+  const attrs = new Map([...m[1].matchAll(ATTR)].map((a) => [a[1], a[2]]));
+  const id = attrs.get("id");
+  const from = attrs.get("from");
+  return id ? { id, ...from ? { from } : {}, text: m[2].trim() } : void 0;
+}
+function ledgeNotice(text) {
+  const m = NOTICE_BLOCK.exec(text.trimStart());
+  if (!m) return void 0;
+  const to = new Map([...m[1].matchAll(ATTR)].map((a) => [a[1], a[2]])).get("to");
+  if (!to) return void 0;
+  const body = m[2].trim();
+  const at = body.lastIndexOf(NOTICE_REASON);
+  return { to, ...at >= 0 ? { reason: body.slice(at + NOTICE_REASON.length) } : {}, text: body };
 }
 var NOTICE_HEAD = /^\[Cross-session ([\w -]+?) notice\]/;
 var NOTICE_SPLIT = /\n\s*(?=\[Cross-session [\w -]+? notice\])/;
@@ -393,7 +483,7 @@ function reduceEvent(s, ev) {
     case "PreToolUse":
     case "PermissionRequest":
     case "Notification": {
-      const notice2 = ev.name === "UserPromptSubmit" && !!ev.text && !!crossSessionNotices(ev.text);
+      const notice2 = ev.name === "UserPromptSubmit" && !!ev.text && (!!crossSessionNotices(ev.text) || !!ledgeNotice(ev.text) || !!ledgeTask(ev.text) || !!ledgeTeamNotice(ev.text));
       if (ev.name === "UserPromptSubmit" && ev.text && !s.topic && !notice2 && !crossSession(ev.text)) s = withTopic(s, ev.text, "prompt");
       if (s.pending?.source === "rpc" && ev.name === "PreToolUse") return { ...s, lastHookAt: at, lastActivityAt: at };
       const incoming = pendingFor(ev);
@@ -520,12 +610,23 @@ function resolveTarget(to, sessions, peers) {
 }
 
 export {
+  teammates,
+  seatContext,
+  resolveRoleAddress,
   crossSession,
   messageNote,
   stripNote,
   ledgeBody,
+  mailId,
+  inline,
   formatLedgeMessage,
   ledgeMessages,
+  formatLedgeNotice,
+  formatTeamNotice,
+  ledgeTeamNotice,
+  formatLedgeTask,
+  ledgeTask,
+  ledgeNotice,
   crossSessionNotices,
   Refusal,
   NO_ALWAYS,

package/dist/cli/{chunk-MQICEVKR.js → chunk-QQZALYNI.js}

@@ -1,23 +1,31 @@
 import {
-  DaemonRefusedError,
-  connect
-} from "./chunk-DEXDXDO4.js";
+  EFFORT_ARGS,
+  MODEL_ARGS
+} from "./chunk-7IQ6FV2F.js";
+import {
+  autonomyArgs,
+  findRole
+} from "./chunk-3HCID6NW.js";
 import {
   exitFile,
   spawnSession
-} from "./chunk-H36JD4E3.js";
+} from "./chunk-TRTS24PF.js";
+import {
+  DaemonRefusedError,
+  connect
+} from "./chunk-GXFU4XAX.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-Q5WWH7FG.js";
+} from "./chunk-HP3G2TYJ.js";
 import {
   realTmux
-} from "./chunk-2H5FJH4Q.js";
+} from "./chunk-WJ6YMZTT.js";
 import {
   log
-} from "./chunk-BNKPXSUY.js";
+} from "./chunk-43D6NMYH.js";
 import {
   ensureLedgeDir
-} from "./chunk-R5462SQM.js";
+} from "./chunk-7ZAA75HG.js";
 
 // src/cli/launch.ts
 import { spawn } from "child_process";
@@ -28,19 +36,30 @@ var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 function parseLaunchArgs(argv) {
   const args = [];
   let name;
+  let role;
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--name") {
       name = argv[++i];
       continue;
     }
+    if (a === "--role") {
+      role = argv[++i];
+      continue;
+    }
     if (a === "--") {
       args.push(...argv.slice(i + 1));
       break;
     }
     args.push(a);
   }
-  return { name, args };
+  return { name, ...role ? { role } : {}, args };
+}
+function roleArgs(tool, role, args) {
+  const own = role.tool === void 0 || role.tool === tool;
+  const hasModel = args.some((a) => a === "--model" || a === "-m" || a.startsWith("--model="));
+  const hasEffort = args.some((a) => a === "--effort" || a.startsWith("--effort=") || a.includes("model_reasoning_effort"));
+  return [...own && role.model && !hasModel ? MODEL_ARGS[tool](role.model) : [], ...own && role.effort && !hasEffort ? EFFORT_ARGS[tool]?.(role.effort) ?? [] : [], ...autonomyArgs(tool, role.autonomy)];
 }
 function portOpen(port) {
   return new Promise((res) => {
@@ -118,7 +137,8 @@ async function createSession(opts) {
       ids.push(s.id);
     }
   }
-  const session = await spawnSession({ ...opts, taken: { names, ids } });
+  const { role, ...rest } = opts;
+  const session = await spawnSession({ ...rest, ...role ? { args: [...roleArgs(opts.tool, role, opts.args), ...opts.args], role: { id: role.id, label: role.label }, ...role.autonomy ? { autonomy: role.autonomy } : {} } : {}, taken: { names, ids } });
   try {
     opts.client?.send({ type: "session.register", session });
   } catch (e) {
@@ -156,15 +176,20 @@ var UNTRACKED = {
 };
 async function launch(tool, argv, opts = {}) {
   await ensureLedgeDir();
-  const { name, args } = parseLaunchArgs(argv);
+  const { name, role: roleId, args } = parseLaunchArgs(argv);
   const port = opts.port ?? PROTOCOL_PORT;
   const socket = opts.tmuxSocket ?? TMUX_SOCKET;
   const tmux = realTmux(socket);
   const cwd = opts.cwd ?? process.cwd();
+  const role = roleId ? findRole(roleId, cwd) : void 0;
+  if (roleId && !role) {
+    console.error(`ledge: r\xF4le inconnu : ${roleId} (aucun fichier .ledge/roles/${roleId}.md ni ~/.ledge/roles/${roleId}.md)`);
+    return 1;
+  }
   const daemon = await ensureDaemon({ port, spawnDaemon: opts.spawnDaemon, retryDelayMs: opts.retryDelayMs });
   let client = daemon.client;
   if (!daemon.client) console.error(UNTRACKED[daemon.reason](port));
-  const create = (c) => createSession({ tool, args, command: opts.command, recordExit: true, name, cwd, tmux, client: c });
+  const create = (c) => createSession({ tool, args, command: opts.command, recordExit: true, name, ...role ? { role } : {}, cwd, tmux, client: c });
   let session;
   try {
     session = await create(client);
@@ -198,6 +223,7 @@ async function launch(tool, argv, opts = {}) {
 
 export {
   parseLaunchArgs,
+  roleArgs,
   ensureDaemon,
   DaemonError,
   createSession,

package/dist/cli/{chunk-H36JD4E3.js → chunk-TRTS24PF.js}

@@ -1,10 +1,10 @@
 import {
   NAMES,
   pickName
-} from "./chunk-Q5WWH7FG.js";
+} from "./chunk-HP3G2TYJ.js";
 import {
   paths
-} from "./chunk-R5462SQM.js";
+} from "./chunk-7ZAA75HG.js";
 
 // src/daemon/transcript.ts
 import { appendFileSync, closeSync, fstatSync, openSync, readFileSync, readSync, statSync } from "fs";
@@ -206,7 +206,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)) env[k] = v;
+  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;
   return { ...env, ...extra };
 }
 async function spawnSession(opts) {
@@ -224,9 +224,27 @@ async function spawnSession(opts) {
   const env = opts.env ?? process.env;
   const transcriptPath = agentSessionId ? claudeTranscriptPath(opts.cwd, agentSessionId, env) : void 0;
   const command = opts.recordExit ? ["sh", "-c", '"$@"; echo $? > "$0"', exitFile(id), ...agent] : agent;
-  await opts.tmux.newSession({ name: tmuxSession, cwd: opts.cwd, env: agentEnv(env, { LEDGE_SESSION: id, LEDGE_NAME: name, ...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, 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 });
   const at = now();
-  return { id, name, tool: opts.tool, cwd: opts.cwd, project, title: `${name} \xB7 ${project}`, tmuxSession, state: "starting", helpers: [], startedAt: at, lastActivityAt: at, source: "launcher", ...agentSessionId ? { agentSessionId } : {}, ...transcriptPath ? { transcriptPath } : {} };
+  return {
+    id,
+    name,
+    tool: opts.tool,
+    cwd: opts.cwd,
+    project,
+    title: `${name} \xB7 ${project}`,
+    tmuxSession,
+    state: "starting",
+    helpers: [],
+    startedAt: at,
+    lastActivityAt: at,
+    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 } : {}
+  };
 }
 
 export {

package/dist/cli/{chunk-TB47EHML.js → chunk-WCS24ICX.js}

@@ -1,25 +1,27 @@
 import {
   connect
-} from "./chunk-DEXDXDO4.js";
+} from "./chunk-GXFU4XAX.js";
 import {
   isArchived
-} from "./chunk-Q5WWH7FG.js";
+} from "./chunk-HP3G2TYJ.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", "OUTIL", "\xC9TAT", "PROJET", "BRANCHE", "SUJET"];
+  const head = [" ", "NOM", ...roles ? ["R\xD4LE"] : [], "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-2H5FJH4Q.js → chunk-WJ6YMZTT.js}

@@ -1,9 +1,9 @@
 import {
   log
-} from "./chunk-BNKPXSUY.js";
+} from "./chunk-43D6NMYH.js";
 import {
   paths
-} from "./chunk-R5462SQM.js";
+} from "./chunk-7ZAA75HG.js";
 
 // src/tmux.ts
 import { execFile } from "child_process";

package/dist/cli/chunk-Y5DJ5INP.js

@@ -0,0 +1,60 @@
+import {
+  CODEX_HOOK_VAR
+} from "./chunk-TRTS24PF.js";
+import {
+  connect
+} from "./chunk-GXFU4XAX.js";
+import {
+  BRIEF_MAX
+} from "./chunk-HP3G2TYJ.js";
+
+// src/cli/handover.ts
+import { randomUUID } from "crypto";
+var HANDOVER_USAGE = `ledge handover "<bilan>"   ton bilan de rel\xE8ve, quand Ledge te le demande (fait, en cours, suite, pi\xE8ges, fichiers cl\xE9s)
+ledge handover show        relire le bilan de la session dont tu as pris la rel\xE8ve`;
+var HANDOVER_MS = 4e3;
+function handoverArgs(args) {
+  if (args.length === 1 && args[0] === "show") return { op: "show" };
+  const text = args.join(" ").trim();
+  if (!args.length || !text || text.length > BRIEF_MAX) return void 0;
+  return { op: "brief", text };
+}
+async function handoverOnClient(client, args, by, ms) {
+  const op = handoverArgs(args);
+  if (!op) return { line: HANDOVER_USAGE, code: 1 };
+  try {
+    const rid = randomUUID();
+    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 };
+  } catch (e) {
+    return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
+  }
+}
+async function runHandover(args, opts = {}) {
+  if (!handoverArgs(args)) return { line: HANDOVER_USAGE, code: args.length ? 1 : 0 };
+  const env = opts.env ?? process.env;
+  const by = env[CODEX_HOOK_VAR] || env.LEDGE_SESSION;
+  if (!by) return { line: "ledge handover ne marche que dans une session lanc\xE9e par Ledge", code: 1 };
+  const deadline = Date.now() + (opts.timeoutMs ?? HANDOVER_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 handoverOnClient(client, args, by, left());
+  } finally {
+    await client.close();
+  }
+}
+
+export {
+  HANDOVER_USAGE,
+  handoverArgs,
+  handoverOnClient,
+  runHandover
+};

package/dist/cli/{chunk-QJVODYJ5.js → chunk-ZUYOA55W.js}

@@ -1,10 +1,10 @@
+import {
+  CODEX_HOOK_VAR
+} from "./chunk-TRTS24PF.js";
 import {
   connect,
   sendMessageAndAwaitAck
-} from "./chunk-DEXDXDO4.js";
-import {
-  CODEX_HOOK_VAR
-} from "./chunk-H36JD4E3.js";
+} from "./chunk-GXFU4XAX.js";
 
 // src/cli/send.ts
 import { randomUUID } from "crypto";
@@ -58,6 +58,40 @@ async function sendMessage(args, opts = {}) {
     await client.close();
   }
 }
+var READ_USAGE = "ledge read <id>   print a long message whole (its id is in the pointer you received)";
+var MAIL_ID = /^m[0-9a-f]{6,40}$/;
+async function readOnClient(client, args, by, ms) {
+  const [id] = args;
+  if (args.length !== 1 || !id || !MAIL_ID.test(id)) return { line: READ_USAGE, code: 1 };
+  try {
+    client.send({ type: "message.read", id, by });
+    const body = await client.next("message.body", ms);
+    if (body.text === void 0) return { line: `introuvable : ${body.reason ?? "raison inconnue"}`, code: 1 };
+    return { line: `De ${body.from} \xE0 ${body.to}, ${body.at} :
+${body.text}`, code: 0 };
+  } catch (e) {
+    return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
+  }
+}
+async function readMessage(args, opts = {}) {
+  if (args.length !== 1 || !MAIL_ID.test(args[0])) return { line: READ_USAGE, code: 1 };
+  const env = opts.env ?? process.env;
+  const by = env[CODEX_HOOK_VAR] || env.LEDGE_SESSION;
+  if (!by) return { line: "ledge read ne marche que dans une session lanc\xE9e par Ledge", code: 1 };
+  const deadline = Date.now() + (opts.timeoutMs ?? SEND_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 readOnClient(client, args, by, left());
+  } finally {
+    await client.close();
+  }
+}
 function parseLedgeCommand(command) {
   command = command.replace(/[\r\n\s]+$/, "");
   const words = [];
@@ -95,11 +129,16 @@ function parseLedgeCommand(command) {
   if (words[0] !== "ledge") return void 0;
   if (words[1] === "who" && words.length === 2) return { cmd: "who" };
   if (words[1] === "send") return { cmd: "send", args: words.slice(2) };
+  if (words[1] === "read") return { cmd: "read", args: words.slice(2) };
+  if (words[1] === "task") return { cmd: "task", args: words.slice(2) };
+  if (words[1] === "handover") return { cmd: "handover", args: words.slice(2) };
   return void 0;
 }
 
 export {
   sendOnClient,
   sendMessage,
+  readOnClient,
+  readMessage,
   parseLedgeCommand
 };