@paradow/ledge 0.8.1 → 0.9.1

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

@@ -1,17 +1,18 @@
 import {
   attachEnv
-} from "./chunk-7AKUPFMS.js";
-import "./chunk-ZPANTZKC.js";
+} from "./chunk-65XGYBHL.js";
+import "./chunk-LYTRXJAQ.js";
 import {
   realTmux
-} from "./chunk-3TNPEAMR.js";
-import "./chunk-L6IGH4LF.js";
+} from "./chunk-TO4XO2ML.js";
+import "./chunk-YUSY3E47.js";
 import {
   connect
-} from "./chunk-6ZKNEJND.js";
+} from "./chunk-IWJAJAPK.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-KJWMK65Y.js";
+} from "./chunk-KDYAHPYN.js";
+import "./chunk-FGOFRWIB.js";
 
 // src/cli/attach.ts
 import { spawn } from "child_process";

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

@@ -5,14 +5,20 @@ import {
 import {
   PROTOCOL_PORT,
   parseClientMessage,
-  parseServerMessage
-} from "./chunk-KJWMK65Y.js";
+  parseServerMessage,
+  readDaemonToken
+} from "./chunk-KDYAHPYN.js";
+import "./chunk-FGOFRWIB.js";
 
 // src/cli/bridge.ts
 import WebSocket from "ws";
+function bearerHeaders() {
+  const token = readDaemonToken();
+  return token ? { authorization: `Bearer ${token}` } : {};
+}
 function bridge(opts = {}) {
   const input = opts.input ?? process.stdin, output = opts.output ?? process.stdout;
-  const ws = new WebSocket(`ws://127.0.0.1:${opts.port ?? PROTOCOL_PORT}`, { maxPayload: MAX_FRAME, handshakeTimeout: 1e4 });
+  const ws = new WebSocket(`ws://127.0.0.1:${opts.port ?? PROTOCOL_PORT}`, { maxPayload: MAX_FRAME, handshakeTimeout: 1e4, headers: bearerHeaders() });
   return new Promise((resolve, reject) => {
     let settled = false, off = () => {
     };

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

@@ -1,20 +1,23 @@
 import {
   exitFile,
   spawnSession
-} from "./chunk-ZPANTZKC.js";
+} from "./chunk-LYTRXJAQ.js";
 import {
   realTmux
-} from "./chunk-3TNPEAMR.js";
+} from "./chunk-TO4XO2ML.js";
 import {
-  ensureLedgeDir,
   log
-} from "./chunk-L6IGH4LF.js";
+} from "./chunk-YUSY3E47.js";
 import {
+  DaemonRefusedError,
   connect
-} from "./chunk-6ZKNEJND.js";
+} from "./chunk-IWJAJAPK.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-KJWMK65Y.js";
+} from "./chunk-KDYAHPYN.js";
+import {
+  ensureLedgeDir
+} from "./chunk-FGOFRWIB.js";
 
 // src/cli/launch.ts
 import { spawn } from "child_process";
@@ -59,6 +62,7 @@ async function probe(port, timeoutMs) {
   try {
     client = await connect({ port, timeoutMs });
   } catch (e) {
+    if (e instanceof DaemonRefusedError) return { client: null, state: "unauthorized" };
     if (e.message === "connect timeout") return { client: null, state: "timeout" };
     return { client: null, state: await portOpen(port) ? "foreign" : "refused" };
   }
@@ -80,6 +84,10 @@ async function ensureDaemon(opts = {}) {
     log(`port ${port} is open but does not speak the Ledge protocol`);
     return { client: null, reason: "foreign" };
   }
+  if (first.state === "unauthorized") {
+    log(`the daemon on port ${port} refused this client's token`);
+    return { client: null, reason: "unauthorized" };
+  }
   if (first.state === "timeout") {
     log(`port ${port} accepted a connection but did not answer within ${timeoutMs} ms`);
     return { client: null, reason: "unresponsive" };
@@ -142,6 +150,7 @@ async function readExitCode(id) {
 }
 var UNTRACKED = {
   foreign: (port) => `ledge: port ${port} is used by another program, session not tracked`,
+  unauthorized: () => "ledge: the daemon refused this client's token (missing or changed), session not tracked; restart the daemon: systemctl --user restart ledge-daemon",
   unresponsive: () => "ledge: daemon not responding, session not tracked",
   unreachable: () => "ledge: daemon not running, session not tracked"
 };

package/dist/cli/{chunk-L6IGH4LF.js → chunk-FGOFRWIB.js}

@@ -17,7 +17,7 @@ function ledgeDir() {
 }
 function paths() {
   const dir = ledgeDir();
-  return { dir, tmuxConf: join(dir, "tmux.conf"), journal: join(dir, "sessions.json"), log: join(dir, "daemon.log"), pid: join(dir, "daemon.pid"), history: join(dir, "history"), machines: join(dir, "machines.json"), projects: join(dir, "projects.json"), island: join(dir, "island.json") };
+  return { dir, tmuxConf: join(dir, "tmux.conf"), journal: join(dir, "sessions.json"), log: join(dir, "daemon.log"), pid: join(dir, "daemon.pid"), history: join(dir, "history"), machines: join(dir, "machines.json"), projects: join(dir, "projects.json"), island: join(dir, "island.json"), token: join(dir, "token") };
 }
 async function ensureLedgeDir() {
   const p = paths();
@@ -32,18 +32,7 @@ async function ensureLedgeDir() {
 ${TITLE_LINES}`);
 }
 
-// src/log.ts
-import { appendFileSync } from "fs";
-function log(line) {
-  try {
-    appendFileSync(paths().log, `${(/* @__PURE__ */ new Date()).toISOString()} | ${line}
-`);
-  } catch {
-  }
-}
-
 export {
   paths,
-  ensureLedgeDir,
-  log
+  ensureLedgeDir
 };

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

@@ -1,7 +1,7 @@
 import {
   cleanTopic,
   sessionTitle
-} from "./chunk-KJWMK65Y.js";
+} from "./chunk-KDYAHPYN.js";
 
 // src/daemon/crossSession.ts
 var FIRST_LINE = /^Another Claude session sent a message:\s*\n/;
@@ -19,6 +19,44 @@ function crossSession(text) {
   }
   return out.length ? out : void 0;
 }
+var NOTICE_HEAD = /^\[Cross-session ([\w -]+?) notice\]/;
+var NOTICE_SPLIT = /\n\s*(?=\[Cross-session [\w -]+? notice\])/;
+var DELIVERY = [
+  [/\bheld by that session\b/, "held"],
+  [/\bdenied by the recipient\b/, "denied"],
+  [/\bnot approved before expiry\b/, "expired"],
+  [/\bapproved and released\b/, "delivered"],
+  [/\bdropped at that session's inbox\b/, "dropped"],
+  [/\b(?:was|were) refused\b/, "refused"]
+];
+function crossSessionNotices(text) {
+  const body = text.trim();
+  if (!NOTICE_HEAD.test(body)) return void 0;
+  return body.split(NOTICE_SPLIT).map((part) => notice(part.trim()));
+}
+function notice(text) {
+  const kind = NOTICE_HEAD.exec(text)[1];
+  if (kind === "idle") {
+    const peer = /"([^"]*)"/.exec(text)?.[1] ?? "";
+    if (/^\[[^\]]*\]\s*No idle signal arrived from "/.test(text)) return { kind: "expired", peer, text };
+    const exited = /\bhas exited(?: \(at ([^)]+)\))?/.exec(text);
+    if (exited) return { kind: "exited", peer, ...exited[1] ? { time: exited[1] } : {}, text };
+    const unavailable = /is not holding your idle subscription(?: \(([^)]*)\))?/.exec(text);
+    if (unavailable) return { kind: "unavailable", peer, ...unavailable[1] ? { reason: unavailable[1] } : {}, text };
+    const time = /\bfinished a turn at (.+?)\.(?=\s|$)/.exec(text)?.[1];
+    const summary = /Its harness reports:\s*«([\s\S]*?)»/.exec(text)?.[1]?.trim();
+    return { kind: "idle", peer, ...time ? { time } : {}, ...summary ? { summary } : {}, text };
+  }
+  if (kind === "delivery") {
+    const status = DELIVERY.find(([re]) => re.test(text))?.[1] ?? "unknown";
+    const many = /\b(\d+) of your messages\b/.exec(text);
+    const to = /\brecipients?:\s*([^;)]*)/.exec(text)?.[1];
+    const recipients = to ? to.split(",").map((r) => r.trim()).filter((r) => r && r !== "\u2026") : [];
+    const reason = status === "dropped" ? /NOT delivered \(([^)]*)\)/.exec(text)?.[1] : void 0;
+    return { kind: "delivery", status, count: many ? Number(many[1]) : 1, recipients, ...reason ? { reason } : {}, text };
+  }
+  return { kind: "other", text };
+}
 
 // src/daemon/state.ts
 var HOOK_PRIORITY_MS = 2e3;
@@ -63,6 +101,11 @@ function pendingTool(p) {
   if (p.kind === "plan") return "ExitPlanMode";
   return p.tool;
 }
+function answeredBy(p, ev) {
+  if (p.source !== "hook" || ev.name !== "PostToolUse" && ev.name !== "PostToolUseFailure") return false;
+  const tool = pendingTool(p);
+  return tool !== void 0 && ev.tool === tool && ev.helperId === p.helperId;
+}
 function clearedByToolRun(p, tool) {
   const t = pendingTool(p);
   return p.source === "pane" || t === void 0 || t === tool;
@@ -235,16 +278,17 @@ function reduceEvent(s, ev) {
     case "PreToolUse":
     case "PermissionRequest":
     case "Notification": {
-      if (ev.name === "UserPromptSubmit" && ev.text && !s.topic && !crossSession(ev.text)) s = withTopic(s, ev.text, "prompt");
+      const notice2 = ev.name === "UserPromptSubmit" && !!ev.text && !!crossSessionNotices(ev.text);
+      if (ev.name === "UserPromptSubmit" && ev.text && !s.topic && !notice2 && !crossSession(ev.text)) s = withTopic(s, ev.text, "prompt");
       const incoming = pendingFor(ev);
       if (incoming) {
-        if (ev.name === "Notification" && s.pending?.source === "hook") return { ...s, lastHookAt: at, lastActivityAt: at };
+        if (ev.name === "Notification" && s.pending) return { ...s, lastHookAt: at, lastActivityAt: at };
         const pending = mergePending(s.pending, incoming);
         const state = pending.kind === "question" ? "waiting_input" : "waiting_permission";
         return { ...s, state, pending, lastHookAt: at, lastActivityAt: at };
       }
       if (ev.name === "Notification" || ev.name === "SessionStart") return { ...s, lastHookAt: at, lastActivityAt: at };
-      const prompted = ev.name === "UserPromptSubmit" && s.lastReply ? withoutReply(s) : s;
+      const prompted = ev.name === "UserPromptSubmit" && s.lastReply && !notice2 ? withoutReply(s) : s;
       if (prompted.pending?.helperId) return underHelper(prompted, "working", at);
       if (prompted === s && s.state === "working" && s.lastActivityAt === at && !s.pending) return s;
       return { ...prompted, state: "working", pending: void 0, lastHookAt: at, lastActivityAt: at };
@@ -252,8 +296,56 @@ function reduceEvent(s, ev) {
   }
 }
 
+// src/daemon/git.ts
+import { execFile } from "child_process";
+import { basename, dirname, resolve } from "path";
+function repositoryId(remote) {
+  const value = remote.trim();
+  try {
+    const url = new URL(value);
+    if (!["https:", "http:", "ssh:", "git:"].includes(url.protocol)) return void 0;
+    return `${url.hostname.toLowerCase()}${url.pathname.replace(/\.git\/?$/, "").replace(/\/$/, "")}`;
+  } catch {
+    const scp = value.match(/^(?:[^@\s]+@)?([a-zA-Z0-9.-]+):([^\s]+)$/);
+    return scp ? `${scp[1].toLowerCase()}/${scp[2].replace(/\.git$/, "").replace(/\/$/, "")}` : void 0;
+  }
+}
+var execGit = (file, args, cwd) => new Promise((res) => {
+  execFile(file, args, { cwd, timeout: 3e3, maxBuffer: 1024 * 1024 }, (err, stdout) => res({ code: err ? 1 : 0, stdout: String(stdout) }));
+});
+async function gitInfo(cwd, exec = execGit) {
+  const r = await exec("git", ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir", "--abbrev-ref", "HEAD"], cwd);
+  if (r.code !== 0) return null;
+  const [toplevel = "", common = "", abbrev = ""] = r.stdout.split("\n").map((l) => l.trim());
+  if (!toplevel || !common || !abbrev) return null;
+  const worktree = resolve(common) !== resolve(toplevel, ".git");
+  const repoPath = worktree ? dirname(resolve(common)) : resolve(toplevel);
+  let branch = abbrev;
+  if (abbrev === "HEAD") {
+    const sha = await exec("git", ["rev-parse", "--short", "HEAD"], cwd);
+    if (sha.code !== 0 || !sha.stdout.trim()) return null;
+    branch = sha.stdout.trim();
+  }
+  const remote = await exec("git", ["config", "--get", "remote.origin.url"], cwd);
+  const repoId = remote.code === 0 ? repositoryId(remote.stdout) : void 0;
+  return { repo: basename(repoPath), repoPath, branch, worktree, ...repoId ? { repoId } : {} };
+}
+async function gitSummary(cwd, exec = execGit) {
+  const status = await exec("git", ["status", "--short", "--branch"], cwd);
+  if (status.code !== 0) return null;
+  const log = await exec("git", ["log", "--oneline", "-10"], cwd);
+  const diff = await exec("git", ["diff", "--stat"], cwd);
+  return [`# git status --short --branch`, status.stdout.trimEnd(), "", "# git log --oneline -10", log.stdout.trimEnd(), "", "# git diff --stat", diff.stdout.trimEnd() || "(clean)"].join("\n");
+}
+
 export {
   crossSession,
+  crossSessionNotices,
   QUESTION_TOOLS,
-  reduce
+  pendingTool,
+  answeredBy,
+  reduce,
+  repositoryId,
+  gitInfo,
+  gitSummary
 };

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

@@ -1,14 +1,23 @@
 import {
   PROTOCOL_PORT,
-  parseServerMessage
-} from "./chunk-KJWMK65Y.js";
+  parseServerMessage,
+  readDaemonToken
+} from "./chunk-KDYAHPYN.js";
 
 // src/client.ts
 import WebSocket from "ws";
+var DaemonRefusedError = class extends Error {
+};
 function connect(opts = {}) {
   const port = opts.port ?? PROTOCOL_PORT;
   const host = opts.host ?? "127.0.0.1";
-  const ws = new WebSocket(`ws://${host}:${port}`);
+  let token;
+  try {
+    token = opts.token === void 0 ? readDaemonToken() : opts.token;
+  } catch {
+    token = null;
+  }
+  const ws = new WebSocket(`ws://${host}:${port}`, token ? { headers: { authorization: `Bearer ${token}` } } : {});
   const queue = [];
   const MAX_QUEUED = 100;
   const waiters = [];
@@ -66,12 +75,13 @@ function connect(opts = {}) {
       if (!settled) {
         settled = true;
         clearTimeout(t);
-        reject(e);
+        reject(/Unexpected server response: 401/.test(e.message) ? new DaemonRefusedError("daemon refused the token") : e);
       }
     });
   });
 }
 
 export {
+  DaemonRefusedError,
   connect
 };

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

@@ -1,5 +1,125 @@
-// ../protocol/src/messages.ts
-import { z as z13 } from "zod";
+import {
+  paths
+} from "./chunk-FGOFRWIB.js";
+
+// src/auth.ts
+import { createHash, randomBytes, timingSafeEqual } from "crypto";
+import { chmod, link, mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { readFileSync } from "fs";
+import { dirname } from "path";
+var TOKEN_RE = /^[0-9a-f]{64}$/;
+var DAEMON_PROTOCOL_PREFIX = "ledge.";
+function isDaemonToken(value) {
+  return TOKEN_RE.test(value);
+}
+function tokenEquals(presented, expected) {
+  const a = createHash("sha256").update(presented.slice(0, 256), "utf8").digest();
+  const b = createHash("sha256").update(expected, "utf8").digest();
+  return timingSafeEqual(a, b);
+}
+function hostAllowed(hostHeader) {
+  const raw = Array.isArray(hostHeader) ? hostHeader[0] : hostHeader;
+  if (!raw || raw.length > 255) return false;
+  const host = raw.trim().toLowerCase();
+  if (!host || host.includes(" ") || host.endsWith(".")) return false;
+  let name;
+  if (host.startsWith("[")) {
+    const end = host.indexOf("]");
+    if (end < 0) return false;
+    name = host.slice(1, end);
+    const rest = host.slice(end + 1);
+    if (rest !== "" && !/^:\d{1,5}$/.test(rest)) return false;
+  } else {
+    const colon = host.lastIndexOf(":");
+    if (colon >= 0) {
+      if (!/^\d{1,5}$/.test(host.slice(colon + 1))) return false;
+      name = host.slice(0, colon);
+    } else name = host;
+  }
+  return name === "localhost" || name === "127.0.0.1" || name === "::1";
+}
+function headerValue(value, max) {
+  const raw = Array.isArray(value) ? value.join(",") : value;
+  return !raw || raw.length > max ? "" : raw;
+}
+function bearerToken(authorization) {
+  if (!authorization || authorization.length > 512) return "";
+  return /^Bearer[ \t]+(\S+)$/i.exec(authorization)?.[1] ?? "";
+}
+function protocolToken(header) {
+  const raw = headerValue(header, 512);
+  if (!raw) return "";
+  for (const part of raw.split(",").slice(0, 8)) {
+    const protocol = part.trim();
+    if (protocol.startsWith(DAEMON_PROTOCOL_PREFIX)) return protocol.slice(DAEMON_PROTOCOL_PREFIX.length);
+  }
+  return "";
+}
+function requestAuthorized(headers, expected) {
+  const bearerOk = tokenEquals(bearerToken(typeof headers.authorization === "string" ? headers.authorization : void 0), expected);
+  const presented = protocolToken(headers["sec-websocket-protocol"]);
+  return bearerOk || presented !== "" && tokenEquals(presented, expected);
+}
+function selectDaemonProtocol(protocols, expected) {
+  for (const protocol of protocols) {
+    if (protocol.startsWith(DAEMON_PROTOCOL_PREFIX) && tokenEquals(protocol.slice(DAEMON_PROTOCOL_PREFIX.length), expected)) return protocol;
+  }
+  return false;
+}
+async function readTokenFile(file) {
+  try {
+    const raw = (await readFile(file, "utf8")).trim();
+    return isDaemonToken(raw) ? raw : void 0;
+  } catch (e) {
+    if (e.code === "ENOENT") return void 0;
+    throw e;
+  }
+}
+async function lockTokenFile(file) {
+  await chmod(file, 384);
+}
+async function ensureDaemonToken() {
+  const file = paths().token;
+  await mkdir(dirname(file), { recursive: true });
+  const current = await readTokenFile(file);
+  if (current) {
+    await lockTokenFile(file);
+    return current;
+  }
+  const token = randomBytes(32).toString("hex");
+  const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  await writeFile(tmp, `${token}
+`, { mode: 384, flag: "wx" });
+  await chmod(tmp, 384);
+  try {
+    await link(tmp, file);
+  } catch (e) {
+    await unlink(tmp).catch(() => {
+    });
+    if (e.code !== "EEXIST") throw e;
+    const raced = await readTokenFile(file);
+    if (raced) {
+      await lockTokenFile(file);
+      return raced;
+    }
+    await writeFile(file, `${token}
+`, { mode: 384 });
+  }
+  await unlink(tmp).catch(() => {
+  });
+  await lockTokenFile(file);
+  const stored = await readTokenFile(file);
+  if (!stored) throw new Error("daemon token was not stored");
+  return stored;
+}
+function readDaemonToken() {
+  try {
+    const raw = readFileSync(paths().token, "utf8").trim();
+    return isDaemonToken(raw) ? raw : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // ../protocol/src/session.ts
 import { z } from "zod";
@@ -83,6 +203,9 @@ function isArchived(s) {
   return s.archivedAt !== void 0;
 }
 
+// ../protocol/src/messages.ts
+import { z as z13 } from "zod";
+
 // ../protocol/src/chat.ts
 import { z as z2 } from "zod";
 var ChatStepSchema = z2.object({
@@ -99,6 +222,8 @@ var ChatProposalSchema = z2.object({
   launchedId: z2.string().optional(),
   error: z2.string().optional()
 });
+var MAX_PROPOSALS = 8;
+var ChatProposalsSchema = z2.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
 var ChatRelaySchema = z2.object({
   id: z2.string().min(1),
   name: z2.string(),
@@ -126,9 +251,11 @@ var ChatTurnSchema = z2.object({
   answeredAt: z2.string().datetime().optional(),
   error: z2.string().optional(),
   proposal: ChatProposalSchema.optional(),
+  proposals: ChatProposalsSchema.optional(),
   relay: ChatRelaySchema.optional(),
   projectProposal: ChatProjectProposalSchema.optional()
 });
+var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
 
 // ../protocol/src/repos.ts
 import { z as z3 } from "zod";
@@ -144,7 +271,7 @@ var ReposInfoSchema = z3.object({ type: z3.literal("repos.info"), requestId: z3.
 // ../protocol/src/scan.ts
 import { z as z4 } from "zod";
 var ReposScanSchema = z4.object({ type: z4.literal("repos.scan"), requestId: z4.string().min(1).max(100), machineId: z4.string().optional() });
-var FoundRepoSchema = z4.object({ path: z4.string(), branch: z4.string().nullable(), remote: z4.string().optional() });
+var FoundRepoSchema = z4.object({ path: z4.string(), branch: z4.string().nullable(), remote: z4.string().optional(), manifest: z4.string().max(200).optional() });
 var ReposFoundSchema = z4.object({ type: z4.literal("repos.found"), requestId: z4.string(), repos: z4.array(FoundRepoSchema).max(500), truncated: z4.boolean(), error: z4.string().optional() });
 
 // ../protocol/src/documents.ts
@@ -339,7 +466,24 @@ var ThreadItemSchema = z11.discriminatedUnion("kind", [
   /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread. */
   z11.object({ kind: z11.literal("sent"), ...base, to: z11.string(), peer: z11.string().optional(), summary: z11.string().optional(), text: z11.string(), status: z11.enum(["sending", "delivered", "read", "failed"]), received: z11.string().optional() }),
   /** A message another agent sent to this session; `from` is its from-name (else its address), `sent` the paired item's id in the peer's thread. */
-  z11.object({ kind: z11.literal("received"), ...base, from: z11.string(), peer: z11.string().optional(), text: z11.string(), sent: z11.string().optional() })
+  z11.object({ kind: z11.literal("received"), ...base, from: z11.string(), peer: z11.string().optional(), text: z11.string(), sent: z11.string().optional() }),
+  /** An automated notice of the agent's harness about messages between sessions (Claude Code's `[Cross-session idle
+   *  notice]` / `[Cross-session delivery notice]`): a system event, never the user's words. `name` is the session it is
+   *  about as quoted, `peer` its Ledge session id; a delivery notice says the outcome of `count` messages to `recipients`. */
+  z11.object({
+    kind: z11.literal("notice"),
+    ...base,
+    notice: z11.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
+    name: z11.string().optional(),
+    peer: z11.string().optional(),
+    time: z11.string().optional(),
+    summary: z11.string().optional(),
+    status: z11.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
+    count: z11.number().int().positive().optional(),
+    recipients: z11.array(z11.string()).optional(),
+    reason: z11.string().optional(),
+    text: z11.string()
+  })
 ]);
 
 // ../protocol/src/decisions.ts
@@ -447,7 +591,7 @@ var ServerMessageSchema = z13.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. */
   z13.object({ type: z13.literal("chat.step"), qid: z13.string(), step: ChatStepSchema }),
   z13.object({ type: z13.literal("chat.delta"), qid: z13.string(), text: z13.string() }),
-  z13.object({ type: z13.literal("chat.done"), qid: z13.string(), text: z13.string(), at: z13.string().datetime(), proposal: ChatProposalSchema.optional(), relay: ChatRelaySchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
+  z13.object({ type: z13.literal("chat.done"), qid: z13.string(), text: z13.string(), at: z13.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
   z13.object({ type: z13.literal("chat.error"), qid: z13.string(), message: z13.string() }),
   z13.object({ type: z13.literal("chat.history"), turns: z13.array(ChatTurnSchema) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
@@ -486,6 +630,8 @@ var ClientMessageSchema = z13.discriminatedUnion("type", [
     prompt: z13.string().optional(),
     continue: z13.boolean().optional(),
     qid: z13.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: z13.array(z13.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(),
     /** Folders in addition to `cwd` (Claude: `--add-dir`); resolved like `cwd`. */
     dirs: z13.array(z13.string().min(1)).max(20).optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
@@ -501,7 +647,14 @@ var ClientMessageSchema = z13.discriminatedUnion("type", [
     /** Copied into the `folder.listing` that answers; the fleet relays only that listing, from the machine asked. */
     requestId: z13.string().min(1).max(100).optional()
   }),
-  z13.object({ type: z13.literal("folder.create"), parent: z13.string().min(1), name: z13.string().min(1) }),
+  z13.object({
+    type: z13.literal("folder.create"),
+    parent: z13.string().min(1),
+    name: z13.string().min(1),
+    /** As for `folder.list`: routing by the fleet, and the request its `folder.listing` answers. */
+    machineId: z13.string().optional(),
+    requestId: z13.string().min(1).max(100).optional()
+  }),
   z13.object({ type: z13.literal("session.reply"), id: z13.string(), text: z13.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. */
   z13.object({ type: z13.literal("session.relay"), qid: z13.string().min(1) }),
@@ -658,7 +811,7 @@ function extractProposal(answer) {
     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 };
+  return last ? { text: text.replace(/\n{3,}/g, "\n\n").trim(), kind: last.kind, raw: last.raw, blocks: found } : { text: answer, kind: null, raw: null, blocks: [] };
 }
 function parseProposalBlock(raw) {
   try {
@@ -697,8 +850,15 @@ function sessionTitle(s) {
 }
 
 export {
+  hostAllowed,
+  requestAuthorized,
+  selectDaemonProtocol,
+  ensureDaemonToken,
+  readDaemonToken,
   SessionSchema,
   isArchived,
+  MAX_PROPOSALS,
+  proposalRows,
   NOTE_NOT_TYPED,
   offers,
   pendingKey,

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

@@ -1,9 +1,9 @@
-import {
-  paths
-} from "./chunk-L6IGH4LF.js";
 import {
   pickName
-} from "./chunk-KJWMK65Y.js";
+} from "./chunk-KDYAHPYN.js";
+import {
+  paths
+} from "./chunk-FGOFRWIB.js";
 
 // src/daemon/transcript.ts
 import { closeSync, fstatSync, openSync, readSync } from "fs";
@@ -95,6 +95,33 @@ function claudePlan(path) {
   }
   return plan?.text;
 }
+function claudeCalls(path) {
+  const calls = [];
+  for (const line of tailLines(path)) {
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.isSidechain === true || !Array.isArray(e.message?.content)) continue;
+    for (const b of e.message.content) {
+      if (e.type === "assistant" && b?.type === "tool_use" && typeof b.id === "string" && typeof b.name === "string") calls.push({ id: b.id, name: b.name, answered: false });
+      else if (e.type === "user" && b?.type === "tool_result") {
+        const c = calls.find((c2) => c2.id === b.tool_use_id);
+        if (c) c.answered = true;
+      }
+    }
+  }
+  return calls;
+}
+function claudeOpenCall(path, tool) {
+  const last = claudeCalls(path).filter((c) => c.name === tool).at(-1);
+  return last && !last.answered ? last.id : void 0;
+}
+function claudeToolAnswered(path, id) {
+  return claudeCalls(path).some((c) => c.id === id && c.answered);
+}
 
 // src/spawn.ts
 import { basename, join as join2 } from "path";
@@ -105,6 +132,10 @@ 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;
@@ -128,7 +159,7 @@ async function spawnSession(opts) {
   const project = basename(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] : [], ...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 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;
@@ -141,6 +172,8 @@ export {
   agentMessages,
   codexPlan,
   claudePlan,
+  claudeOpenCall,
+  claudeToolAnswered,
   CODEX_ENV_VAR,
   CODEX_HOOK_VAR,
   exitFile,

package/dist/cli/{chunk-Q5CLZPYJ.js → chunk-Q7RCYJ4X.js}

@@ -1,10 +1,10 @@
 import {
   run
-} from "./chunk-3TNPEAMR.js";
+} from "./chunk-TO4XO2ML.js";
 import {
   ensureLedgeDir,
   paths
-} from "./chunk-L6IGH4LF.js";
+} from "./chunk-FGOFRWIB.js";
 
 // src/cli/setup.ts
 import { readFile as readFile2, writeFile, mkdir, rename, realpath, rm, stat, lstat, readlink, symlink, unlink } from "fs/promises";

package/dist/cli/{chunk-3TNPEAMR.js → chunk-TO4XO2ML.js}

@@ -1,7 +1,9 @@
 import {
-  log,
+  log
+} from "./chunk-YUSY3E47.js";
+import {
   paths
-} from "./chunk-L6IGH4LF.js";
+} from "./chunk-FGOFRWIB.js";
 
 // src/tmux.ts
 import { execFile } from "child_process";