@paradow/ledge 0.5.4 → 0.6.0

package/dist/cli/chunk-AEV7ODMZ.js

@@ -0,0 +1,698 @@
+// ../protocol/src/messages.ts
+import { z as z13 } 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(),
+  /** What to review in full before deciding, when `text` is only its summary: a plan's markdown. */
+  body: z.string().optional(),
+  tool: z.string().optional(),
+  options: z.array(z.string()).optional(),
+  /** Each option's description, by index ('' when it has none); left out when no option has one. */
+  optionDetails: 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(),
+  /** The reply is a plan the agent proposes (Codex Plan mode): nothing in it is done yet. */
+  plan: z.boolean().optional()
+});
+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({
+  /** Origin is annotated by the overlay, never used as an unqualified session id on the wire. */
+  machineId: z.string().optional(),
+  machineName: z.string().optional(),
+  repoId: z.string().optional(),
+  /** Annotated by the fleet when its machine is unreachable and the last snapshot is kept (keepStale, spec 2026-10-14 §6). */
+  offline: z.boolean().optional(),
+  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(),
+  /** The agent's own session id when Ledge chose it at launch (Claude Code `--session-id`). */
+  agentSessionId: z.string().optional(),
+  /** The agent's transcript: the latest one a hook named (it follows /clear and --resume), else the one the launch implies. */
+  transcriptPath: z.string().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 ChatProposalSchema = z2.object({
+  cwd: z2.string().min(1),
+  project: z2.string(),
+  prompt: z2.string().optional(),
+  tool: ToolSchema,
+  launchedId: z2.string().optional(),
+  error: z2.string().optional()
+});
+var ChatRelaySchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string(),
+  tool: ToolSchema,
+  text: z2.string().min(1),
+  status: z2.enum(["queued", "sent"]).optional(),
+  sentAt: z2.string().datetime().optional(),
+  error: z2.string().optional()
+});
+var ChatProjectProposalSchema = z2.object({
+  name: z2.string().min(1).max(80),
+  description: z2.string().max(500).optional(),
+  repos: z2.array(z2.object({ path: z2.string().min(1).max(4096), why: z2.string().min(1).max(200) })).min(1).max(50),
+  addTo: z2.string().min(1).max(80).optional()
+});
+var ChatTurnSchema = z2.object({
+  machineId: z2.string().optional(),
+  machineName: z2.string().optional(),
+  choices: z2.array(z2.object({ id: z2.string(), label: z2.string() })).optional(),
+  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(),
+  proposal: ChatProposalSchema.optional(),
+  relay: ChatRelaySchema.optional(),
+  projectProposal: ChatProjectProposalSchema.optional()
+});
+
+// ../protocol/src/repos.ts
+import { z as z3 } from "zod";
+var ReposInspectSchema = z3.object({
+  type: z3.literal("repos.inspect"),
+  requestId: z3.string().min(1).max(100),
+  paths: z3.array(z3.string().min(1)).min(1).max(50),
+  machineId: z3.string().optional()
+});
+var RepoInfoSchema = z3.object({ path: z3.string(), exists: z3.boolean(), branch: z3.string().nullable() });
+var ReposInfoSchema = z3.object({ type: z3.literal("repos.info"), requestId: z3.string(), repos: z3.array(RepoInfoSchema) });
+
+// ../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 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
+import { z as z5 } from "zod";
+var DOCUMENT_MAX_BYTES = 1048576;
+var path = z5.string().min(1).max(4096);
+var requestId = z5.string().min(1);
+var DocumentReadSchema = z5.object({
+  type: z5.literal("document.read"),
+  requestId,
+  path,
+  machineId: z5.string().optional(),
+  sessionId: z5.string().min(1).optional(),
+  basePath: path.optional()
+});
+var DocumentContentSchema = z5.object({
+  type: z5.literal("document.content"),
+  requestId,
+  path,
+  text: z5.string(),
+  bytes: z5.number().int().nonnegative(),
+  modifiedAt: z5.string().datetime()
+});
+var DocumentErrorCodeSchema = z5.enum([
+  "not_found",
+  "not_file",
+  "unsupported_path",
+  "unsupported_type",
+  "permission_denied",
+  "too_large",
+  "invalid_utf8",
+  "ambiguous_path",
+  "session_missing",
+  "read_failed"
+]);
+var DocumentErrorSchema = z5.object({
+  type: z5.literal("document.error"),
+  requestId,
+  path,
+  code: DocumentErrorCodeSchema
+});
+
+// ../protocol/src/routing.ts
+import { z as z6 } from "zod";
+var MachineInventorySchema = z6.object({
+  id: z6.string().min(1).max(80),
+  label: z6.string().min(1).max(120),
+  online: z6.boolean(),
+  local: z6.boolean(),
+  sessions: z6.array(z6.object({ id: z6.string(), name: z6.string(), project: z6.string(), cwd: z6.string(), topic: z6.string().optional(), state: z6.string(), readOnly: z6.boolean() })).max(500),
+  folders: z6.array(z6.object({ project: z6.string(), cwd: z6.string() })).max(100)
+});
+var RoutingContextSchema = z6.object({
+  machines: z6.array(MachineInventorySchema).min(1).max(20),
+  history: z6.array(z6.object({ question: z6.string().max(2e4), answer: z6.string().max(2e4).optional(), machineId: z6.string().optional() })).max(50)
+});
+var RouteResultSchema = z6.object({
+  /** Null means an answer or a clarification, never an implicit local destination. */
+  machineId: z6.string().nullable(),
+  text: z6.string().min(1).max(2e4),
+  choices: z6.array(z6.string()).max(20).optional()
+});
+
+// ../protocol/src/ssh.ts
+import { z as z7 } from "zod";
+var SshAliasSchema = z7.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
+
+// ../protocol/src/machines.ts
+import { z as z8 } from "zod";
+var MachineIdSchema = z8.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var MachineSchema = z8.object({
+  id: MachineIdSchema,
+  label: z8.string().trim().min(1).max(80),
+  ssh: SshAliasSchema.optional()
+});
+var MachinesSchema = z8.array(MachineSchema).min(1).max(20).superRefine((list, ctx) => {
+  if (list[0]?.id !== "local" || list[0].ssh !== void 0) ctx.addIssue({ code: "custom", message: "the first machine is local, without ssh", path: [0] });
+  const ids = /* @__PURE__ */ new Set(), aliases = /* @__PURE__ */ new Set();
+  list.forEach((m, i) => {
+    if (i > 0 && !m.ssh) ctx.addIssue({ code: "custom", message: "a remote machine needs an ssh alias", path: [i, "ssh"] });
+    if (ids.has(m.id)) ctx.addIssue({ code: "custom", message: `duplicate id ${m.id}`, path: [i, "id"] });
+    ids.add(m.id);
+    if (m.ssh) {
+      if (aliases.has(m.ssh)) ctx.addIssue({ code: "custom", message: `duplicate ssh alias ${m.ssh}`, path: [i, "ssh"] });
+      aliases.add(m.ssh);
+    }
+  });
+});
+
+// ../protocol/src/island.ts
+import { z as z9 } from "zod";
+var IslandScaleSchema = z9.union([z9.literal("auto"), z9.literal(1), z9.literal(1.25), z9.literal(1.5), z9.literal(2)]);
+var IslandPrefsSchema = z9.object({
+  /** Shown at the top of the screen; hidden, Desktop still notifies. */
+  visible: z9.boolean(),
+  /** The primary screen, or the first other one. */
+  screen: z9.enum(["primary", "second"]),
+  position: z9.enum(["center", "left", "right"]),
+  /** A strip under a maximised window. */
+  discreet: z9.boolean(),
+  islandScale: IslandScaleSchema,
+  panelScale: IslandScaleSchema,
+  /** What the island shows besides asks and questions, which it always shows. */
+  shows: z9.object({
+    /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
+    quick: z9.boolean(),
+    /** The 6 s bubble when an agent finishes. */
+    finished: z9.boolean(),
+    /** An agent's sentence in a bubble. */
+    say: z9.boolean(),
+    /** The sub-agents next to their main agent. */
+    helpers: z9.boolean()
+  }),
+  /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
+  shortcut: z9.string().trim().min(1).max(40)
+});
+
+// ../protocol/src/projects.ts
+import { z as z10 } from "zod";
+var ProjectColorSchema = z10.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
+var ProjectIdSchema = z10.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+function normalizePath(raw) {
+  const p = raw.trim().replace(/\/+/g, "/");
+  return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+}
+var PathSchema = z10.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
+var RepoSchema = z10.object({ machine: MachineIdSchema, path: PathSchema });
+var ProjectSchema = z10.object({
+  id: ProjectIdSchema,
+  name: z10.string().trim().min(1).max(80),
+  color: ProjectColorSchema,
+  description: z10.string().max(500).default(""),
+  repos: z10.array(RepoSchema).max(50)
+});
+var RuleSchema = z10.object({ machine: MachineIdSchema, path: PathSchema, project: ProjectIdSchema });
+function projectsProblems(p) {
+  const out = [];
+  const ids = /* @__PURE__ */ new Set(), names = /* @__PURE__ */ new Set(), repos = /* @__PURE__ */ new Set(), rules = /* @__PURE__ */ new Set();
+  p.projects.forEach((project, i) => {
+    if (ids.has(project.id)) out.push({ code: "duplicate_id", path: ["projects", i, "id"] });
+    ids.add(project.id);
+    const name = project.name.trim().toLocaleLowerCase();
+    if (names.has(name)) out.push({ code: "duplicate_name", path: ["projects", i, "name"] });
+    names.add(name);
+    project.repos.forEach((repo, j) => {
+      const key = `${repo.machine}
+${repo.path}`;
+      if (repos.has(key)) out.push({ code: "duplicate_repo", path: ["projects", i, "repos", j] });
+      repos.add(key);
+    });
+  });
+  p.rules.forEach((rule, i) => {
+    const key = `${rule.machine}
+${rule.path}`;
+    if (rules.has(key)) out.push({ code: "duplicate_rule", path: ["rules", i] });
+    rules.add(key);
+    if (!ids.has(rule.project)) out.push({ code: "unknown_project", path: ["rules", i, "project"] });
+  });
+  return out;
+}
+var ProjectsSchema = z10.object({ projects: z10.array(ProjectSchema).max(100), rules: z10.array(RuleSchema).max(1e3) }).superRefine((p, ctx) => {
+  for (const problem of projectsProblems(p)) ctx.addIssue({ code: "custom", message: problem.code, path: problem.path });
+});
+var DEFAULT_PROJECTS = { projects: [], rules: [] };
+var under = (cwd, path2) => path2 === "/" || cwd === path2 || cwd.startsWith(`${path2}/`);
+function projectOf(session, state) {
+  const machine = session.machineId ?? "local";
+  const cwd = normalizePath(session.cwd);
+  const known = new Set(state.projects.map((p) => p.id));
+  const candidates = [
+    ...state.projects.flatMap((p) => p.repos.filter((r) => r.machine === machine).map((r) => ({ project: p.id, path: r.path, rule: false }))),
+    ...state.rules.filter((r) => r.machine === machine && known.has(r.project)).map((r) => ({ project: r.project, path: r.path, rule: true }))
+  ].filter((c) => under(cwd, c.path));
+  candidates.sort((x, y) => y.path.length - x.path.length || Number(y.rule) - Number(x.rule));
+  return candidates[0]?.project ?? null;
+}
+
+// ../protocol/src/thread.ts
+import { z as z11 } from "zod";
+var ToolStatusSchema = z11.enum(["running", "success", "failed", "unknown"]);
+var FileChangeSchema = z11.object({ path: z11.string().min(1), from: z11.string().min(1).optional(), change: z11.enum(["add", "edit", "delete", "write"]), diff: z11.string().optional() });
+var base = { id: z11.string().min(1), at: z11.string().datetime(), turn: z11.number().int().nonnegative(), helperId: z11.string().optional() };
+var ThreadItemSchema = z11.discriminatedUnion("kind", [
+  z11.object({ kind: z11.literal("prompt"), ...base, text: z11.string() }),
+  z11.object({ kind: z11.literal("message"), ...base, text: z11.string() }),
+  /** `id` is the harness's tool_use_id when it gives one, so the result updates the same row. */
+  z11.object({ kind: z11.literal("tool"), ...base, tool: z11.string(), label: z11.string(), input: z11.string().optional(), output: z11.string().optional(), error: z11.string().optional(), status: ToolStatusSchema, durationMs: z11.number().nonnegative().optional(), files: z11.array(FileChangeSchema).default([]) }),
+  /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again. */
+  z11.object({ kind: z11.literal("permission"), ...base, tool: z11.string(), text: z11.string(), decision: z11.enum(["accept", "deny", "always", "unknown"]).optional() }),
+  z11.object({ kind: z11.literal("reply"), ...base, text: z11.string() }),
+  z11.object({ kind: z11.literal("helper"), ...base, task: z11.string(), agentType: z11.string().optional(), state: z11.enum(["working", "exited"]) })
+]);
+
+// ../protocol/src/decisions.ts
+import { z as z12 } from "zod";
+var DecisionSchema = z12.enum(["accept", "deny", "always"]);
+var NOTE_MAX = 4e3;
+var NOTE_NOT_TYPED = "note_not_typed";
+var DECISION_OFFERS = {
+  claude: { always: ["permission", "diff", "plan"], note: ["permission", "diff", "plan"] },
+  codex: { always: ["permission", "diff"], note: ["permission", "diff", "plan"] },
+  cursor: { always: [], note: ["permission", "plan"] }
+};
+function offers(tool, kind, what) {
+  return DECISION_OFFERS[tool][what].includes(kind);
+}
+function cyrb53(str, seed) {
+  let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
+}
+function pendingKey(p) {
+  const s = JSON.stringify([p.kind, p.text, p.body ?? null, p.tool ?? null, p.options ?? null, p.optionDetails ?? null, p.helperId ?? null]);
+  return cyrb53(s, 0) + cyrb53(s, 1);
+}
+
+// ../protocol/src/messages.ts
+var PROTOCOL_PORT = 47831;
+var SessionEventSchema = z13.object({
+  name: z13.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed"]),
+  at: z13.string().datetime(),
+  source: z13.enum(["hook", "pane", "daemon"]),
+  tool: z13.string().optional(),
+  text: z13.string().optional(),
+  options: z13.array(z13.string()).optional(),
+  /** Each option's description, by index ('' when it has none); left out when no option has one. */
+  optionDetails: z13.array(z13.string()).optional(),
+  kind: z13.enum(["question", "permission", "plan", "diff"]).optional(),
+  /** PanePrompt: what to review in full before deciding (a plan read in the terminal), when `text` is its summary. */
+  body: z13.string().optional(),
+  exitCode: z13.number().int().nullable().optional(),
+  helperId: z13.string().optional(),
+  /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
+  task: z13.string().optional(),
+  /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
+  interrupt: z13.boolean().optional(),
+  /** Native tracking (spec 2026-10-13 §2): the harness's id of the tool call, so its result lands on the same row. */
+  toolUseId: z13.string().optional(),
+  /** The tool's input as the harness gave it, every string capped by the hook. */
+  toolInput: z13.record(z13.string(), z13.unknown()).optional(),
+  /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
+  output: z13.string().optional(),
+  durationMs: z13.number().nonnegative().optional(),
+  /** PostToolUseFailure: the harness's error message. */
+  error: z13.string().optional(),
+  /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
+  transcriptPath: z13.string().optional(),
+  /** Decided: what was chosen when the daemon knows it. */
+  decision: DecisionSchema.optional()
+});
+var RecentSchema = z13.object({ cwd: z13.string().min(1), project: z13.string().min(1), lastAt: z13.string().datetime() });
+var SEMVER = /^\d+\.\d+\.\d+$/;
+var DaemonInfoSchema = z13.object({ version: z13.string(), install: z13.enum(["npm", "git", "unknown"]), systemd: z13.boolean(), manual: z13.string().optional(), routing: z13.boolean().optional() });
+var UpdateFailureSchema = z13.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z13.discriminatedUnion("type", [
+  z13.object({ type: z13.literal("chat.routed"), qid: z13.string(), result: RouteResultSchema }),
+  DocumentContentSchema,
+  DocumentErrorSchema,
+  ReposInfoSchema,
+  ReposFoundSchema,
+  /** `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. */
+  z13.object({ type: z13.literal("snapshot"), sessions: z13.array(SessionSchema), recents: z13.array(RecentSchema).optional(), launcher: z13.array(z13.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z13.object({ type: z13.literal("session.updated"), session: SessionSchema }),
+  z13.object({ type: z13.literal("session.removed"), id: z13.string() }),
+  z13.object({ type: z13.literal("session.preview"), id: z13.string(), lines: z13.array(z13.string()) }),
+  /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
+  z13.object({ type: z13.literal("session.thread"), id: z13.string(), items: z13.array(ThreadItemSchema) }),
+  z13.object({ type: z13.literal("session.thread.item"), id: z13.string(), item: ThreadItemSchema }),
+  /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
+  z13.object({ type: z13.literal("session.launched"), id: z13.string() }),
+  z13.object({ type: z13.literal("recents"), recents: z13.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. */
+  z13.object({
+    type: z13.literal("folder.listing"),
+    path: z13.string(),
+    parent: z13.string().nullable(),
+    entries: z13.array(z13.string()),
+    error: z13.string().optional(),
+    /** The request this answers, when it carried one. */
+    requestId: z13.string().optional(),
+    /** Those `entries` that are Git repositories, with their branch (the short commit when HEAD is detached). */
+    repos: z13.array(z13.object({ name: z13.string(), branch: z13.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. */
+  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.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). */
+  z13.object({ type: z13.literal("update.progress"), version: z13.string(), step: z13.enum(["installing", "restarting"]) }),
+  /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
+  z13.object({ type: z13.literal("update.failed"), version: z13.string(), reason: UpdateFailureSchema, detail: z13.string().optional(), command: z13.string().optional() }),
+  /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
+  z13.object({ type: z13.literal("machines"), machines: MachinesSchema }),
+  /** The local daemon's projects and folder rules (spec 2026-10-16 build §5), sent to local clients only. */
+  z13.object({ type: z13.literal("projects"), projects: ProjectsSchema }),
+  /** The island's settings shared by the local fronts; null until a front sets them (the island then sends its own). Local clients only. */
+  z13.object({ type: z13.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  z13.object({
+    type: z13.literal("error"),
+    message: z13.string(),
+    id: z13.string().optional(),
+    /** Le type du message client refusé. */
+    request: z13.string().optional(),
+    /** Ce que le front doit reconnaître au-delà du texte (NOTE_NOT_TYPED) ; une chaîne libre, qu'un front plus ancien ignore. */
+    code: z13.string().optional()
+  })
+]);
+var ClientMessageSchema = z13.discriminatedUnion("type", [
+  z13.object({ type: z13.literal("chat.route"), qid: z13.string().min(1).max(100), text: z13.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
+  DocumentReadSchema,
+  ReposInspectSchema,
+  ReposScanSchema,
+  /** 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.
+   *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields. */
+  z13.object({
+    type: z13.literal("session.launch"),
+    tool: ToolSchema,
+    cwd: z13.string().min(1),
+    name: z13.string().optional(),
+    prompt: z13.string().optional(),
+    continue: z13.boolean().optional(),
+    qid: z13.string().min(1).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. */
+    machineId: z13.string().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`. */
+  z13.object({
+    type: z13.literal("folder.list"),
+    path: z13.string().optional(),
+    /** Routing by the fleet, removed before the message reaches the daemon. */
+    machineId: z13.string().optional(),
+    /** 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("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) }),
+  /** Takes the card's queued instruction back out of the queue. */
+  z13.object({ type: z13.literal("session.relay.cancel"), qid: z13.string().min(1) }),
+  /** `always` and `note` only where the harness offers them (`offers`); a note goes with `deny`, for the agent to read. */
+  z13.object({
+    type: z13.literal("session.decide"),
+    id: z13.string(),
+    decision: DecisionSchema,
+    note: z13.string().trim().min(1).max(NOTE_MAX).optional(),
+    /** The request the user saw when deciding: refused (the request changed) unless it is still the pending one. Left out by older fronts and the island.
+     *  `key` (pendingKey) covers its whole content; older fronts send kind and text only. */
+    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z13.string().max(64).optional() }).optional()
+  }),
+  z13.object({ type: z13.literal("session.focus"), id: z13.string() }),
+  z13.object({ type: z13.literal("session.kill"), id: z13.string() }),
+  z13.object({ type: z13.literal("session.interrupt"), id: z13.string() }),
+  /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
+  z13.object({ type: z13.literal("session.dismiss"), id: z13.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. */
+  z13.object({ type: z13.literal("session.rename"), id: z13.string(), topic: z13.string().max(500) }),
+  z13.object({ type: z13.literal("session.thread"), id: z13.string() }),
+  z13.object({ type: z13.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). */
+  z13.object({ type: z13.literal("session.event"), id: z13.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z13.string().optional() }),
+  z13.object({ type: z13.literal("session.unregister"), id: z13.string(), exitCode: z13.number().int().nullable() }),
+  z13.object({ type: z13.literal("snapshot.request") }),
+  z13.object({ type: z13.literal("chat.ask"), qid: z13.string().min(1), text: z13.string().min(1), tool: ToolSchema.optional() }),
+  z13.object({ type: z13.literal("chat.cancel"), qid: z13.string().min(1) }),
+  /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
+  z13.object({ type: z13.literal("chat.reset") }),
+  /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
+  z13.object({ type: z13.literal("update.daemon"), version: z13.string().regex(SEMVER) }),
+  /** Replaces the daemon's machines list (first connected front wins); refused unless valid. */
+  z13.object({ type: z13.literal("machines.set"), machines: MachinesSchema }),
+  /** Replaces the local daemon's projects and rules as a whole; refused unless valid. */
+  z13.object({ type: z13.literal("projects.set"), projects: ProjectsSchema }),
+  /** Replaces the island's settings as a whole; refused unless valid. */
+  z13.object({ type: z13.literal("island.set"), prefs: IslandPrefsSchema })
+]);
+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 base2 = cap(wanted);
+    if (free(base2)) return base2;
+    for (let i = 2; ; i++) if (free(`${base2}-${i}`)) return `${base2}-${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/proposal.ts
+import { z as z14 } from "zod";
+var ProposalBlockSchema = z14.object({ cwd: z14.string().trim().min(1), prompt: z14.string().optional() });
+var RelayBlockSchema = z14.object({ session: z14.string().trim().min(1), text: z14.string().trim().min(1) });
+var ProjectBlockSchema = z14.object({
+  name: z14.string().trim().min(1).max(80),
+  description: z14.string().max(500).optional(),
+  repos: z14.array(z14.object({ path: z14.string().min(1).max(4096), why: z14.string().trim().min(1).max(200) })).min(1).max(50),
+  addTo: z14.string().trim().max(80).optional()
+});
+var BLOCK = /```ledge-(session|relay|project)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
+function extractProposal(answer) {
+  const found = [];
+  const text = answer.replace(BLOCK, (_m, kind, body) => {
+    found.push({ kind, raw: body.trim() });
+    return "";
+  });
+  const last = found.at(-1);
+  return last ? { text: text.replace(/\n{3,}/g, "\n\n").trim(), kind: last.kind, raw: last.raw } : { text: answer, kind: null, raw: null };
+}
+function parseProposalBlock(raw) {
+  try {
+    const r = ProposalBlockSchema.safeParse(JSON.parse(raw));
+    return r.success ? r.data : null;
+  } catch {
+    return null;
+  }
+}
+function parseRelayBlock(raw) {
+  try {
+    const r = RelayBlockSchema.safeParse(JSON.parse(raw));
+    return r.success ? r.data : null;
+  } catch {
+    return null;
+  }
+}
+function parseProjectBlock(raw) {
+  try {
+    const r = ProjectBlockSchema.safeParse(JSON.parse(raw));
+    return r.success ? r.data : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../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 {
+  SessionSchema,
+  NOTE_NOT_TYPED,
+  offers,
+  pendingKey,
+  DOCUMENT_MAX_BYTES,
+  SshAliasSchema,
+  MachinesSchema,
+  IslandPrefsSchema,
+  ProjectsSchema,
+  DEFAULT_PROJECTS,
+  projectOf,
+  RouteResultSchema,
+  PROTOCOL_PORT,
+  RecentSchema,
+  parseClientMessage,
+  parseServerMessage,
+  pickName,
+  extractProposal,
+  parseProposalBlock,
+  parseRelayBlock,
+  parseProjectBlock,
+  cleanTopic,
+  sessionTitle
+};