@paradow/ledge 0.17.0 → 0.18.0

package/dist/cli/handover-UXISKYPS.js

@@ -0,0 +1,16 @@
+import {
+  HANDOVER_USAGE,
+  handoverArgs,
+  handoverOnClient,
+  runHandover
+} from "./chunk-Y5DJ5INP.js";
+import "./chunk-TRTS24PF.js";
+import "./chunk-GXFU4XAX.js";
+import "./chunk-HP3G2TYJ.js";
+import "./chunk-7ZAA75HG.js";
+export {
+  HANDOVER_USAGE,
+  handoverArgs,
+  handoverOnClient,
+  runHandover
+};

package/dist/cli/{hook-AE5HC6AS.js → hook-5UAARBWU.js}

@@ -1,37 +1,49 @@
+import {
+  QUESTION_TOOLS,
+  gitInfo,
+  messageNote,
+  readPeers,
+  resolveRoleAddress,
+  resolveTarget,
+  seatContext,
+  teammates
+} from "./chunk-KKNE7BFZ.js";
+import {
+  findRole
+} from "./chunk-3HCID6NW.js";
 import {
   parseLedgeCommand,
   readOnClient,
   sendOnClient
-} from "./chunk-AQ25HFBP.js";
+} from "./chunk-ZUYOA55W.js";
 import {
   taskOnClient
-} from "./chunk-5ZCHFGCV.js";
+} from "./chunk-BVBX222F.js";
+import {
+  handoverOnClient
+} from "./chunk-Y5DJ5INP.js";
+import {
+  CODEX_ENV_VAR,
+  CODEX_HOOK_VAR,
+  codexPlan
+} from "./chunk-TRTS24PF.js";
 import {
   formatWho
-} from "./chunk-Q7YNLP66.js";
+} from "./chunk-WCS24ICX.js";
 import {
   connect,
   sendMessageAndAwaitAck
-} from "./chunk-VVK4I6B5.js";
-import {
-  QUESTION_TOOLS,
-  gitInfo,
-  messageNote,
-  readPeers,
-  resolveTarget
-} from "./chunk-NC5YAEJB.js";
+} from "./chunk-GXFU4XAX.js";
 import {
-  CODEX_ENV_VAR,
-  CODEX_HOOK_VAR,
-  codexPlan
-} from "./chunk-VE4LGNXX.js";
-import "./chunk-QD27W6W5.js";
+  taskClosed
+} from "./chunk-HP3G2TYJ.js";
 import {
   log
-} from "./chunk-JQZHXVIZ.js";
-import "./chunk-ELLXOV4Q.js";
+} from "./chunk-43D6NMYH.js";
+import "./chunk-7ZAA75HG.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;
@@ -317,6 +329,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 [
@@ -324,10 +348,13 @@ function identityContext(s) {
     "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>` te dit qu'un de tes messages n'a pas pu \xEAtre remis.",
-    '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`).'
+    '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`).',
+    ...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) : []
   ].join("\n");
 }
-async function identity(agent, cwd, known, deadline) {
+async function identity(agent, cwd, known, deadline, live = { sessions: [], teams: [] }) {
   const name = known?.name ?? process.env.LEDGE_NAME;
   const dir = known?.cwd ?? cwd;
   if (!name || !dir) return void 0;
@@ -339,9 +366,23 @@ async function identity(agent, cwd, known, deadline) {
     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 } : {}
+    ...known?.worktree ?? git?.worktree ? { worktree: true } : {},
+    ...seatOf(known, dir, live)
   };
 }
+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) {
@@ -351,7 +392,14 @@ 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;
-  const r = resolveTarget(to, snapshot.sessions, readPeers());
+  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());
   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") {
@@ -362,7 +410,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, text: input.message, ...summary ? { summary } : {}, intercept: true }, left());
+  const ack = await sendMessageAndAwaitAck(client, { type: "session.message", rid: toolUseId, from, to: address, 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;
@@ -373,6 +421,7 @@ async function runLedgeCommand(client, cmd, from, deadline) {
   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 === "handover") line = (await handoverOnClient(client, cmd.args, from, left())).line;
   else line = (await sendOnClient(client, cmd.args, from, left())).line;
   return deny(line);
 }
@@ -386,8 +435,10 @@ 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 = [];
   try {
     const payload = JSON.parse(stdin || "{}");
     mapped = agent === "cursor" ? mapCursorHook(eventName, payload, (/* @__PURE__ */ new Date()).toISOString()) : mapHook(agent, eventName, payload, (/* @__PURE__ */ new Date()).toISOString());
@@ -404,7 +455,15 @@ async function runHook(eventName, stdin, opts = {}) {
     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 } : {} });
-    if (identify) known = (await client.next("snapshot", Math.max(0, deadline - Date.now())).catch(() => void 0))?.sessions.find((s) => s.id === mapped.id);
+    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);
     await Promise.race([client.close(), new Promise((r) => setTimeout(r, Math.max(0, deadline - Date.now())))]);
@@ -413,7 +472,8 @@ async function runHook(eventName, stdin, opts = {}) {
   }
   if (relayed) return relayed;
   if (!identify || !mapped) return void 0;
-  const who = await identity(agent, mapped.cwd, known, deadline);
+  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;
   return who ? JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: identityContext(who) } }) : void 0;
 }
 export {
@@ -427,6 +487,7 @@ export {
   mapHook,
   readTranscript,
   runHook,
+  tasksContext,
   toolOutput,
   trimInput,
   underCodexDaemon

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-var USAGE = `ledge <claude|codex|cursor> [--name <bot>] [-- agent args]   start an agent in a tracked session
+var USAGE = `ledge <claude|codex|cursor> [--name <bot>] [--role <id>] [-- agent args]   start an agent in a tracked session (--role: .ledge/roles/<id>.md)
 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)
@@ -12,6 +12,8 @@ ledge who                                                    list the live sessi
 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 handover "<bilan>" | show                              the relief brief, when Ledge asks for it; show: read your predecessor's
+ledge team <up|list> \u2026                                       start a team from a template, list templates, roles and live teams
 ledge tui [--notify bell|osc9|off]                           follow and answer the sessions in this terminal
 ledge bridge                                                 exchange Ledge messages over SSH stdio
 ledge --version                                              print the installed version`;
@@ -21,7 +23,7 @@ async function hookMain(args) {
   try {
     const chunks = [];
     for await (const c of process.stdin) chunks.push(c);
-    const { runHook } = await import("./hook-AE5HC6AS.js");
+    const { runHook } = await import("./hook-5UAARBWU.js");
     const out = await runHook(event, Buffer.concat(chunks).toString("utf8"), { tool });
     if (out) process.stdout.write(`${out}
 `);
@@ -33,7 +35,7 @@ async function main(argv) {
   const [cmd, ...rest] = argv;
   switch (cmd) {
     case "daemon": {
-      const { startDaemon } = await import("./daemon-QEJLAIBT.js");
+      const { startDaemon } = await import("./daemon-SKC7VKYQ.js");
       await startDaemon();
       await new Promise(() => {
       });
@@ -41,17 +43,17 @@ async function main(argv) {
     }
     case "--version":
     case "version": {
-      const { LEDGE_VERSION } = await import("./version-WOGCIZY3.js");
+      const { LEDGE_VERSION } = await import("./version-AEN2CRT2.js");
       console.log(LEDGE_VERSION);
       return 0;
     }
     case "setup": {
-      const { runSetup } = await import("./setup-2VM4GCDJ.js");
+      const { runSetup } = await import("./setup-EEIXRAMU.js");
       for (const l of await runSetup()) console.log(l);
       return 0;
     }
     case "uninstall": {
-      const { runUninstall, uninstallArgs } = await import("./uninstall-AKUWE33D.js");
+      const { runUninstall, uninstallArgs } = await import("./uninstall-UUN7LIIT.js");
       const args = uninstallArgs(rest);
       if (!args) {
         console.log(USAGE);
@@ -62,50 +64,62 @@ async function main(argv) {
       return r.ok ? 0 : 1;
     }
     case "status": {
-      const { printStatus } = await import("./status-3VJAO6UL.js");
+      const { printStatus } = await import("./status-2OCYHOWZ.js");
       console.log(await printStatus());
       return 0;
     }
     case "who": {
-      const { printWho } = await import("./who-37TNDYVA.js");
+      const { printWho } = await import("./who-52MENZTT.js");
       console.log(await printWho());
       return 0;
     }
     case "send": {
-      const { sendMessage } = await import("./send-2OZ3YZRV.js");
+      const { sendMessage } = await import("./send-NLVR6PL2.js");
       const r = await sendMessage(rest);
       console.log(r.line);
       return r.code;
     }
     case "read": {
-      const { readMessage } = await import("./send-2OZ3YZRV.js");
+      const { readMessage } = await import("./send-NLVR6PL2.js");
       const r = await readMessage(rest);
       console.log(r.line);
       return r.code;
     }
     case "task": {
-      const { runTask } = await import("./task-PMKNYP6M.js");
+      const { runTask } = await import("./task-AOOWHPMN.js");
       const r = await runTask(rest);
       console.log(r.line);
       return r.code;
     }
+    case "handover": {
+      const { runHandover } = await import("./handover-UXISKYPS.js");
+      const r = await runHandover(rest);
+      console.log(r.line);
+      return r.code;
+    }
+    case "team": {
+      const { runTeam } = await import("./team-TVNSVYWW.js");
+      const r = await runTeam(rest);
+      console.log(r.line);
+      return r.code;
+    }
     case "tui": {
-      const { runTui } = await import("./tui-DWA2EDC2.js");
+      const { runTui } = await import("./tui-MQLMUUJB.js");
       return runTui(rest);
     }
     case "bridge": {
-      const { bridge } = await import("./bridge-6UHCD76N.js");
+      const { bridge } = await import("./bridge-APNFBPNE.js");
       await bridge();
       return 0;
     }
     case "claude":
     case "codex":
     case "cursor": {
-      const { launch } = await import("./launch-B4G5OFBV.js");
+      const { launch } = await import("./launch-T5FJ42XS.js");
       return launch(cmd, rest);
     }
     case "attach": {
-      const { attach } = await import("./attach-EYIX7FZN.js");
+      const { attach } = await import("./attach-I6TTCGNV.js");
       return attach(rest.find((a) => !a.startsWith("--")) ?? "", { readOnly: rest.includes("--read-only") });
     }
     default:

package/dist/cli/launch-T5FJ42XS.js

@@ -0,0 +1,34 @@
+import {
+  DaemonError,
+  attachEnv,
+  createSession,
+  ensureDaemon,
+  launch,
+  parseLaunchArgs,
+  roleArgs
+} from "./chunk-QQZALYNI.js";
+import "./chunk-7IQ6FV2F.js";
+import "./chunk-3EIRKAX7.js";
+import "./chunk-OLLQBK6N.js";
+import "./chunk-KKNE7BFZ.js";
+import "./chunk-3HCID6NW.js";
+import {
+  agentEnv,
+  exitFile
+} from "./chunk-TRTS24PF.js";
+import "./chunk-GXFU4XAX.js";
+import "./chunk-HP3G2TYJ.js";
+import "./chunk-WJ6YMZTT.js";
+import "./chunk-43D6NMYH.js";
+import "./chunk-7ZAA75HG.js";
+export {
+  DaemonError,
+  agentEnv,
+  attachEnv,
+  createSession,
+  ensureDaemon,
+  exitFile,
+  launch,
+  parseLaunchArgs,
+  roleArgs
+};

package/dist/cli/{send-2OZ3YZRV.js → send-NLVR6PL2.js}

@@ -4,11 +4,11 @@ import {
   readOnClient,
   sendMessage,
   sendOnClient
-} from "./chunk-AQ25HFBP.js";
-import "./chunk-VVK4I6B5.js";
-import "./chunk-VE4LGNXX.js";
-import "./chunk-QD27W6W5.js";
-import "./chunk-ELLXOV4Q.js";
+} from "./chunk-ZUYOA55W.js";
+import "./chunk-TRTS24PF.js";
+import "./chunk-GXFU4XAX.js";
+import "./chunk-HP3G2TYJ.js";
+import "./chunk-7ZAA75HG.js";
 export {
   parseLedgeCommand,
   readMessage,

package/dist/cli/{setup-2VM4GCDJ.js → setup-EEIXRAMU.js}

@@ -14,10 +14,10 @@ import {
   stopDetachedDaemon,
   systemdUnit,
   writeBin
-} from "./chunk-OVJL2QTN.js";
-import "./chunk-LAUNHDTX.js";
-import "./chunk-JQZHXVIZ.js";
-import "./chunk-ELLXOV4Q.js";
+} from "./chunk-FQZ3IX6E.js";
+import "./chunk-WJ6YMZTT.js";
+import "./chunk-43D6NMYH.js";
+import "./chunk-7ZAA75HG.js";
 export {
   BIN_MARK,
   CLAUDE_EVENTS,

package/dist/cli/{status-3VJAO6UL.js → status-2OCYHOWZ.js}

@@ -1,8 +1,8 @@
 import {
   connect
-} from "./chunk-VVK4I6B5.js";
-import "./chunk-QD27W6W5.js";
-import "./chunk-ELLXOV4Q.js";
+} from "./chunk-GXFU4XAX.js";
+import "./chunk-HP3G2TYJ.js";
+import "./chunk-7ZAA75HG.js";
 
 // src/cli/status.ts
 async function printStatus(opts = {}) {

package/dist/cli/{task-PMKNYP6M.js → task-AOOWHPMN.js}

@@ -4,11 +4,11 @@ import {
   runTask,
   taskArgs,
   taskOnClient
-} from "./chunk-5ZCHFGCV.js";
-import "./chunk-VVK4I6B5.js";
-import "./chunk-VE4LGNXX.js";
-import "./chunk-QD27W6W5.js";
-import "./chunk-ELLXOV4Q.js";
+} from "./chunk-BVBX222F.js";
+import "./chunk-TRTS24PF.js";
+import "./chunk-GXFU4XAX.js";
+import "./chunk-HP3G2TYJ.js";
+import "./chunk-7ZAA75HG.js";
 export {
   TASK_USAGE,
   formatTask,

package/dist/cli/team-TVNSVYWW.js

@@ -0,0 +1,101 @@
+import {
+  listDefinitions
+} from "./chunk-3EIRKAX7.js";
+import "./chunk-3HCID6NW.js";
+import {
+  connect
+} from "./chunk-GXFU4XAX.js";
+import "./chunk-HP3G2TYJ.js";
+import "./chunk-43D6NMYH.js";
+import "./chunk-7ZAA75HG.js";
+
+// src/cli/team.ts
+import { randomUUID } from "crypto";
+import { resolve } from "path";
+var TEAM_USAGE = `ledge team up <mod\xE8le> [--cwd <dossier>] [--name <nom>]   lancer une \xE9quipe d'apr\xE8s .ledge/teams/<mod\xE8le>.yaml
+ledge team list [--cwd <dossier>]                           les mod\xE8les, les r\xF4les et les \xE9quipes en cours`;
+var UP_MS = 6e4;
+var DAEMON_DOWN = "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)";
+function teamArgs(args) {
+  const [op, ...rest] = args;
+  const positional = [];
+  let cwd;
+  let name;
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === "--cwd") {
+      cwd = rest[++i];
+      if (!cwd) return void 0;
+    } else if (rest[i] === "--name") {
+      name = rest[++i];
+      if (!name) return void 0;
+    } else positional.push(rest[i]);
+  }
+  if (op === "up" && positional.length === 1) return { op, template: positional[0], ...cwd ? { cwd } : {}, ...name ? { name } : {} };
+  if (op === "list" && positional.length === 0 && !name) return { op, ...cwd ? { cwd } : {} };
+  return void 0;
+}
+var STATE = { active: "active", resting: "au repos", dissolved: "dissoute" };
+function formatTeam(t, sessions) {
+  const byId = new Map(sessions.map((s) => [s.id, s]));
+  return [`${t.id}  ${t.name}  ${STATE[t.state]}  ${t.cwd}`, ...t.seats.map((seat) => {
+    const s = seat.sessionId ? byId.get(seat.sessionId) : void 0;
+    return `  @${seat.role.padEnd(12)} ${s ? `${s.name} (${s.tool}, ${s.state})` : "libre"}`;
+  })].join("\n");
+}
+async function runTeam(args, opts = {}) {
+  const parsed = teamArgs(args);
+  if (!parsed) return { line: TEAM_USAGE, code: args.length ? 1 : 0 };
+  const cwd = resolve(opts.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  if (parsed.op === "list") {
+    const defs = listDefinitions(cwd);
+    const lines = [
+      "MOD\xC8LES",
+      ...defs.templates.length ? defs.templates.map((t) => `  ${t.id.padEnd(16)} ${t.name} \xB7 ${t.seats.map((s) => `@${s.role}`).join(" ")} (${t.source})`) : ["  aucun (~/.ledge/teams/<id>.yaml)"],
+      "",
+      "R\xD4LES",
+      ...defs.roles.length ? defs.roles.map((r) => `  @${r.id.padEnd(15)} ${r.label}${r.tool ? ` \xB7 ${r.tool}` : ""}${r.autonomy && r.autonomy !== "ask" ? ` \xB7 autonomie ${r.autonomy}` : ""} (${r.source})`) : ["  aucun (~/.ledge/roles/<id>.md)"],
+      ...defs.problems.length ? ["", "IGNOR\xC9S", ...defs.problems.map((p) => `  ${p.path} : ${p.reason}`)] : []
+    ];
+    let client2;
+    try {
+      client2 = await connect({ port: opts.port, timeoutMs: 800 });
+    } catch {
+      return { line: [...lines, "", "\xC9QUIPES", `  ${DAEMON_DOWN}`].join("\n"), code: 0 };
+    }
+    try {
+      const snapshot = await client2.next("snapshot");
+      const teams = (await client2.next("teams").catch(() => ({ teams: [] }))).teams.filter((t) => t.state !== "dissolved");
+      return { line: [...lines, "", "\xC9QUIPES", ...teams.length ? teams.map((t) => formatTeam(t, snapshot.sessions)) : ["  aucune"]].join("\n"), code: 0 };
+    } finally {
+      await client2.close();
+    }
+  }
+  let client;
+  try {
+    client = await connect({ port: opts.port, timeoutMs: 1500 });
+  } catch {
+    return { line: DAEMON_DOWN, code: 1 };
+  }
+  try {
+    const rid = randomUUID();
+    client.send({ type: "team.launch", rid, cwd, template: parsed.template, ...parsed.name ? { name: parsed.name } : {} });
+    const r = await Promise.race([client.next("team.launched", UP_MS), client.next("team.failed", UP_MS)]);
+    const snapshot = await client.next("snapshot", 500).catch(() => void 0);
+    if (r.type === "team.failed") return { line: `refus\xE9 : ${r.reason}${r.team ? `
+${formatTeam(r.team, snapshot?.sessions ?? [])}` : ""}`, code: 1 };
+    client.send({ type: "snapshot.request" });
+    const fresh = await client.next("snapshot", 1500).catch(() => snapshot);
+    return { line: `\xE9quipe ${r.team.name} lanc\xE9e
+${formatTeam(r.team, fresh?.sessions ?? [])}`, code: 0 };
+  } catch (e) {
+    return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
+  } finally {
+    await client.close();
+  }
+}
+export {
+  TEAM_USAGE,
+  formatTeam,
+  runTeam,
+  teamArgs
+};