@paradow/ledge 0.3.3 → 0.5.0

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

@@ -1,25 +1,27 @@
 import {
   QUESTION_TOOLS
-} from "./chunk-ZPF5I3LS.js";
+} from "./chunk-SMA4Z3N2.js";
 import {
   CODEX_ENV_VAR,
-  CODEX_HOOK_VAR,
+  CODEX_HOOK_VAR
+} from "./chunk-U4A4XKDM.js";
+import {
   log
-} from "./chunk-OUIDBDIH.js";
-import "./chunk-6ZTCETRG.js";
+} from "./chunk-P2SHPHAN.js";
 import {
   connect
-} from "./chunk-W5XAZ5IS.js";
-import "./chunk-6GMDFIGB.js";
+} from "./chunk-5HVWJTTJ.js";
+import "./chunk-Y4ODVTTN.js";
 
 // src/cli/hook.ts
 import { readFileSync, openSync, fstatSync, readSync, closeSync } from "fs";
 import { basename, join } from "path";
 var str = (v) => typeof v === "string" ? v : void 0;
 var PROMPT_MAX = 500;
+var handBack = (t) => t.startsWith('<agent-message from="');
 var promptText = (p) => {
   const t = str(p.prompt)?.trim();
-  return t ? { text: t.slice(0, PROMPT_MAX) } : {};
+  return t ? { text: t.slice(0, handBack(t) ? INPUT_MAX : PROMPT_MAX) } : {};
 };
 function describeTool(tool, input) {
   const i = input && typeof input === "object" ? input : {};
@@ -40,6 +42,29 @@ function lastReply(p) {
 
 [\u2026]` : text;
 }
+var INPUT_MAX = 8e3;
+function trimInput(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return void 0;
+  const trim = (v) => typeof v === "string" ? v.slice(0, INPUT_MAX) : Array.isArray(v) ? v.map(trim) : v && typeof v === "object" ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, trim(x)])) : v;
+  return trim(input);
+}
+function toolOutput(response) {
+  if (response === null || response === void 0) return void 0;
+  let text;
+  if (typeof response === "string") text = response;
+  else if (Array.isArray(response)) text = response.map((b) => str(b?.text) ?? "").filter(Boolean).join("\n");
+  else if (typeof response === "object" && ("stdout" in response || "stderr" in response)) {
+    const r = response;
+    text = [str(r.stdout), str(r.stderr)].filter(Boolean).join("\n");
+  } else {
+    try {
+      text = JSON.stringify(response);
+    } catch {
+      text = String(response);
+    }
+  }
+  return text.slice(0, REPLY_MAX);
+}
 var NON_TERMINAL_END_REASONS = /* @__PURE__ */ new Set(["clear", "resume"]);
 function mapClaudeHook(eventName, payload, at) {
   return mapHook("claude", eventName, payload, at);
@@ -89,18 +114,29 @@ function mapEvent(eventName, p, at, launched) {
   const tool = str(p.tool_name);
   const agentId = str(p.agent_id) || void 0;
   const base = { at, source: "hook", ...agentId ? { helperId: agentId } : {} };
+  const toolUseId = str(p.tool_use_id) || void 0;
+  const toolInput = trimInput(p.tool_input);
+  const call = { ...toolUseId ? { toolUseId } : {}, ...toolInput ? { toolInput } : {} };
+  const transcript = str(p.transcript_path) ? { transcriptPath: str(p.transcript_path) } : {};
+  const duration = typeof p.duration_ms === "number" && p.duration_ms >= 0 ? { durationMs: p.duration_ms } : {};
   switch (eventName) {
     case "SubagentStart":
     case "SubagentStop": {
       if (!agentId) return null;
       const type = str(p.agent_type) || void 0;
       const task = eventName === "SubagentStart" ? (str(p.description) || str(p.prompt))?.split("\n")[0] : void 0;
-      return { name: eventName, ...base, ...type ? { tool: type } : {}, ...task ? { text: task } : {} };
+      const report = eventName === "SubagentStop" ? lastReply(p) : void 0;
+      const agentTranscript = eventName === "SubagentStop" && str(p.agent_transcript_path) ? { transcriptPath: str(p.agent_transcript_path) } : {};
+      return { name: eventName, ...base, ...type ? { tool: type } : {}, ...task ? { text: task } : {}, ...report ? { text: report } : {}, ...agentTranscript };
+    }
+    case "PostToolUse": {
+      const output = toolOutput(p.tool_response);
+      return { name: "PostToolUse", ...base, tool, ...call, ...output !== void 0 ? { output } : {}, ...duration };
+    }
+    case "PostToolUseFailure": {
+      const error = str(p.error) || void 0;
+      return { name: "PostToolUseFailure", ...base, tool, ...call, ...error ? { error } : {}, ...duration, ...p.is_interrupt === true ? { interrupt: true } : {} };
     }
-    case "PostToolUse":
-      return { name: "PostToolUse", ...base, tool };
-    case "PostToolUseFailure":
-      return { name: "PostToolUseFailure", ...base, tool, ...p.is_interrupt === true ? { interrupt: true } : {} };
     case "StopFailure": {
       const error = str(p.error);
       const details = str(p.error_details);
@@ -113,25 +149,27 @@ function mapEvent(eventName, p, at, launched) {
     case "SessionStart":
       return { name: "SessionStart", ...base };
     case "UserPromptSubmit":
-      return { name: "UserPromptSubmit", ...base, ...promptText(p) };
+      return { name: "UserPromptSubmit", ...base, ...promptText(p), ...transcript };
     case "Stop": {
       const text = lastReply(p);
-      return { name: "Stop", ...base, ...text ? { text } : {} };
+      return { name: "Stop", ...base, ...text ? { text } : {}, ...transcript };
     }
     case "SessionEnd":
       if (launched) return null;
       if (NON_TERMINAL_END_REASONS.has(str(p.reason) ?? "")) return null;
       return { name: "SessionEnd", ...base, exitCode: null };
     case "PermissionRequest":
-      return { name: "PermissionRequest", ...base, tool, text: describeTool(tool, p.tool_input) };
+      return { name: "PermissionRequest", ...base, tool, text: describeTool(tool, p.tool_input), ...call, ...transcript };
     case "PreToolUse": {
       if (tool && QUESTION_TOOLS.has(tool)) {
         const qs = p.tool_input?.questions ?? [];
         const q = qs[0];
-        const options = (q?.options ?? []).map((o) => str(o.label) ?? "").filter(Boolean);
-        return { name: "PreToolUse", ...base, tool, text: str(q?.question) ?? "", options };
+        const opts = (q?.options ?? []).filter((o) => !!str(o.label));
+        const options = opts.map((o) => str(o.label));
+        const optionDetails = opts.map((o) => str(o.description)?.trim() ?? "");
+        return { name: "PreToolUse", ...base, tool, text: str(q?.question) ?? "", options, ...optionDetails.some(Boolean) ? { optionDetails } : {}, ...call, ...transcript };
       }
-      return { name: "PreToolUse", ...base, tool, text: describeTool(tool, p.tool_input) };
+      return { name: "PreToolUse", ...base, tool, text: describeTool(tool, p.tool_input), ...call, ...transcript };
     }
     case "Notification": {
       const type = str(p.notification_type) ?? "";
@@ -219,6 +257,7 @@ function mapCursorHelperEvent(eventName, p, at, helperId) {
 }
 function mapCursorEvent(eventName, p, at, launched, transcript) {
   const { name: tool, input } = unwrapTool(str(p.tool_name), p.tool_input);
+  const toolInput = p.tool_input ? trimInput(input) : void 0;
   const base = { at, source: "hook" };
   switch (eventName) {
     case "sessionStart":
@@ -234,9 +273,9 @@ function mapCursorEvent(eventName, p, at, launched, transcript) {
       return { name: "PreToolUse", ...base, tool, text: describeCursorTool(input) };
     }
     case "postToolUse":
-      return { name: "PostToolUse", ...base, tool };
+      return { name: "PostToolUse", ...base, tool, ...toolInput ? { toolInput } : {} };
     case "postToolUseFailure":
-      return { name: "PostToolUseFailure", ...base, tool, ...p.is_interrupt === true ? { interrupt: true } : {} };
+      return { name: "PostToolUseFailure", ...base, tool, ...toolInput ? { toolInput } : {}, ...p.is_interrupt === true ? { interrupt: true } : {} };
     case "stop":
       if (str(p.status) === "error") return { name: "StopFailure", ...base };
       return { name: "Stop", ...base };
@@ -276,6 +315,7 @@ async function runHook(eventName, stdin, opts = {}) {
   }
 }
 export {
+  INPUT_MAX,
   REPLY_MAX,
   codexLedgeId,
   cursorReply,
@@ -284,5 +324,7 @@ export {
   mapHook,
   readTranscript,
   runHook,
+  toolOutput,
+  trimInput,
   underCodexDaemon
 };

package/dist/cli/index.js

@@ -8,6 +8,7 @@ ledge hook [codex|cursor] <Event>                            receive a hook (rea
 ledge setup                                                  install hooks and ~/.ledge
 ledge uninstall [--purge]                                    remove hooks, service and link (--purge: ~/.ledge too)
 ledge status                                                 list sessions
+ledge bridge                                                 exchange Ledge messages over SSH stdio
 ledge --version                                              print the installed version`;
 async function hookMain(args) {
   const tool = args[0] === "codex" || args[0] === "cursor" ? args[0] : void 0;
@@ -15,7 +16,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-KFSK75QH.js");
     await runHook(event, Buffer.concat(chunks).toString("utf8"), { tool });
   } catch {
   }
@@ -25,7 +26,7 @@ async function main(argv) {
   const [cmd, ...rest] = argv;
   switch (cmd) {
     case "daemon": {
-      const { startDaemon } = await import("./daemon-D5YDWUHB.js");
+      const { startDaemon } = await import("./daemon-6UFCIFQF.js");
       await startDaemon();
       await new Promise(() => {
       });
@@ -33,34 +34,39 @@ async function main(argv) {
     }
     case "--version":
     case "version": {
-      const { LEDGE_VERSION } = await import("./version-3DLAAFBS.js");
+      const { LEDGE_VERSION } = await import("./version-IWGIZJJV.js");
       console.log(LEDGE_VERSION);
       return 0;
     }
     case "setup": {
-      const { runSetup } = await import("./setup-KUWSQLVG.js");
+      const { runSetup } = await import("./setup-EXA6OG5W.js");
       for (const l of await runSetup()) console.log(l);
       return 0;
     }
     case "uninstall": {
-      const { runUninstall } = await import("./uninstall-5GHUYN7P.js");
+      const { runUninstall } = await import("./uninstall-34TVL5BP.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-IW2FESH4.js");
+      const { printStatus } = await import("./status-I7FHW6ZM.js");
       console.log(await printStatus());
       return 0;
     }
+    case "bridge": {
+      const { bridge } = await import("./bridge-R6DKTSYF.js");
+      await bridge();
+      return 0;
+    }
     case "claude":
     case "codex":
     case "cursor": {
-      const { launch } = await import("./launch-DFB54ANN.js");
+      const { launch } = await import("./launch-YKYPT6BU.js");
       return launch(cmd, rest);
     }
     case "attach": {
-      const { attach } = await import("./attach-YBGTDBQI.js");
+      const { attach } = await import("./attach-CUKFTN63.js");
       return attach(rest[0] ?? "");
     }
     default:

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

@@ -5,15 +5,15 @@ import {
   ensureDaemon,
   launch,
   parseLaunchArgs
-} from "./chunk-Y44XZY6I.js";
-import "./chunk-7ICDC2LK.js";
+} from "./chunk-QHDPDZOJ.js";
 import {
   agentEnv,
   exitFile
-} from "./chunk-OUIDBDIH.js";
-import "./chunk-6ZTCETRG.js";
-import "./chunk-W5XAZ5IS.js";
-import "./chunk-6GMDFIGB.js";
+} from "./chunk-U4A4XKDM.js";
+import "./chunk-XZMLFV6H.js";
+import "./chunk-P2SHPHAN.js";
+import "./chunk-5HVWJTTJ.js";
+import "./chunk-Y4ODVTTN.js";
 export {
   DaemonError,
   agentEnv,

package/dist/cli/{setup-KUWSQLVG.js → setup-EXA6OG5W.js}

@@ -13,8 +13,9 @@ import {
   runSetup,
   stopDetachedDaemon,
   systemdUnit
-} from "./chunk-XDRYMOVF.js";
-import "./chunk-6ZTCETRG.js";
+} from "./chunk-HGNMPXXR.js";
+import "./chunk-XZMLFV6H.js";
+import "./chunk-P2SHPHAN.js";
 export {
   CLAUDE_EVENTS,
   CODEX_EVENTS,

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

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

package/dist/cli/{uninstall-5GHUYN7P.js → uninstall-34TVL5BP.js}

@@ -2,10 +2,11 @@ import {
   SERVICE,
   execRunner,
   stopDetachedDaemon
-} from "./chunk-XDRYMOVF.js";
+} from "./chunk-HGNMPXXR.js";
+import "./chunk-XZMLFV6H.js";
 import {
   paths
-} from "./chunk-6ZTCETRG.js";
+} from "./chunk-P2SHPHAN.js";
 
 // src/cli/uninstall.ts
 import { readFile, writeFile, rename, rm, lstat, realpath } from "fs/promises";

package/dist/cli/{version-3DLAAFBS.js → version-IWGIZJJV.js}

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

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@paradow/ledge",
-  "version": "0.3.3",
+  "version": "0.5.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-6GMDFIGB.js

@@ -1,306 +0,0 @@
-// ../protocol/src/messages.ts
-import { z as z4 } from "zod";
-
-// ../protocol/src/session.ts
-import { z } from "zod";
-var ToolSchema = z.enum(["claude", "codex", "cursor"]);
-var SessionStateSchema = z.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
-var PendingSchema = z.object({
-  kind: z.enum(["question", "permission", "plan", "diff"]),
-  text: z.string(),
-  tool: z.string().optional(),
-  options: z.array(z.string()).optional(),
-  source: z.enum(["hook", "pane"]),
-  /** Set when the request comes from a helper (subagent): it is routed through its parent. */
-  helperId: z.string().optional(),
-  /** For a helper-routed request: the state the parent returns to once it is answered (main thread may stop meanwhile). */
-  parentState: SessionStateSchema.optional()
-});
-var ReplySchema = z.object({
-  text: z.string(),
-  at: z.string().datetime()
-});
-var HelperSchema = z.object({
-  id: z.string(),
-  kind: z.string(),
-  task: z.string(),
-  state: SessionStateSchema
-});
-var TopicSourceSchema = z.enum(["user", "pane", "prompt"]);
-var SessionSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  tool: ToolSchema,
-  cwd: z.string(),
-  project: z.string(),
-  title: z.string(),
-  /** One line saying what the session is about (spec 2026-10-11 §3). */
-  topic: z.string().optional(),
-  topicSource: TopicSourceSchema.optional(),
-  /** The repository (its main worktree's folder name and absolute path), the checked-out branch, and whether `cwd` is a linked worktree (§4). */
-  repo: z.string().optional(),
-  repoPath: z.string().optional(),
-  branch: z.string().optional(),
-  worktree: z.boolean().optional(),
-  tmuxSession: z.string().nullable(),
-  state: SessionStateSchema,
-  pending: PendingSchema.optional(),
-  helpers: z.array(HelperSchema).default([]),
-  lastReply: ReplySchema.optional(),
-  startedAt: z.string().datetime(),
-  lastActivityAt: z.string().datetime(),
-  lastHookAt: z.string().datetime().optional(),
-  exitCode: z.number().int().nullable().optional(),
-  exitedAt: z.string().datetime().optional(),
-  lastError: z.string().optional(),
-  source: z.enum(["launcher", "hook_only"])
-});
-
-// ../protocol/src/chat.ts
-import { z as z2 } from "zod";
-var ChatStepSchema = z2.object({
-  kind: z2.enum(["sessions", "pane", "reply", "git", "repo"]),
-  id: z2.string().optional(),
-  name: z2.string().optional(),
-  path: z2.string().optional()
-});
-var ChatTurnSchema = z2.object({
-  qid: z2.string().min(1),
-  question: z2.string(),
-  askedAt: z2.string().datetime(),
-  steps: z2.array(ChatStepSchema),
-  answer: z2.string().optional(),
-  answeredAt: z2.string().datetime().optional(),
-  error: z2.string().optional()
-});
-
-// ../protocol/src/documents.ts
-import { z as z3 } from "zod";
-var DOCUMENT_MAX_BYTES = 1048576;
-var path = z3.string().min(1).max(4096);
-var requestId = z3.string().min(1);
-var DocumentReadSchema = z3.object({
-  type: z3.literal("document.read"),
-  requestId,
-  path,
-  sessionId: z3.string().min(1).optional(),
-  basePath: path.optional()
-});
-var DocumentContentSchema = z3.object({
-  type: z3.literal("document.content"),
-  requestId,
-  path,
-  text: z3.string(),
-  bytes: z3.number().int().nonnegative(),
-  modifiedAt: z3.string().datetime()
-});
-var DocumentErrorCodeSchema = z3.enum([
-  "not_found",
-  "not_file",
-  "unsupported_path",
-  "unsupported_type",
-  "permission_denied",
-  "too_large",
-  "invalid_utf8",
-  "ambiguous_path",
-  "session_missing",
-  "read_failed"
-]);
-var DocumentErrorSchema = z3.object({
-  type: z3.literal("document.error"),
-  requestId,
-  path,
-  code: DocumentErrorCodeSchema
-});
-
-// ../protocol/src/messages.ts
-var PROTOCOL_PORT = 47831;
-var SessionEventSchema = z4.object({
-  name: z4.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed"]),
-  at: z4.string().datetime(),
-  source: z4.enum(["hook", "pane", "daemon"]),
-  tool: z4.string().optional(),
-  text: z4.string().optional(),
-  options: z4.array(z4.string()).optional(),
-  kind: z4.enum(["question", "permission", "plan", "diff"]).optional(),
-  exitCode: z4.number().int().nullable().optional(),
-  helperId: z4.string().optional(),
-  /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z4.string().optional(),
-  /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z4.boolean().optional()
-});
-var RecentSchema = z4.object({ cwd: z4.string().min(1), project: z4.string().min(1), lastAt: z4.string().datetime() });
-var SEMVER = /^\d+\.\d+\.\d+$/;
-var DaemonInfoSchema = z4.object({ version: z4.string(), install: z4.enum(["npm", "git", "unknown"]), systemd: z4.boolean(), manual: z4.string().optional() });
-var UpdateFailureSchema = z4.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
-var ServerMessageSchema = z4.discriminatedUnion("type", [
-  DocumentContentSchema,
-  DocumentErrorSchema,
-  /** `recents`: the folders of past sessions, most recent first. `launcher`: the command that runs `ledge` inside WSL
-   *  (`[node, cli]`), so the overlay can attach a terminal to a session with `<launcher> attach <id>`. `daemon`: absent
-   *  from daemons older than the auto-update. */
-  z4.object({ type: z4.literal("snapshot"), sessions: z4.array(SessionSchema), recents: z4.array(RecentSchema).optional(), launcher: z4.array(z4.string()).optional(), daemon: DaemonInfoSchema.optional() }),
-  z4.object({ type: z4.literal("session.updated"), session: SessionSchema }),
-  z4.object({ type: z4.literal("session.removed"), id: z4.string() }),
-  z4.object({ type: z4.literal("session.preview"), id: z4.string(), lines: z4.array(z4.string()) }),
-  /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
-  z4.object({ type: z4.literal("session.launched"), id: z4.string() }),
-  z4.object({ type: z4.literal("recents"), recents: z4.array(RecentSchema) }),
-  /** Answer to the requester of a `folder.list` or `folder.create`: `path` resolved (`~` expanded), `parent` null at the
-   *  root, `entries` its subfolders by name (hidden ones left out). A failure keeps the asked path and says why in `error`,
-   *  never in an `error` message, which the launch form reads as a failed launch. */
-  z4.object({ type: z4.literal("folder.listing"), path: z4.string(), parent: z4.string().nullable(), entries: z4.array(z4.string()), error: z4.string().optional() }),
-  /** 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.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). */
-  z4.object({ type: z4.literal("update.progress"), version: z4.string(), step: z4.enum(["installing", "restarting"]) }),
-  /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
-  z4.object({ type: z4.literal("update.failed"), version: z4.string(), reason: UpdateFailureSchema, detail: z4.string().optional(), command: z4.string().optional() }),
-  z4.object({ type: z4.literal("error"), message: z4.string(), id: z4.string().optional() })
-]);
-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() }),
-  /** 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) }),
-  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() }),
-  z4.object({ type: z4.literal("session.interrupt"), id: z4.string() }),
-  /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
-  z4.object({ type: z4.literal("session.dismiss"), id: z4.string() }),
-  /** The user names the session's topic from the overlay (500 characters at most, the hook's prompt cap); an empty topic hands back to the automatic sources. */
-  z4.object({ type: z4.literal("session.rename"), id: z4.string(), topic: z4.string().max(500) }),
-  z4.object({ type: z4.literal("session.register"), session: SessionSchema }),
-  /** `agent` and `cwd` describe the session when the daemon does not know it yet (a hook from an agent started without ledge). */
-  z4.object({ type: z4.literal("session.event"), id: z4.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z4.string().optional() }),
-  z4.object({ type: z4.literal("session.unregister"), id: z4.string(), exitCode: z4.number().int().nullable() }),
-  z4.object({ type: z4.literal("snapshot.request") }),
-  z4.object({ type: z4.literal("chat.ask"), qid: z4.string().min(1), text: z4.string().min(1), tool: ToolSchema.optional() }),
-  z4.object({ type: z4.literal("chat.cancel"), qid: z4.string().min(1) }),
-  /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
-  z4.object({ type: z4.literal("chat.reset") }),
-  /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
-  z4.object({ type: z4.literal("update.daemon"), version: z4.string().regex(SEMVER) })
-]);
-function parseClientMessage(raw) {
-  return ClientMessageSchema.parse(raw);
-}
-function parseServerMessage(raw) {
-  return ServerMessageSchema.parse(raw);
-}
-
-// ../protocol/src/names.ts
-var NAMES = [
-  "Otto",
-  "Pim",
-  "Nova",
-  "Bix",
-  "Lu",
-  "Max",
-  "Ida",
-  "Rex",
-  "Zoe",
-  "Kit",
-  "Ari",
-  "Bo",
-  "Cal",
-  "Dee",
-  "Eli",
-  "Fay",
-  "Gus",
-  "Hal",
-  "Ivy",
-  "Jax",
-  "Kai",
-  "Lio",
-  "Mo",
-  "Nia",
-  "Oz",
-  "Pax",
-  "Quin",
-  "Rae",
-  "Sol",
-  "Tad",
-  "Uma",
-  "Vic",
-  "Wyn",
-  "Xen",
-  "Yan",
-  "Zia",
-  "Abe",
-  "Bea",
-  "Cy",
-  "Dot",
-  "Eva",
-  "Fin",
-  "Gil",
-  "Hen",
-  "Iro",
-  "Jo",
-  "Kip",
-  "Lex",
-  "Mia",
-  "Ned",
-  "Ola",
-  "Pat",
-  "Rio",
-  "Sam",
-  "Tia",
-  "Ulf",
-  "Val",
-  "Wes",
-  "Yui",
-  "Zed",
-  "Ash",
-  "Bry",
-  "Cleo",
-  "Dax"
-];
-var cap = (s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
-function pickName(taken, preferred) {
-  const used = new Set(taken);
-  const free = (n) => !used.has(n);
-  const wanted = preferred?.trim();
-  if (wanted) {
-    const base = cap(wanted);
-    if (free(base)) return base;
-    for (let i = 2; ; i++) if (free(`${base}-${i}`)) return `${base}-${i}`;
-  }
-  const first = NAMES.find(free);
-  if (first) return first;
-  for (let i = 2; ; i++) if (free(`${NAMES[0]}-${i}`)) return `${NAMES[0]}-${i}`;
-}
-
-// ../protocol/src/topic.ts
-var TOPIC_MAX = 80;
-function cleanTopic(text) {
-  const line = text.split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0) ?? "";
-  const flat = line.replace(/\s+/g, " ");
-  return flat.length > TOPIC_MAX ? `${flat.slice(0, TOPIC_MAX - 1).trimEnd()}\u2026` : flat;
-}
-function sessionTitle(s) {
-  return `${s.name} \xB7 ${s.topic || s.project}`;
-}
-
-export {
-  DOCUMENT_MAX_BYTES,
-  SessionSchema,
-  PROTOCOL_PORT,
-  RecentSchema,
-  parseClientMessage,
-  parseServerMessage,
-  pickName,
-  cleanTopic,
-  sessionTitle
-};

package/dist/cli/chunk-HDZVQH6J.js

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