@paradow/ledge 0.33.0 → 0.35.0

package/dist/cli/chunk-4HXJQEUN.js

@@ -1,118 +0,0 @@
-import {
-  CODEX_HOOK_VAR
-} from "./chunk-JEGPTNWV.js";
-import {
-  connect
-} from "./chunk-ASYAWVFW.js";
-import {
-  LEDGE_GIVER,
-  TASK_TEXT_MAX,
-  TASK_TITLE_MAX
-} from "./chunk-WXE2NOE5.js";
-
-// src/cli/task.ts
-import { randomUUID } from "crypto";
-var TASK_USAGE = `ledge task give <nom|@r\xF4le> "<titre>" ["<d\xE9tail>"]   confier un travail \xE0 une session (@r\xF4le : dans ton \xE9quipe)
-ledge task give ledge "<question>" "<options, recommandation>"   une d\xE9cision pour l'utilisateur ; sa r\xE9ponse te r\xE9veille
-ledge task list [--all]                         tes t\xE2ches (tenues ou confi\xE9es), ouvertes ; --all : closes aussi
-ledge task show <id>                            une t\xE2che, son d\xE9tail et son historique
-ledge task take <id>                            la prendre
-ledge task done <id> "<r\xE9sultat>"               la terminer, avec ce qui en est sorti (la session qui l'a confi\xE9e est pr\xE9venue)
-ledge task refuse <id> "<raison>"               la refuser, ou l'annuler si tu l'as confi\xE9e
-ledge task pass <id> <nom|@r\xF4le> ["<note>"]     la passer \xE0 une autre session`;
-var TASK_MS = 4e3;
-var ID = /^t[0-9a-f]{6}$/;
-function taskArgs(args) {
-  const [op, ...rest] = args;
-  const id = rest[0] && ID.test(rest[0]) ? rest[0] : void 0;
-  const fits = (min, max) => rest.length >= min && rest.length <= max && rest.slice(0, min).every((a) => a.trim() !== "");
-  switch (op) {
-    case "give":
-      return fits(2, 3) && rest[1].length <= TASK_TITLE_MAX && (rest[2]?.length ?? 0) <= TASK_TEXT_MAX ? { op, to: rest[0], title: rest[1], ...rest[2] ? { text: rest[2] } : {} } : void 0;
-    case "list":
-      return rest.length === 0 ? { op } : rest.length === 1 && rest[0] === "--all" ? { op, all: true } : void 0;
-    case "show":
-    case "take":
-      return fits(1, 1) && id ? { op, task: id } : void 0;
-    case "done":
-      return fits(2, 2) && id && rest[1].length <= TASK_TEXT_MAX ? { op, task: id, text: rest[1] } : void 0;
-    case "refuse":
-      return fits(2, 2) && id && rest[1].length <= TASK_TEXT_MAX ? { op, task: id, text: rest[1] } : void 0;
-    case "pass":
-      return fits(2, 3) && id && (rest[2]?.length ?? 0) <= TASK_TEXT_MAX ? { op, task: id, to: rest[1], ...rest[2] ? { text: rest[2] } : {} } : void 0;
-    default:
-      return void 0;
-  }
-}
-var STATE = { open: "\xE0 prendre", taken: "prise", done: "termin\xE9e", refused: "refus\xE9e", dropped: "abandonn\xE9e" };
-var time = (iso) => iso.slice(0, 16).replace("T", " ");
-function formatTask(t) {
-  return [
-    `${t.id} \xB7 ${STATE[t.state]} \xB7 de ${t.giverName} \xE0 ${t.ownerName} \xB7 ${time(t.at)}`,
-    t.title,
-    ...t.text ? ["", t.text] : [],
-    ...t.result ? ["", `${t.state === "done" ? "R\xE9sultat" : "Raison"} : ${t.result}`] : [],
-    "",
-    "Historique :",
-    ...t.log.map((l) => `  ${time(l.at)} ${l.by} : ${l.what}`)
-  ].join("\n");
-}
-async function taskOnClient(client, args, by, ms) {
-  const op = taskArgs(args);
-  if (!op) return { line: TASK_USAGE, code: 1 };
-  if (by === LEDGE_GIVER) return { line: "refus\xE9 : seul Ledge confie une t\xE2che en son nom", code: 1 };
-  try {
-    client.send({ type: "task.cmd", rid: randomUUID(), by, ...op });
-    const r = await client.next("task.result", ms);
-    if (r.reason !== void 0) return { line: `refus\xE9 : ${r.reason}`, code: 1 };
-    if (op.op === "list") {
-      const list = r.tasks ?? [];
-      if (!list.length) return { line: op.all ? "aucune t\xE2che" : "aucune t\xE2che ouverte", code: 0 };
-      return { line: list.map((t2) => `${t2.id}  ${STATE[t2.state].padEnd(10)} ${t2.giverName} \u2192 ${t2.ownerName}  ${t2.title}`).join("\n"), code: 0 };
-    }
-    const t = r.task;
-    switch (op.op) {
-      case "give":
-        return { line: t.owner === LEDGE_GIVER ? `d\xE9cision ${t.id} pos\xE9e \xE0 l'utilisateur (ledge decide) : sa r\xE9ponse t'arrivera comme une t\xE2che termin\xE9e` : `t\xE2che ${t.id} confi\xE9e \xE0 ${t.ownerName} : elle lui arrive \xE0 son prochain moment libre`, code: 0 };
-      case "take":
-        return { line: `t\xE2che ${t.id} prise`, code: 0 };
-      case "done":
-        return { line: `t\xE2che ${t.id} termin\xE9e ; Ledge pr\xE9vient ${t.giverName}`, code: 0 };
-      case "refuse":
-        return { line: t.giver === by ? `t\xE2che ${t.id} annul\xE9e ; Ledge pr\xE9vient ${t.ownerName}` : `t\xE2che ${t.id} refus\xE9e ; Ledge pr\xE9vient ${t.giverName}`, code: 0 };
-      case "pass":
-        return { line: `t\xE2che ${t.id} pass\xE9e \xE0 ${t.ownerName}`, code: 0 };
-      default:
-        return { line: formatTask(t), code: 0 };
-    }
-  } catch (e) {
-    return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
-  }
-}
-async function runTask(args, opts = {}) {
-  if (!taskArgs(args)) return { line: TASK_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 task ne marche que dans une session lanc\xE9e par Ledge", code: 1 };
-  const deadline = Date.now() + (opts.timeoutMs ?? TASK_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 taskOnClient(client, args, by, left());
-  } finally {
-    await client.close();
-  }
-}
-
-export {
-  TASK_USAGE,
-  taskArgs,
-  formatTask,
-  taskOnClient,
-  runTask
-};

package/dist/cli/chunk-4VNKZOC2.js

@@ -1,160 +0,0 @@
-import {
-  ROLE_LABEL_MAX,
-  ROLE_PROMPT_MAX,
-  RoleSchema
-} from "./chunk-WXE2NOE5.js";
-import {
-  log
-} from "./chunk-6IYPRUQG.js";
-import {
-  ledgeDir
-} from "./chunk-HOOHS3MX.js";
-
-// src/daemon/roles.ts
-import { createHash } from "crypto";
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { dirname, join, resolve } from "path";
-var FILE_MAX = 64 * 1024;
-function repoRoot(cwd) {
-  const start = resolve(cwd);
-  for (let dir = start; ; dir = dirname(dir)) {
-    if (existsSync(join(dir, ".git"))) return dir;
-    if (dirname(dir) === dir) return start;
-  }
-}
-function definitionDirs(kind, cwd) {
-  const home = join(ledgeDir(), kind);
-  const repo = cwd ? join(repoRoot(cwd), ".ledge", kind) : void 0;
-  return [...repo && resolve(repo) !== resolve(home) ? [{ dir: repo, source: "repo" }] : [], { dir: home, source: "home" }];
-}
-function definitionFiles(dir, ext) {
-  let names;
-  try {
-    names = readdirSync(dir);
-  } catch {
-    return [];
-  }
-  return names.filter((n) => ext.some((e) => n.endsWith(e)) && !n.startsWith(".")).sort().map((n) => join(dir, n)).filter((p) => {
-    try {
-      return statSync(p).isFile();
-    } catch {
-      return false;
-    }
-  });
-}
-function readSmall(path) {
-  if (statSync(path).size > FILE_MAX) throw new Error(`file over ${FILE_MAX / 1024} KB`);
-  return readFileSync(path, "utf8");
-}
-function frontMatter(text) {
-  const src = text.replace(/^/, "").replace(/\r\n/g, "\n");
-  const m = /^---\n([\s\S]*?)\n---[ \t]*(?:\n|$)/.exec(src);
-  if (!m) return { fields: {}, body: src.trim() };
-  const fields = {};
-  for (const raw of m[1].split("\n")) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#")) continue;
-    const i = line.indexOf(":");
-    if (i <= 0) throw new Error(`front matter line without a key: ${line.replace(/\s+#.*$/, "").slice(0, 60)}`);
-    fields[line.slice(0, i).trim()] = scalarValue(line.slice(i + 1));
-  }
-  return { fields, body: src.slice(m[0].length).trim() };
-}
-function scalarValue(raw) {
-  const v = raw.trim();
-  const q = v[0];
-  if (q === '"' || q === "'") {
-    const end = v.indexOf(q, 1);
-    if (end > 0 && /^(\s+#.*)?$/.test(v.slice(end + 1))) return v.slice(1, end);
-  }
-  return unquote(v.replace(/(^|\s)#.*$/, "").trim());
-}
-function quoteScalar(v) {
-  if (/[\r\n]/.test(v)) return null;
-  if (/^[\w./@:+-]+$/.test(v) && !/^(true|false|null|yes|no|~)$/i.test(v)) return v;
-  if (!v.includes('"')) return `"${v}"`;
-  if (!v.includes("'")) return `'${v}'`;
-  return null;
-}
-var definitionHash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 16);
-var unquote = (v) => v.length >= 2 && (v[0] === '"' || v[0] === "'") && v.at(-1) === v[0] ? v.slice(1, -1) : v;
-var ROLE_KEYS = /* @__PURE__ */ new Set(["label", "tool", "model", "effort", "autonomy"]);
-function parseRole(id, text, source, path) {
-  let parsed;
-  try {
-    parsed = frontMatter(text);
-  } catch (e) {
-    return e.message;
-  }
-  const { fields, body } = parsed;
-  const unknown = Object.keys(fields).find((k) => !ROLE_KEYS.has(k));
-  if (unknown) return `unknown key ${unknown}`;
-  if (body.length > ROLE_PROMPT_MAX) return `prompt over ${ROLE_PROMPT_MAX} characters`;
-  const label = (fields.label ?? id).slice(0, ROLE_LABEL_MAX);
-  const r = RoleSchema.safeParse({
-    id,
-    label,
-    prompt: body,
-    source,
-    path,
-    ...fields.tool ? { tool: fields.tool } : {},
-    ...fields.model ? { model: fields.model } : {},
-    ...fields.effort ? { effort: fields.effort } : {},
-    ...fields.autonomy ? { autonomy: fields.autonomy } : {}
-  });
-  if (!r.success) {
-    const issue = r.error.issues[0];
-    return `${issue.path.join(".") || "role"}: ${issue.message}`;
-  }
-  return r.data;
-}
-function loadRole(id, path, source, problems) {
-  let r;
-  try {
-    const text = readSmall(path);
-    r = parseRole(id, text, source, path);
-    if (typeof r !== "string") r = { ...r, hash: definitionHash(text) };
-  } catch (e) {
-    r = e.message;
-  }
-  if (typeof r === "string") {
-    log(`role ${path} skipped: ${r}`);
-    problems.push({ path, reason: r });
-    return void 0;
-  }
-  return r;
-}
-function listRoles(cwd) {
-  const roles = /* @__PURE__ */ new Map();
-  const problems = [];
-  for (const { dir, source } of definitionDirs("roles", cwd)) {
-    for (const path of definitionFiles(dir, [".md"])) {
-      const id = path.slice(dir.length + 1, -".md".length);
-      const won = roles.get(id);
-      if (won) {
-        if (source === "home") roles.set(id, { ...won, shadows: path });
-        continue;
-      }
-      const r = loadRole(id, path, source, problems);
-      if (r) roles.set(id, r);
-    }
-  }
-  return { roles: [...roles.values()].sort((a, b) => a.id.localeCompare(b.id)), problems };
-}
-function findRole(id, cwd) {
-  return listRoles(cwd).roles.find((r) => r.id === id);
-}
-
-export {
-  repoRoot,
-  definitionDirs,
-  definitionFiles,
-  readSmall,
-  frontMatter,
-  scalarValue,
-  quoteScalar,
-  definitionHash,
-  loadRole,
-  listRoles,
-  findRole
-};

package/dist/cli/chunk-6IYPRUQG.js

@@ -1,17 +0,0 @@
-import {
-  paths
-} from "./chunk-HOOHS3MX.js";
-
-// src/log.ts
-import { appendFileSync } from "fs";
-function log(line) {
-  try {
-    appendFileSync(paths().log, `${(/* @__PURE__ */ new Date()).toISOString()} | ${line}
-`);
-  } catch {
-  }
-}
-
-export {
-  log
-};

package/dist/cli/chunk-ASYAWVFW.js

@@ -1,95 +0,0 @@
-import {
-  MESSAGE_MAX,
-  PROTOCOL_PORT,
-  SUMMARY_MAX,
-  parseServerMessage,
-  readDaemonToken
-} from "./chunk-WXE2NOE5.js";
-
-// src/client.ts
-import WebSocket from "ws";
-async function sendMessageAndAwaitAck(client, msg, timeoutMs) {
-  if (msg.text.length > MESSAGE_MAX) return { type: "message.ack", rid: msg.rid, outcome: "refused", reason: `message trop long (${msg.text.length} caract\xE8res, ${MESSAGE_MAX} au plus)` };
-  client.send(msg.summary && msg.summary.length > SUMMARY_MAX ? { ...msg, summary: msg.summary.slice(0, SUMMARY_MAX) } : msg);
-  return client.next("message.ack", timeoutMs);
-}
-var DaemonRefusedError = class extends Error {
-};
-function connect(opts = {}) {
-  const port = opts.port ?? PROTOCOL_PORT;
-  const host = opts.host ?? "127.0.0.1";
-  let token;
-  try {
-    token = opts.token === void 0 ? readDaemonToken() : opts.token;
-  } catch {
-    token = null;
-  }
-  const ws = new WebSocket(`ws://${host}:${port}`, token ? { headers: { authorization: `Bearer ${token}` } } : {});
-  const queue = [];
-  const MAX_QUEUED = 100;
-  const waiters = [];
-  ws.on("message", (data) => {
-    let msg;
-    try {
-      msg = parseServerMessage(JSON.parse(String(data)));
-    } catch {
-      return;
-    }
-    const i = waiters.findIndex((w) => w.type === msg.type);
-    if (i >= 0) waiters.splice(i, 1)[0].resolve(msg);
-    else {
-      queue.push(msg);
-      if (queue.length > MAX_QUEUED) queue.shift();
-    }
-  });
-  const client = {
-    send: (msg) => ws.send(JSON.stringify(msg)),
-    next(type, timeoutMs = 1500) {
-      const i = queue.findIndex((m) => m.type === type);
-      if (i >= 0) return Promise.resolve(queue.splice(i, 1)[0]);
-      return new Promise((resolve, reject) => {
-        const w = { type, resolve: (m) => {
-          clearTimeout(t);
-          resolve(m);
-        } };
-        const t = setTimeout(() => {
-          waiters.splice(waiters.indexOf(w), 1);
-          reject(new Error(`timeout waiting for ${type}`));
-        }, timeoutMs);
-        waiters.push(w);
-      });
-    },
-    close: () => new Promise((res) => {
-      if (ws.readyState === WebSocket.CLOSED) return res();
-      ws.once("close", () => res());
-      ws.close();
-    })
-  };
-  return new Promise((resolve, reject) => {
-    const t = setTimeout(() => {
-      ws.terminate();
-      reject(new Error("connect timeout"));
-    }, opts.timeoutMs ?? 1e3);
-    ws.once("open", () => {
-      clearTimeout(t);
-      resolve(client);
-    });
-    let settled = false;
-    ws.once("open", () => {
-      settled = true;
-    });
-    ws.on("error", (e) => {
-      if (!settled) {
-        settled = true;
-        clearTimeout(t);
-        reject(/Unexpected server response: 401/.test(e.message) ? new DaemonRefusedError("daemon refused the token") : e);
-      }
-    });
-  });
-}
-
-export {
-  sendMessageAndAwaitAck,
-  DaemonRefusedError,
-  connect
-};

package/dist/cli/chunk-CCSUP5ZI.js

@@ -1,45 +0,0 @@
-import {
-  connect
-} from "./chunk-ASYAWVFW.js";
-import {
-  isArchived
-} from "./chunk-WXE2NOE5.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 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");
-}
-async function printWho(opts = {}) {
-  let client;
-  try {
-    client = await connect({ port: opts.port, timeoutMs: 800 });
-  } catch {
-    return "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)";
-  }
-  try {
-    return formatWho((await client.next("snapshot")).sessions, opts.self ?? process.env.LEDGE_SESSION);
-  } finally {
-    await client.close();
-  }
-}
-
-export {
-  formatWho,
-  printWho
-};

package/dist/cli/chunk-CPERVAPQ.js

@@ -1,232 +0,0 @@
-import {
-  EFFORT_ARGS,
-  MODEL_ARGS
-} from "./chunk-PZ3F4QH3.js";
-import {
-  findRole
-} from "./chunk-4VNKZOC2.js";
-import {
-  exitFile,
-  spawnSession
-} from "./chunk-JEGPTNWV.js";
-import {
-  DaemonRefusedError,
-  connect
-} from "./chunk-ASYAWVFW.js";
-import {
-  PROTOCOL_PORT,
-  autonomyArgs
-} from "./chunk-WXE2NOE5.js";
-import {
-  realTmux
-} from "./chunk-NLL2EQJ2.js";
-import {
-  log
-} from "./chunk-6IYPRUQG.js";
-import {
-  ensureLedgeDir
-} from "./chunk-HOOHS3MX.js";
-
-// src/cli/launch.ts
-import { spawn } from "child_process";
-import { readFile, rm } from "fs/promises";
-import { createConnection } from "net";
-var TMUX_SOCKET = "ledge";
-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, ...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) => {
-    const s = createConnection({ host: "127.0.0.1", port });
-    s.once("connect", () => {
-      s.end();
-      res(true);
-    });
-    s.once("error", () => res(false));
-  });
-}
-function spawnDetachedDaemon() {
-  const child = spawn(process.execPath, [process.argv[1], "daemon"], { detached: true, stdio: "ignore" });
-  child.unref();
-}
-var closeQuietly = (c) => Promise.race([c.close(), sleep(500)]);
-async function probe(port, timeoutMs) {
-  let client;
-  try {
-    client = await connect({ port, timeoutMs });
-  } catch (e) {
-    if (e instanceof DaemonRefusedError) return { client: null, state: "unauthorized" };
-    if (e.message === "connect timeout") return { client: null, state: "timeout" };
-    return { client: null, state: await portOpen(port) ? "foreign" : "refused" };
-  }
-  try {
-    await client.next("snapshot", timeoutMs);
-    return { client };
-  } catch {
-    void closeQuietly(client);
-    return { client: null, state: "foreign" };
-  }
-}
-async function ensureDaemon(opts = {}) {
-  await ensureLedgeDir();
-  const port = opts.port ?? PROTOCOL_PORT;
-  const timeoutMs = opts.timeoutMs ?? 2e3;
-  const first = await probe(port, timeoutMs);
-  if (first.client) return { client: first.client };
-  if (first.state === "foreign") {
-    log(`port ${port} is open but does not speak the Ledge protocol`);
-    return { client: null, reason: "foreign" };
-  }
-  if (first.state === "unauthorized") {
-    log(`the daemon on port ${port} refused this client's token`);
-    return { client: null, reason: "unauthorized" };
-  }
-  if (first.state === "timeout") {
-    log(`port ${port} accepted a connection but did not answer within ${timeoutMs} ms`);
-    return { client: null, reason: "unresponsive" };
-  }
-  (opts.spawnDaemon ?? spawnDetachedDaemon)();
-  for (let i = 0; i < 3; i++) {
-    await sleep(opts.retryDelayMs ?? 500);
-    const r = await probe(port, timeoutMs);
-    if (r.client) return { client: r.client };
-  }
-  return { client: null, reason: "unreachable" };
-}
-var DaemonError = class extends Error {
-};
-async function createSession(opts) {
-  const names = [];
-  const ids = [];
-  if (opts.client) {
-    let snap;
-    try {
-      opts.client.send({ type: "snapshot.request" });
-      snap = await opts.client.next("snapshot");
-    } catch (e) {
-      throw new DaemonError(`daemon did not answer: ${e.message}`);
-    }
-    for (const s of snap.sessions) {
-      names.push(s.name);
-      ids.push(s.id);
-    }
-  }
-  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) {
-    log(`register failed for ${session.id}: ${e.message}`);
-  }
-  return session;
-}
-function attachEnv(env) {
-  const { TMUX: _ignored, ...rest } = env;
-  return rest;
-}
-function attachInherit(args, env) {
-  return new Promise((resolve) => {
-    const child = spawn("tmux", args, { stdio: "inherit", env });
-    child.on("error", () => resolve(1));
-    child.on("exit", (c) => resolve(c ?? 1));
-  });
-}
-async function readExitCode(id) {
-  const file = exitFile(id);
-  let raw = null;
-  try {
-    raw = await readFile(file, "utf8");
-  } catch {
-  }
-  await rm(file, { force: true });
-  const t = raw?.trim();
-  return t && /^\d+$/.test(t) ? Number(t) : null;
-}
-var UNTRACKED = {
-  foreign: (port) => `ledge: port ${port} is used by another program, session not tracked`,
-  unauthorized: () => "ledge: the daemon refused this client's token (missing or changed), session not tracked; restart the daemon: systemctl --user restart ledge-daemon",
-  unresponsive: () => "ledge: daemon not responding, session not tracked",
-  unreachable: () => "ledge: daemon not running, session not tracked"
-};
-async function launch(tool, argv, opts = {}) {
-  await ensureLedgeDir();
-  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, ...role ? { role } : {}, cwd, tmux, client: c });
-  let session;
-  try {
-    session = await create(client);
-  } catch (e) {
-    if (!(e instanceof DaemonError)) throw e;
-    log(e.message);
-    if (client) void closeQuietly(client);
-    client = null;
-    console.error(UNTRACKED.unresponsive(port));
-    session = await create(null);
-  }
-  if (client) await closeQuietly(client);
-  const tmuxName = session.tmuxSession;
-  if (process.stdout.isTTY) process.stdout.write(`\x1B]0;${session.title}\x07`);
-  const attachCode = await (opts.attach ?? attachInherit)(tmux.attachArgs(tmuxName), attachEnv(process.env));
-  if (await tmux.hasSession(tmuxName)) {
-    if (attachCode !== 0) console.error(`ledge: could not attach; ${session.name} keeps running in tmux session ${tmuxName} (tmux -L ${socket} attach -t ${tmuxName})`);
-    return attachCode;
-  }
-  const exitCode = await readExitCode(session.id);
-  if (client) {
-    try {
-      const c = await connect({ port, timeoutMs: 800 });
-      c.send({ type: "session.unregister", id: session.id, exitCode });
-      await closeQuietly(c);
-    } catch {
-    }
-  }
-  return exitCode ?? 1;
-}
-
-export {
-  parseLaunchArgs,
-  roleArgs,
-  ensureDaemon,
-  DaemonError,
-  createSession,
-  attachEnv,
-  launch
-};