@paradow/ledge 0.9.0 → 0.10.0

package/dist/cli/{attach-HPGWEUKX.js → attach-2DEXQEC2.js}

@@ -1,17 +1,18 @@
 import {
   attachEnv
-} from "./chunk-N3MPPCON.js";
-import "./chunk-564TJJZ6.js";
+} from "./chunk-IC5RHOX6.js";
+import "./chunk-GMKS55KF.js";
 import {
   realTmux
-} from "./chunk-3TNPEAMR.js";
-import "./chunk-L6IGH4LF.js";
+} from "./chunk-TO4XO2ML.js";
+import "./chunk-YUSY3E47.js";
 import {
   connect
-} from "./chunk-XPWGZIYL.js";
+} from "./chunk-TC3XJUJA.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-WM4MAV46.js";
+} from "./chunk-JOCNCNRP.js";
+import "./chunk-FGOFRWIB.js";
 
 // src/cli/attach.ts
 import { spawn } from "child_process";

package/dist/cli/{bridge-2CVD7BMI.js → bridge-ZOHP53DV.js}

@@ -5,14 +5,20 @@ import {
 import {
   PROTOCOL_PORT,
   parseClientMessage,
-  parseServerMessage
-} from "./chunk-WM4MAV46.js";
+  parseServerMessage,
+  readDaemonToken
+} from "./chunk-JOCNCNRP.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-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-564TJJZ6.js → chunk-GMKS55KF.js}

@@ -1,9 +1,9 @@
-import {
-  paths
-} from "./chunk-L6IGH4LF.js";
 import {
   pickName
-} from "./chunk-WM4MAV46.js";
+} from "./chunk-JOCNCNRP.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";
@@ -145,6 +172,8 @@ export {
   agentMessages,
   codexPlan,
   claudePlan,
+  claudeOpenCall,
+  claudeToolAnswered,
   CODEX_ENV_VAR,
   CODEX_HOOK_VAR,
   exitFile,

package/dist/cli/{chunk-N3MPPCON.js → chunk-IC5RHOX6.js}

@@ -1,20 +1,23 @@
 import {
   exitFile,
   spawnSession
-} from "./chunk-564TJJZ6.js";
+} from "./chunk-GMKS55KF.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-XPWGZIYL.js";
+} from "./chunk-TC3XJUJA.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-WM4MAV46.js";
+} from "./chunk-JOCNCNRP.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-WM4MAV46.js → chunk-JOCNCNRP.js}

@@ -1,3 +1,126 @@
+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";
 var ToolSchema = z.enum(["claude", "codex", "cursor"]);
@@ -53,6 +176,8 @@ var SessionSchema = z.object({
   repoPath: z.string().optional(),
   branch: z.string().optional(),
   worktree: z.boolean().optional(),
+  /** The folder the agent works in now, as its last hook reported it: `cwd` stays where it started, this follows a worktree it entered. */
+  workdir: z.string().optional(),
   tmuxSession: z.string().nullable(),
   state: SessionStateSchema,
   pending: PendingSchema.optional(),
@@ -524,7 +649,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) }),
@@ -720,6 +852,11 @@ function sessionTitle(s) {
 }
 
 export {
+  hostAllowed,
+  requestAuthorized,
+  selectDaemonProtocol,
+  ensureDaemonToken,
+  readDaemonToken,
   SessionSchema,
   isArchived,
   MAX_PROPOSALS,

package/dist/cli/{chunk-JVELEEIO.js → chunk-OHKQKXYM.js}

@@ -1,7 +1,7 @@
 import {
   cleanTopic,
   sessionTitle
-} from "./chunk-WM4MAV46.js";
+} from "./chunk-JOCNCNRP.js";
 
 // src/daemon/crossSession.ts
 var FIRST_LINE = /^Another Claude session sent a message:\s*\n/;
@@ -101,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;
@@ -277,7 +282,7 @@ function reduceEvent(s, ev) {
       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 };
@@ -337,6 +342,8 @@ export {
   crossSession,
   crossSessionNotices,
   QUESTION_TOOLS,
+  pendingTool,
+  answeredBy,
   reduce,
   repositoryId,
   gitInfo,

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-XPWGZIYL.js → chunk-TC3XJUJA.js}

@@ -1,14 +1,23 @@
 import {
   PROTOCOL_PORT,
-  parseServerMessage
-} from "./chunk-WM4MAV46.js";
+  parseServerMessage,
+  readDaemonToken
+} from "./chunk-JOCNCNRP.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-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";

package/dist/cli/chunk-XOPH7YDV.js

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

package/dist/cli/chunk-YUSY3E47.js

@@ -0,0 +1,17 @@
+import {
+  paths
+} from "./chunk-FGOFRWIB.js";
+
+// src/log.ts
+import { appendFileSync } from "fs";
+function log(line) {
+  try {
+    appendFileSync(paths().log, `${(/* @__PURE__ */ new Date()).toISOString()} | ${line}
+`);
+  } catch {
+  }
+}
+
+export {
+  log
+};

package/dist/cli/{daemon-SGTQRTHV.js → daemon-RI47DJDX.js}

@@ -4,35 +4,37 @@ import {
 } from "./chunk-OLLQBK6N.js";
 import {
   QUESTION_TOOLS,
+  answeredBy,
   crossSession,
   crossSessionNotices,
   gitInfo,
   gitSummary,
+  pendingTool,
   reduce,
   repositoryId
-} from "./chunk-JVELEEIO.js";
+} from "./chunk-OHKQKXYM.js";
 import {
   agentMessages,
+  claudeOpenCall,
   claudePlan,
+  claudeToolAnswered,
   spawnSession
-} from "./chunk-564TJJZ6.js";
+} from "./chunk-GMKS55KF.js";
 import {
   LEDGE_VERSION
-} from "./chunk-LWPKX7SB.js";
+} from "./chunk-XOPH7YDV.js";
 import {
   SERVICE,
   inDaemonService,
   tmuxServerAtRisk
-} from "./chunk-Q5CLZPYJ.js";
+} from "./chunk-Q7RCYJ4X.js";
 import {
   realTmux,
   runFile
-} from "./chunk-3TNPEAMR.js";
+} from "./chunk-TO4XO2ML.js";
 import {
-  ensureLedgeDir,
-  log,
-  paths
-} from "./chunk-L6IGH4LF.js";
+  log
+} from "./chunk-YUSY3E47.js";
 import {
   DEFAULT_PROJECTS,
   DOCUMENT_MAX_BYTES,
@@ -46,7 +48,9 @@ import {
   RouteResultSchema,
   SessionSchema,
   SshAliasSchema,
+  ensureDaemonToken,
   extractProposal,
+  hostAllowed,
   isArchived,
   offers,
   parseClientMessage,
@@ -57,8 +61,14 @@ import {
   pendingKey,
   pickName,
   projectOf,
-  proposalRows
-} from "./chunk-WM4MAV46.js";
+  proposalRows,
+  requestAuthorized,
+  selectDaemonProtocol
+} from "./chunk-JOCNCNRP.js";
+import {
+  ensureLedgeDir,
+  paths
+} from "./chunk-FGOFRWIB.js";
 
 // src/daemon/index.ts
 import { writeFile as writeFile6, rm as rm5 } from "fs/promises";
@@ -583,6 +593,7 @@ var History = class {
 };
 
 // src/daemon/server.ts
+import { createServer } from "http";
 import { homedir as homedir5 } from "os";
 import { basename as basename3 } from "path";
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
@@ -637,6 +648,9 @@ function dialogMismatch(shown, pending, width) {
   if (pending.tool !== void 0 && COMMAND_TOOLS.has(pending.tool)) return shown.command ? commandMismatch(shown.command, pending.text, width) : UNCHECKED;
   return null;
 }
+function bottomLines(pane, n = 5) {
+  return pane.split("\n").filter((l) => l.trim() !== "").slice(-n).join("\n");
+}
 var flatten = (text) => text.replace(/\s*[\r\n]+\s*/g, " ").trim();
 
 // src/adapters/claude.ts
@@ -766,7 +780,7 @@ function promptStillVisible(lastLines2) {
 }
 var squash = (t) => t.replace(/\s+/g, " ").trim();
 function promptGone(pane, pending) {
-  if (pending.kind !== "question" || !squash(pending.text)) return !promptStillVisible(pane.replace(/\s+$/, "").split("\n").slice(-5).join("\n"));
+  if (pending.kind !== "question" || !squash(pending.text)) return !promptStillVisible(bottomLines(pane));
   const m = detectPrompt(pane);
   if (!m || m.kind !== "question") return true;
   const shown = squash(m.text);
@@ -2569,10 +2583,18 @@ async function readDocument(request, context) {
   if (/^(?:file:|[a-zA-Z]:[\\/]|\\\\)/.test(source) || source.includes("\0")) return failure(request, "unsupported_path");
   if (request.basePath && (!isAbsolute3(request.basePath) || !markdown(request.basePath))) return failure(request, "unsupported_path");
   const expanded = source === "~" ? context.home : source.startsWith("~/") ? resolve6(context.home, source.slice(2)) : source;
-  const base = request.basePath ? dirname5(request.basePath) : context.cwd;
-  if (!isAbsolute3(expanded) && !base) return failure(request, "ambiguous_path");
-  const path = resolve6(base ?? context.home, expanded);
-  if (!markdown(path)) return failure(request, "unsupported_type");
+  const bases = request.basePath ? [dirname5(request.basePath)] : [...new Set([context.workdir, context.cwd].filter((d) => !!d))];
+  if (!isAbsolute3(expanded) && !bases.length) return failure(request, "ambiguous_path");
+  const paths2 = isAbsolute3(expanded) ? [resolve6(expanded)] : bases.map((base) => resolve6(base, expanded));
+  if (!markdown(paths2[0])) return failure(request, "unsupported_type");
+  let read = failure(request, "not_found");
+  for (const path of paths2) {
+    read = await readAt(request, path);
+    if (read.type === "document.content" || read.code !== "not_found") return read;
+  }
+  return read;
+}
+async function readAt(request, path) {
   let file;
   try {
     file = await open2(path, constants2.O_RDONLY | constants2.O_NONBLOCK);
@@ -2859,6 +2881,25 @@ var ALLOWED_ORIGINS = [
 function originAllowed(origin) {
   return origin === void 0 || ALLOWED_ORIGINS.includes(origin);
 }
+function requestPath(url) {
+  const raw = url ?? "/";
+  const q = raw.indexOf("?");
+  return q === -1 ? raw : raw.slice(0, q);
+}
+function refusal(req, token) {
+  const path = requestPath(req.url);
+  if (!(path === "/" || path.startsWith("/ssh/") && SshAliasSchema.safeParse(path.slice(5)).success)) return "path";
+  if (!originAllowed(req.headers.origin)) return "origin";
+  if (!hostAllowed(req.headers.host)) return "host";
+  if (!requestAuthorized(req.headers, token)) return "auth";
+  return null;
+}
+function unauthorized(req, res) {
+  req.resume();
+  const body = "Unauthorized\n";
+  res.writeHead(401, { "Content-Type": "text/plain; charset=utf-8", "Content-Length": Buffer.byteLength(body), "Cache-Control": "no-store", Connection: "close" });
+  res.end(body);
+}
 function logDroppedRequest(id, ev, before, after) {
   if (ev.name !== "PermissionRequest" || !after || after.pending !== before?.pending) return;
   const held = before?.pending;
@@ -2874,22 +2915,36 @@ async function startServer(opts) {
   const agentEnv = opts.agentEnv ?? (async () => ({ ...process.env, ...await loginShellEnv() }));
   const chat = opts.chat ?? createChat({ store, tmux, home: paths().dir, userHome: opts.home, env: agentEnv, bin: opts.claudeBin, now, projects: () => projects, forge: createForge({ env: agentEnv }) });
   const router = createRouter({ env: agentEnv });
+  const token = await ensureDaemonToken();
+  const httpServer = createServer(unauthorized);
+  const sockets = /* @__PURE__ */ new Set();
+  httpServer.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.on("close", () => sockets.delete(socket));
+  });
   const wss = new WebSocketServer({
-    host: opts.host ?? "127.0.0.1",
-    port: opts.port ?? PROTOCOL_PORT,
+    server: httpServer,
     maxPayload: MAX_FRAME,
     verifyClient: ({ req }) => {
-      const path = req.url ?? "/";
-      const ok = originAllowed(req.headers.origin) && (path === "/" || path.startsWith("/ssh/") && SshAliasSchema.safeParse(path.slice(5)).success);
-      if (!ok) log(`refused a connection from origin ${String(req.headers.origin)}`);
-      return ok;
-    }
+      const why = refusal(req, token);
+      if (why) {
+        const origin = String(req.headers.origin ?? "none").replace(/[\r\n]/g, "").slice(0, 120);
+        log(`refused a connection (${why}) from origin ${origin}`);
+      }
+      return why === null;
+    },
+    handleProtocols: (protocols) => selectDaemonProtocol(protocols, token)
   });
   await new Promise((res, rej) => {
-    wss.once("listening", res);
-    wss.once("error", rej);
+    const onError = (e) => rej(e);
+    wss.once("error", onError);
+    httpServer.listen(opts.port ?? PROTOCOL_PORT, opts.host ?? "127.0.0.1", () => {
+      wss.off("error", onError);
+      res();
+    });
   });
-  const port = wss.address().port;
+  wss.on("error", (e) => log(`daemon server error: ${e.message}`));
+  const port = httpServer.address().port;
   const machinesFile = opts.machinesFile ?? paths().machines;
   let machines = readMachines(machinesFile).map((m) => ({ ...m }));
   const machinesMsg = () => ({ type: "machines", machines });
@@ -2971,6 +3026,16 @@ async function startServer(opts) {
     }
   }
   const inFlight = /* @__PURE__ */ new Set();
+  const CONFIRM_MS = opts.confirmMs ?? 3e3;
+  const awaited = /* @__PURE__ */ new Map();
+  function settleByHook(id, ev) {
+    const a = awaited.get(id);
+    const cur = store.get(id)?.pending;
+    if (!a || a.settled || !answeredBy(a.pending, ev) || !cur || pendingKey(cur) !== pendingKey(a.pending)) return;
+    a.settled = true;
+    a.byHook = true;
+    store.apply(id, { name: "Decided", at: now(), source: "daemon", ...a.decision ? { decision: a.decision } : {} });
+  }
   async function injectAndVerify(id, planFor, requirePrompt, decision) {
     const s = store.get(id);
     if (!s) throw new Error(`unknown session ${id}`);
@@ -2986,7 +3051,7 @@ async function startServer(opts) {
       let before = null;
       if (requirePrompt) {
         before = s.tmuxSession ? await tmux.capture(s.tmuxSession, DETECT_LINES) : null;
-        if (before === null || !adapter.promptStillVisible(before.split("\n").slice(-5).join("\n"))) throw new Error(NO_PROMPT);
+        if (before === null || !adapter.promptStillVisible(bottomLines(before))) throw new Error(NO_PROMPT);
         if (!stillTheSame()) throw new Error(STALE);
         if (decided) {
           const shown = adapter.detectPrompt(before) ?? adapter.detectPrompt(await tmux.capture(s.tmuxSession, CHECK_LINES) ?? "");
@@ -2995,21 +3060,41 @@ async function startServer(opts) {
         }
       }
       const plan = typeof planFor === "function" ? planFor(before ?? "") : planFor;
-      const promptGone3 = () => decided && adapter.promptGone ? verifyGone(() => tmux.capture(s.tmuxSession, DETECT_LINES), (p) => !adapter.promptGone(p, decided), opts.verify) : verifyGone(() => tmux.capture(s.tmuxSession, 5), (p) => adapter.promptStillVisible(p), opts.verify);
+      const stillShown = (p) => decided && adapter.promptGone ? !adapter.promptGone(p, decided) : adapter.promptStillVisible(bottomLines(p));
+      const tool = s.tool === "claude" && decided?.source === "hook" ? pendingTool(decided) : void 0;
+      const answer = tool ? { pending: decided, ...decision ? { decision } : {}, settled: false, byHook: false } : void 0;
+      const transcript = tool && !decided.helperId && s.transcriptPath ? s.transcriptPath : void 0;
+      const call = transcript ? claudeOpenCall(transcript, tool) : void 0;
+      const promptGone3 = async () => {
+        if (!answer) return verifyGone(() => tmux.capture(s.tmuxSession, DETECT_LINES), stillShown, opts.verify);
+        const interval = opts.verify?.intervalMs ?? 200;
+        for (const end = Date.now() + CONFIRM_MS; ; ) {
+          if (answer.byHook || call && claudeToolAnswered(transcript, call)) return true;
+          const pane = await tmux.capture(s.tmuxSession, DETECT_LINES);
+          if (answer.byHook || pane !== null && !stillShown(pane)) return true;
+          if (Date.now() >= end) return false;
+          await new Promise((r) => setTimeout(r, interval));
+        }
+      };
+      if (answer) awaited.set(id, answer);
       try {
         await runPlan(s, plan);
       } catch (e) {
         if (e instanceof NoteNotTyped) {
           if (await promptGone3()) {
-            if (stillTheSame()) store.apply(id, { name: "Decided", at: now(), source: "daemon", ...decision ? { decision } : {} });
+            if (answer) answer.settled = true;
+            if (!answer?.byHook && stillTheSame()) store.apply(id, { name: "Decided", at: now(), source: "daemon", ...decision ? { decision } : {} });
             throw e;
           }
           e = new Error(NOT_TAKEN);
         }
+        if (answer?.byHook) return true;
         store.apply(id, { name: "InjectFailed", at: now(), source: "daemon", text: e.message });
         throw e;
       }
       const gone = await promptGone3();
+      if (answer) answer.settled = true;
+      if (answer?.byHook) return true;
       if (!stillTheSame()) return false;
       if (gone) {
         store.apply(id, { name: "Decided", at: now(), source: "daemon", ...decision ? { decision } : {} });
@@ -3019,6 +3104,7 @@ async function startServer(opts) {
       throw new Error(NOT_TAKEN);
     } finally {
       inFlight.delete(id);
+      awaited.delete(id);
     }
   }
   const READ_ONLY = "session started without ledge, read only";
@@ -3085,7 +3171,7 @@ async function startServer(opts) {
       case "document.read": {
         const session = msg.sessionId ? store.get(msg.sessionId) : void 0;
         if (msg.sessionId && !session) return send(ws, { type: "document.error", requestId: msg.requestId, path: msg.path, code: "session_missing" });
-        return send(ws, await readDocument(msg, { cwd: session?.cwd, home: opts.home ?? process.env.HOME ?? "" }));
+        return send(ws, await readDocument(msg, { cwd: session?.cwd, workdir: session?.workdir, home: opts.home ?? process.env.HOME ?? "" }));
       }
       case "repos.inspect":
         return send(ws, { type: "repos.info", requestId: msg.requestId, repos: await inspectRepos(msg.paths, { home: opts.home }) });
@@ -3176,7 +3262,7 @@ async function startServer(opts) {
       case "folder.list":
         return send(ws, await listFolder(msg.path, opts.home, msg.requestId));
       case "folder.create": {
-        const listing = await createFolder(msg.parent, msg.name, opts.home);
+        const listing = await createFolder(msg.parent, msg.name, opts.home, msg.requestId);
         if (!listing.error) log(`created folder ${listing.path}`);
         return send(ws, listing);
       }
@@ -3203,7 +3289,11 @@ async function startServer(opts) {
           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" };
           store.upsert(base);
           store.apply(msg.id, msg.event);
-        } else store.apply(msg.id, msg.event);
+        } else {
+          if (msg.cwd) store.patch(msg.id, { workdir: msg.cwd });
+          settleByHook(msg.id, ev);
+          store.apply(msg.id, msg.event);
+        }
         logDroppedRequest(msg.id, msg.event, before, store.get(msg.id));
         return;
       }
@@ -3336,14 +3426,15 @@ async function startServer(opts) {
   }
   wss.on("connection", (ws, req) => {
     ws.on("error", (e) => log(`socket error: ${e.message}`));
-    if (req.url?.startsWith("/ssh/")) {
+    const path = requestPath(req.url);
+    if (path.startsWith("/ssh/")) {
       if (remoteClients.size >= 20) {
         ws.close(1013, "Too many remote connections");
         return;
       }
       remoteClients.add(ws);
       ws.once("close", () => remoteClients.delete(ws));
-      const parsed = SshAliasSchema.safeParse(req.url.slice(5));
+      const parsed = SshAliasSchema.safeParse(path.slice(5));
       if (!parsed.success) {
         ws.close(1008, "Invalid SSH alias");
         remoteClients.delete(ws);
@@ -3388,7 +3479,8 @@ async function startServer(opts) {
       for (const u of unsubscribeHistory) u();
       relay.close();
       for (const c of wss.clients) c.terminate();
-      wss.close(() => res());
+      for (const socket of sockets) socket.destroy();
+      wss.close(() => httpServer.close(() => res()));
     })
   };
 }

package/dist/cli/{hook-WQYL4YFH.js → hook-W46IWB7I.js}

@@ -1,19 +1,20 @@
 import {
   QUESTION_TOOLS,
   gitInfo
-} from "./chunk-JVELEEIO.js";
+} from "./chunk-OHKQKXYM.js";
 import {
   CODEX_ENV_VAR,
   CODEX_HOOK_VAR,
   codexPlan
-} from "./chunk-564TJJZ6.js";
+} from "./chunk-GMKS55KF.js";
 import {
   log
-} from "./chunk-L6IGH4LF.js";
+} from "./chunk-YUSY3E47.js";
 import {
   connect
-} from "./chunk-XPWGZIYL.js";
-import "./chunk-WM4MAV46.js";
+} from "./chunk-TC3XJUJA.js";
+import "./chunk-JOCNCNRP.js";
+import "./chunk-FGOFRWIB.js";
 
 // src/cli/hook.ts
 import { readFileSync, openSync, fstatSync, readSync, closeSync } from "fs";

package/dist/cli/index.js

@@ -17,7 +17,7 @@ async function hookMain(args) {
   try {
     const chunks = [];
     for await (const c of process.stdin) chunks.push(c);
-    const { runHook } = await import("./hook-WQYL4YFH.js");
+    const { runHook } = await import("./hook-W46IWB7I.js");
     const out = await runHook(event, Buffer.concat(chunks).toString("utf8"), { tool });
     if (out) process.stdout.write(`${out}
 `);
@@ -29,7 +29,7 @@ async function main(argv) {
   const [cmd, ...rest] = argv;
   switch (cmd) {
     case "daemon": {
-      const { startDaemon } = await import("./daemon-SGTQRTHV.js");
+      const { startDaemon } = await import("./daemon-RI47DJDX.js");
       await startDaemon();
       await new Promise(() => {
       });
@@ -37,44 +37,44 @@ async function main(argv) {
     }
     case "--version":
     case "version": {
-      const { LEDGE_VERSION } = await import("./version-XFBINYKQ.js");
+      const { LEDGE_VERSION } = await import("./version-SO5OMPGD.js");
       console.log(LEDGE_VERSION);
       return 0;
     }
     case "setup": {
-      const { runSetup } = await import("./setup-RMPIUCPH.js");
+      const { runSetup } = await import("./setup-7AEH5DC3.js");
       for (const l of await runSetup()) console.log(l);
       return 0;
     }
     case "uninstall": {
-      const { runUninstall } = await import("./uninstall-GI4WT3UQ.js");
+      const { runUninstall } = await import("./uninstall-7U7ENKOS.js");
       const r = await runUninstall({ purge: rest.includes("--purge") });
       for (const l of r.lines) console.log(l);
       return r.ok ? 0 : 1;
     }
     case "status": {
-      const { printStatus } = await import("./status-GGXF4DSQ.js");
+      const { printStatus } = await import("./status-QOXWNLLF.js");
       console.log(await printStatus());
       return 0;
     }
     case "who": {
-      const { printWho } = await import("./who-EJWN7HM6.js");
+      const { printWho } = await import("./who-WVYFPCII.js");
       console.log(await printWho());
       return 0;
     }
     case "bridge": {
-      const { bridge } = await import("./bridge-2CVD7BMI.js");
+      const { bridge } = await import("./bridge-ZOHP53DV.js");
       await bridge();
       return 0;
     }
     case "claude":
     case "codex":
     case "cursor": {
-      const { launch } = await import("./launch-I4T5MFWF.js");
+      const { launch } = await import("./launch-S6XFRSZA.js");
       return launch(cmd, rest);
     }
     case "attach": {
-      const { attach } = await import("./attach-HPGWEUKX.js");
+      const { attach } = await import("./attach-2DEXQEC2.js");
       return attach(rest[0] ?? "");
     }
     default:

package/dist/cli/{launch-I4T5MFWF.js → launch-S6XFRSZA.js}

@@ -5,15 +5,16 @@ import {
   ensureDaemon,
   launch,
   parseLaunchArgs
-} from "./chunk-N3MPPCON.js";
+} from "./chunk-IC5RHOX6.js";
 import {
   agentEnv,
   exitFile
-} from "./chunk-564TJJZ6.js";
-import "./chunk-3TNPEAMR.js";
-import "./chunk-L6IGH4LF.js";
-import "./chunk-XPWGZIYL.js";
-import "./chunk-WM4MAV46.js";
+} from "./chunk-GMKS55KF.js";
+import "./chunk-TO4XO2ML.js";
+import "./chunk-YUSY3E47.js";
+import "./chunk-TC3XJUJA.js";
+import "./chunk-JOCNCNRP.js";
+import "./chunk-FGOFRWIB.js";
 export {
   DaemonError,
   agentEnv,

package/dist/cli/{setup-RMPIUCPH.js → setup-7AEH5DC3.js}

@@ -13,9 +13,10 @@ import {
   runSetup,
   stopDetachedDaemon,
   systemdUnit
-} from "./chunk-Q5CLZPYJ.js";
-import "./chunk-3TNPEAMR.js";
-import "./chunk-L6IGH4LF.js";
+} from "./chunk-Q7RCYJ4X.js";
+import "./chunk-TO4XO2ML.js";
+import "./chunk-YUSY3E47.js";
+import "./chunk-FGOFRWIB.js";
 export {
   CLAUDE_EVENTS,
   CODEX_EVENTS,

package/dist/cli/{status-GGXF4DSQ.js → status-QOXWNLLF.js}

@@ -1,7 +1,8 @@
 import {
   connect
-} from "./chunk-XPWGZIYL.js";
-import "./chunk-WM4MAV46.js";
+} from "./chunk-TC3XJUJA.js";
+import "./chunk-JOCNCNRP.js";
+import "./chunk-FGOFRWIB.js";
 
 // src/cli/status.ts
 async function printStatus(opts = {}) {

package/dist/cli/{uninstall-GI4WT3UQ.js → uninstall-7U7ENKOS.js}

@@ -2,11 +2,12 @@ import {
   SERVICE,
   execRunner,
   stopDetachedDaemon
-} from "./chunk-Q5CLZPYJ.js";
-import "./chunk-3TNPEAMR.js";
+} from "./chunk-Q7RCYJ4X.js";
+import "./chunk-TO4XO2ML.js";
+import "./chunk-YUSY3E47.js";
 import {
   paths
-} from "./chunk-L6IGH4LF.js";
+} from "./chunk-FGOFRWIB.js";
 
 // src/cli/uninstall.ts
 import { readFile, writeFile, rename, rm, lstat, realpath } from "fs/promises";

package/dist/cli/{version-XFBINYKQ.js → version-SO5OMPGD.js}

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

package/dist/cli/{who-EJWN7HM6.js → who-WVYFPCII.js}

@@ -1,9 +1,10 @@
 import {
   connect
-} from "./chunk-XPWGZIYL.js";
+} from "./chunk-TC3XJUJA.js";
 import {
   isArchived
-} from "./chunk-WM4MAV46.js";
+} from "./chunk-JOCNCNRP.js";
+import "./chunk-FGOFRWIB.js";
 
 // src/cli/who.ts
 import { basename } from "path";

package/package.json

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

package/dist/cli/chunk-LWPKX7SB.js

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