@paradow/ledge 0.15.0 → 0.16.0

package/dist/cli/{daemon-NIEJZDEC.js → daemon-HWAHX4RR.js}

@@ -26,8 +26,9 @@ import {
   readPeers,
   reduce,
   repositoryId,
-  shownCommand
-} from "./chunk-CU2E3W4L.js";
+  shownCommand,
+  stripNote
+} from "./chunk-DBSCO3HI.js";
 import {
   PARENT_AGENT_VARS,
   agentEnv,
@@ -35,8 +36,10 @@ import {
   claudeOpenCall,
   claudePlan,
   claudeToolAnswered,
+  labelTranscript,
+  resumeLabel,
   spawnSession
-} from "./chunk-KGEF6OIU.js";
+} from "./chunk-H36JD4E3.js";
 import {
   CHAT_HISTORY_BUDGET,
   DEFAULT_PROJECTS,
@@ -85,6 +88,7 @@ import {
   offers,
   padPlain,
   parseClientMessage,
+  parseCloseBlock,
   parseProjectBlock,
   parseProposalBlock,
   parseRelayBlock,
@@ -96,15 +100,15 @@ import {
   pushEndpointAllowed,
   requestAuthorized,
   selectDaemonProtocol
-} from "./chunk-2LQITRTR.js";
+} from "./chunk-Q5WWH7FG.js";
 import {
   LEDGE_VERSION
-} from "./chunk-EHHYRQWY.js";
+} from "./chunk-CBKKOJIG.js";
 import {
   SERVICE,
   inDaemonService,
   tmuxServerAtRisk
-} from "./chunk-DXVHFVJI.js";
+} from "./chunk-S4ANPQGA.js";
 import {
   realTmux,
   runFile
@@ -567,7 +571,8 @@ var History = class {
           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);
+            const { sender, text } = stripNote(m.text);
+            last = this.receive(id, { kind: "received", id: `recv-${turn + 1}-${i}`, at: ev.at, turn: turn + 1, from: sender ?? m.name ?? m.from, text }, { ...m, ...sender ? { sender } : {} });
           });
           return last;
         }
@@ -625,9 +630,13 @@ var History = class {
         return this.put(id, { kind: "permission", id: `perm-${ev.at}-${this.items(id).length}`, ...common, tool: ev.tool, text: ev.text });
       }
       case "Decided": {
-        if (!ev.decision) return void 0;
+        if (!ev.decision) {
+          if (!ev.byClose) return void 0;
+          const q = [...this.items(id)].reverse().find((i) => i.kind === "tool" && QUESTION_TOOLS.has(i.tool) && i.status === "running" && !i.helperId);
+          return q ? this.put(id, { ...q, status: "unknown", byClose: true }) : void 0;
+        }
         const perm = [...this.items(id)].reverse().find((i) => i.kind === "permission" && i.decision === void 0);
-        return perm && perm.kind === "permission" ? this.put(id, { ...perm, decision: ev.decision }) : void 0;
+        return perm && perm.kind === "permission" ? this.put(id, { ...perm, decision: ev.decision, ...ev.byClose ? { byClose: true } : {} }) : void 0;
       }
       case "AgentMessage": {
         if (!ev.messageId || !ev.text) return void 0;
@@ -697,7 +706,7 @@ var History = class {
     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 };
+    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" ? stripNote(input.message).text : "", status };
   }
   /** A notice as a thread item: the session it is about named, and its Ledge session when it is one. */
   noticeOf(n, common) {
@@ -718,7 +727,7 @@ var History = class {
    *  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. */
   receive(id, recv, m) {
-    const peer = this.peerOf(m.from) ?? (m.name ? this.peerOf(m.name) : void 0);
+    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");
@@ -964,9 +973,22 @@ function optionNumber(text, pending) {
 var FREE_ROW = /^Type something\.?$/;
 var NO_FREE_ROW = "no free-text row in this dialog, answer in the terminal";
 var CLEAR = [{ keys: ["C-u"] }];
+var REPLY_ENTER_DELAY_MS = 300;
+var send = (text) => [{ text }, { waitMs: REPLY_ENTER_DELAY_MS }, { keys: ["Enter"] }];
+function sentFrom(text) {
+  const head = text.replace(/\s+/g, "").slice(0, 40);
+  return (pane) => {
+    const lines = pane.split("\n").map((l) => l.replace(/\s+$/, ""));
+    const box = inputBox(lines);
+    if (!box) return true;
+    const draft = lines.slice(box.top + 1, box.bottom).join("").replace(/\s+/g, "").replace(/^❯/, "");
+    return !draft.includes("[Pastedtext#") && !(head && draft.startsWith(head));
+  };
+}
+var submit = (text, denied) => [...send(text), { until: sentFrom(text), ...denied ? { denied } : {} }];
 function rowPlan(n, text) {
   const row = new RegExp(`^\\s*\u276F\\s*${n}\\.\\s`, "m");
-  return [...digit(n), { until: (p) => row.test(p) }, ...CLEAR, { text }, { keys: ["Enter"] }];
+  return [...digit(n), { until: (p) => row.test(p) }, ...CLEAR, ...send(text)];
 }
 function freeTextPlan(text, pane) {
   const d = pane ? parseDialog(pane) : null;
@@ -993,7 +1015,7 @@ function notePlan(note, pane) {
   const d = pane ? parseDialog(pane) : null;
   const row = d?.kind === "plan" ? d.options.findIndex((o) => PLAN_NOTE_ROW.test(o)) : -1;
   if (row >= 0) return rowPlan(row + 1, text);
-  return [{ keys: ["Escape"] }, { until: atRest, denied: true }, ...CLEAR, { text }, { keys: ["Enter"] }];
+  return [{ keys: ["Escape"] }, { until: atRest, denied: true }, ...CLEAR, ...submit(text, true)];
 }
 var claudeAdapter = {
   tool: "claude",
@@ -1025,9 +1047,12 @@ var claudeAdapter = {
     const n = optionNumber(flat, pending);
     if (n !== null) return digit(n);
     if (pending?.kind === "question") return freeTextPlan(flat, pane);
-    return [{ text: flat }, { keys: ["Enter"] }];
+    return submit(flat);
   },
-  interruptKeys: () => ["Escape"]
+  interruptKeys: () => ["Escape"],
+  // `/exit` quits Claude Code 2.1.x, also after a typed draft was cleared with Ctrl+U (seen in tmux).
+  exitText: () => "/exit",
+  exitPlan: () => [...CLEAR, ...send("/exit")]
 };
 
 // src/adapters/codex.ts
@@ -1157,7 +1182,7 @@ function optionNumber2(options, re) {
   const i = options.findIndex((o) => re.test(o));
   return i < 0 ? null : i + 1;
 }
-var REPLY_ENTER_DELAY_MS = 300;
+var REPLY_ENTER_DELAY_MS2 = 300;
 var ALWAYS2 = /don['’]t ask again/i;
 function alwaysKeys(d) {
   const i = d?.kind === "approval" ? d.raw.findIndex((o) => ALWAYS2.test(o)) : -1;
@@ -1168,7 +1193,7 @@ function alwaysKeys(d) {
 function noteKeys(d, note) {
   if (d?.kind === "confirm") throw new Refusal(NO_NOTE, "not_offered");
   const no = d?.kind === "plan" ? optionNumber2(d.options, /^No\b/) : null;
-  return [...no ? digit2(no) : [{ keys: ["Escape"] }], { until: atRest2, denied: true }, { text: flatten(note) }, { waitMs: REPLY_ENTER_DELAY_MS }, { keys: ["Enter"] }];
+  return [...no ? digit2(no) : [{ keys: ["Escape"] }], { until: atRest2, denied: true }, { text: flatten(note) }, { waitMs: REPLY_ENTER_DELAY_MS2 }, { keys: ["Enter"] }];
 }
 var codexAdapter = {
   tool: "codex",
@@ -1199,10 +1224,14 @@ var codexAdapter = {
   replyPlan(text, pending) {
     const flat = flatten(text);
     if (pending?.kind === "question" && /^[1-9]$/.test(flat)) return digit2(Number(flat));
-    return [{ text: flat }, { waitMs: REPLY_ENTER_DELAY_MS }, { keys: ["Enter"] }];
+    return [{ text: flat }, { waitMs: REPLY_ENTER_DELAY_MS2 }, { keys: ["Enter"] }];
   },
   // Esc interrupts the turn; Ctrl+C clears the draft and a second one quits Codex.
-  interruptKeys: () => ["Escape"]
+  interruptKeys: () => ["Escape"],
+  // Codex 0.162, seen in tmux: Ctrl+U clears a typed draft, then `/exit` and `/quit` both quit it (a draft cleared that
+  // way does not stop either from quitting).
+  exitText: () => "/exit",
+  exitPlan: () => [{ keys: ["C-u"] }, { text: "/exit" }, { waitMs: REPLY_ENTER_DELAY_MS2 }, { keys: ["Enter"] }]
 };
 
 // src/adapters/cursor.ts
@@ -1392,6 +1421,7 @@ function notePlan2(lines, note) {
   if (parsePlan(lines)) return [{ text: "p" }, { until: (p) => REVISE.test(p) }, ...typeIt];
   return [{ text: "n" }, { until: inSkipField }, ...typeIt];
 }
+var EXIT_ENTER_DELAY_MS = 300;
 var cursorAdapter = {
   tool: "cursor",
   detectPrompt: detectPrompt3,
@@ -1420,7 +1450,12 @@ var cursorAdapter = {
     return [{ text: flat }, { until: typed(flat) }, { keys: ["Enter"] }];
   },
   // Ctrl-C aborts a running turn; at rest it only clears the input line, it never quits.
-  interruptKeys: () => ["C-c"]
+  interruptKeys: () => ["C-c"],
+  // Not run on the real CLI (its TUI asked for a login that could not be done here): `/exit` as the quit command is an assumption,
+  // not verified on the real CLI; the `killSession` fallback covers it if wrong. Ctrl-C at rest only clears the input line. No `until`
+  // (replyPlan's `typed` check): a pause lets the text land in the input before Enter.
+  exitText: () => "/exit",
+  exitPlan: () => [{ keys: ["C-c"] }, { text: "/exit" }, { waitMs: EXIT_ENTER_DELAY_MS }, { keys: ["Enter"] }]
 };
 
 // src/adapters/preview.ts
@@ -1501,6 +1536,11 @@ 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);
+      try {
+        opts.labelExited?.();
+      } catch (e) {
+        log(`resume labels failed: ${e.message}`);
+      }
       for (const snapshot of store.all()) {
         const s = store.get(snapshot.id);
         if (!s) continue;
@@ -3005,7 +3045,7 @@ function runJsonl(file, args, o, parse, onEvent, spawnImpl = nodeSpawn2) {
 var PERSONA = `Tu es Ledge, le compagnon qui veille sur les sessions d'agents (Claude Code, Codex, Cursor Agent, OMP) de l'utilisateur. Tu lis, tu ne touches \xE0 rien : seulement des commandes de lecture (cat, ls, rg\u2026), aucune commande qui modifie quoi que ce soit, pas d'\xE9criture, et tu n'envoies jamais rien toi-m\xEAme \xE0 une session.
 Tes sources : le dossier courant contient sessions.md (toutes les sessions, leur \xE9tat et le nom de leurs fichiers), pane-<id>.txt (les derni\xE8res lignes du terminal d'une session), reply-<id>.md (sa derni\xE8re r\xE9ponse), git-<id>.txt (status, log et diff --stat de son dossier) folders.md (les dossiers r\xE9cents o\xF9 l'utilisateur a lanc\xE9 des sessions) et, quand il existe, projects.md (les projets, leurs d\xE9p\xF4ts par machine et les dossiers rang\xE9s). Les d\xE9p\xF4ts eux-m\xEAmes sont lisibles, avec les outils de lecture de ton harnais, pour aller plus loin. Pour une question sur les issues, les pull/merge requests, la CI ou ce qui a \xE9t\xE9 merg\xE9, lis forge.md puis le forge-<projet>.md concern\xE9 : le daemon y a \xE9crit ce qu'il a lu de GitHub ou GitLab, avec l'heure de lecture, que tu cites. Si ce fichier manque, ou s'il dit que \`gh\`/\`glab\` est absent, non connect\xE9 ou que le d\xE9p\xF4t n'a pas de forge, dis que Ledge n'a pas acc\xE8s \xE0 cette forge au lieu de supposer.
 Commence toujours par lire sessions.md. Ne lis que ce que la question demande.
-R\xE9ponds dans la langue de la question, en 3 \xE0 10 lignes, en Markdown simple : paragraphes courts, listes \xE0 puces, \`code\` pour les commandes, fichiers et branches. Nomme chaque bot par son pr\xE9nom en gras (**Nova**) la premi\xE8re fois. Dis d'o\xF9 vient chaque fait et de quand il date quand cela compte. Si une information manque, dis-le au lieu de supposer. Tu n'agis jamais toi-m\xEAme ; tu peux lui dire quel bot ouvrir. Quand l'utilisateur demande explicitement d'ouvrir ou de lancer une session, et seulement si le dossier est s\xFBr \u2014 un chemin absolu lu dans sessions.md ou folders.md, ou donn\xE9 tel quel par l'utilisateur \u2014, r\xE9ponds en une ou deux lignes puis termine par un bloc \`\`\`ledge-session contenant {"cwd": "<chemin>", "prompt": "<l'instruction, s'il y en a une>"}. Si plusieurs dossiers conviennent ou aucun, ne mets pas de bloc : cite les candidats et demande lequel. Pour plusieurs sessions demand\xE9es d'un coup, \xE9cris une ligne par session puis un bloc \`\`\`ledge-session par session, 8 sessions au plus, avec la m\xEAme r\xE8gle pour chaque dossier : ne mets un bloc que pour les dossiers s\xFBrs, et pour chacun des autres cite les candidats et demande lequel. Quand l'utilisateur demande explicitement de dire, demander ou envoyer quelque chose \xE0 une session, et seulement si une seule session de sessions.md correspond et qu'elle n'est pas en lecture seule, r\xE9ponds en une ou deux lignes puis termine par un bloc \`\`\`ledge-relay contenant {"session": "<id>", "text": "<l'instruction, formul\xE9e pour l'agent>"}. Si plusieurs sessions conviennent ou aucune, ne mets pas de bloc : cite les candidats et demande laquelle. Tu ne proposes un projet que si l'utilisateur demande explicitement de cr\xE9er un projet ou d'en compl\xE9ter un : lis alors projects.md, puis \xE9cris une r\xE9ponse qui se suffit \xE0 elle-m\xEAme (le nom, chaque d\xE9p\xF4t et pourquoi ; rien n'est cr\xE9\xE9 avant sa validation) et termine par un bloc \`\`\`ledge-project contenant {"name": "<nom>", "description": "<une phrase>", "repos": [{"path": "<chemin absolu>", "why": "<pourquoi ce d\xE9p\xF4t>"}], "addTo": "<nom exact d'un projet de projects.md>"}. Ne cite que des chemins absolus lus dans sessions.md, folders.md ou projects.md : n'invente jamais de chemin. Pour compl\xE9ter un projet existant, mets son nom exact dans addTo ; pour un nouveau projet, omets addTo, et la description si tu n'en as pas. Ne propose pas un d\xE9p\xF4t qui appartient d\xE9j\xE0 \xE0 un projet de projects.md. Si aucun d\xE9p\xF4t ne convient, ne mets pas de bloc et dis-le.`;
+R\xE9ponds dans la langue de la question, en 3 \xE0 10 lignes, en Markdown simple : paragraphes courts, listes \xE0 puces, \`code\` pour les commandes, fichiers et branches. Nomme chaque bot par son pr\xE9nom en gras (**Nova**) la premi\xE8re fois. Dis d'o\xF9 vient chaque fait et de quand il date quand cela compte. Si une information manque, dis-le au lieu de supposer. Tu n'agis jamais toi-m\xEAme ; tu peux lui dire quel bot ouvrir. Quand l'utilisateur demande explicitement d'ouvrir ou de lancer une session, et seulement si le dossier est s\xFBr \u2014 un chemin absolu lu dans sessions.md ou folders.md, ou donn\xE9 tel quel par l'utilisateur \u2014, r\xE9ponds en une ou deux lignes puis termine par un bloc \`\`\`ledge-session contenant {"cwd": "<chemin>", "prompt": "<l'instruction, s'il y en a une>"}. Si plusieurs dossiers conviennent ou aucun, ne mets pas de bloc : cite les candidats et demande lequel. Pour plusieurs sessions demand\xE9es d'un coup, \xE9cris une ligne par session puis un bloc \`\`\`ledge-session par session, 8 sessions au plus, avec la m\xEAme r\xE8gle pour chaque dossier : ne mets un bloc que pour les dossiers s\xFBrs, et pour chacun des autres cite les candidats et demande lequel. Quand l'utilisateur demande explicitement de dire, demander ou envoyer quelque chose \xE0 une session, et seulement si une seule session de sessions.md correspond et qu'elle n'est pas en lecture seule, r\xE9ponds en une ou deux lignes puis termine par un bloc \`\`\`ledge-relay contenant {"session": "<id>", "text": "<l'instruction, formul\xE9e pour l'agent>"}. Si plusieurs sessions conviennent ou aucune, ne mets pas de bloc : cite les candidats et demande laquelle. Quand l'utilisateur demande explicitement de fermer, clore, arr\xEAter ou quitter une ou plusieurs sessions, r\xE9ponds en une ou deux lignes puis termine par un bloc \`\`\`ledge-close contenant {"session": "<id>"} par session, 8 au plus, et seulement pour les sessions de sessions.md qui correspondent sans ambigu\xEFt\xE9, qui ne sont pas en lecture seule et pas d\xE9j\xE0 termin\xE9es. Pour chacune des autres, cite les candidats et demande laquelle, ou dis pourquoi elle ne peut pas \xEAtre ferm\xE9e. La fermeture est propre et la conversation reste reprenable. Si l'utilisateur veut d'abord un point de reprise, propose seulement le relais de cette demande et dis-lui de demander la fermeture une fois les r\xE9ponses arriv\xE9es. Tu ne proposes un projet que si l'utilisateur demande explicitement de cr\xE9er un projet ou d'en compl\xE9ter un : lis alors projects.md, puis \xE9cris une r\xE9ponse qui se suffit \xE0 elle-m\xEAme (le nom, chaque d\xE9p\xF4t et pourquoi ; rien n'est cr\xE9\xE9 avant sa validation) et termine par un bloc \`\`\`ledge-project contenant {"name": "<nom>", "description": "<une phrase>", "repos": [{"path": "<chemin absolu>", "why": "<pourquoi ce d\xE9p\xF4t>"}], "addTo": "<nom exact d'un projet de projects.md>"}. Ne cite que des chemins absolus lus dans sessions.md, folders.md ou projects.md : n'invente jamais de chemin. Pour compl\xE9ter un projet existant, mets son nom exact dans addTo ; pour un nouveau projet, omets addTo, et la description si tu n'en as pas. Ne propose pas un d\xE9p\xF4t qui appartient d\xE9j\xE0 \xE0 un projet de projects.md. Si aucun d\xE9p\xF4t ne convient, ne mets pas de bloc et dis-le.`;
 function claudeArgs(o) {
   return [
     "-p",
@@ -3296,6 +3336,24 @@ function createChat(deps) {
     }
     return { id: s.id, name: s.name, tool: s.tool, text: block.text };
   }
+  function closesFrom(blocks, qid) {
+    const rows = [];
+    for (const { raw } of blocks) {
+      const block = parseCloseBlock(raw);
+      if (!block) {
+        log(`chat ${qid}: close ignored, invalid block: ${raw.slice(0, 200)}`);
+        continue;
+      }
+      const s = deps.store.get(block.session);
+      const why = !s ? "unknown session" : s.source === "hook_only" ? "read-only session" : s.state === "exited" ? "session has exited" : rows.some((r) => r.id === s.id) ? "duplicate session" : null;
+      if (why) {
+        log(`chat ${qid}: close ignored: ${why} ${block.session}`);
+        continue;
+      }
+      rows.push({ id: s.id, name: s.name, tool: s.tool });
+    }
+    return rows;
+  }
   async function projectFrom(raw, qid) {
     const block = parseProjectBlock(raw);
     if (!block) {
@@ -3390,6 +3448,9 @@ function createChat(deps) {
     }
     const proposal = proposals[0];
     const relay = kind === "relay" ? relayFrom(raw, turn.qid) : void 0;
+    const closeBlocks = kind === "close" ? blocks.filter((b) => b.kind === "close") : [];
+    if (closeBlocks.length > MAX_PROPOSALS) log(`chat ${turn.qid}: ${closeBlocks.length - MAX_PROPOSALS} sessions beyond ${MAX_PROPOSALS} ignored`);
+    const closes = closesFrom(closeBlocks.slice(0, MAX_PROPOSALS), turn.qid);
     const projectProposal = kind === "project" ? await projectFrom(raw, turn.qid) : void 0;
     turn.answer = text;
     turn.answeredAt = now();
@@ -3398,8 +3459,9 @@ function createChat(deps) {
       turn.proposals = proposals;
     }
     if (relay) turn.relay = relay;
+    if (closes.length > 0) turn.closes = closes;
     if (projectProposal) turn.projectProposal = projectProposal;
-    emit({ type: "chat.done", qid: turn.qid, text, at: turn.answeredAt, ...proposal ? { proposal, proposals } : {}, ...relay ? { relay } : {}, ...projectProposal ? { projectProposal } : {} });
+    emit({ type: "chat.done", qid: turn.qid, text, at: turn.answeredAt, ...proposal ? { proposal, proposals } : {}, ...relay ? { relay } : {}, ...closes.length > 0 ? { closes } : {}, ...projectProposal ? { projectProposal } : {} });
     return { ok: true };
   }
   return {
@@ -3432,6 +3494,26 @@ function createChat(deps) {
       t.relay = { id, name, tool, text, ...patch };
       emit({ type: "chat.history", turns });
     },
+    close: (qid, row) => {
+      rollDay();
+      return turnOf(qid)?.closes?.[row];
+    },
+    markClosed(qid, row, how, emit) {
+      const t = turnOf(qid);
+      const c = t?.closes?.[row];
+      if (!t || !c) return;
+      const next2 = { ...c, closedAt: now(), how };
+      delete next2.error;
+      t.closes = t.closes.map((r, i) => i === row ? next2 : r);
+      emit({ type: "chat.history", turns });
+    },
+    markCloseFailed(qid, row, message, emit) {
+      const t = turnOf(qid);
+      const c = t?.closes?.[row];
+      if (!t || !c) return;
+      t.closes = t.closes.map((r, i) => i === row ? { ...c, error: message } : r);
+      emit({ type: "chat.history", turns });
+    },
     // A roll caught here is silent otherwise: the overlays would keep showing yesterday's queued card.
     queuedRelays(emit) {
       if (rollDay()) emit?.({ type: "chat.history", turns });
@@ -3847,6 +3929,7 @@ function createRelay(d) {
   const now = d.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const typing = d.typing ?? /* @__PURE__ */ new Set();
   const sending = /* @__PURE__ */ new Set();
+  const open3 = (id) => free(d.store.get(id)) && !typing.has(id) && !d.closing?.has(id);
   const emitTo = (thread) => (m) => {
     try {
       d.threads.emitterOf(thread)?.(m);
@@ -3883,14 +3966,14 @@ function createRelay(d) {
   }
   function kick(id) {
     const q = queued().find((x) => x.relay.id === id);
-    if (!q || typing.has(id) || !free(d.store.get(id))) return;
+    if (!q || !open3(id)) return;
     void deliverAndKick(q.thread, q.qid, q.relay).catch((e) => log(`relay ${q.qid} failed: ${e.message}`));
   }
   async function deliverAndKick(thread, qid, r) {
     const refused = await deliver(thread, qid, r);
     if (refused) {
       if (queued().some((q) => q.relay.id === r.id)) kick(r.id);
-      else if (free(d.store.get(r.id)) && !typing.has(r.id)) d.next?.(r.id);
+      else if (open3(r.id)) d.next?.(r.id);
     }
     return refused;
   }
@@ -3907,7 +3990,7 @@ function createRelay(d) {
         }
         return;
       }
-      if (free(s) && !typing.has(id)) kick(id);
+      if (open3(id)) kick(id);
     } catch (e) {
       log(`relay change handler failed: ${e.message}`);
     }
@@ -3925,7 +4008,7 @@ function createRelay(d) {
         mark(thread, qid, { error: m });
         throw new Error(m);
       }
-      if (free(s) && !typing.has(r.id)) {
+      if (open3(r.id)) {
         if (queued().some((q) => q.relay.id === r.id)) {
           markQueued(thread, qid);
           kick(r.id);
@@ -3946,7 +4029,7 @@ function createRelay(d) {
     settle(id) {
       try {
         if (queued().some((q) => q.relay.id === id)) kick(id);
-        else if (free(d.store.get(id)) && !typing.has(id)) d.next?.(id);
+        else if (open3(id)) d.next?.(id);
       } catch (e) {
         log(`relay settle failed: ${e.message}`);
       }
@@ -3994,6 +4077,74 @@ async function launchFromChat(deps, qid, rows = [0]) {
   return { launched, failed };
 }
 
+// src/chat/close.ts
+var CloseRefused = class extends Error {
+  constructor(message, underWay = false) {
+    super(message);
+    this.underWay = underWay;
+  }
+  underWay;
+};
+async function closeFromChat(deps, qid, rows) {
+  const { chat, inFlight } = deps;
+  const safe = (m) => {
+    try {
+      deps.emit(m);
+    } catch (e) {
+      log(`close: emit failed: ${e.message}`);
+    }
+  };
+  const known = [...new Set(rows ?? [...Array(MAX_PROPOSALS).keys()])].filter((r) => chat.close(qid, r));
+  if (known.length === 0) throw new CloseRefused("unknown close");
+  const todo = known.filter((r) => !chat.close(qid, r).closedAt && !inFlight.has(`${qid}#${r}`));
+  if (todo.length === 0) throw new CloseRefused("already closed", known.some((r) => !chat.close(qid, r).closedAt));
+  for (const r of todo) inFlight.add(`${qid}#${r}`);
+  const closed = [];
+  const failed = [];
+  try {
+    await Promise.all(todo.map(async (r) => {
+      const { id } = chat.close(qid, r);
+      let how;
+      try {
+        ({ how } = await deps.close(id));
+      } catch (e) {
+        failed.push({ row: r, message: e.message });
+        chat.markCloseFailed(qid, r, e.message, safe);
+        return;
+      } finally {
+        inFlight.delete(`${qid}#${r}`);
+      }
+      closed.push({ row: r, id, how });
+      try {
+        chat.markClosed(qid, r, how, safe);
+      } catch (e) {
+        log(`close of ${id}: marking row ${r} failed: ${e.message}`);
+      }
+      try {
+        deps.onClosed?.(r, id, how);
+      } catch (e) {
+        log(`close of ${id}: onClosed failed: ${e.message}`);
+      }
+    }));
+  } finally {
+    for (const r of todo) inFlight.delete(`${qid}#${r}`);
+  }
+  const byRow = (a, b) => a.row - b.row;
+  return { closed: closed.sort(byRow), failed: failed.sort(byRow) };
+}
+function cardOf(threads, qid) {
+  const thread = threads.owner(qid);
+  const chat = thread && threads.all().find(([id]) => id === thread)?.[1];
+  if (!thread || !chat) return void 0;
+  return { thread, chat, emit: (m) => {
+    try {
+      threads.emitterOf(thread)?.(m);
+    } catch (e) {
+      log(`close: emit to ${thread} failed: ${e.message}`);
+    }
+  } };
+}
+
 // src/daemon/mailbox.ts
 var MAX_SEEN = 1e3;
 var PASSING = [
@@ -4007,7 +4158,7 @@ function createMailbox(d) {
   const now = d.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const queue = [];
   const seen = /* @__PURE__ */ new Map();
-  const ready = (id) => free(d.store.get(id)) && !d.typing.has(id) && !d.relayQueued(id);
+  const ready = (id) => free(d.store.get(id)) && !d.typing.has(id) && !d.closing?.has(id) && !d.relayQueued(id);
   async function deliver(m) {
     const s = d.store.get(m.target);
     if (!s) {
@@ -4255,6 +4406,16 @@ function toPhoneTurn(t) {
     const r = t.relay;
     out.relay = { id: r.id, name: r.name, tool: r.tool, text: r.text, ...r.status ? { status: r.status } : {}, ...r.sentAt ? { sentAt: r.sentAt } : {}, ...r.error !== void 0 ? { failed: true } : {} };
   }
+  if (t.closes) {
+    out.closes = t.closes.map((c) => ({
+      id: c.id,
+      name: c.name,
+      tool: c.tool,
+      ...c.how ? { how: c.how } : {},
+      ...c.closedAt ? { closedAt: c.closedAt } : {},
+      ...c.error !== void 0 ? { failed: true } : {}
+    }));
+  }
   return out;
 }
 var bytes = (v) => Buffer.byteLength(JSON.stringify(v), "utf8");
@@ -4266,14 +4427,14 @@ function toPhoneHistory(turns) {
   while (from < projected.length && total > CHAT_HISTORY_BUDGET) total -= sizes[from++] + 1;
   return projected.slice(from);
 }
-function phoneEmitter(send, chat, opts = {}) {
+function phoneEmitter(send2, chat, opts = {}) {
   const now = opts.now ?? Date.now;
   const throttleMs = opts.throttleMs ?? 250;
   const live2 = /* @__PURE__ */ new Map();
   const flushLive = (qid) => {
     const l = live2.get(qid);
     if (l && l.text !== l.sent) {
-      send({ type: "chat.delta", qid, text: l.text.slice(0, THREAD_TEXT_MAX) }, `chat.live:${qid}`);
+      send2({ type: "chat.delta", qid, text: l.text.slice(0, THREAD_TEXT_MAX) }, `chat.live:${qid}`);
       l.sent = l.text;
     }
   };
@@ -4290,8 +4451,8 @@ function phoneEmitter(send, chat, opts = {}) {
     flushLive(qid);
     live2.delete(qid);
     const turn = chat.history().find((t) => t.qid === qid);
-    if (turn) send({ type: "chat.done", qid, turn: toPhoneTurn(turn) });
-    else send({ type: "chat.error", qid, code: "failed" });
+    if (turn) send2({ type: "chat.done", qid, turn: toPhoneTurn(turn) });
+    else send2({ type: "chat.error", qid, code: "failed" });
   };
   const finished = /* @__PURE__ */ new Set();
   const finish = (qid) => {
@@ -4301,9 +4462,9 @@ function phoneEmitter(send, chat, opts = {}) {
   return (m) => {
     switch (m.type) {
       case "chat.history":
-        return send({ type: "chat.history", turns: toPhoneHistory(m.turns) }, "chat.history");
+        return send2({ type: "chat.history", turns: toPhoneHistory(m.turns) }, "chat.history");
       case "chat.step":
-        return send({ type: "chat.step", qid: m.qid, step: stepOf(m.step) });
+        return send2({ type: "chat.step", qid: m.qid, step: stepOf(m.step) });
       case "chat.delta": {
         if (finished.has(m.qid)) return;
         const l = live2.get(m.qid) ?? { text: "", sent: "", at: Number.NEGATIVE_INFINITY };
@@ -4335,13 +4496,13 @@ function phoneEmitter(send, chat, opts = {}) {
         live2.delete(m.qid);
         finish(m.qid);
         const code = errorCode2(m.message);
-        send({ type: "chat.error", qid: m.qid, code });
+        send2({ type: "chat.error", qid: m.qid, code });
         return code === "busy" ? void 0 : opts.onEnd?.({ qid: m.qid, code });
       }
       default: {
         const qid = m.qid;
         const turn = typeof qid === "string" ? chat.history().find((t) => t.qid === qid) : void 0;
-        if (turn) send({ type: "chat.done", qid: turn.qid, turn: toPhoneTurn(turn) });
+        if (turn) send2({ type: "chat.done", qid: turn.qid, turn: toPhoneTurn(turn) });
       }
     }
   };
@@ -5152,6 +5313,25 @@ function createPhoneGateway(deps) {
     const done = await deps.launchChat(`device:${deviceId}`, msg.qid, targets);
     return done.launched.length > 0 ? { status: "applied" } : { status: "failed" };
   };
+  const chatClose = async (deviceId, msg) => {
+    const turn = ownTurn(deviceId, msg.qid);
+    if (!turn || !deps.closeChat) return { status: "rejected", reason: "unknown_session" };
+    const closes = turn.closes;
+    const targets = msg.rows ?? (closes ? [...closes.keys()] : []);
+    if (!closes || targets.length === 0) return { status: "rejected", reason: "invalid" };
+    for (const r of targets) if (!closes[r]) return { status: "rejected", reason: "invalid" };
+    if (deps.credential(deviceId) === null) return { status: "rejected", reason: "confirm_required" };
+    if (targets.every((r) => closes[r].closedAt)) return { status: "failed" };
+    const refused = checkAssertion(deviceId, msg.assertion, "close", msg.qid);
+    if (refused) return refused;
+    try {
+      const done = await deps.closeChat(`device:${deviceId}`, msg.qid, targets);
+      return done.closed.length > 0 ? { status: "applied" } : { status: "failed" };
+    } catch (e) {
+      if (e instanceof CloseRefused) return { status: e.underWay ? "applied" : "failed" };
+      throw e;
+    }
+  };
   const run2 = async (deviceId, msg) => {
     if (msg.type === "credential.register") return register(deviceId, msg);
     if (msg.type === "device.forget") return { status: "applied" };
@@ -5166,6 +5346,7 @@ function createPhoneGateway(deps) {
     }
     if (msg.type === "chat.relay") return chatRelay(deviceId, msg);
     if (msg.type === "chat.launch") return chatLaunch(deviceId, msg);
+    if (msg.type === "chat.close") return chatClose(deviceId, msg);
     const refused = precheck(deviceId, msg);
     if (refused) return refused;
     const out = local(msg);
@@ -5269,18 +5450,30 @@ function createPhoneGateway(deps) {
           if (!live2(msg.id)) return push(deviceId, { type: "error", code: "unknown_session", request: msg.type });
           const cred = deps.credential(deviceId);
           if (!cred || cred.rpId !== rp.rpId) return invalid();
-          const challenge2 = deps.challenges.issue({ deviceId, purpose: "decide", subject: subjectOf(msg.id, msg.expect.key, live2(msg.id)) });
-          return push(deviceId, { type: "confirm.challenge", purpose: "decide", challenge: challenge2, rpId: rp.rpId, credentialId: cred.id, expiresInMs: CHALLENGE_TTL_MS });
+          const challenge = deps.challenges.issue({ deviceId, purpose: "decide", subject: subjectOf(msg.id, msg.expect.key, live2(msg.id)) });
+          return push(deviceId, { type: "confirm.challenge", purpose: "decide", challenge, rpId: rp.rpId, credentialId: cred.id, expiresInMs: CHALLENGE_TTL_MS });
         }
         if (msg.purpose === "launch") {
           if (msg.qid === void 0 || !ownTurn(deviceId, msg.qid)) return invalid();
           const cred = deps.credential(deviceId);
           if (!cred || cred.rpId !== rp.rpId) return invalid();
-          const challenge2 = deps.challenges.issue({ deviceId, purpose: "launch", subject: msg.qid });
-          return push(deviceId, { type: "confirm.challenge", purpose: "launch", challenge: challenge2, rpId: rp.rpId, credentialId: cred.id, expiresInMs: CHALLENGE_TTL_MS });
+          const challenge = deps.challenges.issue({ deviceId, purpose: "launch", subject: msg.qid });
+          return push(deviceId, { type: "confirm.challenge", purpose: "launch", challenge, rpId: rp.rpId, credentialId: cred.id, expiresInMs: CHALLENGE_TTL_MS });
+        }
+        if (msg.purpose === "close") {
+          if (msg.qid === void 0 || !ownTurn(deviceId, msg.qid)) return invalid();
+          const cred = deps.credential(deviceId);
+          if (!cred || cred.rpId !== rp.rpId) return invalid();
+          const challenge = deps.challenges.issue({ deviceId, purpose: "close", subject: msg.qid });
+          return push(deviceId, { type: "confirm.challenge", purpose: "close", challenge, rpId: rp.rpId, credentialId: cred.id, expiresInMs: CHALLENGE_TTL_MS });
+        }
+        if (msg.purpose === "register") {
+          const challenge = deps.challenges.issue({ deviceId, purpose: "register", subject: "" });
+          return push(deviceId, { type: "confirm.challenge", purpose: "register", challenge, rpId: rp.rpId, expiresInMs: CHALLENGE_TTL_MS });
         }
-        const challenge = deps.challenges.issue({ deviceId, purpose: "register", subject: "" });
-        return push(deviceId, { type: "confirm.challenge", purpose: "register", challenge, rpId: rp.rpId, expiresInMs: CHALLENGE_TTL_MS });
+        const unhandled = msg.purpose;
+        void unhandled;
+        return invalid();
       }
       case "session.read": {
         const s = live2(msg.id);
@@ -5307,7 +5500,7 @@ function createPhoneGateway(deps) {
       const request = typeof type === "string" && REQUEST_NAME.test(type) ? type : void 0;
       log2(`phone message refused: ${request ?? "?"}`);
       const op = OperationIdSchema.safeParse(raw?.op);
-      if ((request === "push.subscribe" || request === "chat.launch") && op.success && approved(deviceId)) return push(deviceId, { type: "operation.result", op: op.data, status: "rejected", reason: "invalid" });
+      if ((request === "push.subscribe" || request === "chat.launch" || request === "chat.close") && op.success && approved(deviceId)) return push(deviceId, { type: "operation.result", op: op.data, status: "rejected", reason: "invalid" });
       return push(deviceId, { type: "error", code: "invalid", ...request !== void 0 ? { request } : {} });
     }
     const msg = parsed.data;
@@ -5671,7 +5864,7 @@ async function startServer(opts) {
   const islandMsg = () => ({ type: "island", prefs: island });
   const mobile = opts.mobile;
   const unavailable = !mobile && opts.mobileUnavailable !== void 0 ? { enabled: false, relayUrl: DEFAULT_RELAY_URL, account: null, signin: null, signinError: null, link: { state: "unavailable", error: opts.mobileUnavailable.slice(0, 200) }, devices: [], pairings: [] } : void 0;
-  const send = (ws, msg) => {
+  const send2 = (ws, msg) => {
     if (ws.readyState === WebSocket2.OPEN) ws.send(JSON.stringify(msg));
   };
   const localClients = /* @__PURE__ */ new Set();
@@ -5679,7 +5872,7 @@ async function startServer(opts) {
   let gateway;
   let notifyChatEnd;
   const broadcast = (msg) => {
-    for (const c of localClients) send(c, msg);
+    for (const c of localClients) send2(c, msg);
     gateway?.forward(msg);
   };
   threads.setEmitter("desktop", broadcast);
@@ -5699,9 +5892,10 @@ async function startServer(opts) {
   ] : [];
   const unsubscribeMobile = mobile?.onChange(() => broadcast({ type: "mobile", state: mobile.state() }));
   const typing = /* @__PURE__ */ new Set();
-  const relayThreads = opts.chat ? {
+  const closing = /* @__PURE__ */ new Set();
+  const cardThreads = opts.chat ? {
     all: () => [["desktop", chat]],
-    owner: (qid) => chat.relay(qid) ? "desktop" : void 0,
+    owner: (qid) => chat.relay(qid) || chat.close(qid, 0) ? "desktop" : void 0,
     emitterOf: () => broadcast,
     queuedRelays: () => chat.queuedRelays(broadcast).map((q) => ({ thread: "desktop", ...q }))
   } : threads;
@@ -5710,15 +5904,38 @@ async function startServer(opts) {
     store,
     replyTo: replyText,
     typing,
+    closing,
     now,
-    relayQueued: (id) => relayThreads.queuedRelays().some((q) => q.relay.id === id),
+    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: relayThreads, store, replyTo: replyText, now, typing, next: (id) => mailbox.kick(id) });
+  const relay = createRelay({ threads: cardThreads, store, replyTo: replyText, now, typing, closing, next: (id) => mailbox.kick(id) });
   const previews = /* @__PURE__ */ new Map();
   const titles = /* @__PURE__ */ new Map();
+  const labelled = /* @__PURE__ */ new Map();
+  const unlabelled = /* @__PURE__ */ new Set();
+  const livePeers = opts.peers ?? (() => readPeers());
+  const labelExit = (s) => {
+    unlabelled.delete(s.id);
+    if (s.tool !== "claude" || s.source !== "launcher" || s.state !== "exited" || !s.transcriptPath || !s.topic || s.topic === s.name || labelled.get(s.id) === (s.exitedAt ?? "")) return;
+    const id = basename4(s.transcriptPath, ".jsonl");
+    if (livePeers().some((p) => p.sessionId === id)) {
+      unlabelled.add(s.id);
+      return;
+    }
+    labelled.set(s.id, s.exitedAt ?? "");
+    const r = labelTranscript(s.transcriptPath, s.name, resumeLabel(s.name, s.topic));
+    if (r instanceof Error) log(`resume label of ${s.id} not written: ${r.message}`);
+  };
+  const labelExited = () => {
+    for (const id of [...unlabelled]) {
+      const s = store.get(id);
+      if (s) labelExit(s);
+      else unlabelled.delete(id);
+    }
+  };
   const unsubscribe = store.onChange((c) => {
     if (c.type === "recents") return broadcast({ type: "recents", recents: c.recents });
     if (c.type === "updated" && c.session.tmuxSession && titles.get(c.session.id) !== c.session.title) {
@@ -5728,7 +5945,10 @@ async function startServer(opts) {
     if (c.type === "removed") {
       previews.delete(c.id);
       titles.delete(c.id);
+      labelled.delete(c.id);
+      unlabelled.delete(c.id);
     }
+    if (c.type === "updated") labelExit(c.session);
     if (c.type === "updated" && c.session.modelNext) void applyModelNext(c.session.id).catch((e) => log(`model change of ${c.session.id} failed: ${e.message}`));
     broadcast(c.type === "updated" ? { type: "session.updated", session: c.session } : { type: "session.removed", id: c.id });
   });
@@ -5867,10 +6087,83 @@ async function startServer(opts) {
     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" });
   }
+  const CLOSE_FREE_MS = opts.close?.freeMs ?? 1e4;
+  const CLOSE_EXIT_MS = opts.close?.exitMs ?? 15e3;
+  async function closeWait(id, ms, ok) {
+    for (const end = Date.now() + ms; ; ) {
+      const cur = store.get(id);
+      if (!cur || cur.state === "exited" && !typing.has(id)) return "gone";
+      if (ok(cur)) return "ok";
+      if (Date.now() >= end) return "timeout";
+      await new Promise((r) => setTimeout(r, UNTIL_POLL_MS));
+    }
+  }
+  async function closeSession(s) {
+    const id = s.id;
+    const cur = store.get(id);
+    if (!cur) throw unknownSession();
+    if (cur.source === "hook_only") throw readOnly();
+    if (cur.state === "exited") throw new Refusal("the session has already exited", "busy");
+    if (closing.has(id)) throw new Refusal("a close is already in progress", "busy");
+    closing.add(id);
+    try {
+      if (backendOf(cur) === "omp-rpc") {
+        await omp.close(id).catch((e) => log(`close of omp ${id} failed: ${e.message}`));
+        store.apply(id, { name: "PaneGone", at: now(), source: "daemon" });
+        return { how: "exit" };
+      }
+      const adapter = adapterFor(cur.tool);
+      const { tmuxSession: pane, pending } = cur;
+      if (!free(cur) && pane) {
+        const asked = pending && pendingKey(pending);
+        const sent = await tmux.sendKeys(pane, adapter.interruptKeys()).then(() => true, (e) => {
+          log(`close of ${id}: the interrupt failed: ${e.message}`);
+          return false;
+        });
+        const still = store.get(id)?.pending;
+        if (sent && pending && !pending.helperId && still && pendingKey(still) === asked) {
+          if (pending.kind === "question") store.apply(id, { name: "Decided", at: now(), source: "daemon", byClose: true });
+          else if (pending.source === "hook") store.apply(id, { name: "Decided", at: now(), source: "daemon", decision: "deny", byClose: true });
+        }
+      }
+      let why;
+      const idle = (x) => free(x) && !typing.has(id) && !inFlight.has(id);
+      const until = Date.now() + CLOSE_FREE_MS;
+      let freed = await closeWait(id, CLOSE_FREE_MS, idle);
+      while (freed === "ok" && !idle(store.get(id))) freed = await closeWait(id, Math.max(0, until - Date.now()), idle);
+      if (freed === "gone") return { how: "exit" };
+      if (freed === "timeout") why = `its prompt was not free after ${CLOSE_FREE_MS} ms`;
+      else {
+        let typed2 = true;
+        typing.add(id);
+        inFlight.add(id);
+        try {
+          await runPlan(store.get(id), adapter.exitPlan());
+        } catch (e) {
+          typed2 = false;
+          log(`close of ${id}: the exit command failed: ${e.message}`);
+        } finally {
+          typing.delete(id);
+          inFlight.delete(id);
+        }
+        why = typed2 ? `still running ${CLOSE_EXIT_MS} ms after its exit command` : "its exit command could not be typed";
+        if (typed2 && await closeWait(id, CLOSE_EXIT_MS, () => false) === "gone") return { how: "exit" };
+      }
+      const last = store.get(id);
+      if (!last || last.state === "exited") return { how: "exit" };
+      if (last.tmuxSession) await tmux.killSession(last.tmuxSession).catch((e) => log(`kill of ${last.tmuxSession} failed: ${e.message}`));
+      store.apply(id, { name: "PaneGone", at: now(), source: "daemon" });
+      log(`close of ${id}: killed (${why})`);
+      return { how: "killed" };
+    } finally {
+      closing.delete(id);
+    }
+  }
   async function replyTo(id, text, how = {}) {
     const s = store.get(id);
     if (!s) return unknownSession();
     if (s.source === "hook_only") return readOnly();
+    if (closing.has(id)) return new Refusal("the session is being closed", "busy");
     if (backendOf(s) === "omp-rpc") return replyOmp(s, text, how.steer === true);
     if (s.pending && s.pending.kind !== "question") return new Refusal(`a ${s.pending.kind} prompt takes accept or deny, not a reply`, "not_offered");
     if (text.trim() === "") return new Refusal("empty reply", "invalid");
@@ -5966,7 +6259,7 @@ async function startServer(opts) {
   }
   async function applyModelNext(id) {
     const s = store.get(id);
-    if (!s?.modelNext || !free(s) || typing.has(id) || relayThreads.queuedRelays().some((q) => q.relay.id === id)) return;
+    if (!s?.modelNext || !free(s) || typing.has(id) || closing.has(id) || cardThreads.queuedRelays().some((q) => q.relay.id === id)) return;
     if (backendOf(s) === "omp-rpc") return applyOmpModel(s);
     const key = resumeKey(s);
     if (!key || s.source !== "launcher") {
@@ -5988,6 +6281,21 @@ async function startServer(opts) {
     }
   }
   const chatLaunches = /* @__PURE__ */ new Set();
+  const chatCloses = /* @__PURE__ */ new Set();
+  const cardSessionCloses = /* @__PURE__ */ new Map();
+  function closeForCard(id) {
+    const running = cardSessionCloses.get(id);
+    if (running) return running;
+    const s = store.get(id);
+    if (!s) throw unknownSession();
+    const p = closeSession(s);
+    cardSessionCloses.set(id, p);
+    const done = () => {
+      if (cardSessionCloses.get(id) === p) cardSessionCloses.delete(id);
+    };
+    p.then(done, done);
+    return p;
+  }
   async function launch(req) {
     if (req.tool === "omp") return launchOmp(req);
     if (req.approval) throw new Error(`launch: ${req.tool} takes no approval mode`);
@@ -6280,6 +6588,27 @@ async function startServer(opts) {
         return relay.request(msg.qid);
       case "session.relay.cancel":
         return relay.cancel(msg.qid);
+      // A chat's close card (spec 2026-10-21 close §4), on the thread that holds the turn: each row closed answers the
+      // requester, the card's state reaches the thread's clients through chat.history. A failed row is the requester's one
+      // `error`, once every row has settled.
+      case "session.close": {
+        const card = cardOf(cardThreads, msg.qid);
+        if (!card) return refuse("unknown close");
+        try {
+          const done = await closeFromChat({
+            chat: card.chat,
+            emit: card.emit,
+            inFlight: chatCloses,
+            close: closeForCard,
+            onClosed: (row, id, how) => reply({ type: "session.closed", qid: msg.qid, row, id, how })
+          }, msg.qid, msg.rows);
+          if (done.failed.length > 0) throw new Error(done.failed[0].message);
+        } catch (e) {
+          if (e instanceof CloseRefused) return refuse(e.message);
+          throw e;
+        }
+        return;
+      }
       // Broadcast: every overlay shows the same progress, and the one that asked may be the one that reconnects.
       // A busy refusal goes to the asker only: it must not fail the flow the other overlays follow.
       case "update.daemon":
@@ -6354,6 +6683,16 @@ async function startServer(opts) {
         }
       }, qid, rows);
     },
+    closeChat: (thread, qid, rows) => {
+      const card = cardOf(cardThreads, qid);
+      if (!card || card.thread !== thread) return Promise.reject(new CloseRefused("unknown close"));
+      return closeFromChat({
+        chat: card.chat,
+        emit: card.emit,
+        inFlight: chatCloses,
+        close: closeForCard
+      }, qid, rows);
+    },
     onChatEnd: (deviceId, end) => notifyChatEnd?.(deviceId, end.code),
     version: opts.daemon?.version ?? "unknown",
     boot: randomUUID3(),
@@ -6396,14 +6735,14 @@ async function startServer(opts) {
       void agentEnv2().then((env) => {
         if (ws.readyState === WebSocket2.OPEN) (opts.ssh ?? serveSsh)(ws, alias, { env });
       }).catch((e) => {
-        send(ws, { type: "error", message: e.message });
+        send2(ws, { type: "error", message: e.message });
         ws.close(1011);
       });
       return;
     }
     localClients.add(ws);
     ws.once("close", () => localClients.delete(ws));
-    const reply = (m) => send(ws, m);
+    const reply = (m) => send2(ws, m);
     sendSnapshot(reply);
     ws.on("message", (data) => {
       let msg;
@@ -6425,6 +6764,11 @@ async function startServer(opts) {
     broadcast,
     preview,
     omp,
+    closeSession: (id) => {
+      const s = store.get(id);
+      return s ? closeSession(s) : Promise.reject(unknownSession());
+    },
+    labelExited,
     close: () => new Promise((res) => {
       unsubscribe();
       for (const u of unsubscribeHistory) u();
@@ -6480,35 +6824,35 @@ function createDaemonUpdater(deps) {
   return {
     running: () => busy,
     /** `reply` reaches only the asking client: a busy refusal must not fail the flow other overlays are following. */
-    async update(version, send, reply = send) {
+    async update(version, send2, reply = send2) {
       if (busy) return reply({ type: "update.failed", version, reason: "busy" });
       const info = deps.info();
       const cmd = npmCommand(deps.execPath ?? process.execPath, version);
       const shown = `${cmd.file} ${cmd.args.join(" ")}`;
-      if (info.install !== "npm") return send({ type: "update.failed", version, reason: "git-install", ...info.manual ? { command: info.manual } : {} });
-      if (!info.systemd) return send({ type: "update.failed", version, reason: "no-systemd", command: shown });
+      if (info.install !== "npm") return send2({ type: "update.failed", version, reason: "git-install", ...info.manual ? { command: info.manual } : {} });
+      if (!info.systemd) return send2({ type: "update.failed", version, reason: "no-systemd", command: shown });
       busy = true;
       try {
-        if (await deps.atRisk()) return send({ type: "update.failed", version, reason: "sessions-at-risk" });
-        send({ type: "update.progress", version, step: "installing" });
+        if (await deps.atRisk()) return send2({ type: "update.failed", version, reason: "sessions-at-risk" });
+        send2({ type: "update.progress", version, step: "installing" });
         log(`update: ${shown}`);
         const r = await deps.npm(cmd);
         if (r.code !== 0) {
           log(`update: npm failed (${r.code})
 ${r.output}`);
-          return send({ type: "update.failed", version, reason: "npm-failed", detail: lastLines(r.output), command: shown });
+          return send2({ type: "update.failed", version, reason: "npm-failed", detail: lastLines(r.output), command: shown });
         }
-        send({ type: "update.progress", version, step: "restarting" });
+        send2({ type: "update.progress", version, step: "restarting" });
         await deps.save();
         const code = await deps.restart();
         if (code !== 0) {
           log(`update: systemctl restart failed (${code})`);
-          return send({ type: "update.failed", version, reason: "no-systemd", command: RESTART_COMMAND });
+          return send2({ type: "update.failed", version, reason: "no-systemd", command: RESTART_COMMAND });
         }
         restarting = true;
       } catch (e) {
         log(`update: ${e.stack ?? String(e)}`);
-        send({ type: "update.failed", version, reason: "npm-failed", detail: e instanceof Error ? e.message : String(e) });
+        send2({ type: "update.failed", version, reason: "npm-failed", detail: e instanceof Error ? e.message : String(e) });
       } finally {
         if (!restarting) busy = false;
       }
@@ -7946,7 +8290,7 @@ async function startDaemon(opts = {}) {
   }
   const server = await startServer({ store, tmux, port: opts.port, daemon, updater, history, mobile, mobileUnavailable });
   ompLive = () => server.omp.liveCount();
-  const poller = startPoller({ store, tmux, broadcastPreview: server.preview });
+  const poller = startPoller({ store, tmux, broadcastPreview: server.preview, labelExited: server.labelExited });
   await writeFile7(paths().pid, String(process.pid));
   log(`daemon started on ${server.port} with ${store.all().length} sessions`);
   let stopping = null;