@paradow/ledge 0.3.2 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # @paradow/ledge (WSL side)
 
-The Ledge daemon and CLI: follow and answer your WSL agent sessions (Claude Code, Codex, Cursor Agent) from the Ledge island on Windows. See the [repository README](https://github.com/Paradow-dev/ledge#readme) for the whole picture.
+The Ledge daemon and CLI: follow and answer your WSL agent sessions (Claude Code, Codex, Cursor Agent) from the Ledge island on Windows. See the [repository README](https://github.com/Lyssaen/ledge#readme) for the whole picture.
 
 ## Install
 

package/dist/cli/{attach-YBGTDBQI.js → attach-IKK5XQGC.js}

@@ -1,17 +1,17 @@
 import {
   attachEnv
-} from "./chunk-Y44XZY6I.js";
+} from "./chunk-ZPR4LCDM.js";
 import {
   realTmux
-} from "./chunk-7ICDC2LK.js";
-import "./chunk-OUIDBDIH.js";
+} from "./chunk-DMV5VW4Q.js";
+import "./chunk-B73JDPSW.js";
 import "./chunk-6ZTCETRG.js";
 import {
   connect
-} from "./chunk-W5XAZ5IS.js";
+} from "./chunk-34DHZSGH.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-6GMDFIGB.js";
+} from "./chunk-YT4T7DL2.js";
 
 // src/cli/attach.ts
 import { spawn } from "child_process";

package/dist/cli/{chunk-W5XAZ5IS.js → chunk-34DHZSGH.js}

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

package/dist/cli/{chunk-ZPF5I3LS.js → chunk-5OJZV5MV.js}

@@ -1,7 +1,7 @@
 import {
   cleanTopic,
   sessionTitle
-} from "./chunk-6GMDFIGB.js";
+} from "./chunk-YT4T7DL2.js";
 
 // src/daemon/state.ts
 var HOOK_PRIORITY_MS = 2e3;

package/dist/cli/{chunk-OUIDBDIH.js → chunk-B73JDPSW.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-6ZTCETRG.js";
 import {
   pickName
-} from "./chunk-6GMDFIGB.js";
+} from "./chunk-YT4T7DL2.js";
 
 // src/log.ts
 import { appendFileSync } from "fs";

package/dist/cli/{chunk-7ICDC2LK.js → chunk-DMV5VW4Q.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./chunk-OUIDBDIH.js";
+} from "./chunk-B73JDPSW.js";
 import {
   paths
 } from "./chunk-6ZTCETRG.js";

package/dist/cli/chunk-Y74YLRHP.js

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

package/dist/cli/{chunk-6GMDFIGB.js → chunk-YT4T7DL2.js}

@@ -64,6 +64,23 @@ var ChatStepSchema = z2.object({
   name: z2.string().optional(),
   path: z2.string().optional()
 });
+var ChatProposalSchema = z2.object({
+  cwd: z2.string().min(1),
+  project: z2.string(),
+  prompt: z2.string().optional(),
+  tool: ToolSchema,
+  launchedId: z2.string().optional(),
+  error: z2.string().optional()
+});
+var ChatRelaySchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string(),
+  tool: ToolSchema,
+  text: z2.string().min(1),
+  status: z2.enum(["queued", "sent"]).optional(),
+  sentAt: z2.string().datetime().optional(),
+  error: z2.string().optional()
+});
 var ChatTurnSchema = z2.object({
   qid: z2.string().min(1),
   question: z2.string(),
@@ -71,7 +88,9 @@ var ChatTurnSchema = z2.object({
   steps: z2.array(ChatStepSchema),
   answer: z2.string().optional(),
   answeredAt: z2.string().datetime().optional(),
-  error: z2.string().optional()
+  error: z2.string().optional(),
+  proposal: ChatProposalSchema.optional(),
+  relay: ChatRelaySchema.optional()
 });
 
 // ../protocol/src/documents.ts
@@ -154,7 +173,7 @@ var ServerMessageSchema = z4.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. */
   z4.object({ type: z4.literal("chat.step"), qid: z4.string(), step: ChatStepSchema }),
   z4.object({ type: z4.literal("chat.delta"), qid: z4.string(), text: z4.string() }),
-  z4.object({ type: z4.literal("chat.done"), qid: z4.string(), text: z4.string(), at: z4.string().datetime() }),
+  z4.object({ type: z4.literal("chat.done"), qid: z4.string(), text: z4.string(), at: z4.string().datetime(), proposal: ChatProposalSchema.optional(), relay: ChatRelaySchema.optional() }),
   z4.object({ type: z4.literal("chat.error"), qid: z4.string(), message: z4.string() }),
   z4.object({ type: z4.literal("chat.history"), turns: z4.array(ChatTurnSchema) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
@@ -166,13 +185,18 @@ var ServerMessageSchema = z4.discriminatedUnion("type", [
 var ClientMessageSchema = z4.discriminatedUnion("type", [
   DocumentReadSchema,
   /** The overlay starts a session: `cwd` is a WSL path (`~` allowed), `name` a preferred bot name (the daemon picks a
-   *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation. */
-  z4.object({ type: z4.literal("session.launch"), tool: ToolSchema, cwd: z4.string().min(1), name: z4.string().optional(), prompt: z4.string().optional(), continue: z4.boolean().optional() }),
+   *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation.
+   *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields. */
+  z4.object({ type: z4.literal("session.launch"), tool: ToolSchema, cwd: z4.string().min(1), name: z4.string().optional(), prompt: z4.string().optional(), continue: z4.boolean().optional(), qid: z4.string().min(1).optional() }),
   /** The launch form's folder browser: list a folder's subfolders (home when no `path`), or make `name` inside `parent`
    *  and list it. Both are answered with a `folder.listing`. */
   z4.object({ type: z4.literal("folder.list"), path: z4.string().optional() }),
   z4.object({ type: z4.literal("folder.create"), parent: z4.string().min(1), name: z4.string().min(1) }),
   z4.object({ type: z4.literal("session.reply"), id: z4.string(), text: z4.string().min(1) }),
+  /** The chat card's instruction (spec 2026-10-12 relay §4): sent now if the session is free, else queued until it is. */
+  z4.object({ type: z4.literal("session.relay"), qid: z4.string().min(1) }),
+  /** Takes the card's queued instruction back out of the queue. */
+  z4.object({ type: z4.literal("session.relay.cancel"), qid: z4.string().min(1) }),
   z4.object({ type: z4.literal("session.decide"), id: z4.string(), decision: z4.enum(["accept", "deny"]) }),
   z4.object({ type: z4.literal("session.focus"), id: z4.string() }),
   z4.object({ type: z4.literal("session.kill"), id: z4.string() }),
@@ -282,6 +306,37 @@ function pickName(taken, preferred) {
   for (let i = 2; ; i++) if (free(`${NAMES[0]}-${i}`)) return `${NAMES[0]}-${i}`;
 }
 
+// ../protocol/src/proposal.ts
+import { z as z5 } from "zod";
+var ProposalBlockSchema = z5.object({ cwd: z5.string().trim().min(1), prompt: z5.string().optional() });
+var RelayBlockSchema = z5.object({ session: z5.string().trim().min(1), text: z5.string().trim().min(1) });
+var BLOCK = /```ledge-(session|relay)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
+function extractProposal(answer) {
+  const found = [];
+  const text = answer.replace(BLOCK, (_m, kind, body) => {
+    found.push({ kind, raw: body.trim() });
+    return "";
+  });
+  const last = found.at(-1);
+  return last ? { text: text.replace(/\n{3,}/g, "\n\n").trim(), kind: last.kind, raw: last.raw } : { text: answer, kind: null, raw: null };
+}
+function parseProposalBlock(raw) {
+  try {
+    const r = ProposalBlockSchema.safeParse(JSON.parse(raw));
+    return r.success ? r.data : null;
+  } catch {
+    return null;
+  }
+}
+function parseRelayBlock(raw) {
+  try {
+    const r = RelayBlockSchema.safeParse(JSON.parse(raw));
+    return r.success ? r.data : null;
+  } catch {
+    return null;
+  }
+}
+
 // ../protocol/src/topic.ts
 var TOPIC_MAX = 80;
 function cleanTopic(text) {
@@ -294,13 +349,16 @@ function sessionTitle(s) {
 }
 
 export {
-  DOCUMENT_MAX_BYTES,
   SessionSchema,
+  DOCUMENT_MAX_BYTES,
   PROTOCOL_PORT,
   RecentSchema,
   parseClientMessage,
   parseServerMessage,
   pickName,
+  extractProposal,
+  parseProposalBlock,
+  parseRelayBlock,
   cleanTopic,
   sessionTitle
 };

package/dist/cli/{chunk-Y44XZY6I.js → chunk-ZPR4LCDM.js}

@@ -1,20 +1,20 @@
 import {
   realTmux
-} from "./chunk-7ICDC2LK.js";
+} from "./chunk-DMV5VW4Q.js";
 import {
   exitFile,
   log,
   spawnSession
-} from "./chunk-OUIDBDIH.js";
+} from "./chunk-B73JDPSW.js";
 import {
   ensureLedgeDir
 } from "./chunk-6ZTCETRG.js";
 import {
   connect
-} from "./chunk-W5XAZ5IS.js";
+} from "./chunk-34DHZSGH.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-6GMDFIGB.js";
+} from "./chunk-YT4T7DL2.js";
 
 // src/cli/launch.ts
 import { spawn } from "child_process";

package/dist/cli/{daemon-R4YWK3YV.js → daemon-2KHF4XUC.js}

@@ -1,9 +1,9 @@
 import {
   reduce
-} from "./chunk-ZPF5I3LS.js";
+} from "./chunk-5OJZV5MV.js";
 import {
   LEDGE_VERSION
-} from "./chunk-JW5Y7ZLT.js";
+} from "./chunk-Y74YLRHP.js";
 import {
   SERVICE
 } from "./chunk-XDRYMOVF.js";
@@ -11,11 +11,11 @@ import {
   realTmux,
   run,
   runFile
-} from "./chunk-7ICDC2LK.js";
+} from "./chunk-DMV5VW4Q.js";
 import {
   log,
   spawnSession
-} from "./chunk-OUIDBDIH.js";
+} from "./chunk-B73JDPSW.js";
 import {
   ensureLedgeDir,
   paths
@@ -25,9 +25,12 @@ import {
   PROTOCOL_PORT,
   RecentSchema,
   SessionSchema,
+  extractProposal,
   parseClientMessage,
+  parseProposalBlock,
+  parseRelayBlock,
   pickName
-} from "./chunk-6GMDFIGB.js";
+} from "./chunk-YT4T7DL2.js";
 
 // src/daemon/index.ts
 import { writeFile as writeFile4, rm as rm3 } from "fs/promises";
@@ -154,7 +157,7 @@ var Store = class {
 };
 
 // src/daemon/server.ts
-import { basename as basename3 } from "path";
+import { basename as basename4 } from "path";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/adapters/claude.ts
@@ -976,7 +979,7 @@ function loginShellEnv(opts = {}) {
 // src/chat/service.ts
 import { randomUUID } from "crypto";
 import { mkdir as mkdir4, readFile as readFile2, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname4, join as join3 } from "path";
+import { basename as basename3, dirname as dirname4, join as join3 } from "path";
 
 // src/chat/context.ts
 import { mkdir as mkdir3, rm, writeFile as writeFile2 } from "fs/promises";
@@ -1005,6 +1008,7 @@ async function writeContext(dir, input) {
       `- repository: ${s.repo ?? s.project}${s.branch ? `, branch ${s.branch}${s.worktree ? " (linked worktree)" : ""}` : ""}`,
       `- started: ${s.startedAt}, last activity: ${s.lastActivityAt}`
     );
+    if (s.source === "hook_only") lines.push("- read-only: Ledge cannot send to it");
     if (s.pending) lines.push(`- pending ${s.pending.kind}: ${s.pending.text}`);
     const live = s.helpers.filter((h) => h.state !== "exited");
     if (live.length) lines.push(`- subagents: ${live.map((h) => h.task || h.kind).join("; ")}`);
@@ -1032,6 +1036,15 @@ async function writeContext(dir, input) {
   }
   await writeFile2(join2(dir, "sessions.md"), lines.join("\n"));
   steps.set("sessions.md", { kind: "sessions" });
+  const recents = input.recents ?? [];
+  await writeFile2(join2(dir, "folders.md"), [
+    "# Recent folders",
+    "",
+    "The folders the user started sessions in, most recent first.",
+    "",
+    ...recents.length ? recents.map((r) => `- ${r.project}: ${r.cwd} (last used ${r.lastAt})`) : ["- (none yet)"],
+    ""
+  ].join("\n"));
   const repoPaths = [...new Set(input.sessions.map((s) => s.repoPath ?? s.cwd).filter((p) => p && !coversHome(p)).map((p) => resolve3(p)))];
   return { dir, steps, repoPaths };
 }
@@ -1091,10 +1104,10 @@ function runJsonl(file, args, o, parse, onEvent, spawnImpl = nodeSpawn) {
 }
 
 // src/chat/claude.ts
-var PERSONA = `Tu es Ledge, le compagnon qui veille sur les sessions d'agents (Claude Code, Codex, Cursor Agent) de l'utilisateur. Tu lis, tu ne touches \xE0 rien : pas de commande, pas d'\xE9criture, jamais d'instruction envoy\xE9e \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) et git-<id>.txt (status, log et diff --stat de son dossier). Les d\xE9p\xF4ts eux-m\xEAmes sont lisibles (Read, Grep, Glob) pour aller plus loin.
+var PERSONA = `Tu es Ledge, le compagnon qui veille sur les sessions d'agents (Claude Code, Codex, Cursor Agent) 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) et folders.md (les dossiers r\xE9cents o\xF9 l'utilisateur a lanc\xE9 des sessions). Les d\xE9p\xF4ts eux-m\xEAmes sont lisibles, avec les outils de lecture de ton harnais, pour aller plus loin.
 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 ne proposes jamais d'agir \xE0 la place de l'utilisateur ; tu peux lui dire quel bot ouvrir.`;
+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. 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.`;
 function claudeArgs(o) {
   return [
     "-p",
@@ -1256,10 +1269,10 @@ function createChat(deps) {
   const CANCELLED = { ok: false, message: "cancelled", resumed: false };
   function rollDay() {
     const day = today();
-    if (turnsDay !== day) {
-      turns = [];
-      turnsDay = day;
-    }
+    if (turnsDay === day) return false;
+    turns = [];
+    turnsDay = day;
+    return true;
   }
   async function daySession(fresh, tool) {
     const day = today();
@@ -1282,6 +1295,44 @@ function createChat(deps) {
     return p === null ? null : p.split("\n");
   };
   const contextDir = join3(deps.home, "chat", "context");
+  async function proposalFrom(raw, tool, qid) {
+    const block = parseProposalBlock(raw);
+    if (!block) {
+      log(`chat ${qid}: proposal ignored, invalid block: ${raw.slice(0, 200)}`);
+      return void 0;
+    }
+    try {
+      const cwd = await resolveFolder(block.cwd, deps.userHome);
+      const prompt = block.prompt?.trim();
+      if (prompt?.startsWith("-")) {
+        log(`chat ${qid}: proposal ignored: prompt starts with "-"`);
+        return void 0;
+      }
+      return { cwd, project: basename3(cwd), tool, ...prompt ? { prompt } : {} };
+    } catch (e) {
+      log(`chat ${qid}: proposal ignored: ${e.message}`);
+      return void 0;
+    }
+  }
+  function relayFrom(raw, qid) {
+    const block = parseRelayBlock(raw);
+    if (!block) {
+      log(`chat ${qid}: relay ignored, invalid block: ${raw.slice(0, 200)}`);
+      return void 0;
+    }
+    if (block.text.trimStart().startsWith("!")) {
+      log(`chat ${qid}: relay ignored: bash-mode instruction ${block.session}`);
+      return void 0;
+    }
+    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" : null;
+    if (why) {
+      log(`chat ${qid}: relay ignored: ${why} ${block.session}`);
+      return void 0;
+    }
+    return { id: s.id, name: s.name, tool: s.tool, text: block.text };
+  }
+  const turnOf = (qid) => turns.find((t) => t.qid === qid);
   async function attempt(turn, emit, fresh, mine, tool) {
     try {
       return await run3(turn, emit, fresh, mine, tool);
@@ -1292,7 +1343,7 @@ function createChat(deps) {
     }
   }
   async function run3(turn, emit, fresh, mine, tool) {
-    const ctx = await writeContext(contextDir, { sessions: deps.store.all(), now: now(), capture, git: (cwd) => gitSummary(cwd) });
+    const ctx = await writeContext(contextDir, { sessions: deps.store.all(), recents: deps.store.recents(), now: now(), capture, git: (cwd) => gitSummary(cwd) });
     if (mine.cancelled) return CANCELLED;
     const { sessionId, resume } = await daySession(fresh, tool);
     const label2 = TOOL_LABEL[tool];
@@ -1331,13 +1382,49 @@ function createChat(deps) {
     if (timedOut) return { ok: false, message: `${label2} did not answer within 3 minutes`, resumed: false };
     if (r.code !== 0) return { ok: false, message: r.code === null ? `${label2} could not start: ${r.stderr.trim() || "not found in PATH"}` : r.stderr.trim() || `${label2} exited with code ${r.code}`, resumed: resume };
     if (resultError) return { ok: false, message: resultError, resumed: false };
-    turn.answer = answer;
+    const { text, kind, raw } = extractProposal(answer);
+    const proposal = kind === "session" ? await proposalFrom(raw, tool, turn.qid) : void 0;
+    const relay = kind === "relay" ? relayFrom(raw, turn.qid) : void 0;
+    turn.answer = text;
     turn.answeredAt = now();
-    emit({ type: "chat.done", qid: turn.qid, text: answer, at: turn.answeredAt });
+    if (proposal) turn.proposal = proposal;
+    if (relay) turn.relay = relay;
+    emit({ type: "chat.done", qid: turn.qid, text, at: turn.answeredAt, ...proposal ? { proposal } : {}, ...relay ? { relay } : {} });
     return { ok: true };
   }
   return {
     history: () => turns,
+    proposal: (qid) => turnOf(qid)?.proposal,
+    markLaunched(qid, id, emit) {
+      const t = turnOf(qid);
+      if (!t?.proposal) return;
+      const next = { ...t.proposal, launchedId: id };
+      delete next.error;
+      t.proposal = next;
+      emit({ type: "chat.history", turns });
+    },
+    markFailed(qid, message, emit) {
+      const t = turnOf(qid);
+      if (!t?.proposal) return;
+      t.proposal = { ...t.proposal, error: message };
+      emit({ type: "chat.history", turns });
+    },
+    relay: (qid) => {
+      rollDay();
+      return turnOf(qid)?.relay;
+    },
+    markRelay(qid, patch, emit) {
+      const t = turnOf(qid);
+      if (!t?.relay) return;
+      const { id, name, tool, text } = t.relay;
+      t.relay = { id, name, tool, text, ...patch };
+      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 });
+      return turns.flatMap((t) => t.relay?.status === "queued" ? [{ qid: t.qid, relay: t.relay }] : []);
+    },
     cancel(qid) {
       if (current?.qid === qid) {
         current.cancelled = true;
@@ -1447,6 +1534,88 @@ async function readDocument(request, context) {
   }
 }
 
+// src/daemon/relay.ts
+var free = (s) => !!s && (s.state === "idle" || s.state === "error") && !s.pending;
+var stopped = (name) => `${name} stopped before it got the instruction`;
+function createRelay(d) {
+  const now = d.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const typing = /* @__PURE__ */ new Set();
+  const sending = /* @__PURE__ */ new Set();
+  async function deliver(qid, r) {
+    typing.add(r.id);
+    sending.add(qid);
+    try {
+      let refused;
+      try {
+        refused = await d.replyTo(r.id, r.text);
+      } catch (e) {
+        refused = e.message;
+      }
+      if (refused) {
+        log(`relay ${qid} to ${r.id} failed: ${refused}`);
+        d.chat.markRelay(qid, { error: refused }, d.broadcast);
+      } else d.chat.markRelay(qid, { status: "sent", sentAt: now() }, d.broadcast);
+      return refused;
+    } finally {
+      typing.delete(r.id);
+      sending.delete(qid);
+    }
+  }
+  function kick(id) {
+    const q = d.chat.queuedRelays(d.broadcast).find((x) => x.relay.id === id);
+    if (!q || typing.has(id) || !free(d.store.get(id))) return;
+    void deliverAndKick(q.qid, q.relay).catch((e) => log(`relay ${q.qid} failed: ${e.message}`));
+  }
+  async function deliverAndKick(qid, r) {
+    const refused = await deliver(qid, r);
+    if (refused) kick(r.id);
+    return refused;
+  }
+  const unsubscribe = d.store.onChange((c) => {
+    if (c.type === "recents") return;
+    const id = c.type === "updated" ? c.session.id : c.id;
+    const queued = d.chat.queuedRelays(d.broadcast).filter((q) => q.relay.id === id);
+    if (queued.length === 0) return;
+    const s = c.type === "updated" ? c.session : void 0;
+    if (!s || s.state === "exited") {
+      for (const q of queued) if (!sending.has(q.qid)) d.chat.markRelay(q.qid, { error: stopped(q.relay.name) }, d.broadcast);
+      return;
+    }
+    if (free(s) && !typing.has(id)) kick(id);
+  });
+  return {
+    async request(qid) {
+      const r = d.chat.relay(qid);
+      if (!r) throw new Error("unknown relay");
+      if (r.status === "sent" || sending.has(qid)) throw new Error("already sent");
+      if (r.status === "queued") throw new Error("already queued");
+      const s = d.store.get(r.id);
+      if (!s || s.state === "exited") {
+        const m = stopped(r.name);
+        d.chat.markRelay(qid, { error: m }, d.broadcast);
+        throw new Error(m);
+      }
+      if (free(s) && !typing.has(r.id)) {
+        if (d.chat.queuedRelays().some((q) => q.relay.id === r.id)) {
+          d.chat.markRelay(qid, { status: "queued" }, d.broadcast);
+          kick(r.id);
+          return;
+        }
+        const refused = await deliverAndKick(qid, r);
+        if (refused) throw new Error(refused);
+        return;
+      }
+      d.chat.markRelay(qid, { status: "queued" }, d.broadcast);
+    },
+    cancel(qid) {
+      if (sending.has(qid)) throw new Error("already sent");
+      if (d.chat.relay(qid)?.status !== "queued") throw new Error("nothing queued");
+      d.chat.markRelay(qid, {}, d.broadcast);
+    },
+    close: unsubscribe
+  };
+}
+
 // src/daemon/server.ts
 var CONTINUE_ARGS = { claude: ["--continue"], codex: ["resume", "--last"], cursor: ["--continue"] };
 function launchArgs(msg) {
@@ -1476,7 +1645,7 @@ async function startServer(opts) {
   const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const launcher = opts.launcher ?? [process.execPath, process.argv[1] ?? "ledge"];
   const agentEnv = opts.agentEnv ?? (async () => ({ ...process.env, ...await loginShellEnv() }));
-  const chat = opts.chat ?? createChat({ store, tmux, home: paths().dir, env: agentEnv, bin: opts.claudeBin, now });
+  const chat = opts.chat ?? createChat({ store, tmux, home: paths().dir, userHome: opts.home, env: agentEnv, bin: opts.claudeBin, now });
   const wss = new WebSocketServer({
     host: opts.host ?? "127.0.0.1",
     port: opts.port ?? PROTOCOL_PORT,
@@ -1497,6 +1666,7 @@ async function startServer(opts) {
   const broadcast = (msg) => {
     for (const c of wss.clients) send(c, msg);
   };
+  const relay = createRelay({ chat, store, replyTo, broadcast, now });
   const previews = /* @__PURE__ */ new Map();
   const titles = /* @__PURE__ */ new Map();
   const unsubscribe = store.onChange((c) => {
@@ -1582,6 +1752,29 @@ async function startServer(opts) {
   const NO_PROMPT = "no prompt visible in the terminal, open the tab";
   const NOT_TAKEN = "the terminal did not take it";
   const FREE_TEXT = "free-text answers are not supported yet, answer in the terminal";
+  async function replyTo(id, text) {
+    const s = store.get(id);
+    if (!s) return "unknown session";
+    if (s.source === "hook_only") return READ_ONLY;
+    if (s.pending && s.pending.kind !== "question") return `a ${s.pending.kind} prompt takes accept or deny, not a reply`;
+    if (text.trim() === "") return "empty reply";
+    if (s.pending?.kind === "question" && !/^[1-9]$/.test(text.trim())) return FREE_TEXT;
+    const pending = s.pending;
+    const adapter = adapterFor(s.tool);
+    await injectAndVerify(id, (pane) => adapter.replyPlan(text, pending, pane || void 0), !!pending);
+    return null;
+  }
+  const chatLaunches = /* @__PURE__ */ new Set();
+  async function launch(req) {
+    const cwd = await resolveFolder(req.cwd, opts.home);
+    const live = store.all();
+    const env = await agentEnv();
+    const session = await spawnSession({ tool: req.tool, args: launchArgs(req), name: req.name, cwd, tmux, now, env, taken: { names: live.filter((s) => s.state !== "exited").map((s) => s.name), ids: live.map((s) => s.id) } });
+    store.upsert(session);
+    store.touchRecent(session.cwd, session.project, session.startedAt);
+    log(`launched ${session.name} (${session.tool}) in ${session.cwd} as ${session.id}`);
+    return session;
+  }
   async function handle(ws, msg) {
     switch (msg.type) {
       case "document.read": {
@@ -1618,14 +1811,23 @@ async function startServer(opts) {
         return;
       }
       case "session.launch": {
-        const cwd = await resolveFolder(msg.cwd, opts.home);
-        const live = store.all();
-        const env = await agentEnv();
-        const session = await spawnSession({ tool: msg.tool, args: launchArgs(msg), name: msg.name, cwd, tmux, now, env, taken: { names: live.filter((s) => s.state !== "exited").map((s) => s.name), ids: live.map((s) => s.id) } });
-        store.upsert(session);
-        store.touchRecent(session.cwd, session.project, session.startedAt);
-        log(`launched ${session.name} (${session.tool}) in ${session.cwd} as ${session.id}`);
-        return send(ws, { type: "session.launched", id: session.id });
+        if (msg.qid === void 0) return send(ws, { type: "session.launched", id: (await launch(msg)).id });
+        const qid = msg.qid;
+        const p = chat.proposal(qid);
+        if (!p) return send(ws, { type: "error", message: "unknown proposal" });
+        if (p.launchedId || chatLaunches.has(qid)) return send(ws, { type: "error", message: "already launched" });
+        chatLaunches.add(qid);
+        try {
+          const session = await launch({ tool: p.tool, cwd: p.cwd, prompt: p.prompt });
+          send(ws, { type: "session.launched", id: session.id });
+          chat.markLaunched(qid, session.id, broadcast);
+        } catch (e) {
+          chat.markFailed(qid, e.message, broadcast);
+          throw e;
+        } finally {
+          chatLaunches.delete(qid);
+        }
+        return;
       }
       case "folder.list":
         return send(ws, await listFolder(msg.path, opts.home));
@@ -1639,7 +1841,7 @@ async function startServer(opts) {
         if (!before) {
           const taken = store.all().map((s) => s.name);
           const cwd = msg.cwd ?? "";
-          const base = { id: msg.id, name: pickName(taken), tool: msg.agent ?? "claude", cwd, project: basename3(cwd) || "unknown", title: "untracked session", tmuxSession: null, state: "working", helpers: [], startedAt: msg.event.at, lastActivityAt: msg.event.at, source: "hook_only" };
+          const base = { id: msg.id, name: pickName(taken), tool: msg.agent ?? "claude", cwd, project: basename4(cwd) || "unknown", title: "untracked session", tmuxSession: null, state: "working", helpers: [], startedAt: msg.event.at, lastActivityAt: msg.event.at, source: "hook_only" };
           store.upsert(reduce(base, msg.event));
         } else store.apply(msg.id, msg.event);
         logDroppedRequest(msg.id, msg.event, before, store.get(msg.id));
@@ -1663,15 +1865,9 @@ async function startServer(opts) {
         return injectAndVerify(msg.id, (pane) => adapter.keysFor(msg.decision, pending, pane), true);
       }
       case "session.reply": {
-        const s = store.get(msg.id);
-        if (!s) return send(ws, { type: "error", id: msg.id, message: "unknown session" });
-        if (s.source === "hook_only") return send(ws, { type: "error", id: msg.id, message: READ_ONLY });
-        if (s.pending && s.pending.kind !== "question") return send(ws, { type: "error", id: msg.id, message: `a ${s.pending.kind} prompt takes accept or deny, not a reply` });
-        if (msg.text.trim() === "") return send(ws, { type: "error", id: msg.id, message: "empty reply" });
-        if (s.pending?.kind === "question" && !/^[1-9]$/.test(msg.text.trim())) return send(ws, { type: "error", id: msg.id, message: FREE_TEXT });
-        const pending = s.pending;
-        const adapter = adapterFor(s.tool);
-        return injectAndVerify(msg.id, (pane) => adapter.replyPlan(msg.text, pending, pane || void 0), !!pending);
+        const refused = await replyTo(msg.id, msg.text);
+        if (refused) send(ws, { type: "error", id: msg.id, message: refused });
+        return;
       }
       case "session.interrupt": {
         const s = store.get(msg.id);
@@ -1695,6 +1891,11 @@ async function startServer(opts) {
         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);
+      case "session.relay.cancel":
+        return relay.cancel(msg.qid);
       // 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":
@@ -1734,6 +1935,7 @@ async function startServer(opts) {
     preview,
     close: () => new Promise((res) => {
       unsubscribe();
+      relay.close();
       for (const c of wss.clients) c.terminate();
       wss.close(() => res());
     })

package/dist/cli/{hook-HP23ZISG.js → hook-QH44D3JC.js}

@@ -1,16 +1,16 @@
 import {
   QUESTION_TOOLS
-} from "./chunk-ZPF5I3LS.js";
+} from "./chunk-5OJZV5MV.js";
 import {
   CODEX_ENV_VAR,
   CODEX_HOOK_VAR,
   log
-} from "./chunk-OUIDBDIH.js";
+} from "./chunk-B73JDPSW.js";
 import "./chunk-6ZTCETRG.js";
 import {
   connect
-} from "./chunk-W5XAZ5IS.js";
-import "./chunk-6GMDFIGB.js";
+} from "./chunk-34DHZSGH.js";
+import "./chunk-YT4T7DL2.js";
 
 // src/cli/hook.ts
 import { readFileSync, openSync, fstatSync, readSync, closeSync } from "fs";

package/dist/cli/index.js

@@ -15,7 +15,7 @@ async function hookMain(args) {
   try {
     const chunks = [];
     for await (const c of process.stdin) chunks.push(c);
-    const { runHook } = await import("./hook-HP23ZISG.js");
+    const { runHook } = await import("./hook-QH44D3JC.js");
     await runHook(event, Buffer.concat(chunks).toString("utf8"), { tool });
   } catch {
   }
@@ -25,7 +25,7 @@ async function main(argv) {
   const [cmd, ...rest] = argv;
   switch (cmd) {
     case "daemon": {
-      const { startDaemon } = await import("./daemon-R4YWK3YV.js");
+      const { startDaemon } = await import("./daemon-2KHF4XUC.js");
       await startDaemon();
       await new Promise(() => {
       });
@@ -33,7 +33,7 @@ async function main(argv) {
     }
     case "--version":
     case "version": {
-      const { LEDGE_VERSION } = await import("./version-3OPYJ4FQ.js");
+      const { LEDGE_VERSION } = await import("./version-J6BW646U.js");
       console.log(LEDGE_VERSION);
       return 0;
     }
@@ -49,18 +49,18 @@ async function main(argv) {
       return r.ok ? 0 : 1;
     }
     case "status": {
-      const { printStatus } = await import("./status-IW2FESH4.js");
+      const { printStatus } = await import("./status-E2VZMTAF.js");
       console.log(await printStatus());
       return 0;
     }
     case "claude":
     case "codex":
     case "cursor": {
-      const { launch } = await import("./launch-DFB54ANN.js");
+      const { launch } = await import("./launch-CPNM5RX7.js");
       return launch(cmd, rest);
     }
     case "attach": {
-      const { attach } = await import("./attach-YBGTDBQI.js");
+      const { attach } = await import("./attach-IKK5XQGC.js");
       return attach(rest[0] ?? "");
     }
     default:

package/dist/cli/{launch-DFB54ANN.js → launch-CPNM5RX7.js}

@@ -5,15 +5,15 @@ import {
   ensureDaemon,
   launch,
   parseLaunchArgs
-} from "./chunk-Y44XZY6I.js";
-import "./chunk-7ICDC2LK.js";
+} from "./chunk-ZPR4LCDM.js";
+import "./chunk-DMV5VW4Q.js";
 import {
   agentEnv,
   exitFile
-} from "./chunk-OUIDBDIH.js";
+} from "./chunk-B73JDPSW.js";
 import "./chunk-6ZTCETRG.js";
-import "./chunk-W5XAZ5IS.js";
-import "./chunk-6GMDFIGB.js";
+import "./chunk-34DHZSGH.js";
+import "./chunk-YT4T7DL2.js";
 export {
   DaemonError,
   agentEnv,

package/dist/cli/{status-IW2FESH4.js → status-E2VZMTAF.js}

@@ -1,7 +1,7 @@
 import {
   connect
-} from "./chunk-W5XAZ5IS.js";
-import "./chunk-6GMDFIGB.js";
+} from "./chunk-34DHZSGH.js";
+import "./chunk-YT4T7DL2.js";
 
 // src/cli/status.ts
 async function printStatus(opts = {}) {

package/dist/cli/{version-3OPYJ4FQ.js → version-J6BW646U.js}

@@ -1,6 +1,6 @@
 import {
   LEDGE_VERSION
-} from "./chunk-JW5Y7ZLT.js";
+} from "./chunk-Y74YLRHP.js";
 export {
   LEDGE_VERSION
 };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@paradow/ledge",
-  "version": "0.3.2",
+  "version": "0.4.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" },
   "files": ["dist"],
   "engines": { "node": ">=22" },
-  "repository": { "type": "git", "url": "git+https://github.com/Paradow-dev/ledge.git", "directory": "packages/ledge" },
-  "homepage": "https://github.com/Paradow-dev/ledge#readme",
+  "repository": { "type": "git", "url": "git+https://github.com/Lyssaen/ledge.git", "directory": "packages/ledge" },
+  "homepage": "https://github.com/Lyssaen/ledge#readme",
   "license": "UNLICENSED",
   "publishConfig": { "access": "public", "provenance": true },
   "scripts": {

package/dist/cli/chunk-JW5Y7ZLT.js

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