@paradow/ledge 0.15.0 → 0.16.0

package/README.md

@@ -30,7 +30,7 @@ pnpm --filter @paradow/ledge build
 chmod +x packages/ledge/dist/cli/index.js
 mkdir -p ~/.local/bin
 ln -sf "$PWD/packages/ledge/dist/cli/index.js" ~/.local/bin/ledge   # ~/.local/bin must be on the PATH Claude Code uses for hooks
-ledge setup
+ledge setup                         # the link becomes a script that runs the CLI with this node (a session Ledge launches may have no node on its PATH: nvm)
 ```
 
 The daemon is spawned from the built CLI (`dist/cli/index.js`), so rebuild after changes (`pnpm --filter @paradow/ledge build`).
@@ -39,13 +39,15 @@ The daemon is spawned from the built CLI (`dist/cli/index.js`), so rebuild after
 
 ```sh
 ledge claude            # start Claude Code in a tracked tmux session (tab renamed to the bot)
-ledge claude --name max # pick the bot's name
+ledge claude --name max # pick the session's Ledge name
 ledge status            # list bots and what they wait for
 ledge attach <id>       # put this terminal on a running session (what the overlay opens a tab with)
 ledge daemon            # run the daemon in the foreground (normally run by the systemd service)
-ledge uninstall         # undo ledge setup: hooks, service and the ~/.local/bin link (--purge: ~/.ledge too)
+ledge uninstall         # undo ledge setup: hooks, service and ~/.local/bin/ledge (--purge: ~/.ledge too)
 ```
 
+When a Claude it launched exits, Ledge appends a `custom-title` « name - topic » to its transcript, so `claude --resume` lists the conversation that way, unless the user named it (`claude -n`, `/rename`).
+
 `ledge setup` installs `ledge-daemon.service` as a systemd user unit, starts it and enables linger, so the daemon runs from WSL boot and restarts after a crash. Rerun it after a node upgrade or a repository move: the unit is rewritten and the service restarted. Useful commands:
 
 ```sh
@@ -89,6 +91,8 @@ The question goes on stdin, never in argv, and `LEDGE_CHAT=1` is set so Ledge's
 - `~/.ledge/chat.json` holds the day's conversation (its date, session id and which tool it belongs to); a new day, a `chat.reset`, or a change of harness starts a new conversation, and a question after a failed resume starts a new one too.
 - One question at a time; a turn that takes more than 180 s is stopped and the chat says it timed out (no retry). `chat.reset` is refused while a question is running.
 
+- Close card: asked to close sessions, the harness ends its answer with one `ledge-close` block per session (8 at most; the daemon takes the id, name and tool from its own store). The card's **Close** sends `session.close { qid, rows? }`: the daemon sends the interrupt keys and waits up to 10 s for a free prompt, types the agent's exit command (`/exit`) once it is free, then waits up to 15 s for the session to end. A pending request is only interrupted, never answered or typed into: a hook's request for the main thread is recorded as a permission denied (or a question dismissed) by the close; a request read off the screen, or a helper's, is interrupted with nothing recorded (a helper's keeps the prompt busy, so that close ends in the kill). The tmux session is killed when the prompt is still not free after 10 s (nothing is typed) or when the agent is still running 15 s after the exit command. The session ends `exited`, not archived, so `session.resume` brings it back. The phone's chat shows the same card, and its **Fermer** / **Fermer tout (n)** send `chat.close` through the gateway, which needs a passkey assertion bound to the `qid` with purpose `close` (a `launch` or `decide` assertion is never accepted); without a registered passkey the gateway answers `confirm_required` and the app shows the setup hint. `rows` is validated like `chat.launch`'s (ints 0..7, unique, 1 to 8), a failed row is only `failed: true` (no error text reaches the phone), and `chat.close` is volatile: never replayed after a page reload. Asked again for rows still being closed (a reload mid-close), the gateway answers `applied`: that close answers for them. Two cards naming one session share its close: the second waits for it and marks its row with the same outcome, never `a close is already in progress`. There is no `ledge close` for agents: only Ledge's chat closes sessions.
+
 Session names and tab titles: Ledge sets `set-titles` in `~/.ledge/tmux.conf`. A tmux server that is already running re-reads `tmux.conf` only after it restarts, so `set-titles` applies to new tmux servers. The tab string is `${name} · ${topic ?? project}`; `session.rename` from the overlay updates it.
 
 ## Tests

package/dist/cli/{attach-Y4OMZXAH.js → attach-5H727FCW.js}

@@ -1,14 +1,14 @@
 import {
   attachEnv
-} from "./chunk-4IBQ4PG6.js";
+} from "./chunk-MQICEVKR.js";
 import {
   connect
-} from "./chunk-PXO4FFJR.js";
-import "./chunk-KGEF6OIU.js";
+} from "./chunk-DEXDXDO4.js";
+import "./chunk-H36JD4E3.js";
 import {
   PROTOCOL_PORT,
   backendOf
-} from "./chunk-2LQITRTR.js";
+} from "./chunk-Q5WWH7FG.js";
 import {
   realTmux
 } from "./chunk-2H5FJH4Q.js";

package/dist/cli/{bridge-6K523KUX.js → bridge-LXMOQN6Q.js}

@@ -7,7 +7,7 @@ import {
   parseClientMessage,
   parseServerMessage,
   readDaemonToken
-} from "./chunk-2LQITRTR.js";
+} from "./chunk-Q5WWH7FG.js";
 import "./chunk-R5462SQM.js";
 
 // src/cli/bridge.ts

package/dist/cli/chunk-CBKKOJIG.js

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

package/dist/cli/{chunk-CU2E3W4L.js → chunk-DBSCO3HI.js}

@@ -1,7 +1,10 @@
+import {
+  ledgeTitleRest
+} from "./chunk-H36JD4E3.js";
 import {
   cleanTopic,
   sessionTitle
-} from "./chunk-2LQITRTR.js";
+} from "./chunk-Q5WWH7FG.js";
 
 // src/daemon/crossSession.ts
 var FIRST_LINE = /^Another Claude session sent a message:\s*\n/;
@@ -21,14 +24,21 @@ function crossSession(text) {
 }
 var LEDGE_CLOSE = "</ledge-message>";
 var LEDGE_BLOCK = /^<ledge-message\b([^>]*)>([\s\S]*?)(?:<\/ledge-message>|$)/;
-var note = (from, to) => `(message de la session ${from}, pas de l'utilisateur ; pour r\xE9pondre : ${to === "codex" ? `ledge send ${from} "\u2026"` : `SendMessage vers ${from}`})`;
+var messageNote = (from, to) => `(message de la session ${from}, pas de l'utilisateur ; pour r\xE9pondre : ${to === "codex" ? `ledge send ${from} "\u2026"` : `SendMessage vers ${from}`})`;
+var NOTE_SENDER = /^\(message de la session (.+?), pas de l'utilisateur ; /;
+function stripNote(text) {
+  const body = text.trimStart();
+  const sender = NOTE_SENDER.exec(body)?.[1];
+  const lead = sender === void 0 ? void 0 : [messageNote(sender, "codex"), messageNote(sender, "claude")].find((n) => body.startsWith(n));
+  return lead ? { sender, text: body.slice(lead.length).trim() } : { text };
+}
 var ESCAPES = /\x1b(?:\[[0-?]*[ -/]*[@-~]|[\]PX^_][^\x07\x1b]*(?:\x07|\x1b\\)|[ -/]*[0-~])/g;
 var CONTROLS = /[\x00-\x1f\x7f-\x9f]/g;
 var typable = (text, newline) => text.replace(ESCAPES, "").replace(/\r\n|\r|\n/g, newline).replace(CONTROLS, " ");
 var ledgeBody = (text) => typable(text.replaceAll("<", "\u2039"), " \u23CE ");
 function formatLedgeMessage(m) {
   const from = typable(m.from, " ").replace(/["<>]/g, "").trim();
-  return `<ledge-message from="${from}" tool="${m.tool}">${note(from, m.to)} ${ledgeBody(m.text)}${LEDGE_CLOSE}`;
+  return `<ledge-message from="${from}" tool="${m.tool}">${messageNote(from, m.to)} ${ledgeBody(m.text)}${LEDGE_CLOSE}`;
 }
 function ledgeMessages(text) {
   const m = LEDGE_BLOCK.exec(text.trimStart());
@@ -37,9 +47,7 @@ function ledgeMessages(text) {
   const from = attrs.get("from");
   const tool = attrs.get("tool");
   if (!from) return void 0;
-  const body = m[2].trimStart();
-  const lead = [note(from, "codex"), note(from, "claude")].find((n) => body.startsWith(n));
-  return [{ from, ...tool ? { tool } : {}, text: (lead ? body.slice(lead.length) : body).trim() }];
+  return [{ from, ...tool ? { tool } : {}, text: stripNote(m[2]).text.trim() }];
 }
 var NOTICE_HEAD = /^\[Cross-session ([\w -]+?) notice\]/;
 var NOTICE_SPLIT = /\n\s*(?=\[Cross-session [\w -]+? notice\])/;
@@ -315,8 +323,13 @@ function reduceEvent(s, ev) {
       return { ...s, state: "exited", pending: void 0, exitCode: null, exitedAt: s.exitedAt ?? at, lastActivityAt: at };
     case "PaneChanged":
       return s.lastActivityAt === at ? s : { ...s, lastActivityAt: at };
-    case "PaneTitle":
-      return s.topicSource === "user" ? s : withTopic(s, ev.text ?? "", "pane");
+    case "PaneTitle": {
+      if (s.topicSource === "user") return s;
+      const t = ev.text ?? "";
+      const rest = ledgeTitleRest(t, s.name);
+      if (rest === "") return s.topicSource === "pane" && s.topic !== void 0 && ledgeTitleRest(s.topic, s.name) === "" ? withTopic(s, "", void 0) : s;
+      return withTopic(s, rest ?? t, "pane");
+    }
     case "Renamed":
       return withTopic(s, ev.text ?? "", ev.text?.trim() ? "user" : void 0);
     case "PaneIdle": {
@@ -356,9 +369,10 @@ function reduceEvent(s, ev) {
     case "PanePrompt": {
       const incoming = pendingFor(ev);
       const moved = s.pending?.source === "hook" && s.pending.kind === "question" && incoming.kind === "question" && !sameQuestion(incoming.text, s.pending.text);
-      if (s.pending?.source === "hook" && !moved) return s;
+      const bare = s.pending?.source === "hook" && s.pending.kind === "permission" && !s.pending.tool;
+      if (s.pending?.source === "hook" && !moved && !bare) return s;
       if (!moved && hooksReportPrompts(s) && lastHookAt && Date.parse(at) - Date.parse(lastHookAt) < HOOK_PRIORITY_MS) return s;
-      let pending = moved ? { ...incoming, ...s.pending.helperId ? { helperId: s.pending.helperId } : {} } : mergePending(s.pending, incoming);
+      let pending = moved ? { ...incoming, ...s.pending.helperId ? { helperId: s.pending.helperId } : {} } : bare ? incoming : mergePending(s.pending, incoming);
       if (pending.kind === "plan" && !pending.body && s.tool === "codex" && s.lastReply) pending = { ...pending, body: s.lastReply.text };
       if (s.pending && samePending(s.pending, pending)) return s;
       const state = pending.kind === "question" ? "waiting_input" : "waiting_permission";
@@ -454,37 +468,61 @@ function parsePeer(path) {
     return void 0;
   }
 }
-function readPeers(dir = defaultDir()) {
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function readPeers(dir = defaultDir(), alive = pidAlive) {
   let names;
   try {
     names = readdirSync(dir);
   } catch {
     return [];
   }
-  return names.filter((n) => n.endsWith(".json")).flatMap((n) => parsePeer(join(dir, n)) ?? []);
+  return names.filter((n) => n.endsWith(".json")).flatMap((n) => parsePeer(join(dir, n)) ?? []).filter((p) => alive(p.pid));
+}
+function addressOf(s, peers) {
+  const t = s.transcriptPath && basename2(s.transcriptPath, ".jsonl");
+  const byTranscript = t ? peers.filter((p) => p.sessionId === t) : [];
+  const found = byTranscript.length ? byTranscript : peers.filter((p) => s.agentSessionId && p.sessionId === s.agentSessionId);
+  return found.length === 1 ? found[0].address : void 0;
 }
 var bareName = (name) => name.replace(/ \[[^\]]*\]$/, "");
-function peerFor(target, peers, sessions, dir = defaultDir()) {
-  const name = bareName(target);
-  const found = peers.filter((p) => p.name === name || p.address === name);
-  if (!found.length && name.startsWith("uds:") && name.endsWith(".sock")) {
-    const pid = basename2(name, ".sock");
-    const direct = /^\d+$/.test(pid) ? parsePeer(join(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;
+var sessionOf = (id, sessions) => sessions.find((s) => s.agentSessionId === id || s.transcriptPath?.endsWith(`/${id}.jsonl`));
+function lookup(to, sessions, peers) {
+  const name = bareName(to);
+  if (name.startsWith("uds:")) {
+    const via = peers.find((p) => p.address === name);
+    return { target: via && sessionOf(via.sessionId, sessions), via };
   }
-  return void 0;
+  const t = sessions.find((s) => s.name === name && s.state !== "exited" && !s.archivedAt);
+  if (t) return { target: t };
+  const named = peers.filter((p) => p.name === name);
+  if (named.length > 1) return { reason: `plusieurs sessions s'appellent ${name}` };
+  return { target: named[0] && sessionOf(named[0].sessionId, sessions) };
 }
 function ledgePeer(target, peers, sessions) {
-  const name = bareName(target);
-  return peerFor(target, peers, sessions) ?? sessions.find((s) => s.name === name && s.state !== "exited");
+  return lookup(target, sessions, peers).target;
+}
+function resolveTarget(to, sessions, peers) {
+  const { target: t, via, reason } = lookup(to, sessions, peers);
+  if (reason) return { outcome: "refused", reason };
+  if (!t) return { outcome: "unknown" };
+  if (t.source === "hook_only") return { outcome: "refused", reason: `${t.name} n'a pas \xE9t\xE9 lanc\xE9e par Ledge : impossible de lui \xE9crire` };
+  if (t.tool !== "claude") return { outcome: "ledge", target: t };
+  const address = via?.address ?? addressOf(t, peers);
+  return address ? { outcome: "native", target: t, address } : { outcome: "refused", reason: `${t.name} n'est pas joignable` };
 }
 
 export {
   crossSession,
+  messageNote,
+  stripNote,
   ledgeBody,
   formatLedgeMessage,
   ledgeMessages,
@@ -507,5 +545,6 @@ export {
   gitSummary,
   readPeers,
   bareName,
-  ledgePeer
+  ledgePeer,
+  resolveTarget
 };

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

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

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

@@ -1,14 +1,25 @@
 import {
+  NAMES,
   pickName
-} from "./chunk-2LQITRTR.js";
+} from "./chunk-Q5WWH7FG.js";
 import {
   paths
 } from "./chunk-R5462SQM.js";
 
 // src/daemon/transcript.ts
-import { closeSync, fstatSync, openSync, readSync } from "fs";
+import { appendFileSync, closeSync, fstatSync, openSync, readFileSync, readSync, statSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { basename, join } from "path";
+
+// src/names.ts
+var ledgeShaped = (n, own) => n === own || NAMES.includes(n.replace(/-\d+$/, ""));
+function ledgeTitleRest(title, own) {
+  if (ledgeShaped(title, own)) return "";
+  const i = title.startsWith(`${own} - `) ? own.length : title.indexOf(" - ");
+  return i > 0 && ledgeShaped(title.slice(0, i), own) ? title.slice(i + 3).trim() : void 0;
+}
+
+// src/daemon/transcript.ts
 var TAIL_BYTES = 512 * 1024;
 function tailLines(path, bytes = TAIL_BYTES) {
   let fd;
@@ -122,9 +133,50 @@ function claudeOpenCall(path, tool) {
 function claudeToolAnswered(path, id) {
   return claudeCalls(path).some((c) => c.id === id && c.answered);
 }
+var LABEL_MAX = 80;
+function resumeLabel(name, topic) {
+  const label = `${name} - ${topic}`.replace(/\s+/g, " ").trim();
+  return label.length > LABEL_MAX ? `${label.slice(0, LABEL_MAX - 1)}\u2026` : label;
+}
+function lastTitle(lines) {
+  let last;
+  for (const line of lines) {
+    if (!line.includes('"custom-title"')) continue;
+    try {
+      const e = JSON.parse(line);
+      if (e.type === "custom-title" && typeof e.customTitle === "string") last = { customTitle: e.customTitle, ledge: e.ledge };
+    } catch {
+    }
+  }
+  return last;
+}
+var ledgeOwned = (t, name) => t.ledge === true || t.customTitle.startsWith(`${name} - `) || ledgeTitleRest(t.customTitle, name) === "";
+function labelTranscript(path, name, label) {
+  try {
+    const last = lastTitle(tailLines(path)) ?? (statSync(path).size > TAIL_BYTES ? lastTitle(readFileSync(path, "utf8").split("\n")) : void 0);
+    if (last && (last.customTitle === label || !ledgeOwned(last, name))) return false;
+    const fd = openSync(path, "r");
+    let lead = "";
+    try {
+      const size = fstatSync(fd).size;
+      if (size > 0) {
+        const b = Buffer.alloc(1);
+        readSync(fd, b, 0, 1, size - 1);
+        if (b[0] !== 10) lead = "\n";
+      }
+    } finally {
+      closeSync(fd);
+    }
+    appendFileSync(path, `${lead}${JSON.stringify({ type: "custom-title", customTitle: label, sessionId: basename(path, ".jsonl"), ledge: true })}
+`);
+    return true;
+  } catch (e) {
+    return e instanceof Error ? e : new Error(String(e));
+  }
+}
 
 // src/spawn.ts
-import { basename, join as join2 } from "path";
+import { basename as basename2, join as join2 } from "path";
 import { randomBytes, randomUUID } from "crypto";
 var AGENT_BIN = { claude: "claude", codex: "codex", cursor: "cursor-agent", omp: "omp" };
 var CODEX_ENV_VAR = "LEDGE_CODEX_SESSION";
@@ -132,10 +184,6 @@ var CODEX_HOOK_VAR = "LEDGE_CODEX_HOOK_SESSION";
 function agentIdArgs(tool, id) {
   return tool === "codex" ? ["-c", `shell_environment_policy.set.${CODEX_HOOK_VAR}="${id}"`] : [];
 }
-var CLAUDE_OWN_NAME = /^(-n|--name)(=|$)/;
-function agentNameArgs(tool, name, args) {
-  return tool === "claude" && !args.some((a) => CLAUDE_OWN_NAME.test(a)) ? ["-n", name] : [];
-}
 var CLAUDE_OWN_SESSION = /^(--resume|-r|--continue|-c|--session-id|--fork-session)(=|$)/;
 function claudeSessionId(tool, args) {
   return tool === "claude" && !args.some((a) => CLAUDE_OWN_SESSION.test(a)) ? randomUUID() : void 0;
@@ -169,10 +217,10 @@ async function spawnSession(opts) {
     id = randomBytes(2).toString("hex");
   while (takenIds.has(id));
   const name = pickName(opts.taken.names, opts.name);
-  const project = basename(opts.cwd) || opts.cwd;
+  const project = basename2(opts.cwd) || opts.cwd;
   const tmuxSession = `ledge-${id}`;
   const agentSessionId = opts.command ? void 0 : claudeSessionId(opts.tool, opts.args);
-  const agent = opts.command ?? [AGENT_BIN[opts.tool], ...agentIdArgs(opts.tool, id), ...agentSessionId ? ["--session-id", agentSessionId] : [], ...agentNameArgs(opts.tool, name, opts.args), ...opts.args];
+  const agent = opts.command ?? [AGENT_BIN[opts.tool], ...agentIdArgs(opts.tool, id), ...agentSessionId ? ["--session-id", agentSessionId] : [], ...opts.args];
   const env = opts.env ?? process.env;
   const transcriptPath = agentSessionId ? claudeTranscriptPath(opts.cwd, agentSessionId, env) : void 0;
   const command = opts.recordExit ? ["sh", "-c", '"$@"; echo $? > "$0"', exitFile(id), ...agent] : agent;
@@ -182,11 +230,14 @@ async function spawnSession(opts) {
 }
 
 export {
+  ledgeTitleRest,
   agentMessages,
   codexPlan,
   claudePlan,
   claudeOpenCall,
   claudeToolAnswered,
+  resumeLabel,
+  labelTranscript,
   CODEX_ENV_VAR,
   CODEX_HOOK_VAR,
   exitFile,

package/dist/cli/{chunk-4IBQ4PG6.js → chunk-MQICEVKR.js}

@@ -1,14 +1,14 @@
 import {
   DaemonRefusedError,
   connect
-} from "./chunk-PXO4FFJR.js";
+} from "./chunk-DEXDXDO4.js";
 import {
   exitFile,
   spawnSession
-} from "./chunk-KGEF6OIU.js";
+} from "./chunk-H36JD4E3.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-2LQITRTR.js";
+} from "./chunk-Q5WWH7FG.js";
 import {
   realTmux
 } from "./chunk-2H5FJH4Q.js";

package/dist/cli/{chunk-2LQITRTR.js → chunk-Q5WWH7FG.js}

@@ -145,6 +145,15 @@ var ChatRelaySchema = z2.object({
   sentAt: z2.string().datetime().optional(),
   error: z2.string().optional()
 });
+var ChatCloseSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string(),
+  tool: ToolSchema,
+  closedAt: z2.string().datetime().optional(),
+  how: z2.enum(["exit", "killed"]).optional(),
+  error: z2.string().optional()
+});
+var ChatClosesSchema = z2.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
 var ChatProjectProposalSchema = z2.object({
   name: z2.string().min(1).max(80),
   description: z2.string().max(500).optional(),
@@ -165,6 +174,7 @@ var ChatTurnSchema = z2.object({
   proposal: ChatProposalSchema.optional(),
   proposals: ChatProposalsSchema.optional(),
   relay: ChatRelaySchema.optional(),
+  closes: ChatClosesSchema.optional(),
   projectProposal: ChatProjectProposalSchema.optional()
 });
 var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
@@ -396,10 +406,12 @@ var base = { id: z12.string().min(1), at: z12.string().datetime(), turn: z12.num
 var ThreadItemSchema = z12.discriminatedUnion("kind", [
   z12.object({ kind: z12.literal("prompt"), ...base, text: z12.string() }),
   z12.object({ kind: z12.literal("message"), ...base, text: z12.string() }),
-  /** `id` is the harness's tool_use_id when it gives one, so the result updates the same row. */
-  z12.object({ kind: z12.literal("tool"), ...base, tool: z12.string(), label: z12.string(), input: z12.string().optional(), output: z12.string().optional(), error: z12.string().optional(), status: ToolStatusSchema, durationMs: z12.number().nonnegative().optional(), files: z12.array(FileChangeSchema).default([]) }),
-  /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again. */
-  z12.object({ kind: z12.literal("permission"), ...base, tool: z12.string(), text: z12.string(), decision: z12.enum(["accept", "deny", "always", "unknown"]).optional() }),
+  /** `id` is the harness's tool_use_id when it gives one, so the result updates the same row; `byClose`: a question
+   *  dismissed by Ledge closing the session. */
+  z12.object({ kind: z12.literal("tool"), ...base, tool: z12.string(), label: z12.string(), input: z12.string().optional(), output: z12.string().optional(), error: z12.string().optional(), status: ToolStatusSchema, durationMs: z12.number().nonnegative().optional(), files: z12.array(FileChangeSchema).default([]), byClose: z12.literal(true).optional() }),
+  /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again;
+   *  `byClose`: denied by Ledge closing the session. */
+  z12.object({ kind: z12.literal("permission"), ...base, tool: z12.string(), text: z12.string(), decision: z12.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z12.literal(true).optional() }),
   z12.object({ kind: z12.literal("reply"), ...base, text: z12.string() }),
   z12.object({ kind: z12.literal("helper"), ...base, task: z12.string(), agentType: z12.string().optional(), state: z12.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, `via` set when Ledge's mailbox carries it. */
@@ -548,6 +560,8 @@ var SessionEventSchema = z15.object({
   transcriptPath: z15.string().optional(),
   /** Decided: what was chosen when the daemon knows it. */
   decision: DecisionSchema.optional(),
+  /** Decided: the request was refused by Ledge closing the session (its interrupt keys), not by the user's answer. */
+  byClose: z15.literal(true).optional(),
   /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
   agentSessionId: z15.string().optional()
 });
@@ -594,6 +608,8 @@ var ServerMessageSchema = z15.discriminatedUnion("type", [
   z15.object({ type: z15.literal("session.thread.item"), id: z15.string(), item: ThreadItemSchema }),
   /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
   z15.object({ type: z15.literal("session.launched"), id: z15.string() }),
+  /** Answer to the requester of a `session.close`, once per row closed: the session `id` and how it ended. */
+  z15.object({ type: z15.literal("session.closed"), qid: z15.string(), row: z15.number().int().min(0), id: z15.string(), how: z15.enum(["exit", "killed"]) }),
   z15.object({ type: z15.literal("recents"), recents: z15.array(RecentSchema) }),
   /** Answer to the requester of a `folder.list` or `folder.create`: `path` resolved (`~` expanded), `parent` null at the
    *  root, `entries` its subfolders by name (hidden ones left out). A failure keeps the asked path and says why in `error`,
@@ -612,7 +628,7 @@ var ServerMessageSchema = z15.discriminatedUnion("type", [
   /** The chat (spec 2026-10-11 §5): what Ledge reads, its words as they come, the final text, or why it stopped; the day's turns after each snapshot. */
   z15.object({ type: z15.literal("chat.step"), qid: z15.string(), step: ChatStepSchema }),
   z15.object({ type: z15.literal("chat.delta"), qid: z15.string(), text: z15.string() }),
-  z15.object({ type: z15.literal("chat.done"), qid: z15.string(), text: z15.string(), at: z15.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
+  z15.object({ type: z15.literal("chat.done"), qid: z15.string(), text: z15.string(), at: z15.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
   z15.object({ type: z15.literal("chat.error"), qid: z15.string(), message: z15.string() }),
   z15.object({ type: z15.literal("chat.history"), turns: z15.array(ChatTurnSchema) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
@@ -641,6 +657,7 @@ var ServerMessageSchema = z15.discriminatedUnion("type", [
 ]);
 var MESSAGE_MAX = 2e4;
 var SUMMARY_MAX = 500;
+var launchRows = z15.array(z15.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
 var ClientMessageSchema = z15.discriminatedUnion("type", [
   z15.object({ type: z15.literal("chat.route"), qid: z15.string().min(1).max(100), text: z15.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
   DocumentReadSchema,
@@ -660,7 +677,7 @@ var ClientMessageSchema = z15.discriminatedUnion("type", [
     continue: z15.boolean().optional(),
     qid: z15.string().min(1).optional(),
     /** With `qid`: the card's rows to launch (#24), indexes into the turn's `proposals`, each once; the first row without it. */
-    rows: z15.array(z15.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice").optional(),
+    rows: launchRows.optional(),
     /** Folders in addition to `cwd` (Claude: `--add-dir`); resolved like `cwd`. */
     dirs: z15.array(z15.string().min(1)).max(20).optional(),
     /** The agent's model and effort (#58), the agent's own default when left out; with `qid`, for every row launched. */
@@ -697,6 +714,8 @@ var ClientMessageSchema = z15.discriminatedUnion("type", [
   z15.object({ type: z15.literal("session.relay"), qid: z15.string().min(1) }),
   /** Takes the card's queued instruction back out of the queue. */
   z15.object({ type: z15.literal("session.relay.cancel"), qid: z15.string().min(1) }),
+  /** The chat's close card: closes the turn's sessions, `rows` (indexes into its `closes`) or all of them. */
+  z15.object({ type: z15.literal("session.close"), qid: z15.string().min(1), rows: launchRows.optional() }),
   /** `always` and `note` only where the harness offers them (`offers`); a note goes with `deny`, for the agent to read. */
   z15.object({
     type: z15.literal("session.decide"),
@@ -857,7 +876,8 @@ var ProjectBlockSchema = z16.object({
   repos: z16.array(z16.object({ path: z16.string().min(1).max(4096), why: z16.string().trim().min(1).max(200) })).min(1).max(50),
   addTo: z16.string().trim().max(80).optional()
 });
-var BLOCK = /```ledge-(session|relay|project)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
+var CloseBlockSchema = z16.object({ session: z16.string().trim().min(1) });
+var BLOCK = /```ledge-(session|relay|project|close)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
 function extractProposal(answer) {
   const found = [];
   const text = answer.replace(BLOCK, (_m, kind, body) => {
@@ -883,6 +903,14 @@ function parseRelayBlock(raw) {
     return null;
   }
 }
+function parseCloseBlock(raw) {
+  try {
+    const r = CloseBlockSchema.safeParse(JSON.parse(raw));
+    return r.success ? r.data : null;
+  } catch {
+    return null;
+  }
+}
 function parseProjectBlock(raw) {
   try {
     const r = ProjectBlockSchema.safeParse(JSON.parse(raw));
@@ -1084,7 +1112,7 @@ var AssertionSchema = z20.object({
   authenticatorData: B64U2.max(4096),
   signature: B64U2.max(1024)
 });
-var ConfirmPurposeSchema = z20.enum(["register", "decide", "launch"]);
+var ConfirmPurposeSchema = z20.enum(["register", "decide", "launch", "close"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
 var PhoneChatProposalSchema = z20.object({
   project: z20.string().max(80),
@@ -1102,6 +1130,14 @@ var PhoneChatRelaySchema = z20.object({
   sentAt: z20.string().datetime().optional(),
   failed: z20.literal(true).optional()
 }).strict();
+var PhoneChatCloseSchema = z20.object({
+  id: z20.string().min(1),
+  name: z20.string(),
+  tool: ToolSchema,
+  how: z20.enum(["exit", "killed"]).optional(),
+  closedAt: z20.string().datetime().optional(),
+  failed: z20.literal(true).optional()
+}).strict();
 var ChatErrorCodeSchema = z20.enum(["busy", "timeout", "cancelled", "failed"]);
 var PhoneChatTurnSchema = z20.object({
   qid: OperationIdSchema,
@@ -1113,11 +1149,13 @@ var PhoneChatTurnSchema = z20.object({
   error: ChatErrorCodeSchema.optional(),
   proposals: z20.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
   relay: PhoneChatRelaySchema.optional(),
+  closes: z20.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
   cut: z20.literal(true).optional()
 }).strict();
 var CHAT_HISTORY_BUDGET = 393216;
 var sessionId = z20.string().min(1).max(100);
 var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z20.string().min(1).max(64) });
+var CardRowsSchema = z20.array(z20.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
 var PhoneClientMessageSchema = z20.discriminatedUnion("type", [
   z20.object({ type: z20.literal("snapshot.request") }),
   z20.object({ type: z20.literal("session.thread"), id: sessionId }),
@@ -1171,7 +1209,8 @@ var PhoneClientMessageSchema = z20.discriminatedUnion("type", [
   z20.object({ type: z20.literal("chat.reset") }),
   z20.object({ type: z20.literal("chat.history") }),
   z20.object({ type: z20.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
-  z20.object({ type: z20.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: z20.array(z20.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice").optional(), assertion: AssertionSchema.optional() }),
+  z20.object({ type: z20.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z20.object({ type: z20.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
   /** Whether the phone's app is in front: a device that is visible gets no push. */
   z20.object({ type: z20.literal("presence"), visible: z20.boolean() })
 ]);
@@ -1345,10 +1384,12 @@ export {
   SUMMARY_MAX,
   parseClientMessage,
   parseServerMessage,
+  NAMES,
   pickName,
   extractProposal,
   parseProposalBlock,
   parseRelayBlock,
+  parseCloseBlock,
   parseProjectBlock,
   TOPIC_MAX,
   cleanTopic,

package/dist/cli/{chunk-IMSPQUFC.js → chunk-QJVODYJ5.js}

@@ -1,10 +1,10 @@
 import {
   connect,
   sendMessageAndAwaitAck
-} from "./chunk-PXO4FFJR.js";
+} from "./chunk-DEXDXDO4.js";
 import {
   CODEX_HOOK_VAR
-} from "./chunk-KGEF6OIU.js";
+} from "./chunk-H36JD4E3.js";
 
 // src/cli/send.ts
 import { randomUUID } from "crypto";