@paradow/ledge 0.28.0 → 0.29.0-snapshot.41297455946.1

package/dist/cli/{decide-OSSTI3FE.js → decide-JSY46QZC.js}

@@ -1,26 +1,25 @@
 import {
   CODEX_HOOK_VAR
-} from "./chunk-LG3XFIPV.js";
+} from "./chunk-O4MUYFPH.js";
 import {
   connect
-} from "./chunk-VMGACWNP.js";
+} from "./chunk-FWLT3SAN.js";
 import {
-  LEDGE_GIVER,
-  TASK_TEXT_MAX
-} from "./chunk-VKRFHDRK.js";
-import "./chunk-HOOHS3MX.js";
+  ASK_ANSWER_MAX
+} from "./chunk-2X56ZRK7.js";
+import "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 
 // src/cli/decide.ts
 import { randomUUID } from "crypto";
 var DECIDE_USAGE = `ledge decide                       les d\xE9cisions que les sessions attendent de toi
 ledge decide <id> "<r\xE9ponse>"      y r\xE9pondre : la session qui l'a demand\xE9e reprend`;
-var ID = /^t[0-9a-f]{6}$/;
+var ID = /^a[0-9a-f]{6}$/;
 var DECIDE_MS = 4e3;
 function decideArgs(args) {
   if (!args.length) return { op: "list" };
   const [id, text] = args;
-  return args.length === 2 && ID.test(id) && text.trim() && text.length <= TASK_TEXT_MAX ? { op: "done", task: id, text } : void 0;
+  return args.length === 2 && ID.test(id) && text.trim() && text.length <= ASK_ANSWER_MAX ? { op: "answer", id, text } : void 0;
 }
 async function runDecide(args, opts = {}) {
   const op = decideArgs(args);
@@ -35,15 +34,14 @@ async function runDecide(args, opts = {}) {
   }
   try {
     if (op.op === "list") {
-      client.send({ type: "task.cmd", rid: randomUUID(), by: LEDGE_GIVER, op: "list" });
-      const asked = ((await client.next("task.result", DECIDE_MS)).tasks ?? []).filter((t) => t.owner === LEDGE_GIVER);
-      if (!asked.length) return { line: "aucune d\xE9cision en attente", code: 0 };
-      return { line: asked.map((t) => [`${t.id}  de ${t.giverName}  ${t.title}`, ...t.text ? t.text.split("\n").map((l) => `    ${l}`) : []].join("\n")).join("\n\n"), code: 0 };
+      const open = (await client.next("asks", DECIDE_MS)).asks.filter((a) => a.state === "open");
+      if (!open.length) return { line: "aucune d\xE9cision en attente", code: 0 };
+      return { line: open.map((a) => [`${a.id}  de ${a.fromName}  ${a.question}`, ...a.options ? a.options.split("\n").map((l) => `    ${l}`) : []].join("\n")).join("\n\n"), code: 0 };
     }
-    client.send({ type: "task.cmd", rid: randomUUID(), by: LEDGE_GIVER, op: "done", task: op.task, text: op.text });
-    const r = await client.next("task.result", DECIDE_MS);
-    if (r.reason !== void 0) return { line: `refus\xE9 : ${r.reason}`, code: 1 };
-    return { line: `r\xE9ponse envoy\xE9e \xE0 ${r.task.giverName}`, code: 0 };
+    client.send({ type: "ask.answer", rid: randomUUID(), id: op.id, text: op.text });
+    const r = await client.next("ask.result", DECIDE_MS);
+    if (!r.ask) return { line: `refus\xE9 : ${r.reason ?? "raison inconnue"}`, code: 1 };
+    return { line: `r\xE9ponse envoy\xE9e \xE0 ${r.ask.fromName}`, code: 0 };
   } catch (e) {
     return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
   } finally {

package/dist/cli/{handover-2G7OEWIG.js → handover-5RUSRVAD.js}

@@ -3,11 +3,11 @@ import {
   handoverArgs,
   handoverOnClient,
   runHandover
-} from "./chunk-JLUHY5AB.js";
-import "./chunk-LG3XFIPV.js";
-import "./chunk-VMGACWNP.js";
-import "./chunk-VKRFHDRK.js";
-import "./chunk-HOOHS3MX.js";
+} from "./chunk-OR2NHT5O.js";
+import "./chunk-O4MUYFPH.js";
+import "./chunk-FWLT3SAN.js";
+import "./chunk-2X56ZRK7.js";
+import "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 export {
   HANDOVER_USAGE,

package/dist/cli/{hook-XY4E5H7O.js → hook-QQP3ENGA.js}

@@ -1,53 +1,55 @@
 import {
   QUESTION_TOOLS,
   gitInfo,
+  mandateSummary,
   messageNote,
   readPeers,
-  resolveRoleAddress,
   resolveTarget,
-  seatContext,
-  takeImages,
-  teammates
-} from "./chunk-ZI47U5CQ.js";
+  rigSeatContext,
+  takeImages
+} from "./chunk-GY35ZR5I.js";
 import {
-  findRole
-} from "./chunk-JHFKBKSO.js";
+  HUMAN_ADDRESS
+} from "./chunk-DJMFCYF4.js";
+import {
+  log
+} from "./chunk-G3ST5WKR.js";
 import {
   parseLedgeCommand,
   readOnClient,
   sendOnClient
-} from "./chunk-3CF4FQWG.js";
+} from "./chunk-VQR5ME75.js";
 import {
-  taskOnClient
-} from "./chunk-CIQAFCX3.js";
+  askOnClient
+} from "./chunk-LOXLGCGN.js";
 import {
   handoverOnClient
-} from "./chunk-JLUHY5AB.js";
+} from "./chunk-OR2NHT5O.js";
+import {
+  brainOnClient
+} from "./chunk-S6BZV7AY.js";
+import "./chunk-TCQ5PYIF.js";
 import {
   CODEX_ENV_VAR,
   CODEX_HOOK_VAR,
   codexPlan
-} from "./chunk-LG3XFIPV.js";
+} from "./chunk-O4MUYFPH.js";
 import {
   formatWho
-} from "./chunk-3NQNWGDX.js";
+} from "./chunk-6EW2FD2U.js";
 import {
   connect,
   sendMessageAndAwaitAck
-} from "./chunk-VMGACWNP.js";
+} from "./chunk-FWLT3SAN.js";
 import {
-  taskClosed
-} from "./chunk-VKRFHDRK.js";
-import {
-  log
-} from "./chunk-6IYPRUQG.js";
+  SESSION_KEY_VAR
+} from "./chunk-2X56ZRK7.js";
 import {
   paths
-} from "./chunk-HOOHS3MX.js";
+} from "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 
 // src/cli/hook.ts
-import { randomUUID } from "crypto";
 import { readFileSync, openSync, fstatSync, readSync, closeSync } from "fs";
 import { basename, join } from "path";
 var str = (v) => typeof v === "string" ? v : void 0;
@@ -129,6 +131,13 @@ function codexLedgeId(env = process.env, daemon = underCodexDaemon) {
   if (env[CODEX_ENV_VAR] && !daemon()) return env[CODEX_ENV_VAR];
   return void 0;
 }
+var seat = (o) => o ? { openrig: o } : {};
+function openrigSeat(agent, env = process.env, daemon = underCodexDaemon) {
+  const sessionName = env.OPENRIG_SESSION_NAME;
+  if (!sessionName) return void 0;
+  if (agent === "codex" && daemon()) return void 0;
+  return { sessionName, ...env.OPENRIG_NODE_ID ? { nodeId: env.OPENRIG_NODE_ID } : {} };
+}
 function mapHook(agent, eventName, payload, at) {
   if (!payload || typeof payload !== "object") return null;
   const p = payload;
@@ -141,7 +150,7 @@ function mapHook(agent, eventName, payload, at) {
   if (!event) return null;
   const task = agent === "claude" && event.helperId ? helperDescription(str(p.transcript_path), event.helperId) : void 0;
   const agentSessionId = !event.helperId ? str(p.session_id) : void 0;
-  return { id, event: { ...event, ...task ? { task } : {}, ...agentSessionId ? { agentSessionId } : {} }, agent, ...cwd ? { cwd } : {} };
+  return { id, event: { ...event, ...task ? { task } : {}, ...agentSessionId ? { agentSessionId } : {} }, agent, ...cwd ? { cwd } : {}, ...seat(openrigSeat(agent)) };
 }
 function helperDescription(transcriptPath, agentId) {
   if (!transcriptPath?.endsWith(".jsonl") || !/^[\w-]+$/.test(agentId)) return void 0;
@@ -285,7 +294,7 @@ function mapCursorHook(eventName, payload, at, env = process.env) {
   const roots = Array.isArray(p.workspace_roots) ? p.workspace_roots : [];
   const cwd = str(roots[0]) || void 0;
   const event = helper ? mapCursorHelperEvent(eventName, p, at, sessionId) : mapCursorEvent(eventName, p, at, !!env.LEDGE_SESSION, transcript);
-  return event ? { id, event: helper || event.helperId ? event : { ...event, agentSessionId: sessionId }, agent: "cursor", ...cwd ? { cwd } : {} } : null;
+  return event ? { id, event: helper || event.helperId ? event : { ...event, agentSessionId: sessionId }, agent: "cursor", ...cwd ? { cwd } : {}, ...seat(openrigSeat("cursor", env)) } : null;
 }
 function mapCursorHelperEvent(eventName, p, at, helperId) {
   const base = { at, source: "hook", helperId };
@@ -337,32 +346,18 @@ function mapCursorEvent(eventName, p, at, launched, transcript) {
       return null;
   }
 }
-var TASKS_TOLD = 10;
-var TASK_STATE = { open: "ouverte", taken: "prise", done: "termin\xE9e", refused: "refus\xE9e", dropped: "abandonn\xE9e" };
-function tasksContext(tasks) {
-  if (!tasks.length) return void 0;
-  const shown = tasks.slice(0, TASKS_TOLD);
-  return [
-    "Tes t\xE2ches en cours (elles sont gard\xE9es par Ledge, pas dans ta conversation) :",
-    ...shown.map((t) => `- ${t.id} \xB7 ${TASK_STATE[t.state]} \xB7 \xAB ${t.title} \xBB \xB7 confi\xE9e par ${t.giverName}`),
-    ...tasks.length > shown.length ? [`- et ${tasks.length - shown.length} autre(s) : ledge task list`] : [],
-    "Relis-en une avec `ledge task show <id>` avant de reprendre."
-  ].join("\n");
-}
 function identityContext(s) {
   const where = [`projet ${s.repo ?? s.project}`, ...s.branch ? [`branche ${s.branch}`] : [], ...s.worktree ? [`worktree ${basename(s.cwd) || s.cwd}`] : []].join(", ");
   return [
     `Tu es ${s.name}, ${where} : une session lanc\xE9e par Ledge (${s.tool}). Les autres sessions Ledge te connaissent sous le nom ${s.name}.`,
     "Pour voir les autres sessions (nom, outil, \xE9tat, projet, branche, sujet), lance `ledge who`.",
-    s.tool === "claude" ? "Pour \xE9crire \xE0 une autre session Ledge, Claude ou Codex, utilise son nom Ledge (donn\xE9 par `ledge who`) comme adresse SendMessage : Ledge le transmet. `ListAgents` montre les noms internes de Claude, pas les noms Ledge." : "Pour \xE9crire \xE0 une autre session Ledge, lance `ledge send <nom> \"<message>\"` (seul, sans && ni |). Ledge ex\xE9cute lui-m\xEAme `ledge send`, `ledge read`, `ledge task` et `ledge who` : leur r\xE9sultat t'arrive comme \xAB Command blocked by PreToolUse hook: \u2026 \xBB, c'est la r\xE9ponse, pas une erreur.",
-    "Un long message d'une autre session t'arrive en aper\xE7u avec son id : lance `ledge read <id>` pour le lire en entier. Une `<ledge-notice>` vient de Ledge : soit un de tes messages n'a pas pu \xEAtre remis, soit un changement te concerne (ta consigne de r\xF4le, ton \xE9quipe).",
-    'Un message sert \xE0 pr\xE9venir ; pour confier un travail qui ne doit pas se perdre, lance plut\xF4t `ledge task give <nom> "<titre>" "<d\xE9tail>"` (`ledge task` pour le reste). Une `<ledge-task>` t\'en confie une, ou te dit comment une des tiennes a fini : quand on t\'en confie une, prends-la (`ledge task take <id>`) et termine-la toujours (`ledge task done <id> "<r\xE9sultat>"`, ou `refuse`). Une d\xE9cision qui revient \xE0 l\'utilisateur se pose avec `ledge task give ledge "<question>" "<options, ta recommandation>"` : sa r\xE9ponse te r\xE9veille, inutile d\'attendre la fin pour la poser.',
-    ...s.seat ? [s.seat] : [],
-    ...s.relieves ? [`Tu as pris la rel\xE8ve de ${s.relieves.name}, dont le contexte \xE9tait plein : relis son bilan avec \`ledge handover show\`.`] : [],
-    ...s.tasks ? [tasksContext(s.tasks) ?? ""].filter(Boolean) : []
+    s.tool === "claude" ? "Pour \xE9crire \xE0 une autre session Ledge, Claude ou Codex, utilise son nom Ledge (donn\xE9 par `ledge who`) comme adresse SendMessage : Ledge le transmet. `ListAgents` montre les noms internes de Claude, pas les noms Ledge." : "Pour \xE9crire \xE0 une autre session Ledge, lance `ledge send <nom> \"<message>\"` (seul, sans && ni |). Ledge ex\xE9cute lui-m\xEAme `ledge send`, `ledge read`, `ledge ask` et `ledge who` : leur r\xE9sultat t'arrive comme \xAB Command blocked by PreToolUse hook: \u2026 \xBB, c'est la r\xE9ponse, pas une erreur.",
+    "Un long message d'une autre session t'arrive en aper\xE7u avec son id : lance `ledge read <id>` pour le lire en entier. Une `<ledge-notice>` vient de Ledge : soit un de tes messages n'a pas pu \xEAtre remis, soit un changement te concerne.",
+    'Un message sert \xE0 pr\xE9venir. Une d\xE9cision qui revient \xE0 l\'utilisateur se pose avec `ledge ask "<question>" "<options, ta recommandation>"` : sa r\xE9ponse te r\xE9veille (une `<ledge-answer>`), inutile d\'attendre la fin pour la poser.',
+    ...s.relieves ? [`Tu as pris la rel\xE8ve de ${s.relieves.name}, dont le contexte \xE9tait plein : relis son bilan avec \`ledge handover show\`.`] : []
   ].join("\n");
 }
-async function identity(agent, cwd, known, deadline, live = { sessions: [], teams: [] }) {
+async function identity(agent, cwd, known, deadline) {
   const name = known?.name ?? process.env.LEDGE_NAME;
   const dir = known?.cwd ?? cwd;
   if (!name || !dir) return void 0;
@@ -374,23 +369,9 @@ async function identity(agent, cwd, known, deadline, live = { sessions: [], team
     project: known?.project ?? (basename(dir) || dir),
     ...known?.repo ?? git?.repo ? { repo: known?.repo ?? git.repo } : {},
     ...known?.branch ?? git?.branch ? { branch: known?.branch ?? git.branch } : {},
-    ...known?.worktree ?? git?.worktree ? { worktree: true } : {},
-    ...seatOf(known, dir, live)
+    ...known?.worktree ?? git?.worktree ? { worktree: true } : {}
   };
 }
-function seatOf(known, dir, live) {
-  const roleId = known?.role ?? process.env.LEDGE_ROLE;
-  if (!roleId) return {};
-  let role;
-  try {
-    role = findRole(roleId, dir);
-  } catch {
-    role = void 0;
-  }
-  const team = known?.team ? live.teams.find((t) => t.id === known.team && t.state !== "dissolved") : void 0;
-  const seat = seatContext({ ...role ? { role } : {}, roleId, roleLabel: known?.roleLabel, ...team ? { team: { name: team.name, members: teammates(team, live.sessions).filter((m) => m.name !== known?.name) } } : {} });
-  return seat ? { seat } : {};
-}
 var SEND_MESSAGE_MS = 1500;
 var deny = (reason) => JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } });
 async function relayMessage(client, from, toolUseId, input, deadline) {
@@ -400,14 +381,7 @@ async function relayMessage(client, from, toolUseId, input, deadline) {
   const snapshot = await client.next("snapshot", left());
   const sender = snapshot.sessions.find((s) => s.id === from);
   if (sender?.source !== "launcher") return void 0;
-  let address = to;
-  if (to.startsWith("@")) {
-    const teams = sender.team ? (await client.next("teams", left()).catch(() => void 0))?.teams ?? [] : [];
-    const role = resolveRoleAddress(to, from, snapshot.sessions, teams);
-    if ("reason" in role) return deny(`Ledge n'a pas pu transmettre le message \xE0 ${to} : ${role.reason}`);
-    address = role.to;
-  }
-  const r = resolveTarget(address, snapshot.sessions, readPeers());
+  const r = resolveTarget(to, snapshot.sessions, readPeers());
   if (r.outcome === "unknown") return void 0;
   if (r.outcome === "refused") return deny(`Ledge n'a pas pu transmettre le message \xE0 ${to} : ${r.reason}`);
   if (r.outcome === "native") {
@@ -418,7 +392,7 @@ async function relayMessage(client, from, toolUseId, input, deadline) {
   }
   const tool = r.target.tool;
   const summary = str(input.summary);
-  const ack = await sendMessageAndAwaitAck(client, { type: "session.message", rid: toolUseId, from, to: address, text: input.message, ...summary ? { summary } : {}, intercept: true }, left());
+  const ack = await sendMessageAndAwaitAck(client, { type: "session.message", rid: toolUseId, from, to, text: input.message, ...summary ? { summary } : {}, intercept: true }, left());
   const target = `${to} (${tool})`;
   const reason = ack.outcome === "accepted" ? `Message transmis par Ledge \xE0 ${target} : il le re\xE7oit maintenant.` : ack.outcome === "queued" ? `Message transmis par Ledge \xE0 ${target} : il le recevra d\xE8s qu'il sera libre.` : ack.outcome === "refused" ? `Ledge n'a pas pu transmettre le message \xE0 ${to} : ${ack.reason ?? "raison inconnue"}` : void 0;
   return reason ? deny(reason) : void 0;
@@ -426,13 +400,41 @@ async function relayMessage(client, from, toolUseId, input, deadline) {
 async function runLedgeCommand(client, cmd, from, deadline) {
   const left = () => Math.max(0, deadline - Date.now());
   let line;
-  if (cmd.cmd === "who") line = formatWho((await client.next("snapshot", left())).sessions, from);
+  if (cmd.cmd === "brain") line = (await brainOnClient(client, cmd.args, from, process.env[SESSION_KEY_VAR], left())).line;
+  else if (cmd.cmd === "who") line = formatWho((await client.next("snapshot", left())).sessions, from);
   else if (cmd.cmd === "read") line = (await readOnClient(client, cmd.args, from, left())).line;
-  else if (cmd.cmd === "task") line = (await taskOnClient(client, cmd.args, from, left())).line;
+  else if (cmd.cmd === "ask") line = (await askOnClient(client, cmd.args, from, left())).line;
   else if (cmd.cmd === "handover") line = (await handoverOnClient(client, cmd.args, from, left())).line;
   else line = (await sendOnClient(client, cmd.args, from, left())).line;
   return deny(line);
 }
+var WRAPPERS = "sudo|env|exec|command|nohup|time|timeout|nice|stdbuf|watch|xargs|then|do|else|elif|if|while|until";
+var WRAPPER_ARG = "(?:-\\S+(?:\\s+[^-\\s;&|]\\S*)?|\\d[\\w.]*)\\s+";
+var COMMAND_AT = `(?:^|[;&|({!\`\\n])\\s*(?:(?:[A-Za-z_][A-Za-z0-9_]*=\\S*|${WRAPPERS})\\s+(?:${WRAPPER_ARG})*)*`;
+var LOOPBACK = "(?<![\\w.])(?:127(?:\\.\\d+){1,3}|localhost|0\\.0\\.0\\.0|0|::1)";
+var OPENRIG_API = `\\b(?:curl|wget|https?|httpie|xh|nc|ncat|netcat|telnet|socat)\\b[^;&|\\n]*?${LOOPBACK}\\]?(?::|\\s+)7433\\b|/dev/(?:tcp|udp)/${LOOPBACK}/7433\\b`;
+var BRAIN_FORBIDDEN = new RegExp(`${COMMAND_AT}(?:\\S*/)?(?:rig|tmux)(?=$|[\\s;&|)\`])|${OPENRIG_API}`, "mi");
+var BRAIN_REFUSAL = "Le cerveau de Ledge ne lance ni rig, ni tmux, ni l'API d'OpenRig lui-m\xEAme : passe par `ledge brain \u2026`.";
+function brainRefusal(command) {
+  return BRAIN_FORBIDDEN.test(command) ? BRAIN_REFUSAL : null;
+}
+var isBrainId = (id) => id === "brain" || !!id?.startsWith("brain-");
+function isBrain(agent, id, env, daemon = underCodexDaemon) {
+  if (isBrainId(id)) return true;
+  if (env.LEDGE_BRAIN !== "1") return false;
+  return agent !== "codex" || !env[CODEX_HOOK_VAR] && !daemon();
+}
+var BRAIN_CONTEXT = "Tu es Ledge, l'humain des rigs OpenRig de l'utilisateur et son seul interlocuteur. Tes consignes, ton mandat et ta m\xE9moire sont dans CLAUDE.md / AGENTS.md de ce dossier ; tu n'agis que par `ledge brain \u2026`.";
+function seatStart(seat2) {
+  let text = null;
+  try {
+    text = readFileSync(paths().mandate, "utf8");
+  } catch {
+  }
+  const rig = seat2.slice(seat2.indexOf("@") + 1);
+  const additionalContext = rigSeatContext({ seat: seat2, rig, human: HUMAN_ADDRESS, mandate: mandateSummary(text) });
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext } });
+}
 async function runHook(eventName, stdin, opts = {}) {
   const agent = opts.tool ?? "claude";
   const label = agent === "claude" ? eventName : `${agent} ${eventName}`;
@@ -443,10 +445,9 @@ async function runHook(eventName, stdin, opts = {}) {
   let mapped = null;
   let identify = false;
   let known;
-  let live = { sessions: [], teams: [] };
   let deadline = Date.now() + (opts.timeoutMs ?? 100);
   let relayed;
-  let held = [];
+  let brain = false;
   try {
     const payload = JSON.parse(stdin || "{}");
     mapped = agent === "cursor" ? mapCursorHook(eventName, payload, (/* @__PURE__ */ new Date()).toISOString()) : mapHook(agent, eventName, payload, (/* @__PURE__ */ new Date()).toISOString());
@@ -455,22 +456,22 @@ async function runHook(eventName, stdin, opts = {}) {
       return void 0;
     }
     const launchedId = agent === "codex" ? codexLedgeId() : agent === "claude" ? process.env.LEDGE_SESSION : void 0;
-    identify = eventName === "SessionStart" && !!launchedId && mapped.id === launchedId;
+    brain = agent !== "cursor" && isBrain(agent, launchedId, process.env, opts.daemon);
+    identify = !brain && eventName === "SessionStart" && !!launchedId && mapped.id === launchedId;
     const input = payload.tool_input ?? {};
+    const shell = eventName === "PreToolUse" && str(payload.tool_name) === "Bash" && typeof input.command === "string" ? input.command : void 0;
+    const refusal = brain && shell !== void 0 ? brainRefusal(shell) : null;
+    if (refusal) relayed = deny(refusal);
     const intercept = agent === "claude" && eventName === "PreToolUse" && str(payload.tool_name) === "SendMessage" && typeof input.to === "string" && typeof input.message === "string" && !!input.message;
-    const command = agent === "codex" && eventName === "PreToolUse" && str(payload.tool_name) === "Bash" && typeof input.command === "string" ? parseLedgeCommand(input.command) : void 0;
+    const parsed = agent === "codex" && !refusal && shell !== void 0 ? parseLedgeCommand(shell) : void 0;
+    const command = parsed?.cmd === "brain" && !brain ? void 0 : parsed;
     const timeoutMs = opts.timeoutMs ?? (identify ? 1e3 : intercept || command ? SEND_MESSAGE_MS : 100);
     deadline = Date.now() + timeoutMs;
     const client = await connect({ port: opts.port, timeoutMs });
-    client.send({ type: "session.event", id: mapped.id, event: mapped.event, agent: mapped.agent, ...mapped.cwd ? { cwd: mapped.cwd } : {} });
+    client.send({ type: "session.event", id: mapped.id, event: mapped.event, agent: mapped.agent, ...mapped.cwd ? { cwd: mapped.cwd } : {}, ...seat(mapped.openrig) });
     if (identify) {
       const snapshot = await client.next("snapshot", Math.max(0, deadline - Date.now())).catch(() => void 0);
       known = snapshot?.sessions.find((s) => s.id === mapped.id);
-      const teamList = known?.team ? (await client.next("teams", Math.max(0, deadline - Date.now())).catch(() => void 0))?.teams : void 0;
-      live = { sessions: snapshot?.sessions ?? [], teams: teamList ?? [] };
-      client.send({ type: "task.cmd", rid: randomUUID(), by: mapped.id, op: "list" });
-      const listed = await client.next("task.result", Math.max(0, deadline - Date.now())).catch(() => void 0);
-      held = (listed?.tasks ?? []).filter((t) => t.owner === mapped.id && !taskClosed(t));
     }
     if (intercept) relayed = await relayMessage(client, mapped.id, str(payload.tool_use_id), input, deadline);
     if (command) relayed = await runLedgeCommand(client, command, mapped.id, deadline);
@@ -479,23 +480,28 @@ async function runHook(eventName, stdin, opts = {}) {
     log(`hook ${label} dropped: ${e.message}`);
   }
   if (relayed) return relayed;
+  if (brain && eventName === "SessionStart" && mapped) return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: BRAIN_CONTEXT } });
+  if (eventName === "SessionStart" && mapped?.openrig && !identify && !process.env.LEDGE_SESSION) return seatStart(mapped.openrig.sessionName);
   if (!identify || !mapped) return void 0;
-  const found = await identity(agent, mapped.cwd, known, deadline, live);
-  const who = found ? { ...found, ...held.length ? { tasks: held } : {}, ...known?.relieves ? { relieves: known.relieves } : {} } : void 0;
+  const found = await identity(agent, mapped.cwd, known, deadline);
+  const who = found ? { ...found, ...known?.relieves ? { relieves: known.relieves } : {} } : void 0;
   return who ? JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: identityContext(who) } }) : void 0;
 }
 export {
+  BRAIN_CONTEXT,
+  BRAIN_FORBIDDEN,
   INPUT_MAX,
   REPLY_MAX,
+  brainRefusal,
   codexLedgeId,
   cursorReply,
   identityContext,
   mapClaudeHook,
   mapCursorHook,
   mapHook,
+  openrigSeat,
   readTranscript,
   runHook,
-  tasksContext,
   toolOutput,
   trimInput,
   underCodexDaemon

package/dist/cli/index.js

@@ -1,7 +1,15 @@
 #!/usr/bin/env node
+import "./chunk-U67V476Y.js";
+
+// src/cli/removed.ts
+function removedCommand(cmd) {
+  if (cmd === "task") return `ledge task a \xE9t\xE9 retir\xE9 : pour une d\xE9cision qui revient \xE0 l'utilisateur, ledge ask "<question>" "<options, ta recommandation>"`;
+  if (cmd === "team") return "ledge team a \xE9t\xE9 retir\xE9";
+  return void 0;
+}
 
 // src/cli/index.ts
-var USAGE = `ledge <claude|codex|cursor> [--name <bot>] [--role <id>] [-- agent args]   start an agent in a tracked session (--role: .ledge/roles/<id>.md)
+var USAGE = `ledge <claude|codex|cursor> [--name <bot>] [-- agent args]   start an agent in a tracked session
 ledge attach [--read-only] <id>                              put this terminal on a running session
 ledge daemon                                                 run the daemon in the foreground
 ledge hook [codex|cursor] <Event>                            receive a hook (reads JSON on stdin)
@@ -11,13 +19,13 @@ ledge status                                                 list sessions
 ledge who                                                    list the live sessions (name, tool, state, project, branch, topic)
 ledge send <nom> "<message>" [--summary <texte>]             write to another Ledge session
 ledge read <id>                                              print a long message whole (the id is in its pointer)
-ledge task <give|list|show|take|done|refuse|pass> \u2026         give another session work, take it, close it (ledge task: details)
+ledge ask "<question>" "<options, ta recommandation>"        ask the user a decision; the answer wakes you
 ledge decide [<id> "<r\xE9ponse>"]                               the decisions sessions wait for from you; answer one
 ledge handover "<bilan>" | show                              the relief brief, when Ledge asks for it; show: read your predecessor's
-ledge team <up|list|join|leave|resume|dissolve|save> \u2026       start, list and run teams (ledge team: details; --json for agents)
 ledge close <session>\u2026 [--json]                              close sessions cleanly (their conversation stays resumable)
 ledge tui [--notify bell|osc9|off] [--here]                  follow and answer the sessions (in a Ledge tab of Windows Terminal unless --here)
 ledge bridge                                                 exchange Ledge messages over SSH stdio
+ledge brain <say|decide|ask|rig|send|propose|remember|who|rigs|escalations|rules> \u2026   only from Ledge's brain session
 ledge --version                                              print the installed version`;
 async function hookMain(args) {
   const tool = args[0] === "codex" || args[0] === "cursor" ? args[0] : void 0;
@@ -25,7 +33,7 @@ async function hookMain(args) {
   try {
     const chunks = [];
     for await (const c of process.stdin) chunks.push(c);
-    const { runHook } = await import("./hook-XY4E5H7O.js");
+    const { runHook } = await import("./hook-QQP3ENGA.js");
     const out = await runHook(event, Buffer.concat(chunks).toString("utf8"), { tool });
     if (out) process.stdout.write(`${out}
 `);
@@ -37,7 +45,7 @@ async function main(argv) {
   const [cmd, ...rest] = argv;
   switch (cmd) {
     case "daemon": {
-      const { startDaemon } = await import("./daemon-ZUHJKLSL.js");
+      const { startDaemon } = await import("./daemon-ICC6LBCO.js");
       await startDaemon();
       await new Promise(() => {
       });
@@ -45,17 +53,17 @@ async function main(argv) {
     }
     case "--version":
     case "version": {
-      const { LEDGE_VERSION } = await import("./version-L2Y7MRH6.js");
+      const { LEDGE_VERSION } = await import("./version-QMHFVP3N.js");
       console.log(LEDGE_VERSION);
       return 0;
     }
     case "setup": {
-      const { runSetup } = await import("./setup-K42IVMHS.js");
+      const { runSetup } = await import("./setup-OLVRJLJE.js");
       for (const l of await runSetup()) console.log(l);
       return 0;
     }
     case "uninstall": {
-      const { runUninstall, uninstallArgs } = await import("./uninstall-4IMMR55T.js");
+      const { runUninstall, uninstallArgs } = await import("./uninstall-X65CWHIJ.js");
       const args = uninstallArgs(rest);
       if (!args) {
         console.log(USAGE);
@@ -66,76 +74,80 @@ async function main(argv) {
       return r.ok ? 0 : 1;
     }
     case "status": {
-      const { printStatus } = await import("./status-4Z2VJFID.js");
+      const { printStatus } = await import("./status-Z3I33KZJ.js");
       console.log(await printStatus());
       return 0;
     }
     case "who": {
-      const { printWho } = await import("./who-PSKHASMK.js");
+      const { printWho } = await import("./who-C2VMEM35.js");
       console.log(await printWho());
       return 0;
     }
     case "send": {
-      const { sendMessage } = await import("./send-RUHGKLMA.js");
+      const { sendMessage } = await import("./send-BIIH6SQW.js");
       const r = await sendMessage(rest);
       console.log(r.line);
       return r.code;
     }
     case "read": {
-      const { readMessage } = await import("./send-RUHGKLMA.js");
+      const { readMessage } = await import("./send-BIIH6SQW.js");
       const r = await readMessage(rest);
       console.log(r.line);
       return r.code;
     }
-    case "task": {
-      const { runTask } = await import("./task-2GESYTOL.js");
-      const r = await runTask(rest);
+    case "ask": {
+      const { runAsk } = await import("./ask-L3PSQZ2K.js");
+      const r = await runAsk(rest);
       console.log(r.line);
       return r.code;
     }
     case "decide": {
-      const { runDecide } = await import("./decide-OSSTI3FE.js");
+      const { runDecide } = await import("./decide-JSY46QZC.js");
       const r = await runDecide(rest);
       console.log(r.line);
       return r.code;
     }
     case "handover": {
-      const { runHandover } = await import("./handover-2G7OEWIG.js");
+      const { runHandover } = await import("./handover-5RUSRVAD.js");
       const r = await runHandover(rest);
       console.log(r.line);
       return r.code;
     }
     case "close": {
-      const { runClose } = await import("./action-NQRSZEC5.js");
+      const { runClose } = await import("./action-MCR4BCSE.js");
       const r = await runClose(rest);
       console.log(r.line);
       return r.code;
     }
-    case "team": {
-      const { runTeam } = await import("./team-MTSKNMAE.js");
-      const r = await runTeam(rest);
-      console.log(r.line);
-      return r.code;
-    }
     case "tui": {
-      const { runTui } = await import("./tui-4IRYQXYU.js");
+      const { runTui } = await import("./tui-AIXCETOB.js");
       return runTui(rest);
     }
+    case "brain": {
+      const { runBrain } = await import("./brain-BJTBN2ZK.js");
+      const r = await runBrain(rest);
+      console.log(r.line);
+      return r.code;
+    }
     case "bridge": {
-      const { bridge } = await import("./bridge-XCTXVWKH.js");
+      const { bridge } = await import("./bridge-YBHXFEFX.js");
       await bridge();
       return 0;
     }
     case "claude":
     case "codex":
     case "cursor": {
-      const { launch } = await import("./launch-7WOARLZM.js");
+      const { launch } = await import("./launch-RTBGUJSC.js");
       return launch(cmd, rest);
     }
     case "attach": {
-      const { attach } = await import("./attach-KXOSFUHO.js");
+      const { attach } = await import("./attach-R7FT7LFH.js");
       return attach(rest.find((a) => !a.startsWith("--")) ?? "", { readOnly: rest.includes("--read-only") });
     }
+    case "task":
+    case "team":
+      console.log(removedCommand(cmd));
+      return 1;
     default:
       console.log(USAGE);
       return cmd ? 1 : 0;

package/dist/cli/launch-RTBGUJSC.js

@@ -0,0 +1,28 @@
+import {
+  DaemonError,
+  attachEnv,
+  createSession,
+  ensureDaemon,
+  launch,
+  parseLaunchArgs
+} from "./chunk-UMQGRTA4.js";
+import "./chunk-KBSXP63H.js";
+import "./chunk-G3ST5WKR.js";
+import {
+  agentEnv,
+  exitFile
+} from "./chunk-O4MUYFPH.js";
+import "./chunk-FWLT3SAN.js";
+import "./chunk-2X56ZRK7.js";
+import "./chunk-W724IVDC.js";
+import "./chunk-U67V476Y.js";
+export {
+  DaemonError,
+  agentEnv,
+  attachEnv,
+  createSession,
+  ensureDaemon,
+  exitFile,
+  launch,
+  parseLaunchArgs
+};

package/dist/cli/{send-RUHGKLMA.js → send-BIIH6SQW.js}

@@ -4,11 +4,11 @@ import {
   readOnClient,
   sendMessage,
   sendOnClient
-} from "./chunk-3CF4FQWG.js";
-import "./chunk-LG3XFIPV.js";
-import "./chunk-VMGACWNP.js";
-import "./chunk-VKRFHDRK.js";
-import "./chunk-HOOHS3MX.js";
+} from "./chunk-VQR5ME75.js";
+import "./chunk-O4MUYFPH.js";
+import "./chunk-FWLT3SAN.js";
+import "./chunk-2X56ZRK7.js";
+import "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 export {
   parseLedgeCommand,

package/dist/cli/{setup-K42IVMHS.js → setup-OLVRJLJE.js}

@@ -14,10 +14,10 @@ import {
   stopDetachedDaemon,
   systemdUnit,
   writeBin
-} from "./chunk-K7UEKSB2.js";
-import "./chunk-NLL2EQJ2.js";
-import "./chunk-6IYPRUQG.js";
-import "./chunk-HOOHS3MX.js";
+} from "./chunk-WYRQZA4G.js";
+import "./chunk-KBSXP63H.js";
+import "./chunk-G3ST5WKR.js";
+import "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 export {
   BIN_MARK,

package/dist/cli/{status-4Z2VJFID.js → status-Z3I33KZJ.js}

@@ -1,8 +1,8 @@
 import {
   connect
-} from "./chunk-VMGACWNP.js";
-import "./chunk-VKRFHDRK.js";
-import "./chunk-HOOHS3MX.js";
+} from "./chunk-FWLT3SAN.js";
+import "./chunk-2X56ZRK7.js";
+import "./chunk-W724IVDC.js";
 import "./chunk-U67V476Y.js";
 
 // src/cli/status.ts