@paradow/ledge 0.16.1 → 0.17.0

package/dist/cli/chunk-V2H7UD2N.js

@@ -0,0 +1,6 @@
+// src/version.ts
+var LEDGE_VERSION = true ? "0.17.0" : "0.0.0-dev";
+
+export {
+  LEDGE_VERSION
+};

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

@@ -1,10 +1,10 @@
 import {
   NAMES,
   pickName
-} from "./chunk-Q5WWH7FG.js";
+} from "./chunk-QD27W6W5.js";
 import {
   paths
-} from "./chunk-R5462SQM.js";
+} from "./chunk-ELLXOV4Q.js";
 
 // src/daemon/transcript.ts
 import { appendFileSync, closeSync, fstatSync, openSync, readFileSync, readSync, statSync } from "fs";

package/dist/cli/{chunk-DEXDXDO4.js → chunk-VVK4I6B5.js}

@@ -4,7 +4,7 @@ import {
   SUMMARY_MAX,
   parseServerMessage,
   readDaemonToken
-} from "./chunk-Q5WWH7FG.js";
+} from "./chunk-QD27W6W5.js";
 
 // src/client.ts
 import WebSocket from "ws";

package/dist/cli/{daemon-DKH63BGV.js → daemon-QEJLAIBT.js}

@@ -17,18 +17,24 @@ import {
   dialogMismatch,
   flatten,
   formatLedgeMessage,
+  formatLedgeNotice,
+  formatLedgeTask,
   gitInfo,
   gitSummary,
+  inline,
   ledgeBody,
   ledgeMessages,
+  ledgeNotice,
   ledgePeer,
+  ledgeTask,
+  mailId,
   pendingTool,
   readPeers,
   reduce,
   repositoryId,
   shownCommand,
   stripNote
-} from "./chunk-DBSCO3HI.js";
+} from "./chunk-NC5YAEJB.js";
 import {
   PARENT_AGENT_VARS,
   agentEnv,
@@ -39,7 +45,7 @@ import {
   labelTranscript,
   resumeLabel,
   spawnSession
-} from "./chunk-H36JD4E3.js";
+} from "./chunk-VE4LGNXX.js";
 import {
   CHAT_HISTORY_BUDGET,
   DEFAULT_PROJECTS,
@@ -99,30 +105,31 @@ import {
   proposalRows,
   pushEndpointAllowed,
   requestAuthorized,
-  selectDaemonProtocol
-} from "./chunk-Q5WWH7FG.js";
+  selectDaemonProtocol,
+  taskClosed
+} from "./chunk-QD27W6W5.js";
 import {
   LEDGE_VERSION
-} from "./chunk-J4ICZEGP.js";
+} from "./chunk-V2H7UD2N.js";
 import {
   SERVICE,
   inDaemonService,
   tmuxServerAtRisk
-} from "./chunk-S4ANPQGA.js";
+} from "./chunk-OVJL2QTN.js";
 import {
   realTmux,
   runFile
-} from "./chunk-2H5FJH4Q.js";
+} from "./chunk-LAUNHDTX.js";
 import {
   log
-} from "./chunk-BNKPXSUY.js";
+} from "./chunk-JQZHXVIZ.js";
 import {
   ensureLedgeDir,
   paths
-} from "./chunk-R5462SQM.js";
+} from "./chunk-ELLXOV4Q.js";
 
 // src/daemon/index.ts
-import { writeFile as writeFile7, rm as rm6 } from "fs/promises";
+import { writeFile as writeFile8, rm as rm6 } from "fs/promises";
 import { join as join17 } from "path";
 
 // src/daemon/omp/owner.ts
@@ -594,6 +601,40 @@ var History = class {
           });
           return last;
         }
+        const failed = ledgeNotice(ev.text);
+        if (failed) {
+          this.turns.set(id, turn + 1);
+          const peer = this.peerOf(failed.to);
+          return this.put(id, {
+            kind: "notice",
+            id: `notice-${turn + 1}-0`,
+            at: ev.at,
+            turn: turn + 1,
+            notice: "delivery",
+            status: "refused",
+            count: 1,
+            recipients: [failed.to],
+            name: failed.to,
+            ...peer ? { peer } : {},
+            ...failed.reason ? { reason: failed.reason } : {},
+            text: failed.text
+          });
+        }
+        const task = ledgeTask(ev.text);
+        if (task) {
+          this.turns.set(id, turn + 1);
+          const peer = task.from ? this.peerOf(task.from) : void 0;
+          return this.put(id, {
+            kind: "notice",
+            id: `notice-${turn + 1}-0`,
+            at: ev.at,
+            turn: turn + 1,
+            notice: "other",
+            ...task.from ? { name: task.from } : {},
+            ...peer ? { peer } : {},
+            text: task.text
+          });
+        }
         this.turns.set(id, turn + 1);
         return this.put(id, { kind: "prompt", id: `prompt-${turn + 1}`, at: ev.at, turn: turn + 1, text: ev.text });
       }
@@ -725,15 +766,17 @@ var History = class {
   }
   /** Puts a received card, paired with the sender's sent one when the sender is a Ledge session: the last of its
    *  messages to this session not read yet, the one whose text starts like the body if any (the hook may have cut
-   *  either), both read as Ledge types a body (a multi-line one arrives on one line). That sent one becomes read, in the sender's thread. */
+   *  either), both read as Ledge types a body (a multi-line one arrives on one line). A message the mailbox typed names
+   *  its id: the sent card of that id is the one, and its text replaces a pointer's. That sent one becomes read, in the sender's thread. */
   receive(id, recv, m) {
     const peer = (m.sender ? this.peerOf(m.sender) : void 0) ?? this.peerOf(m.from) ?? (m.name ? this.peerOf(m.name) : void 0);
     if (!peer) return this.put(id, recv);
     const head = (t) => ledgeBody(t).trim().slice(0, 200);
     const open3 = this.items(peer).filter((i) => i.kind === "sent" && i.peer === id && i.status !== "read");
-    const sent = [...open3].reverse().find((i) => head(i.text) === head(recv.text)) ?? open3.at(-1);
+    const byId = m.id ? open3.find((i) => mailId(i.id) === m.id) : void 0;
+    const sent = byId ?? [...open3].reverse().find((i) => head(i.text) === head(recv.text)) ?? open3.at(-1);
     if (sent) this.put(peer, { ...sent, status: "read", received: recv.id });
-    return this.put(id, { ...recv, peer, ...sent ? { sent: sent.id } : {} });
+    return this.put(id, { ...recv, ...byId ? { text: byId.text } : {}, peer, ...sent ? { sent: sent.id } : {} });
   }
   /** The turn (or the helper) is over: an action still running will not get its result from this side. It shows as
    *  unknown, not as waiting forever; a result that arrives later still settles it (callFor finds it by id). */
@@ -4145,8 +4188,46 @@ function cardOf(threads, qid) {
   } };
 }
 
+// src/daemon/journal.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { writeFile as writeFile7, rename as rename3 } from "fs/promises";
+function jsonJournal(path, name, read) {
+  let pending;
+  let writing = Promise.resolve();
+  const drain = async () => {
+    while (pending !== void 0) {
+      const state = pending;
+      pending = void 0;
+      const tmp = `${path}.tmp`;
+      try {
+        await writeFile7(tmp, JSON.stringify(state));
+        await rename3(tmp, path);
+      } catch (e) {
+        log(`${name} journal not written: ${e.message}`);
+      }
+    }
+  };
+  return {
+    load() {
+      try {
+        return read(JSON.parse(readFileSync4(path, "utf8")));
+      } catch {
+        return void 0;
+      }
+    },
+    save(state) {
+      const idle = pending === void 0;
+      pending = state;
+      if (idle) writing = writing.then(drain);
+    },
+    flush: () => writing
+  };
+}
+
 // src/daemon/mailbox.ts
 var MAX_SEEN = 1e3;
+var BODY_MAX = 200;
+var BODY_TTL_MS = 7 * 24 * 3600 * 1e3;
 var PASSING = [
   /^a decision is already in progress$/,
   /^an? \w+ prompt takes accept or deny, not a reply$/,
@@ -4154,34 +4235,58 @@ var PASSING = [
   /^free-text answers are not supported yet\b/,
   /^the request changed, look again$/
 ];
+var GONE = "la session n'existe plus";
+var ENDED = "la session s'est termin\xE9e avant de le recevoir";
+var reachable = (s) => !!s && s.source === "launcher" && s.state !== "exited" && !isArchived(s) && (!!s.tmuxSession || backendOf(s) === "omp-rpc");
 function createMailbox(d) {
   const now = d.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const queue = [];
   const seen = /* @__PURE__ */ new Map();
+  const bodies = /* @__PURE__ */ new Map();
+  const save = () => {
+    const oldest = Date.parse(now()) - BODY_TTL_MS;
+    for (const [id, b] of bodies) if (Date.parse(b.at) < oldest || bodies.size > BODY_MAX) bodies.delete(id);
+    d.journal?.save({ queue: [...queue], bodies: [...bodies.values()] });
+  };
   const ready = (id) => free(d.store.get(id)) && !d.typing.has(id) && !d.closing?.has(id) && !d.relayQueued(id);
+  function fail2(m, reason) {
+    log(`${m.kind} ${m.rid} to ${m.target} failed: ${reason}`);
+    if (m.kind === "notice") return;
+    d.sent.mark(m.from, m.rid, "failed");
+    const sender = d.store.get(m.from);
+    if (!reachable(sender)) return;
+    notice(sender, formatLedgeNotice({ to: m.to, text: m.text, reason }), `${m.rid}:notice`);
+  }
+  function notice(s, text, rid) {
+    queue.push({ kind: "notice", id: mailId(rid), rid, from: "", sender: { name: "Ledge", tool: s.tool }, target: s.id, to: s.name, text });
+    queueMicrotask(() => kick(s.id));
+  }
   async function deliver(m) {
     const s = d.store.get(m.target);
     if (!s) {
-      d.sent.mark(m.from, m.rid, "failed");
+      fail2(m, GONE);
+      save();
       queueMicrotask(() => kick(m.target));
       return;
     }
     d.typing.add(m.target);
     try {
       let refused;
+      const text = m.kind === "notice" ? m.text : formatLedgeMessage({ from: m.sender.name, tool: m.sender.tool, text: m.text, to: s.tool, id: m.id, ...m.summary ? { summary: m.summary } : {} });
       try {
-        refused = await d.replyTo(m.target, formatLedgeMessage({ from: m.sender.name, tool: m.sender.tool, text: m.text, to: s.tool }));
+        refused = await d.replyTo(m.target, text);
       } catch (e) {
         refused = e.message;
       }
       const live2 = d.store.get(m.target);
       if (refused && PASSING.some((re) => re.test(refused)) && live2 && live2.state !== "exited") {
-        log(`message ${m.rid} to ${m.target} waits: ${refused}`);
+        log(`${m.kind} ${m.rid} to ${m.target} waits: ${refused}`);
         queue.unshift(m);
         return;
       }
-      if (refused) log(`message ${m.rid} to ${m.target} failed: ${refused}`);
-      d.sent.mark(m.from, m.rid, refused ? "failed" : "delivered");
+      if (refused) fail2(m, refused);
+      else if (m.kind === "message") d.sent.mark(m.from, m.rid, "delivered");
+      save();
       if (refused) queueMicrotask(() => kick(m.target));
     } finally {
       d.typing.delete(m.target);
@@ -4192,18 +4297,22 @@ function createMailbox(d) {
     const i = queue.findIndex((m2) => m2.target === id);
     if (i < 0) return;
     const [m] = queue.splice(i, 1);
-    void deliver(m).catch((e) => log(`message ${m.rid} failed: ${e.message}`));
+    void deliver(m).catch((e) => log(`${m.kind} ${m.rid} failed: ${e.message}`));
+  }
+  function failFor(id, reason) {
+    let changed = false;
+    for (let i = queue.length - 1; i >= 0; i--) if (queue[i].target === id) {
+      const [m] = queue.splice(i, 1);
+      fail2(m, reason);
+      changed = true;
+    }
+    if (changed) save();
   }
   const unsubscribe = d.store.onChange((c) => {
     if (c.type === "recents") return;
     const id = c.type === "updated" ? c.session.id : c.id;
-    if (c.type === "removed" || c.session.state === "exited") {
-      for (let i = queue.length - 1; i >= 0; i--) if (queue[i].target === id) {
-        const [m] = queue.splice(i, 1);
-        d.sent.mark(m.from, m.rid, "failed");
-      }
-      return;
-    }
+    if (c.type === "removed") return failFor(id, GONE);
+    if (c.session.state === "exited") return failFor(id, ENDED);
     kick(id);
   });
   const target = (to) => {
@@ -4215,6 +4324,30 @@ function createMailbox(d) {
     if (seen.size > MAX_SEEN) seen.delete(seen.keys().next().value);
     return ack;
   };
+  const idFor = (rid) => {
+    for (const length of [6, 8, 10, 40]) {
+      const id = mailId(rid, length);
+      const held = bodies.get(id);
+      if (!held || held.rid === rid) return id;
+    }
+    return mailId(rid, 40);
+  };
+  const loaded = d.journal?.load();
+  if (loaded) {
+    for (const b of loaded.bodies) bodies.set(b.id, b);
+    const failed = [];
+    for (const m of loaded.queue) {
+      const t = d.store.get(m.target);
+      if (t && t.state !== "exited") queue.push(m);
+      else failed.push([m, t ? ENDED : GONE]);
+    }
+    for (const [m, reason] of failed) fail2(m, reason);
+    if (failed.length) save();
+    if (queue.length) log(`mailbox: ${queue.length} message(s) still waiting from the last run`);
+    queueMicrotask(() => {
+      for (const id of new Set(queue.map((m) => m.target))) kick(id);
+    });
+  }
   return {
     submit(m) {
       const first = seen.get(m.rid);
@@ -4226,17 +4359,188 @@ function createMailbox(d) {
       const sender = d.store.get(m.from);
       if (!sender) return refuse("session \xE9mettrice inconnue");
       if (t.source === "hook_only" || !t.tmuxSession && backendOf(t) !== "omp-rpc") return refuse(`${t.name} n'a pas \xE9t\xE9 lanc\xE9e par Ledge : impossible de lui \xE9crire`);
-      d.sent.record(m.from, { rid: m.rid, at: now(), to: t.name, peer: t.id, text: m.text, ...m.summary ? { summary: m.summary } : {} });
+      const at = now();
+      const id = idFor(m.rid);
+      d.sent.record(m.from, { rid: m.rid, at, to: t.name, peer: t.id, text: m.text, ...m.summary ? { summary: m.summary } : {} });
+      if (!inline(m.text)) bodies.set(id, { id, rid: m.rid, from: sender.id, fromName: sender.name, target: t.id, to: t.name, at, text: m.text });
       const outcome = ready(t.id) ? "accepted" : "queued";
-      queue.push({ rid: m.rid, from: m.from, sender: { name: sender.name, tool: sender.tool }, target: t.id, text: m.text });
+      queue.push({ kind: "message", id, rid: m.rid, from: m.from, sender: { name: sender.name, tool: sender.tool }, target: t.id, to: t.name, text: m.text, ...m.summary ? { summary: m.summary } : {} });
+      save();
       const ack = remember(m.rid, { type: "message.ack", rid: m.rid, outcome });
       if (outcome === "accepted") kick(t.id);
       return ack;
     },
+    read({ id, by }) {
+      const b = bodies.get(id);
+      if (!b) return { type: "message.body", id, reason: `aucun message ${id} (seuls les longs messages des 7 derniers jours se relisent)` };
+      if (by !== b.from && by !== b.target) return { type: "message.body", id, reason: `le message ${id} ne t'est pas adress\xE9` };
+      return { type: "message.body", id, from: b.fromName, to: b.to, at: b.at, text: b.text };
+    },
+    notify(target2, text, rid) {
+      const s = d.store.get(target2);
+      if (!reachable(s)) return false;
+      notice(s, text, rid);
+      save();
+      return true;
+    },
     kick,
     close: unsubscribe
   };
 }
+function fileJournal(path) {
+  return jsonJournal(path, "mailbox", (raw) => {
+    const r = raw;
+    return r ? { queue: Array.isArray(r.queue) ? r.queue : [], bodies: Array.isArray(r.bodies) ? r.bodies : [] } : void 0;
+  });
+}
+
+// src/daemon/tasks.ts
+import { randomBytes as randomBytes2 } from "crypto";
+var CLOSED_TTL_MS = 7 * 24 * 3600 * 1e3;
+var CLOSED_MAX = 300;
+var QUOTE = 200;
+var quote = (s) => {
+  const flat = s.trim().replace(/\s+/g, " ");
+  return flat.length > QUOTE ? `${flat.slice(0, QUOTE)}\u2026` : flat;
+};
+var reachable2 = (s) => !!s && s.source === "launcher" && s.state !== "exited" && !isArchived(s) && (!!s.tmuxSession || backendOf(s) === "omp-rpc");
+function createTasks(d) {
+  const now = d.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const tasks = /* @__PURE__ */ new Map();
+  for (const t of d.journal?.load() ?? []) tasks.set(t.id, t);
+  const save = () => {
+    const oldest = Date.parse(now()) - CLOSED_TTL_MS;
+    const closed = [...tasks.values()].filter(taskClosed);
+    for (const t of closed) if (Date.parse(t.updatedAt) < oldest) tasks.delete(t.id);
+    const left = closed.filter((t) => tasks.has(t.id));
+    for (const t of left.slice(0, Math.max(0, left.length - CLOSED_MAX))) tasks.delete(t.id);
+    d.journal?.save([...tasks.values()]);
+  };
+  const newId = () => {
+    for (; ; ) {
+      const id = `t${randomBytes2(3).toString("hex")}`;
+      if (!tasks.has(id)) return id;
+    }
+  };
+  const target = (to) => {
+    const name = bareName(to);
+    return d.store.all().find((s) => s.name === name && s.state !== "exited" && !isArchived(s));
+  };
+  const put = (t, by, what) => {
+    const at = now();
+    const next2 = { ...t, updatedAt: at, log: [...t.log, { at, by, what }] };
+    tasks.set(t.id, next2);
+    save();
+    return next2;
+  };
+  const tellOwner = (t, from, lead) => d.mailbox.notify(t.owner, formatLedgeTask({
+    id: t.id,
+    from,
+    text: `${lead} \xAB ${t.title} \xBB. Lis-la : ledge task show ${t.id} ; prends-la : ledge task take ${t.id} ; \xE0 la fin : ledge task done ${t.id} "r\xE9sultat" (ou ledge task refuse ${t.id} "raison").`
+  }), `${t.id}:${t.log.length}`);
+  const tellGiver = (t, from, what) => d.mailbox.notify(t.giver, formatLedgeTask({
+    id: t.id,
+    from,
+    text: `T\xE2che \xAB ${t.title} \xBB ${what} (ledge task show ${t.id})`
+  }), `${t.id}:${t.log.length}`);
+  const dropFor = (id) => {
+    for (const t of [...tasks.values()]) {
+      if (t.owner !== id || taskClosed(t)) continue;
+      const dropped = put({ ...t, state: "dropped" }, "Ledge", `${t.ownerName} s'est termin\xE9e sans la finir`);
+      log(`task ${t.id} dropped: ${t.ownerName} ended`);
+      tellGiver(dropped, "Ledge", `abandonn\xE9e : ${t.ownerName} s'est termin\xE9e sans la finir`);
+    }
+  };
+  for (const owner of new Set([...tasks.values()].filter((t) => !taskClosed(t)).map((t) => t.owner))) {
+    const s = d.store.get(owner);
+    if (!s || s.state === "exited") dropFor(owner);
+  }
+  const unsubscribe = d.store.onChange((c) => {
+    if (c.type === "recents") return;
+    if (c.type === "removed") return dropFor(c.id);
+    if (c.session.state === "exited") dropFor(c.session.id);
+  });
+  function run2(cmd) {
+    const refuse = (reason) => ({ type: "task.result", rid: cmd.rid, reason });
+    const ok = (task) => ({ type: "task.result", rid: cmd.rid, task });
+    const me = d.store.get(cmd.by);
+    if (!me) return refuse("session inconnue");
+    if (cmd.op === "list") {
+      const mine = [...tasks.values()].filter((t2) => (t2.owner === me.id || t2.giver === me.id) && (cmd.all || !taskClosed(t2)));
+      return { type: "task.result", rid: cmd.rid, tasks: mine.sort((a, b) => a.at.localeCompare(b.at)) };
+    }
+    if (cmd.op === "give") {
+      if (!cmd.to || !cmd.title) return refuse("il faut un destinataire et un titre");
+      const t2 = target(cmd.to);
+      if (!t2) return refuse(`aucune session Ledge nomm\xE9e ${cmd.to}`);
+      if (t2.id === me.id) return refuse("tu ne peux pas te confier une t\xE2che");
+      if (!reachable2(t2)) return refuse(`${t2.name} n'a pas \xE9t\xE9 lanc\xE9e par Ledge : impossible de lui confier une t\xE2che`);
+      const at = now();
+      const task = {
+        id: newId(),
+        title: cmd.title.trim(),
+        ...cmd.text?.trim() ? { text: cmd.text.trim() } : {},
+        giver: me.id,
+        giverName: me.name,
+        owner: t2.id,
+        ownerName: t2.name,
+        state: "open",
+        at,
+        updatedAt: at,
+        log: [{ at, by: me.name, what: `confi\xE9e \xE0 ${t2.name}` }]
+      };
+      tasks.set(task.id, task);
+      save();
+      tellOwner(task, me.name, `T\xE2che de ${me.name} :`);
+      return ok(task);
+    }
+    if (!cmd.task) return refuse("il faut l'id de la t\xE2che");
+    const t = tasks.get(cmd.task);
+    if (!t) return refuse(`aucune t\xE2che ${cmd.task}`);
+    const owner = t.owner === me.id;
+    const giver = t.giver === me.id;
+    if (cmd.op === "show") return owner || giver ? ok(t) : refuse(`la t\xE2che ${t.id} n'est ni \xE0 toi ni de toi`);
+    if (taskClosed(t)) return refuse(`la t\xE2che ${t.id} est d\xE9j\xE0 close (${t.state})`);
+    switch (cmd.op) {
+      case "take":
+        if (!owner) return refuse(`la t\xE2che ${t.id} est \xE0 ${t.ownerName}, pas \xE0 toi`);
+        return ok(t.state === "taken" ? t : put({ ...t, state: "taken" }, me.name, "prise"));
+      case "done": {
+        if (!owner) return refuse(`seule la session qui la tient (${t.ownerName}) peut la terminer`);
+        const result = cmd.text?.trim();
+        const done = put({ ...t, state: "done", ...result ? { result } : {} }, me.name, result ? `termin\xE9e : ${result}` : "termin\xE9e");
+        tellGiver(done, me.name, `termin\xE9e par ${me.name}${result ? ` : ${quote(result)}` : ""}`);
+        return ok(done);
+      }
+      case "refuse": {
+        if (!owner && !giver) return refuse(`la t\xE2che ${t.id} n'est ni \xE0 toi ni de toi`);
+        const reason = cmd.text?.trim();
+        if (!reason) return refuse("il faut une raison");
+        const refused = put({ ...t, state: "refused", result: reason }, me.name, `${owner ? "refus\xE9e" : "annul\xE9e"} : ${reason}`);
+        if (owner) tellGiver(refused, me.name, `refus\xE9e par ${me.name} : ${quote(reason)}`);
+        if (giver && !owner) d.mailbox.notify(t.owner, formatLedgeTask({ id: t.id, from: me.name, text: `T\xE2che \xAB ${t.title} \xBB annul\xE9e par ${me.name} : ${quote(reason)}. Arr\xEAte d'y travailler.` }), `${t.id}:${refused.log.length}`);
+        return ok(refused);
+      }
+      case "pass": {
+        if (!owner) return refuse(`seule la session qui la tient (${t.ownerName}) peut la passer`);
+        if (!cmd.to) return refuse("il faut le nom de la session \xE0 qui la passer");
+        const next2 = target(cmd.to);
+        if (!next2) return refuse(`aucune session Ledge nomm\xE9e ${cmd.to}`);
+        if (next2.id === me.id) return refuse("elle est d\xE9j\xE0 \xE0 toi");
+        if (!reachable2(next2)) return refuse(`${next2.name} n'a pas \xE9t\xE9 lanc\xE9e par Ledge : impossible de lui passer une t\xE2che`);
+        const note = cmd.text?.trim();
+        const passed = put({ ...t, owner: next2.id, ownerName: next2.name, state: "open" }, me.name, `pass\xE9e \xE0 ${next2.name}${note ? ` : ${note}` : ""}`);
+        tellOwner(passed, me.name, `T\xE2che pass\xE9e par ${me.name}${note ? ` (${quote(note)})` : ""}, confi\xE9e par ${t.giverName} :`);
+        return ok(passed);
+      }
+    }
+    return refuse("op\xE9ration inconnue");
+  }
+  return { run: run2, close: unsubscribe };
+}
+function tasksJournal(path) {
+  return jsonJournal(path, "tasks", (raw) => Array.isArray(raw) ? raw : void 0);
+}
 
 // src/chat/routing.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -4947,7 +5251,7 @@ function capabilities() {
 }
 
 // src/mobile/challenges.ts
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 var CHALLENGE_TTL_MS = 6e4;
 var MAX_OUTSTANDING = 1e3;
 function createChallengeStore(opts = {}) {
@@ -4966,7 +5270,7 @@ function createChallengeStore(opts = {}) {
       const slot2 = slotOf(b);
       const previous = slots.get(slot2);
       if (previous !== void 0) pending.delete(previous);
-      const challenge = randomBytes2(32).toString("base64url");
+      const challenge = randomBytes3(32).toString("base64url");
       pending.set(challenge, { binding: { deviceId: b.deviceId, purpose: b.purpose, subject: b.subject }, issuedAt: now(), slot: slot2 });
       slots.set(slot2, challenge);
       while (pending.size > max) {
@@ -5586,13 +5890,13 @@ function createPhoneGateway(deps) {
 }
 
 // src/mobile/push/encrypt.ts
-import { createCipheriv, createECDH, hkdfSync, randomBytes as randomBytes3 } from "crypto";
+import { createCipheriv, createECDH, hkdfSync, randomBytes as randomBytes4 } from "crypto";
 var RS = 4096;
 var expand = (ikm, salt, info, len) => Buffer.from(hkdfSync("sha256", ikm, salt, Buffer.from(info, "latin1"), len));
 function encryptPush(plain, sub, opts = {}) {
   const uaPublic = Buffer.from(sub.p256dh, "base64url");
   const authSecret = Buffer.from(sub.auth, "base64url");
-  const salt = Buffer.from(opts.salt ?? randomBytes3(16));
+  const salt = Buffer.from(opts.salt ?? randomBytes4(16));
   if (salt.length !== 16) throw new Error("salt must be 16 octets");
   if (uaPublic.length !== 65 || uaPublic[0] !== 4) throw new Error("p256dh is not an uncompressed P-256 point");
   const eph = createECDH("prime256v1");
@@ -5628,7 +5932,7 @@ function encryptPush(plain, sub, opts = {}) {
 // src/mobile/push/triggers.ts
 var TAG_MAX = 32;
 var TITLE_MAX = 80;
-var BODY_MAX = 120;
+var BODY_MAX2 = 120;
 var GENERIC_REASONS = /* @__PURE__ */ new Set(["Allow the requested shell command?"]);
 var safeTag = (s) => s.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, TAG_MAX);
 function cut(s, n) {
@@ -5652,11 +5956,11 @@ function pushFor(before, after, all) {
   const p = after.pending;
   if (p && (!before?.pending || pendingKey(p) !== pendingKey(before.pending))) {
     const url = `/#/request/${encodeURIComponent(after.id)}/${encodeURIComponent(pendingKey(p))}`;
-    if (p.kind === "question") return { v: 1, kind: "question", title: cut(`${after.name} a une question`, TITLE_MAX), body: cut(p.text.trim(), BODY_MAX), url, badge, tag };
-    return { v: 1, kind: "request", title: cut(`${after.name} attend votre accord`, TITLE_MAX), body: cut(requestBody(after), BODY_MAX), url, badge, tag };
+    if (p.kind === "question") return { v: 1, kind: "question", title: cut(`${after.name} a une question`, TITLE_MAX), body: cut(p.text.trim(), BODY_MAX2), url, badge, tag };
+    return { v: 1, kind: "request", title: cut(`${after.name} attend votre accord`, TITLE_MAX), body: cut(requestBody(after), BODY_MAX2), url, badge, tag };
   }
   if (before?.state === "working" && after.state === "idle" && !p) {
-    return { v: 1, kind: "finished", title: cut(`${after.name} a termin\xE9`, TITLE_MAX), body: cut((after.lastReply?.text ?? "").trim(), BODY_MAX), url: `/#/thread/${encodeURIComponent(after.id)}`, badge, tag };
+    return { v: 1, kind: "finished", title: cut(`${after.name} a termin\xE9`, TITLE_MAX), body: cut((after.lastReply?.text ?? "").trim(), BODY_MAX2), url: `/#/thread/${encodeURIComponent(after.id)}`, badge, tag };
   }
   return null;
 }
@@ -5906,12 +6210,14 @@ async function startServer(opts) {
     typing,
     closing,
     now,
+    ...opts.mail ? { journal: opts.mail } : {},
     relayQueued: (id) => cardThreads.queuedRelays().some((q) => q.relay.id === id),
     sent: { record: (id, m) => {
       history?.recordSent(id, m);
     }, mark: (id, rid, status) => history?.markSent(id, rid, status) }
   });
   const relay = createRelay({ threads: cardThreads, store, replyTo: replyText, now, typing, closing, next: (id) => mailbox.kick(id) });
+  const tasks = createTasks({ store, mailbox, now, ...opts.tasks ? { journal: opts.tasks } : {} });
   const previews = /* @__PURE__ */ new Map();
   const titles = /* @__PURE__ */ new Map();
   const labelled = /* @__PURE__ */ new Map();
@@ -6583,6 +6889,10 @@ async function startServer(opts) {
       // An agent's message to another session: acked at once, typed when the target is free.
       case "session.message":
         return reply(mailbox.submit(msg));
+      case "message.read":
+        return reply(mailbox.read(msg));
+      case "task.cmd":
+        return reply(tasks.run(msg));
       // A chat card's instruction: a refusal reaches the requester as an `error`, the card's state everyone through chat.history.
       case "session.relay":
         return relay.request(msg.qid);
@@ -6777,6 +7087,7 @@ async function startServer(opts) {
       gateway?.stop();
       relay.close();
       mailbox.close();
+      tasks.close();
       void omp.closeAll();
       for (const c of wss.clients) c.terminate();
       for (const socket of sockets) socket.destroy();
@@ -6878,7 +7189,7 @@ ${output}` } : { code: r.code, output };
 }
 
 // src/mobile/files.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, renameSync as renameSync4, chmodSync, unlinkSync } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, chmodSync, unlinkSync } from "fs";
 import { z } from "zod";
 
 // ../seal/src/errors.ts
@@ -7162,7 +7473,7 @@ function writePrivate(file, content) {
 }
 function readText(file, name) {
   try {
-    return readFileSync4(file, "utf8");
+    return readFileSync5(file, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw new Error(`${name} cannot be read (${e.code ?? "error"})`);
@@ -8288,10 +8599,12 @@ async function startDaemon(opts = {}) {
     log(`mobile access not available: ${e.message}`);
     mobileUnavailable = e.message.slice(0, 200);
   }
-  const server = await startServer({ store, tmux, port: opts.port, daemon, updater, history, mobile, mobileUnavailable });
+  const mail = fileJournal(paths().mail);
+  const taskJournal = tasksJournal(paths().tasks);
+  const server = await startServer({ store, tmux, port: opts.port, daemon, updater, history, mobile, mobileUnavailable, mail, tasks: taskJournal });
   ompLive = () => server.omp.liveCount();
   const poller = startPoller({ store, tmux, broadcastPreview: server.preview, labelExited: server.labelExited });
-  await writeFile7(paths().pid, String(process.pid));
+  await writeFile8(paths().pid, String(process.pid));
   log(`daemon started on ${server.port} with ${store.all().length} sessions`);
   let stopping = null;
   const stop = () => stopping ??= (async () => {
@@ -8302,6 +8615,8 @@ async function startDaemon(opts = {}) {
     await mobile?.stop();
     await store.save();
     await history.flush();
+    await mail.flush();
+    await taskJournal.flush();
     await rm6(paths().pid, { force: true });
     log("daemon stopped");
   })();