@paradow/ledge 0.11.0 → 0.12.0

package/dist/cli/{chunk-JOCNCNRP.js → chunk-VY45MACP.js}

@@ -2,125 +2,6 @@ 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"]);
@@ -188,6 +69,9 @@ var SessionSchema = z.object({
   startedAt: z.string().datetime(),
   lastActivityAt: z.string().datetime(),
   lastHookAt: z.string().datetime().optional(),
+  /** The model and effort Ledge launched the agent with (#58); left out, the agent's own default. */
+  model: z.string().optional(),
+  effort: z.string().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. */
@@ -206,7 +90,7 @@ function isArchived(s) {
 }
 
 // ../protocol/src/messages.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // ../protocol/src/chat.ts
 import { z as z2 } from "zod";
@@ -270,34 +154,60 @@ var ReposInspectSchema = z3.object({
 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
+// ../protocol/src/models.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(), manifest: z4.string().max(200).optional() });
-var ReposFoundSchema = z4.object({ type: z4.literal("repos.found"), requestId: z4.string(), repos: z4.array(FoundRepoSchema).max(500), truncated: z4.boolean(), error: z4.string().optional() });
+var ModelIdSchema = z4.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
+var EffortSchema = z4.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
+var ModelChoiceSchema = z4.object({
+  id: ModelIdSchema,
+  label: z4.string(),
+  description: z4.string().optional(),
+  efforts: z4.array(EffortSchema).optional(),
+  defaultEffort: EffortSchema.optional(),
+  isDefault: z4.boolean().optional()
+});
+var ModelsListSchema = z4.object({
+  type: z4.literal("models.list"),
+  requestId: z4.string().min(1).max(100),
+  tool: ToolSchema,
+  machineId: z4.string().optional()
+});
+var ModelsListingSchema = z4.object({
+  type: z4.literal("models.listing"),
+  requestId: z4.string(),
+  tool: ToolSchema,
+  models: z4.array(ModelChoiceSchema),
+  error: z4.string().optional()
+});
 
-// ../protocol/src/documents.ts
+// ../protocol/src/scan.ts
 import { z as z5 } from "zod";
+var ReposScanSchema = z5.object({ type: z5.literal("repos.scan"), requestId: z5.string().min(1).max(100), machineId: z5.string().optional() });
+var FoundRepoSchema = z5.object({ path: z5.string(), branch: z5.string().nullable(), remote: z5.string().optional(), manifest: z5.string().max(200).optional() });
+var ReposFoundSchema = z5.object({ type: z5.literal("repos.found"), requestId: z5.string(), repos: z5.array(FoundRepoSchema).max(500), truncated: z5.boolean(), error: z5.string().optional() });
+
+// ../protocol/src/documents.ts
+import { z as z6 } 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"),
+var path = z6.string().min(1).max(4096);
+var requestId = z6.string().min(1);
+var DocumentReadSchema = z6.object({
+  type: z6.literal("document.read"),
   requestId,
   path,
-  machineId: z5.string().optional(),
-  sessionId: z5.string().min(1).optional(),
+  machineId: z6.string().optional(),
+  sessionId: z6.string().min(1).optional(),
   basePath: path.optional()
 });
-var DocumentContentSchema = z5.object({
-  type: z5.literal("document.content"),
+var DocumentContentSchema = z6.object({
+  type: z6.literal("document.content"),
   requestId,
   path,
-  text: z5.string(),
-  bytes: z5.number().int().nonnegative(),
-  modifiedAt: z5.string().datetime()
+  text: z6.string(),
+  bytes: z6.number().int().nonnegative(),
+  modifiedAt: z6.string().datetime()
 });
-var DocumentErrorCodeSchema = z5.enum([
+var DocumentErrorCodeSchema = z6.enum([
   "not_found",
   "not_file",
   "unsupported_path",
@@ -309,47 +219,47 @@ var DocumentErrorCodeSchema = z5.enum([
   "session_missing",
   "read_failed"
 ]);
-var DocumentErrorSchema = z5.object({
-  type: z5.literal("document.error"),
+var DocumentErrorSchema = z6.object({
+  type: z6.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)
+import { z as z7 } from "zod";
+var MachineInventorySchema = z7.object({
+  id: z7.string().min(1).max(80),
+  label: z7.string().min(1).max(120),
+  online: z7.boolean(),
+  local: z7.boolean(),
+  sessions: z7.array(z7.object({ id: z7.string(), name: z7.string(), project: z7.string(), cwd: z7.string(), topic: z7.string().optional(), state: z7.string(), readOnly: z7.boolean() })).max(500),
+  folders: z7.array(z7.object({ project: z7.string(), cwd: z7.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 RoutingContextSchema = z7.object({
+  machines: z7.array(MachineInventorySchema).min(1).max(20),
+  history: z7.array(z7.object({ question: z7.string().max(2e4), answer: z7.string().max(2e4).optional(), machineId: z7.string().optional() })).max(50)
 });
-var RouteResultSchema = z6.object({
+var RouteResultSchema = z7.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()
+  machineId: z7.string().nullable(),
+  text: z7.string().min(1).max(2e4),
+  choices: z7.array(z7.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}$/);
+import { z as z8 } from "zod";
+var SshAliasSchema = z8.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({
+import { z as z9 } from "zod";
+var MachineIdSchema = z9.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var MachineSchema = z9.object({
   id: MachineIdSchema,
-  label: z8.string().trim().min(1).max(80),
+  label: z9.string().trim().min(1).max(80),
   ssh: SshAliasSchema.optional()
 });
-var MachinesSchema = z8.array(MachineSchema).min(1).max(20).superRefine((list, ctx) => {
+var MachinesSchema = z9.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) => {
@@ -364,51 +274,51 @@ var MachinesSchema = z8.array(MachineSchema).min(1).max(20).superRefine((list, c
 });
 
 // ../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({
+import { z as z10 } from "zod";
+var IslandScaleSchema = z10.union([z10.literal("auto"), z10.literal(1), z10.literal(1.25), z10.literal(1.5), z10.literal(2)]);
+var IslandPrefsSchema = z10.object({
   /** Shown at the top of the screen; hidden, Desktop still notifies. */
-  visible: z9.boolean(),
+  visible: z10.boolean(),
   /** The primary screen, or the first other one. */
-  screen: z9.enum(["primary", "second"]),
-  position: z9.enum(["center", "left", "right"]),
+  screen: z10.enum(["primary", "second"]),
+  position: z10.enum(["center", "left", "right"]),
   /** A strip under a maximised window. */
-  discreet: z9.boolean(),
+  discreet: z10.boolean(),
   islandScale: IslandScaleSchema,
   panelScale: IslandScaleSchema,
   /** What the island shows besides asks and questions, which it always shows. */
-  shows: z9.object({
+  shows: z10.object({
     /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
-    quick: z9.boolean(),
+    quick: z10.boolean(),
     /** The 6 s bubble when an agent finishes. */
-    finished: z9.boolean(),
+    finished: z10.boolean(),
     /** An agent's sentence in a bubble. */
-    say: z9.boolean(),
+    say: z10.boolean(),
     /** The sub-agents next to their main agent. */
-    helpers: z9.boolean()
+    helpers: z10.boolean()
   }),
   /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
-  shortcut: z9.string().trim().min(1).max(40)
+  shortcut: z10.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}$/);
+import { z as z11 } from "zod";
+var ProjectColorSchema = z11.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
+var ProjectIdSchema = z11.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({
+var PathSchema = z11.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
+var RepoSchema = z11.object({ machine: MachineIdSchema, path: PathSchema });
+var ProjectSchema = z11.object({
   id: ProjectIdSchema,
-  name: z10.string().trim().min(1).max(80),
+  name: z11.string().trim().min(1).max(80),
   color: ProjectColorSchema,
-  description: z10.string().max(500).default(""),
-  repos: z10.array(RepoSchema).max(50)
+  description: z11.string().max(500).default(""),
+  repos: z11.array(RepoSchema).max(50)
 });
-var RuleSchema = z10.object({ machine: MachineIdSchema, path: PathSchema, project: ProjectIdSchema });
+var RuleSchema = z11.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();
@@ -434,7 +344,7 @@ ${rule.path}`;
   });
   return out;
 }
-var ProjectsSchema = z10.object({ projects: z10.array(ProjectSchema).max(100), rules: z10.array(RuleSchema).max(1e3) }).superRefine((p, ctx) => {
+var ProjectsSchema = z11.object({ projects: z11.array(ProjectSchema).max(100), rules: z11.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: [] };
@@ -452,45 +362,45 @@ function projectOf(session, state) {
 }
 
 // ../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() }),
+import { z as z12 } from "zod";
+var ToolStatusSchema = z12.enum(["running", "success", "failed", "unknown"]);
+var FileChangeSchema = z12.object({ path: z12.string().min(1), from: z12.string().min(1).optional(), change: z12.enum(["add", "edit", "delete", "write"]), diff: z12.string().optional() });
+var base = { id: z12.string().min(1), at: z12.string().datetime(), turn: z12.number().int().nonnegative(), helperId: z12.string().optional() };
+var ThreadItemSchema = z12.discriminatedUnion("kind", [
+  z12.object({ kind: z12.literal("prompt"), ...base, text: z12.string() }),
+  z12.object({ kind: z12.literal("message"), ...base, text: z12.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([]) }),
+  z12.object({ kind: z12.literal("tool"), ...base, tool: z12.string(), label: z12.string(), input: z12.string().optional(), output: z12.string().optional(), error: z12.string().optional(), status: ToolStatusSchema, durationMs: z12.number().nonnegative().optional(), files: z12.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"]) }),
-  /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread. */
-  z11.object({ kind: z11.literal("sent"), ...base, to: z11.string(), peer: z11.string().optional(), summary: z11.string().optional(), text: z11.string(), status: z11.enum(["sending", "delivered", "read", "failed"]), received: z11.string().optional() }),
+  z12.object({ kind: z12.literal("permission"), ...base, tool: z12.string(), text: z12.string(), decision: z12.enum(["accept", "deny", "always", "unknown"]).optional() }),
+  z12.object({ kind: z12.literal("reply"), ...base, text: z12.string() }),
+  z12.object({ kind: z12.literal("helper"), ...base, task: z12.string(), agentType: z12.string().optional(), state: z12.enum(["working", "exited"]) }),
+  /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread, `via` set when Ledge's mailbox carries it. */
+  z12.object({ kind: z12.literal("sent"), ...base, to: z12.string(), peer: z12.string().optional(), summary: z12.string().optional(), text: z12.string(), status: z12.enum(["sending", "delivered", "read", "failed"]), received: z12.string().optional(), via: z12.literal("ledge").optional() }),
   /** A message another agent sent to this session; `from` is its from-name (else its address), `sent` the paired item's id in the peer's thread. */
-  z11.object({ kind: z11.literal("received"), ...base, from: z11.string(), peer: z11.string().optional(), text: z11.string(), sent: z11.string().optional() }),
+  z12.object({ kind: z12.literal("received"), ...base, from: z12.string(), peer: z12.string().optional(), text: z12.string(), sent: z12.string().optional() }),
   /** An automated notice of the agent's harness about messages between sessions (Claude Code's `[Cross-session idle
    *  notice]` / `[Cross-session delivery notice]`): a system event, never the user's words. `name` is the session it is
    *  about as quoted, `peer` its Ledge session id; a delivery notice says the outcome of `count` messages to `recipients`. */
-  z11.object({
-    kind: z11.literal("notice"),
+  z12.object({
+    kind: z12.literal("notice"),
     ...base,
-    notice: z11.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
-    name: z11.string().optional(),
-    peer: z11.string().optional(),
-    time: z11.string().optional(),
-    summary: z11.string().optional(),
-    status: z11.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
-    count: z11.number().int().positive().optional(),
-    recipients: z11.array(z11.string()).optional(),
-    reason: z11.string().optional(),
-    text: z11.string()
+    notice: z12.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
+    name: z12.string().optional(),
+    peer: z12.string().optional(),
+    time: z12.string().optional(),
+    summary: z12.string().optional(),
+    status: z12.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
+    count: z12.number().int().positive().optional(),
+    recipients: z12.array(z12.string()).optional(),
+    reason: z12.string().optional(),
+    text: z12.string()
   })
 ]);
 
 // ../protocol/src/decisions.ts
-import { z as z12 } from "zod";
-var DecisionSchema = z12.enum(["accept", "deny", "always"]);
+import { z as z13 } from "zod";
+var DecisionSchema = z13.enum(["accept", "deny", "always"]);
 var NOTE_MAX = 4e3;
 var NOTE_NOT_TYPED = "note_not_typed";
 var DECISION_OFFERS = {
@@ -519,192 +429,215 @@ function pendingKey(p) {
 
 // ../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(),
+var SessionEventSchema = z14.object({
+  name: z14.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed"]),
+  at: z14.string().datetime(),
+  source: z14.enum(["hook", "pane", "daemon"]),
+  tool: z14.string().optional(),
+  text: z14.string().optional(),
+  options: z14.array(z14.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(),
+  optionDetails: z14.array(z14.string()).optional(),
+  kind: z14.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(),
+  body: z14.string().optional(),
+  exitCode: z14.number().int().nullable().optional(),
+  helperId: z14.string().optional(),
   /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z13.string().optional(),
+  task: z14.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z13.boolean().optional(),
+  interrupt: z14.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(),
+  toolUseId: z14.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(),
+  toolInput: z14.record(z14.string(), z14.unknown()).optional(),
   /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
-  output: z13.string().optional(),
-  durationMs: z13.number().nonnegative().optional(),
+  output: z14.string().optional(),
+  durationMs: z14.number().nonnegative().optional(),
   /** PostToolUseFailure: the harness's error message. */
-  error: z13.string().optional(),
+  error: z14.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(),
+  transcriptPath: z14.string().optional(),
   /** Decided: what was chosen when the daemon knows it. */
   decision: DecisionSchema.optional(),
   /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
-  agentSessionId: z13.string().optional()
+  agentSessionId: z14.string().optional()
 });
-var RecentSchema = z13.object({ cwd: z13.string().min(1), project: z13.string().min(1), lastAt: z13.string().datetime() });
+var RecentSchema = z14.object({ cwd: z14.string().min(1), project: z14.string().min(1), lastAt: z14.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(), archive: 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 }),
+var DaemonInfoSchema = z14.object({
+  version: z14.string(),
+  install: z14.enum(["npm", "git", "unknown"]),
+  systemd: z14.boolean(),
+  manual: z14.string().optional(),
+  routing: z14.boolean().optional(),
+  archive: z14.boolean().optional(),
+  /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
+  models: z14.boolean().optional(),
+  /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
+  home: z14.string().optional()
+});
+var UpdateFailureSchema = z14.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z14.discriminatedUnion("type", [
+  z14.object({ type: z14.literal("chat.routed"), qid: z14.string(), result: RouteResultSchema }),
   DocumentContentSchema,
   DocumentErrorSchema,
   ReposInfoSchema,
   ReposFoundSchema,
+  ModelsListingSchema,
   /** `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()) }),
+  z14.object({ type: z14.literal("snapshot"), sessions: z14.array(SessionSchema), recents: z14.array(RecentSchema).optional(), launcher: z14.array(z14.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z14.object({ type: z14.literal("session.updated"), session: SessionSchema }),
+  z14.object({ type: z14.literal("session.removed"), id: z14.string() }),
+  z14.object({ type: z14.literal("session.preview"), id: z14.string(), lines: z14.array(z14.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 }),
+  z14.object({ type: z14.literal("session.thread"), id: z14.string(), items: z14.array(ThreadItemSchema) }),
+  z14.object({ type: z14.literal("session.thread.item"), id: z14.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) }),
+  z14.object({ type: z14.literal("session.launched"), id: z14.string() }),
+  z14.object({ type: z14.literal("recents"), recents: z14.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(),
+  z14.object({
+    type: z14.literal("folder.listing"),
+    path: z14.string(),
+    parent: z14.string().nullable(),
+    entries: z14.array(z14.string()),
+    error: z14.string().optional(),
     /** The request this answers, when it carried one. */
-    requestId: z13.string().optional(),
+    requestId: z14.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()
+    repos: z14.array(z14.object({ name: z14.string(), branch: z14.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(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
-  z13.object({ type: z13.literal("chat.error"), qid: z13.string(), message: z13.string() }),
-  z13.object({ type: z13.literal("chat.history"), turns: z13.array(ChatTurnSchema) }),
+  z14.object({ type: z14.literal("chat.step"), qid: z14.string(), step: ChatStepSchema }),
+  z14.object({ type: z14.literal("chat.delta"), qid: z14.string(), text: z14.string() }),
+  z14.object({ type: z14.literal("chat.done"), qid: z14.string(), text: z14.string(), at: z14.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
+  z14.object({ type: z14.literal("chat.error"), qid: z14.string(), message: z14.string() }),
+  z14.object({ type: z14.literal("chat.history"), turns: z14.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"]) }),
+  z14.object({ type: z14.literal("update.progress"), version: z14.string(), step: z14.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() }),
+  z14.object({ type: z14.literal("update.failed"), version: z14.string(), reason: UpdateFailureSchema, detail: z14.string().optional(), command: z14.string().optional() }),
   /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
-  z13.object({ type: z13.literal("machines"), machines: MachinesSchema }),
+  z14.object({ type: z14.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 }),
+  z14.object({ type: z14.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(),
+  z14.object({ type: z14.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  /** The daemon's immediate answer to a `session.message`: delivered (`accepted`), held for later (`queued`), left to Claude's own SendMessage (`native`), or refused with a `reason`. */
+  z14.object({ type: z14.literal("message.ack"), rid: z14.string(), outcome: z14.enum(["accepted", "queued", "native", "refused"]), reason: z14.string().optional() }),
+  z14.object({
+    type: z14.literal("error"),
+    message: z14.string(),
+    id: z14.string().optional(),
     /** Le type du message client refusé. */
-    request: z13.string().optional(),
+    request: z14.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()
+    code: z14.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 }),
+var MESSAGE_MAX = 2e4;
+var SUMMARY_MAX = 500;
+var ClientMessageSchema = z14.discriminatedUnion("type", [
+  z14.object({ type: z14.literal("chat.route"), qid: z14.string().min(1).max(100), text: z14.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
   DocumentReadSchema,
   ReposInspectSchema,
   ReposScanSchema,
+  ModelsListSchema,
   /** 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"),
+   *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields
+   *  but `rows`, `model` and `effort`. */
+  z14.object({
+    type: z14.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(),
+    cwd: z14.string().min(1),
+    name: z14.string().optional(),
+    prompt: z14.string().optional(),
+    continue: z14.boolean().optional(),
+    qid: z14.string().min(1).optional(),
     /** With `qid`: the card's rows to launch (#24), indexes into the turn's `proposals`, each once; the first row without it. */
-    rows: z13.array(z13.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice").optional(),
+    rows: z14.array(z14.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice").optional(),
     /** Folders in addition to `cwd` (Claude: `--add-dir`); resolved like `cwd`. */
-    dirs: z13.array(z13.string().min(1)).max(20).optional(),
+    dirs: z14.array(z14.string().min(1)).max(20).optional(),
+    /** The agent's model and effort (#58), the agent's own default when left out; with `qid`, for every row launched. */
+    model: ModelIdSchema.optional(),
+    effort: EffortSchema.optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z13.string().optional()
+    machineId: z14.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(),
+  z14.object({
+    type: z14.literal("folder.list"),
+    path: z14.string().optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z13.string().optional(),
+    machineId: z14.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()
+    requestId: z14.string().min(1).max(100).optional()
   }),
-  z13.object({
-    type: z13.literal("folder.create"),
-    parent: z13.string().min(1),
-    name: z13.string().min(1),
+  z14.object({
+    type: z14.literal("folder.create"),
+    parent: z14.string().min(1),
+    name: z14.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()
+    machineId: z14.string().optional(),
+    requestId: z14.string().min(1).max(100).optional()
   }),
-  z13.object({ type: z13.literal("session.reply"), id: z13.string(), text: z13.string().min(1) }),
+  z14.object({ type: z14.literal("session.reply"), id: z14.string(), text: z14.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) }),
+  z14.object({ type: z14.literal("session.relay"), qid: z14.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) }),
+  z14.object({ type: z14.literal("session.relay.cancel"), qid: z14.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(),
+  z14.object({
+    type: z14.literal("session.decide"),
+    id: z14.string(),
     decision: DecisionSchema,
-    note: z13.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z14.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()
+    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z14.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() }),
+  z14.object({ type: z14.literal("session.focus"), id: z14.string() }),
+  z14.object({ type: z14.literal("session.kill"), id: z14.string() }),
+  z14.object({ type: z14.literal("session.interrupt"), id: z14.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() }),
+  z14.object({ type: z14.literal("session.dismiss"), id: z14.string() }),
   /** Puts a session in the archive: it leaves the live list but is kept. */
-  z13.object({ type: z13.literal("session.archive"), id: z13.string() }),
+  z14.object({ type: z14.literal("session.archive"), id: z14.string() }),
   /** Takes an archived session back out of the archive, as it was. */
-  z13.object({ type: z13.literal("session.restore"), id: z13.string() }),
+  z14.object({ type: z14.literal("session.restore"), id: z14.string() }),
   /** Starts the agent again on an archived session's conversation. */
-  z13.object({ type: z13.literal("session.resume"), id: z13.string() }),
+  z14.object({ type: z14.literal("session.resume"), id: z14.string() }),
   /** Deletes a session for good, archived or not. */
-  z13.object({ type: z13.literal("session.delete"), id: z13.string() }),
+  z14.object({ type: z14.literal("session.delete"), id: z14.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 }),
+  z14.object({ type: z14.literal("session.rename"), id: z14.string(), topic: z14.string().max(500) }),
+  z14.object({ type: z14.literal("session.thread"), id: z14.string() }),
+  z14.object({ type: z14.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) }),
+  z14.object({ type: z14.literal("session.event"), id: z14.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z14.string().optional() }),
+  z14.object({ type: z14.literal("session.unregister"), id: z14.string(), exitCode: z14.number().int().nullable() }),
+  z14.object({ type: z14.literal("snapshot.request") }),
+  z14.object({ type: z14.literal("chat.ask"), qid: z14.string().min(1), text: z14.string().min(1), tool: ToolSchema.optional() }),
+  z14.object({ type: z14.literal("chat.cancel"), qid: z14.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") }),
+  z14.object({ type: z14.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) }),
+  z14.object({ type: z14.literal("update.daemon"), version: z14.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 }),
+  z14.object({ type: z14.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 }),
+  z14.object({ type: z14.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 })
+  z14.object({ type: z14.literal("island.set"), prefs: IslandPrefsSchema }),
+  /** One session writing to another by Ledge name (`to` may end in ` [ref]`); `intercept` (the Claude hook): answer `native` unless `to` is a live non-Claude session. */
+  z14.object({ type: z14.literal("session.message"), rid: z14.string().min(1), from: z14.string().min(1), to: z14.string().min(1), text: z14.string().min(1).max(MESSAGE_MAX), summary: z14.string().max(SUMMARY_MAX).optional(), intercept: z14.boolean().optional() })
 ]);
 function parseClientMessage(raw) {
   return ClientMessageSchema.parse(raw);
@@ -796,14 +729,14 @@ function pickName(taken, preferred) {
 }
 
 // ../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()
+import { z as z15 } from "zod";
+var ProposalBlockSchema = z15.object({ cwd: z15.string().trim().min(1), prompt: z15.string().optional() });
+var RelayBlockSchema = z15.object({ session: z15.string().trim().min(1), text: z15.string().trim().min(1) });
+var ProjectBlockSchema = z15.object({
+  name: z15.string().trim().min(1).max(80),
+  description: z15.string().max(500).optional(),
+  repos: z15.array(z15.object({ path: z15.string().min(1).max(4096), why: z15.string().trim().min(1).max(200) })).min(1).max(50),
+  addTo: z15.string().trim().max(80).optional()
 });
 var BLOCK = /```ledge-(session|relay|project)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
 function extractProposal(answer) {
@@ -851,12 +784,126 @@ function sessionTitle(s) {
   return `${s.name} \xB7 ${s.topic || s.project}`;
 }
 
+// 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;
+  }
+}
+
 export {
-  hostAllowed,
-  requestAuthorized,
-  selectDaemonProtocol,
-  ensureDaemonToken,
-  readDaemonToken,
   SessionSchema,
   isArchived,
   MAX_PROPOSALS,
@@ -871,9 +918,13 @@ export {
   ProjectsSchema,
   DEFAULT_PROJECTS,
   projectOf,
+  ModelIdSchema,
+  EffortSchema,
   RouteResultSchema,
   PROTOCOL_PORT,
   RecentSchema,
+  MESSAGE_MAX,
+  SUMMARY_MAX,
   parseClientMessage,
   parseServerMessage,
   pickName,
@@ -882,5 +933,10 @@ export {
   parseRelayBlock,
   parseProjectBlock,
   cleanTopic,
-  sessionTitle
+  sessionTitle,
+  hostAllowed,
+  requestAuthorized,
+  selectDaemonProtocol,
+  ensureDaemonToken,
+  readDaemonToken
 };