@paradow/ledge 0.6.0 → 0.8.0

package/dist/cli/{attach-FDMNVXYR.js → attach-KTZOG7E5.js}

@@ -1,17 +1,17 @@
 import {
   attachEnv
-} from "./chunk-QJG7M6BJ.js";
-import "./chunk-HYB7ZZN4.js";
+} from "./chunk-7AKUPFMS.js";
+import "./chunk-ZPANTZKC.js";
 import {
   realTmux
 } from "./chunk-3TNPEAMR.js";
 import "./chunk-L6IGH4LF.js";
 import {
   connect
-} from "./chunk-Z4YH2DLP.js";
+} from "./chunk-6ZKNEJND.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-AEV7ODMZ.js";
+} from "./chunk-KJWMK65Y.js";
 
 // src/cli/attach.ts
 import { spawn } from "child_process";

package/dist/cli/{bridge-AFAK3FU5.js → bridge-QKQW7UD6.js}

@@ -6,7 +6,7 @@ import {
   PROTOCOL_PORT,
   parseClientMessage,
   parseServerMessage
-} from "./chunk-AEV7ODMZ.js";
+} from "./chunk-KJWMK65Y.js";
 
 // src/cli/bridge.ts
 import WebSocket from "ws";

package/dist/cli/chunk-3KKTSYHP.js

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

package/dist/cli/{chunk-Z4YH2DLP.js → chunk-6ZKNEJND.js}

@@ -1,7 +1,7 @@
 import {
   PROTOCOL_PORT,
   parseServerMessage
-} from "./chunk-AEV7ODMZ.js";
+} from "./chunk-KJWMK65Y.js";
 
 // src/client.ts
 import WebSocket from "ws";

package/dist/cli/{chunk-QJG7M6BJ.js → chunk-7AKUPFMS.js}

@@ -1,7 +1,7 @@
 import {
   exitFile,
   spawnSession
-} from "./chunk-HYB7ZZN4.js";
+} from "./chunk-ZPANTZKC.js";
 import {
   realTmux
 } from "./chunk-3TNPEAMR.js";
@@ -11,10 +11,10 @@ import {
 } from "./chunk-L6IGH4LF.js";
 import {
   connect
-} from "./chunk-Z4YH2DLP.js";
+} from "./chunk-6ZKNEJND.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-AEV7ODMZ.js";
+} from "./chunk-KJWMK65Y.js";
 
 // src/cli/launch.ts
 import { spawn } from "child_process";

package/dist/cli/{chunk-AEV7ODMZ.js → chunk-KJWMK65Y.js}

@@ -30,7 +30,9 @@ var HelperSchema = z.object({
   id: z.string(),
   kind: z.string(),
   task: z.string(),
-  state: SessionStateSchema
+  state: SessionStateSchema,
+  /** When this helper finished; retained across daemon restarts until its five-minute expiry. */
+  finishedAt: z.string().datetime().optional()
 });
 var TopicSourceSchema = z.enum(["user", "pane", "prompt"]);
 var SessionSchema = z.object({
@@ -59,6 +61,8 @@ var SessionSchema = z.object({
   pending: PendingSchema.optional(),
   helpers: z.array(HelperSchema).default([]),
   lastReply: ReplySchema.optional(),
+  /** The last message this session sent to another agent: its tool_use_id, the address, the peer's Ledge session id, a one-line summary. */
+  lastMessage: z.object({ id: z.string(), to: z.string(), peer: z.string().optional(), summary: z.string(), at: z.string().datetime() }).optional(),
   startedAt: z.string().datetime(),
   lastActivityAt: z.string().datetime(),
   lastHookAt: z.string().datetime().optional(),
@@ -69,8 +73,15 @@ var SessionSchema = z.object({
   exitCode: z.number().int().nullable().optional(),
   exitedAt: z.string().datetime().optional(),
   lastError: z.string().optional(),
-  source: z.enum(["launcher", "hook_only"])
+  source: z.enum(["launcher", "hook_only"]),
+  /** When the session was put in the archive (session management): set, it leaves the live list and waits to be restored, resumed or deleted. */
+  archivedAt: z.string().datetime().optional(),
+  /** When the session was last taken out of the archive: the poller's retirement clock restarts from it, not from `exitedAt`. */
+  restoredAt: z.string().datetime().optional()
 });
+function isArchived(s) {
+  return s.archivedAt !== void 0;
+}
 
 // ../protocol/src/chat.ts
 import { z as z2 } from "zod";
@@ -324,7 +335,11 @@ var ThreadItemSchema = z11.discriminatedUnion("kind", [
   /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again. */
   z11.object({ kind: z11.literal("permission"), ...base, tool: z11.string(), text: z11.string(), decision: z11.enum(["accept", "deny", "always", "unknown"]).optional() }),
   z11.object({ kind: z11.literal("reply"), ...base, text: z11.string() }),
-  z11.object({ kind: z11.literal("helper"), ...base, task: z11.string(), agentType: z11.string().optional(), state: z11.enum(["working", "exited"]) })
+  z11.object({ kind: z11.literal("helper"), ...base, task: z11.string(), agentType: z11.string().optional(), state: z11.enum(["working", "exited"]) }),
+  /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread. */
+  z11.object({ kind: z11.literal("sent"), ...base, to: z11.string(), peer: z11.string().optional(), summary: z11.string().optional(), text: z11.string(), status: z11.enum(["sending", "delivered", "read", "failed"]), received: z11.string().optional() }),
+  /** A message another agent sent to this session; `from` is its from-name (else its address), `sent` the paired item's id in the peer's thread. */
+  z11.object({ kind: z11.literal("received"), ...base, from: z11.string(), peer: z11.string().optional(), text: z11.string(), sent: z11.string().optional() })
 ]);
 
 // ../protocol/src/decisions.ts
@@ -388,11 +403,13 @@ var SessionEventSchema = z13.object({
   /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
   transcriptPath: z13.string().optional(),
   /** Decided: what was chosen when the daemon knows it. */
-  decision: DecisionSchema.optional()
+  decision: DecisionSchema.optional(),
+  /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
+  agentSessionId: z13.string().optional()
 });
 var RecentSchema = z13.object({ cwd: z13.string().min(1), project: z13.string().min(1), lastAt: z13.string().datetime() });
 var SEMVER = /^\d+\.\d+\.\d+$/;
-var DaemonInfoSchema = z13.object({ version: z13.string(), install: z13.enum(["npm", "git", "unknown"]), systemd: z13.boolean(), manual: z13.string().optional(), routing: z13.boolean().optional() });
+var DaemonInfoSchema = z13.object({ version: z13.string(), install: z13.enum(["npm", "git", "unknown"]), systemd: z13.boolean(), manual: z13.string().optional(), routing: z13.boolean().optional(), archive: z13.boolean().optional() });
 var UpdateFailureSchema = z13.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
 var ServerMessageSchema = z13.discriminatedUnion("type", [
   z13.object({ type: z13.literal("chat.routed"), qid: z13.string(), result: RouteResultSchema }),
@@ -505,6 +522,14 @@ var ClientMessageSchema = z13.discriminatedUnion("type", [
   z13.object({ type: z13.literal("session.interrupt"), id: z13.string() }),
   /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
   z13.object({ type: z13.literal("session.dismiss"), id: z13.string() }),
+  /** Puts a session in the archive: it leaves the live list but is kept. */
+  z13.object({ type: z13.literal("session.archive"), id: z13.string() }),
+  /** Takes an archived session back out of the archive, as it was. */
+  z13.object({ type: z13.literal("session.restore"), id: z13.string() }),
+  /** Starts the agent again on an archived session's conversation. */
+  z13.object({ type: z13.literal("session.resume"), id: z13.string() }),
+  /** Deletes a session for good, archived or not. */
+  z13.object({ type: z13.literal("session.delete"), id: z13.string() }),
   /** The user names the session's topic from the overlay (500 characters at most, the hook's prompt cap); an empty topic hands back to the automatic sources. */
   z13.object({ type: z13.literal("session.rename"), id: z13.string(), topic: z13.string().max(500) }),
   z13.object({ type: z13.literal("session.thread"), id: z13.string() }),
@@ -673,6 +698,7 @@ function sessionTitle(s) {
 
 export {
   SessionSchema,
+  isArchived,
   NOTE_NOT_TYPED,
   offers,
   pendingKey,

package/dist/cli/{chunk-VK2IBMW7.js → chunk-Y5TCZTFL.js}

@@ -1,7 +1,24 @@
 import {
   cleanTopic,
   sessionTitle
-} from "./chunk-AEV7ODMZ.js";
+} from "./chunk-KJWMK65Y.js";
+
+// src/daemon/crossSession.ts
+var FIRST_LINE = /^Another Claude session sent a message:\s*\n/;
+var BLOCK = /<cross-session-message\b([^>]*)>([\s\S]*?)(?:<\/cross-session-message>|(?=\n[ \t]*<cross-session-message\b)|$)/g;
+var ATTR = /([\w-]+)="([^"]*)"/g;
+function crossSession(text) {
+  const body = text.trimStart().replace(FIRST_LINE, "");
+  if (!body.startsWith("<cross-session-message")) return void 0;
+  const out = [];
+  for (const m of body.matchAll(BLOCK)) {
+    const attrs = new Map([...m[1].matchAll(ATTR)].map((a) => [a[1], a[2]]));
+    const from = attrs.get("from");
+    const name = attrs.get("from-name");
+    if (from) out.push({ from, ...name ? { name } : {}, text: m[2].trim() });
+  }
+  return out.length ? out : void 0;
+}
 
 // src/daemon/state.ts
 var HOOK_PRIORITY_MS = 2e3;
@@ -134,6 +151,24 @@ function withTopic(s, text, source) {
   return { ...next, title: sessionTitle(next) };
 }
 function reduce(s, ev) {
+  const next = reduceEvent(s, ev);
+  if (next === s) return s;
+  let changed = false;
+  const helpers = next.helpers.map((h) => {
+    if (h.state === "exited" || next.state === "exited") {
+      if (h.state === "exited" && h.finishedAt) return h;
+      changed = true;
+      return { ...h, state: "exited", finishedAt: h.finishedAt ?? next.exitedAt ?? ev.at };
+    }
+    if (!h.finishedAt) return h;
+    changed = true;
+    const { finishedAt: _gone, ...active } = h;
+    return active;
+  });
+  return changed ? { ...next, helpers } : next;
+}
+function reduceEvent(s, ev) {
+  if (ev.agentSessionId && !ev.helperId && ev.agentSessionId !== s.agentSessionId) s = { ...s, agentSessionId: ev.agentSessionId };
   if (s.state === "exited") return s;
   s = endCursorHelpers(s, ev);
   const at = ev.at;
@@ -200,7 +235,7 @@ function reduce(s, ev) {
     case "PreToolUse":
     case "PermissionRequest":
     case "Notification": {
-      if (ev.name === "UserPromptSubmit" && ev.text && !s.topic) s = withTopic(s, ev.text, "prompt");
+      if (ev.name === "UserPromptSubmit" && ev.text && !s.topic && !crossSession(ev.text)) s = withTopic(s, ev.text, "prompt");
       const incoming = pendingFor(ev);
       if (incoming) {
         if (ev.name === "Notification" && s.pending?.source === "hook") return { ...s, lastHookAt: at, lastActivityAt: at };
@@ -218,6 +253,7 @@ function reduce(s, ev) {
 }
 
 export {
+  crossSession,
   QUESTION_TOOLS,
   reduce
 };

package/dist/cli/{chunk-HYB7ZZN4.js → chunk-ZPANTZKC.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-L6IGH4LF.js";
 import {
   pickName
-} from "./chunk-AEV7ODMZ.js";
+} from "./chunk-KJWMK65Y.js";
 
 // src/daemon/transcript.ts
 import { closeSync, fstatSync, openSync, readSync } from "fs";
@@ -120,8 +120,8 @@ function agentEnv(base, extra) {
 async function spawnSession(opts) {
   const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const takenIds = new Set(opts.taken.ids);
-  let id;
-  do
+  let id = opts.id;
+  if (id === void 0) do
     id = randomBytes(2).toString("hex");
   while (takenIds.has(id));
   const name = pickName(opts.taken.names, opts.name);

package/dist/cli/{daemon-SKI3UKOJ.js → daemon-SRNTDIZW.js}

@@ -1,15 +1,16 @@
 import {
   QUESTION_TOOLS,
+  crossSession,
   reduce
-} from "./chunk-VK2IBMW7.js";
+} from "./chunk-Y5TCZTFL.js";
 import {
   agentMessages,
   claudePlan,
   spawnSession
-} from "./chunk-HYB7ZZN4.js";
+} from "./chunk-ZPANTZKC.js";
 import {
   LEDGE_VERSION
-} from "./chunk-FFVZIXKG.js";
+} from "./chunk-3KKTSYHP.js";
 import {
   SERVICE,
   inDaemonService,
@@ -41,6 +42,7 @@ import {
   SessionSchema,
   SshAliasSchema,
   extractProposal,
+  isArchived,
   offers,
   parseClientMessage,
   parseProjectBlock,
@@ -50,7 +52,7 @@ import {
   pendingKey,
   pickName,
   projectOf
-} from "./chunk-AEV7ODMZ.js";
+} from "./chunk-KJWMK65Y.js";
 
 // src/daemon/index.ts
 import { writeFile as writeFile5, rm as rm5 } from "fs/promises";
@@ -59,6 +61,7 @@ import { writeFile as writeFile5, rm as rm5 } from "fs/promises";
 import { readFile, writeFile, rename, mkdir } from "fs/promises";
 import { dirname } from "path";
 var MAX_RECENTS = 12;
+var ARCHIVE_MAX = 200;
 var Store = class {
   sessions = /* @__PURE__ */ new Map();
   recentList = [];
@@ -67,33 +70,49 @@ var Store = class {
   timer = null;
   saving = Promise.resolve();
   journalPath;
+  /** Set by an unclean load and saved with the journal: a later clean-looking load must not be trusted for cleanups. */
+  incomplete = false;
   constructor(opts = {}) {
     this.journalPath = opts.journalPath ?? paths().journal;
   }
+  /**
+   * Reads the journal. `clean` is false when it was missing, unreadable, or an entry was dropped by the schema, or when
+   * an earlier load was so (the mark is saved with the journal): what the store holds may then not be every session,
+   * and nothing may be cleaned up on the strength of it (the threads of the sessions it misses).
+   */
   async load() {
     let raw;
     try {
       raw = await readFile(this.journalPath, "utf8");
     } catch {
-      return;
+      return { clean: false, reason: "no journal" };
     }
-    if (!raw.trim()) return;
+    const bad = async (reason) => {
+      this.incomplete = true;
+      await writeFile(`${this.journalPath}.incomplete`, raw, { flag: "wx" }).catch(() => void 0);
+      return { clean: false, reason };
+    };
+    if (!raw.trim()) return bad("empty journal");
     let parsed;
     try {
       parsed = JSON.parse(raw);
     } catch (e) {
       log(`journal unreadable, starting empty: ${e.message}`);
-      return;
+      return bad("unreadable journal");
     }
     const list = parsed?.sessions;
     if (!Array.isArray(list)) {
       log("journal unreadable, starting empty: no sessions array");
-      return;
+      return bad("no sessions array");
     }
+    let dropped = 0;
     for (const item of list) {
       const r = SessionSchema.safeParse(item);
       if (r.success) this.sessions.set(r.data.id, r.data);
-      else log(`journal entry dropped: ${r.error.issues[0]?.message ?? "invalid"}`);
+      else {
+        dropped++;
+        log(`journal entry dropped: ${r.error.issues[0]?.message ?? "invalid"}`);
+      }
     }
     const recents = parsed?.recents;
     if (Array.isArray(recents)) {
@@ -103,6 +122,12 @@ var Store = class {
       }
       this.recentList = this.recentList.slice(0, MAX_RECENTS);
     }
+    if (dropped) return bad(`${dropped} journal ${dropped === 1 ? "entry" : "entries"} dropped`);
+    if (parsed.incomplete === true) {
+      this.incomplete = true;
+      return { clean: false, reason: "an earlier load was incomplete" };
+    }
+    return { clean: true };
   }
   all() {
     return [...this.sessions.values()];
@@ -130,14 +155,33 @@ var Store = class {
     if (Object.keys(fields).every((k) => cur[k] === fields[k])) return;
     this.upsert({ ...cur, ...fields });
   }
+  /** Sets the archive date (kept if already set), then drops the oldest archives past `ARCHIVE_MAX`. */
+  archive(id, at) {
+    const cur = this.sessions.get(id);
+    if (!cur) return void 0;
+    const next = cur.archivedAt === void 0 ? { ...cur, archivedAt: at } : cur;
+    if (next !== cur) this.upsert(next);
+    const archived = this.all().filter((s) => s.archivedAt !== void 0).sort((a, b) => a.archivedAt.localeCompare(b.archivedAt));
+    for (const old of archived.slice(0, Math.max(0, archived.length - ARCHIVE_MAX))) this.remove(old.id);
+    return this.sessions.get(id);
+  }
+  /** Takes the session out of the archive; `at` (a restore by the user) restarts the retirement clock from then. */
+  unarchive(id, at) {
+    const cur = this.sessions.get(id);
+    if (!cur) return void 0;
+    if (cur.archivedAt === void 0) return cur;
+    const { archivedAt: _gone, ...rest } = cur;
+    const next = at !== void 0 ? { ...rest, restoredAt: at } : rest;
+    this.upsert(next);
+    return next;
+  }
   /** Every event applied to a known session, before the reducer decides whether it changes anything. */
   onEvent(listener) {
     this.eventListeners.add(listener);
     return () => this.eventListeners.delete(listener);
   }
   apply(id, event) {
-    const cur = this.sessions.get(id);
-    if (!cur) return void 0;
+    if (!this.sessions.has(id)) return void 0;
     for (const l of this.eventListeners) {
       try {
         l(id, event);
@@ -145,6 +189,8 @@ var Store = class {
         log(`event listener failed: ${e.message}`);
       }
     }
+    const cur = this.sessions.get(id);
+    if (!cur) return void 0;
     const next = reduce(cur, event);
     if (next === cur) return cur;
     this.sessions.set(id, next);
@@ -171,7 +217,7 @@ var Store = class {
   async write() {
     await mkdir(dirname(this.journalPath), { recursive: true });
     const tmp = `${this.journalPath}.tmp`;
-    await writeFile(tmp, JSON.stringify({ savedAt: (/* @__PURE__ */ new Date()).toISOString(), sessions: this.all(), recents: this.recentList }, null, 2));
+    await writeFile(tmp, JSON.stringify({ savedAt: (/* @__PURE__ */ new Date()).toISOString(), ...this.incomplete ? { incomplete: true } : {}, sessions: this.all(), recents: this.recentList }, null, 2));
     await rename(tmp, this.journalPath);
   }
   emit(c) {
@@ -282,8 +328,11 @@ var History = class {
   listeners = /* @__PURE__ */ new Set();
   writes = Promise.resolve();
   dir;
+  /** The Ledge session a SendMessage address or a sender's name is, when it is one (peers.ts). */
+  peerOf;
   constructor(opts = {}) {
     this.dir = opts.dir ?? paths().history;
+    this.peerOf = opts.peerOf ?? (() => void 0);
   }
   items(id) {
     return this.threads.get(id) ?? [];
@@ -355,6 +404,15 @@ var History = class {
           if (helper?.kind === "helper") this.settle(id, (i) => i.helperId === back.helperId);
           return back.report ? this.put(id, { kind: "reply", id: `report-${back.helperId}`, at: ev.at, turn: helper?.turn ?? turn, helperId: back.helperId, text: back.report }) : void 0;
         }
+        const messages = crossSession(ev.text);
+        if (messages) {
+          this.turns.set(id, turn + 1);
+          let last;
+          messages.forEach((m, i) => {
+            last = this.receive(id, { kind: "received", id: `recv-${turn + 1}-${i}`, at: ev.at, turn: turn + 1, from: m.name ?? m.from, text: m.text }, m);
+          });
+          return last;
+        }
         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 });
       }
@@ -362,6 +420,7 @@ var History = class {
         if (!ev.tool) return void 0;
         const existing = ev.toolUseId && this.items(id).find((i) => i.id === ev.toolUseId);
         if (existing) return existing;
+        if (ev.tool === "SendMessage") return this.put(id, this.sentOf(ev, common, "sending"));
         const input = inputText(ev.toolInput);
         return this.put(id, { kind: "tool", id: ev.toolUseId ?? `tool-${ev.at}-${this.items(id).length}`, ...common, tool: ev.tool, label: ev.text ?? ev.tool, ...input ? { input } : {}, status: "running", files: filesOf(ev.tool, ev.toolInput) });
       }
@@ -369,6 +428,11 @@ var History = class {
       case "PostToolUseFailure": {
         if (!ev.tool) return void 0;
         const failed = ev.name === "PostToolUseFailure";
+        if (ev.tool === "SendMessage") {
+          const sent = this.items(id).find((i) => i.kind === "sent" && i.id === ev.toolUseId);
+          if (sent?.status === "read") return sent;
+          return this.put(id, sent ? { ...sent, status: failed ? "failed" : "delivered" } : this.sentOf(ev, common, failed ? "failed" : "delivered"));
+        }
         const row = this.callFor(id, ev);
         const base = row ?? { kind: "tool", id: ev.toolUseId ?? `tool-${ev.at}-${this.items(id).length}`, ...common, tool: ev.tool, label: ev.text ?? ev.tool, status: "running", files: filesOf(ev.tool, ev.toolInput) };
         const error = failed ? ev.error ?? (ev.interrupt ? "interrupted" : "failed") : void 0;
@@ -419,7 +483,7 @@ var History = class {
     if (!opts.force && now - (this.synced.get(key) ?? 0) < SYNC_MS) return [];
     this.synced.set(key, now);
     const items = this.items(id);
-    const since = opts.helperId ? items.find((i) => i.id === opts.helperId)?.at : [...items].reverse().find((i) => i.kind === "prompt")?.at;
+    const since = opts.helperId ? items.find((i) => i.id === opts.helperId)?.at : [...items].reverse().find((i) => i.kind === "prompt" || i.kind === "received")?.at;
     if (!since) return [];
     const have = new Set(items.map((i) => i.id));
     const turn = this.turns.get(id) ?? 0;
@@ -430,6 +494,25 @@ var History = class {
     }
     return added;
   }
+  /** A SendMessage's card, from its input: `to` the address used, `peer` the Ledge session that address is. */
+  sentOf(ev, common, status) {
+    const input = ev.toolInput ?? {};
+    const to = typeof input.to === "string" ? input.to : "";
+    const peer = to ? this.peerOf(to) : void 0;
+    return { kind: "sent", id: ev.toolUseId ?? `sent-${ev.at}`, ...common, to, ...peer ? { peer } : {}, ...typeof input.summary === "string" && input.summary ? { summary: input.summary } : {}, text: typeof input.message === "string" ? input.message : "", status };
+  }
+  /** 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). That sent one becomes read, in the sender's thread. */
+  receive(id, recv, m) {
+    const peer = this.peerOf(m.from) ?? (m.name ? this.peerOf(m.name) : void 0);
+    if (!peer) return this.put(id, recv);
+    const head = (t) => 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);
+    if (sent) this.put(peer, { ...sent, status: "read", received: recv.id });
+    return this.put(id, { ...recv, 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). */
   settle(id, mine) {
@@ -1258,6 +1341,7 @@ async function gitSummary(cwd, exec = execGit) {
 // src/daemon/poller.ts
 var DETECT_LINES = 60;
 var REST_MS = 2e3;
+var HELPER_RETENTION_MS = 5 * 60 * 1e3;
 function startPoller(opts) {
   const { store, tmux } = opts;
   const adapterFor2 = opts.adapterFor ?? adapterFor;
@@ -1289,7 +1373,9 @@ function startPoller(opts) {
       const deadCheck = t - lastDeadCheck >= deadCheckMs;
       if (deadCheck) lastDeadCheck = t;
       for (const id of previews.keys()) if (!store.get(id)) previews.delete(id);
-      for (const s of store.all()) {
+      for (const snapshot of store.all()) {
+        const s = store.get(snapshot.id);
+        if (!s) continue;
         try {
           await pollOne(s, t, deadCheck);
         } catch (e) {
@@ -1301,9 +1387,22 @@ function startPoller(opts) {
     }
   }
   async function pollOne(s, t, deadCheck) {
+    const helpers = s.helpers.flatMap((h2) => {
+      if (s.pending?.helperId === h2.id || h2.state !== "exited" && s.state !== "exited") return [h2];
+      const finishedAt = h2.finishedAt ?? s.exitedAt ?? s.lastActivityAt;
+      if (t - Date.parse(finishedAt) >= HELPER_RETENTION_MS) return [];
+      return h2.finishedAt && h2.state === "exited" ? [h2] : [{ ...h2, state: "exited", finishedAt }];
+    });
+    if (helpers.length !== s.helpers.length || helpers.some((h2, i) => h2 !== s.helpers[i])) {
+      s = { ...s, helpers };
+      store.upsert(s);
+    }
     if (s.state === "exited") {
       forget(s.id);
-      if (s.exitedAt && t - Date.parse(s.exitedAt) > retireMs) store.remove(s.id);
+      if (!s.archivedAt && s.exitedAt) {
+        const since = Math.max(Date.parse(s.exitedAt), s.restoredAt ? Date.parse(s.restoredAt) : -Infinity);
+        if (t - since > retireMs) store.archive(s.id, now());
+      }
       return;
     }
     if ((deadCheck || !gitSeen.has(s.id)) && s.cwd) {
@@ -2127,7 +2226,7 @@ function createChat(deps) {
     }
   }
   async function run2(turn, emit, fresh, mine, tool) {
-    const ctx = await writeContext(contextDir, { sessions: deps.store.all(), recents: deps.store.recents(), projects: deps.projects?.(), now: now(), capture, git: (cwd) => gitSummary(cwd) });
+    const ctx = await writeContext(contextDir, { sessions: deps.store.all().filter((s) => !isArchived(s)), recents: deps.store.recents(), projects: deps.projects?.(), now: now(), capture, git: (cwd) => gitSummary(cwd) });
     if (mine.cancelled) return CANCELLED;
     const { sessionId, resume } = await daySession(fresh, tool);
     const label2 = TOOL_LABEL[tool];
@@ -2606,6 +2705,11 @@ function serveSsh(ws, alias, opts = {}) {
 
 // src/daemon/server.ts
 var CONTINUE_ARGS = { claude: ["--continue"], codex: ["resume", "--last"], cursor: ["--continue"] };
+var RESUME_ARGS = { claude: (id) => ["--resume", id], codex: (id) => ["resume", id], cursor: (id) => ["--resume", id] };
+function resumeKey(s) {
+  if (s.agentSessionId) return s.agentSessionId;
+  return s.tool === "claude" && s.transcriptPath ? basename4(s.transcriptPath, ".jsonl") : void 0;
+}
 var MULTI_DIR_ARGS = { claude: (dirs) => ["--add-dir", ...dirs] };
 function launchArgs(msg) {
   const prompt = msg.prompt?.trim();
@@ -2617,6 +2721,7 @@ var NoteNotTyped = class extends Error {
     super("denied, but the note could not be typed");
   }
 };
+var DELETED_TTL_MS = 5 * 60 * 1e3;
 var ALLOWED_ORIGINS = [
   "tauri://localhost",
   "http://tauri.localhost",
@@ -2680,7 +2785,13 @@ async function startServer(opts) {
   };
   const history = opts.history;
   const unsubscribeHistory = history ? [
-    history.onItem((id, item) => broadcast({ type: "session.thread.item", id, item })),
+    history.onItem((id, item) => {
+      broadcast({ type: "session.thread.item", id, item });
+      const cur = store.get(id)?.lastMessage;
+      if (item.kind === "sent" && item.status !== "read" && item.status !== "failed" && cur?.id !== item.id && (!cur || item.at >= cur.at)) {
+        store.patch(id, { lastMessage: { id: item.id, to: item.to, ...item.peer ? { peer: item.peer } : {}, summary: item.summary ?? item.text.split("\n")[0].slice(0, 120), at: item.at } });
+      }
+    }),
     store.onEvent((id, ev) => history.record(id, ev)),
     store.onChange((c) => {
       if (c.type === "removed") history.forget(c.id);
@@ -2702,7 +2813,7 @@ async function startServer(opts) {
     broadcast(c.type === "updated" ? { type: "session.updated", session: c.session } : { type: "session.removed", id: c.id });
   });
   const sendSnapshot = (ws) => {
-    send(ws, { type: "snapshot", sessions: store.all(), recents: store.recents(), launcher, ...opts.daemon ? { daemon: { ...opts.daemon, routing: true } } : {} });
+    send(ws, { type: "snapshot", sessions: store.all(), recents: store.recents(), launcher, ...opts.daemon ? { daemon: { ...opts.daemon, routing: true, archive: true } } : {} });
     send(ws, machinesMsg());
     send(ws, projectsMsg());
     send(ws, islandMsg());
@@ -2791,6 +2902,11 @@ async function startServer(opts) {
   const NOT_TAKEN = "the terminal did not take it";
   const FREE_TEXT = "free-text answers are not supported yet, answer in the terminal";
   const NOT_OFFERED = "this answer is not offered for this request, answer in the terminal";
+  async function endSession(s) {
+    if (s.source !== "launcher" || s.state === "exited") return;
+    if (s.tmuxSession) await tmux.killSession(s.tmuxSession).catch((e) => log(`kill of ${s.tmuxSession} failed: ${e.message}`));
+    store.apply(s.id, { name: "PaneGone", at: now(), source: "daemon" });
+  }
   async function replyTo(id, text) {
     const s = store.get(id);
     if (!s) return "unknown session";
@@ -2803,6 +2919,19 @@ async function startServer(opts) {
     await injectAndVerify(id, (pane) => adapter.replyPlan(text, pending, pane || void 0), !!pending);
     return null;
   }
+  const deleted = /* @__PURE__ */ new Map();
+  function markDeleted(id) {
+    const t = Date.now();
+    for (const [k, at] of deleted) if (t - at > DELETED_TTL_MS) deleted.delete(k);
+    deleted.set(id, t);
+  }
+  function recentlyDeleted(id) {
+    const at = deleted.get(id);
+    if (at === void 0) return false;
+    if (Date.now() - at <= DELETED_TTL_MS) return true;
+    deleted.delete(id);
+    return false;
+  }
   const chatLaunches = /* @__PURE__ */ new Set();
   async function launch(req) {
     if (req.dirs?.length && !MULTI_DIR_ARGS[req.tool]) throw new Error(`launch: ${req.tool} takes one folder`);
@@ -2917,6 +3046,7 @@ async function startServer(opts) {
       }
       case "session.event": {
         const ev = msg.event;
+        if (recentlyDeleted(msg.id)) return;
         const ownTurn = !ev.helperId && (ev.name === "PreToolUse" || ev.name === "PermissionRequest" || ev.name === "Stop");
         const helperEnd = ev.name === "SubagentStop" && !!ev.helperId;
         if (history && ev.transcriptPath && (ownTurn || helperEnd)) {
@@ -2926,7 +3056,11 @@ async function startServer(opts) {
             log(`transcript not read for ${msg.id}: ${e.message}`);
           }
         }
+        const terminal = ev.name === "SessionEnd" || ev.name === "PaneGone";
+        const stored = store.get(msg.id);
+        if (stored?.archivedAt && stored.state !== "exited" && !terminal) store.unarchive(msg.id);
         const before = store.get(msg.id);
+        if (!before && terminal) return;
         if (!before) {
           const taken = store.all().map((s) => s.name);
           const cwd = msg.cwd ?? "";
@@ -2988,6 +3122,54 @@ async function startServer(opts) {
         store.remove(msg.id);
         return;
       }
+      case "session.archive": {
+        const s = store.get(msg.id);
+        if (!s) return refuse("unknown session", msg.id);
+        await endSession(s);
+        store.archive(msg.id, now());
+        return;
+      }
+      case "session.restore": {
+        if (!store.get(msg.id)) return refuse("unknown session", msg.id);
+        store.unarchive(msg.id, now());
+        return;
+      }
+      case "session.resume": {
+        const s = store.get(msg.id);
+        if (!s) return refuse("unknown session", msg.id);
+        if (s.state !== "exited") return refuse("the session is still running", msg.id);
+        const key = resumeKey(s);
+        if (!key) return refuse("no conversation to resume", msg.id);
+        const { archivedAt: _a, exitedAt: _e, exitCode: _c, ...rest } = s;
+        store.upsert({ ...rest, state: "starting", source: "launcher", agentSessionId: key });
+        try {
+          const cwd = await resolveFolder(s.cwd, opts.home);
+          const env = await agentEnv();
+          const spawned = await spawnSession({ tool: s.tool, id: s.id, name: s.name, args: RESUME_ARGS[s.tool](key), cwd, tmux, now, env, taken: { names: store.all().filter((o) => o.id !== s.id && o.state !== "exited").map((o) => o.name), ids: [] } });
+          const cur = store.get(s.id);
+          if (!cur || cur.archivedAt !== void 0) {
+            if (spawned.tmuxSession) await tmux.killSession(spawned.tmuxSession).catch((e) => log(`kill of ${spawned.tmuxSession} failed: ${e.message}`));
+            log(`resume of ${s.id} dropped: the session was ${cur ? "archived" : "deleted"} meanwhile`);
+            return;
+          }
+          const { topic, topicSource, repo, repoPath, branch, worktree, repoId, project, transcriptPath } = s;
+          store.upsert({ ...spawned, agentSessionId: key, ...transcriptPath ? { transcriptPath } : {}, ...topic ? { topic } : {}, ...topicSource ? { topicSource } : {}, ...repo ? { repo } : {}, ...repoPath ? { repoPath } : {}, ...branch ? { branch } : {}, ...worktree !== void 0 ? { worktree } : {}, ...repoId ? { repoId } : {}, project });
+          log(`resumed ${spawned.name} (${spawned.tool}) in ${spawned.cwd} as ${spawned.id}`);
+        } catch (e) {
+          const cur = store.get(s.id);
+          if (cur && cur.archivedAt === void 0 && cur.state === "starting") store.upsert(s);
+          return refuse(e.message, msg.id);
+        }
+        return;
+      }
+      case "session.delete": {
+        const s = store.get(msg.id);
+        if (!s) return refuse("unknown session", msg.id);
+        if (s.source === "launcher" || s.state === "exited") markDeleted(msg.id);
+        await endSession(s);
+        store.remove(msg.id);
+        return;
+      }
       // 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);
@@ -3166,11 +3348,49 @@ ${output}` } : { code: r.code, output };
   };
 }
 
+// src/daemon/peers.ts
+import { readdirSync, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { basename as basename5, join as join10 } from "path";
+var defaultDir = () => join10(process.env.CLAUDE_CONFIG_DIR ?? join10(homedir6(), ".claude"), "sessions");
+function parsePeer(path) {
+  try {
+    const j = JSON.parse(readFileSync4(path, "utf8"));
+    if (typeof j.pid !== "number" || typeof j.sessionId !== "string" || typeof j.name !== "string" || typeof j.messagingSocketPath !== "string") return void 0;
+    return { pid: j.pid, sessionId: j.sessionId, name: j.name, address: `uds:${j.messagingSocketPath}` };
+  } catch {
+    return void 0;
+  }
+}
+function readPeers(dir = defaultDir()) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((n) => n.endsWith(".json")).flatMap((n) => parsePeer(join10(dir, n)) ?? []);
+}
+function peerFor(target, peers, sessions, dir = defaultDir()) {
+  const name = target.replace(/ \[[^\]]*\]$/, "");
+  const found = peers.filter((p) => p.name === name || p.address === name);
+  if (!found.length && name.startsWith("uds:") && name.endsWith(".sock")) {
+    const pid = basename5(name, ".sock");
+    const direct = /^\d+$/.test(pid) ? parsePeer(join10(dir, `${pid}.json`)) : void 0;
+    if (direct) found.push(direct);
+  }
+  for (const { sessionId: id } of found) {
+    const s = sessions.find((s2) => s2.agentSessionId === id || s2.transcriptPath?.endsWith(`/${id}.jsonl`));
+    if (s) return s;
+  }
+  return void 0;
+}
+
 // src/daemon/index.ts
 async function startDaemon(opts = {}) {
   await ensureLedgeDir();
   const store = new Store();
-  await store.load();
+  const loaded = await store.load();
   const tmux = opts.tmux ?? realTmux(opts.tmuxSocket ?? "ledge");
   let live2 = null;
   try {
@@ -3179,17 +3399,19 @@ async function startDaemon(opts = {}) {
     log(`startup prune skipped, tmux unavailable: ${e.message}`);
   }
   if (live2) for (const s of store.all()) {
-    if (s.tmuxSession && !live2.has(s.tmuxSession)) store.remove(s.id);
+    if (s.tmuxSession && !live2.has(s.tmuxSession)) store.apply(s.id, { name: "PaneGone", at: (/* @__PURE__ */ new Date()).toISOString(), source: "daemon" });
   }
   const daemon = await daemonInfo();
   const updater = createDaemonUpdater(realUpdaterDeps({ info: daemon, save: () => store.save() }));
-  const history = new History();
+  const history = new History({ peerOf: (t) => peerFor(t, readPeers(), store.all())?.id });
   try {
     await history.load();
   } catch (e) {
     log(`history not loaded: ${e.message}`);
   }
-  for (const id of history.ids()) if (!store.get(id)) history.forget(id);
+  if (loaded.clean) {
+    for (const id of history.ids()) if (!store.get(id)) history.forget(id);
+  } else log(`history cleanup skipped: ${loaded.reason}`);
   const server = await startServer({ store, tmux, port: opts.port, daemon, updater, history });
   const poller = startPoller({ store, tmux, broadcastPreview: server.preview });
   await writeFile5(paths().pid, String(process.pid));

package/dist/cli/{hook-CT5OKGHQ.js → hook-BBVUY4RK.js}

@@ -1,33 +1,34 @@
 import {
   QUESTION_TOOLS
-} from "./chunk-VK2IBMW7.js";
+} from "./chunk-Y5TCZTFL.js";
 import {
   CODEX_ENV_VAR,
   CODEX_HOOK_VAR,
   codexPlan
-} from "./chunk-HYB7ZZN4.js";
+} from "./chunk-ZPANTZKC.js";
 import {
   log
 } from "./chunk-L6IGH4LF.js";
 import {
   connect
-} from "./chunk-Z4YH2DLP.js";
-import "./chunk-AEV7ODMZ.js";
+} from "./chunk-6ZKNEJND.js";
+import "./chunk-KJWMK65Y.js";
 
 // src/cli/hook.ts
 import { readFileSync, openSync, fstatSync, readSync, closeSync } from "fs";
 import { basename, join } from "path";
 var str = (v) => typeof v === "string" ? v : void 0;
 var PROMPT_MAX = 500;
-var handBack = (t) => t.startsWith('<agent-message from="');
+var fromAgent = (t) => t.startsWith('<agent-message from="') || t.startsWith("<cross-session-message ");
 var promptText = (p) => {
   const t = str(p.prompt)?.trim();
-  return t ? { text: t.slice(0, handBack(t) ? INPUT_MAX : PROMPT_MAX) } : {};
+  return t ? { text: t.slice(0, fromAgent(t) ? INPUT_MAX : PROMPT_MAX) } : {};
 };
 function describeTool(tool, input) {
   const i = input && typeof input === "object" ? input : {};
   if (tool === "Bash") return str(i.command) ?? "";
   if (tool === "Edit" || tool === "Write" || tool === "MultiEdit" || tool === "Read") return str(i.file_path) ?? "";
+  if (tool === "SendMessage") return str(i.summary) || `\u2192 ${str(i.to) ?? ""}`;
   if (tool === "ExitPlanMode") return str(i.plan)?.split("\n")[0] ?? "plan";
   if (tool === "apply_patch") {
     const files = [...(str(i.command) ?? "").matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm)].map((m) => m[1].trim());
@@ -102,7 +103,8 @@ function mapHook(agent, eventName, payload, at) {
   const event = mapEvent(eventName, p, at, launched);
   if (!event) return null;
   const task = agent === "claude" && event.helperId ? helperDescription(str(p.transcript_path), event.helperId) : void 0;
-  return { id, event: task ? { ...event, task } : event, agent, ...cwd ? { cwd } : {} };
+  const agentSessionId = !event.helperId ? str(p.session_id) : void 0;
+  return { id, event: { ...event, ...task ? { task } : {}, ...agentSessionId ? { agentSessionId } : {} }, agent, ...cwd ? { cwd } : {} };
 }
 function helperDescription(transcriptPath, agentId) {
   if (!transcriptPath?.endsWith(".jsonl") || !/^[\w-]+$/.test(agentId)) return void 0;
@@ -246,7 +248,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, agent: "cursor", ...cwd ? { cwd } : {} } : null;
+  return event ? { id, event: helper || event.helperId ? event : { ...event, agentSessionId: sessionId }, agent: "cursor", ...cwd ? { cwd } : {} } : null;
 }
 function mapCursorHelperEvent(eventName, p, at, helperId) {
   const base = { at, source: "hook", helperId };

package/dist/cli/index.js

@@ -16,7 +16,7 @@ async function hookMain(args) {
   try {
     const chunks = [];
     for await (const c of process.stdin) chunks.push(c);
-    const { runHook } = await import("./hook-CT5OKGHQ.js");
+    const { runHook } = await import("./hook-BBVUY4RK.js");
     await runHook(event, Buffer.concat(chunks).toString("utf8"), { tool });
   } catch {
   }
@@ -26,7 +26,7 @@ async function main(argv) {
   const [cmd, ...rest] = argv;
   switch (cmd) {
     case "daemon": {
-      const { startDaemon } = await import("./daemon-SKI3UKOJ.js");
+      const { startDaemon } = await import("./daemon-SRNTDIZW.js");
       await startDaemon();
       await new Promise(() => {
       });
@@ -34,7 +34,7 @@ async function main(argv) {
     }
     case "--version":
     case "version": {
-      const { LEDGE_VERSION } = await import("./version-3CHJ23IV.js");
+      const { LEDGE_VERSION } = await import("./version-M6IZZGUV.js");
       console.log(LEDGE_VERSION);
       return 0;
     }
@@ -50,23 +50,23 @@ async function main(argv) {
       return r.ok ? 0 : 1;
     }
     case "status": {
-      const { printStatus } = await import("./status-TACDR6DZ.js");
+      const { printStatus } = await import("./status-L2GROM4J.js");
       console.log(await printStatus());
       return 0;
     }
     case "bridge": {
-      const { bridge } = await import("./bridge-AFAK3FU5.js");
+      const { bridge } = await import("./bridge-QKQW7UD6.js");
       await bridge();
       return 0;
     }
     case "claude":
     case "codex":
     case "cursor": {
-      const { launch } = await import("./launch-LVMFX3KF.js");
+      const { launch } = await import("./launch-RWT4EWWI.js");
       return launch(cmd, rest);
     }
     case "attach": {
-      const { attach } = await import("./attach-FDMNVXYR.js");
+      const { attach } = await import("./attach-KTZOG7E5.js");
       return attach(rest[0] ?? "");
     }
     default:

package/dist/cli/{launch-LVMFX3KF.js → launch-RWT4EWWI.js}

@@ -5,15 +5,15 @@ import {
   ensureDaemon,
   launch,
   parseLaunchArgs
-} from "./chunk-QJG7M6BJ.js";
+} from "./chunk-7AKUPFMS.js";
 import {
   agentEnv,
   exitFile
-} from "./chunk-HYB7ZZN4.js";
+} from "./chunk-ZPANTZKC.js";
 import "./chunk-3TNPEAMR.js";
 import "./chunk-L6IGH4LF.js";
-import "./chunk-Z4YH2DLP.js";
-import "./chunk-AEV7ODMZ.js";
+import "./chunk-6ZKNEJND.js";
+import "./chunk-KJWMK65Y.js";
 export {
   DaemonError,
   agentEnv,

package/dist/cli/{status-TACDR6DZ.js → status-L2GROM4J.js}

@@ -1,7 +1,7 @@
 import {
   connect
-} from "./chunk-Z4YH2DLP.js";
-import "./chunk-AEV7ODMZ.js";
+} from "./chunk-6ZKNEJND.js";
+import "./chunk-KJWMK65Y.js";
 
 // src/cli/status.ts
 async function printStatus(opts = {}) {

package/dist/cli/{version-3CHJ23IV.js → version-M6IZZGUV.js}

@@ -1,6 +1,6 @@
 import {
   LEDGE_VERSION
-} from "./chunk-FFVZIXKG.js";
+} from "./chunk-3KKTSYHP.js";
 export {
   LEDGE_VERSION
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paradow/ledge",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Follow and answer your WSL agent sessions (Claude Code, Codex, Cursor Agent) from the Ledge island on Windows.",
   "type": "module",
   "bin": { "ledge": "dist/cli/index.js" },

package/dist/cli/chunk-FFVZIXKG.js

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