@paradow/ledge 0.28.0 → 0.29.0-snapshot.41306023381.1

package/dist/cli/{chunk-VKRFHDRK.js → chunk-G6ESCKEX.js}

@@ -1,42 +1,208 @@
 import {
   paths
-} from "./chunk-HOOHS3MX.js";
+} from "./chunk-W724IVDC.js";
 
-// ../protocol/src/handover.ts
+// src/auth.ts
+import { createHash, createHmac, 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;
+}
+var SESSION_KEY_VAR = "LEDGE_SESSION_KEY";
+function sessionKey(id2, token = readDaemonToken()) {
+  return token ? createHmac("sha256", token).update(`ledge-session:${id2}`).digest("hex") : void 0;
+}
+function readDaemonToken() {
+  try {
+    const raw = readFileSync(paths().token, "utf8").trim();
+    return isDaemonToken(raw) ? raw : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// ../protocol/src/asks.ts
 import { z } from "zod";
-var ContextSchema = z.object({ used: z.number().int().min(0), window: z.number().int().positive(), at: z.string().datetime() });
+var ASK_QUESTION_MAX = 2e3;
+var ASK_OPTIONS_MAX = 4e3;
+var ASK_ANSWER_MAX = 4e3;
+var AskIdSchema = z.string().regex(/^a[0-9a-f]{6}$/);
+var AskSchema = z.object({
+  id: AskIdSchema,
+  from: z.string().min(1),
+  fromName: z.string(),
+  question: z.string().min(1).max(ASK_QUESTION_MAX),
+  options: z.string().max(ASK_OPTIONS_MAX),
+  at: z.string().datetime(),
+  state: z.enum(["open", "answered", "dropped"]),
+  answer: z.object({ text: z.string().min(1).max(ASK_ANSWER_MAX), at: z.string().datetime() }).optional(),
+  closedAt: z.string().datetime().optional()
+});
+var AskRefusalSchema = z.enum(["unknown", "closed", "dropped", "not_session", "invalid"]);
+var AskCreateSchema = z.object({
+  type: z.literal("ask.create"),
+  rid: z.string().min(1).max(100),
+  by: z.string().min(1),
+  question: z.string().trim().min(1).max(ASK_QUESTION_MAX),
+  options: AskSchema.shape.options
+});
+var AskAnswerSchema = z.object({
+  type: z.literal("ask.answer"),
+  rid: z.string().min(1).max(100),
+  id: AskIdSchema,
+  text: z.string().trim().min(1).max(ASK_ANSWER_MAX),
+  machineId: z.string().optional()
+});
+var AsksMessageSchema = z.object({ type: z.literal("asks"), asks: z.array(AskSchema) });
+var AskUpdatedSchema = z.object({ type: z.literal("ask.updated"), ask: AskSchema });
+var AskResultSchema = z.object({
+  type: z.literal("ask.result"),
+  rid: z.string(),
+  ask: AskSchema.optional(),
+  code: AskRefusalSchema.optional(),
+  reason: z.string().optional()
+});
+var askShown = (a) => a.state === "open";
+
+// ../protocol/src/handover.ts
+import { z as z2 } from "zod";
+var ContextSchema = z2.object({ used: z2.number().int().min(0), window: z2.number().int().positive(), at: z2.string().datetime() });
 var CONTEXT_NEAR = 0.8;
 var CONTEXT_NEAR_MIN = 0.5;
 var CONTEXT_NEAR_MAX = 0.95;
-var ContextPrefsSchema = z.object({ near: z.number().min(CONTEXT_NEAR_MIN).max(CONTEXT_NEAR_MAX) });
+var ContextPrefsSchema = z2.object({ near: z2.number().min(CONTEXT_NEAR_MIN).max(CONTEXT_NEAR_MAX) });
 var contextShare = (c) => c ? Math.min(1, c.used / c.window) : void 0;
 var contextNear = (c, near = CONTEXT_NEAR) => (contextShare(c) ?? 0) >= near;
-var HandoverStateSchema = z.enum(["briefing", "launching", "done", "failed"]);
-var HandoverSchema = z.object({
+var HandoverStateSchema = z2.enum(["briefing", "launching", "done", "failed"]);
+var HandoverSchema = z2.object({
   state: HandoverStateSchema,
-  at: z.string().datetime(),
+  at: z2.string().datetime(),
   /** The relief, once launched. */
-  to: z.string().optional(),
-  toName: z.string().optional(),
-  reason: z.string().optional(),
+  to: z2.string().optional(),
+  toName: z2.string().optional(),
+  reason: z2.string().optional(),
   /** Started by Ledge itself (a seat working without asking), not by the user. */
-  auto: z.literal(true).optional()
+  auto: z2.literal(true).optional()
 });
-var RelievesSchema = z.object({ id: z.string(), name: z.string(), at: z.string().datetime() });
+var RelievesSchema = z2.object({ id: z2.string(), name: z2.string(), at: z2.string().datetime() });
 var BRIEF_MAX = 2e4;
-var ContextSetSchema = z.object({ type: z.literal("context.set"), prefs: ContextPrefsSchema });
-var ContextPrefsMessageSchema = z.object({ type: z.literal("context.prefs"), prefs: ContextPrefsSchema });
-var SessionHandoverSchema = z.object({ type: z.literal("session.handover"), rid: z.string().min(1).max(100), id: z.string().min(1) });
-var HandoverBriefSchema = z.object({ type: z.literal("handover.brief"), rid: z.string().min(1).max(100), by: z.string().min(1), text: z.string().min(1).max(BRIEF_MAX) });
-var HandoverShowSchema = z.object({ type: z.literal("handover.show"), rid: z.string().min(1).max(100), by: z.string().min(1) });
-var SessionHandoverResultSchema = z.object({ type: z.literal("session.handover.result"), rid: z.string(), ok: z.boolean(), reason: z.string().optional() });
-var HandoverResultSchema = z.object({ type: z.literal("handover.result"), rid: z.string(), text: z.string().optional(), reason: z.string().optional() });
+var ContextSetSchema = z2.object({ type: z2.literal("context.set"), prefs: ContextPrefsSchema });
+var ContextPrefsMessageSchema = z2.object({ type: z2.literal("context.prefs"), prefs: ContextPrefsSchema });
+var SessionHandoverSchema = z2.object({ type: z2.literal("session.handover"), rid: z2.string().min(1).max(100), id: z2.string().min(1) });
+var HandoverBriefSchema = z2.object({ type: z2.literal("handover.brief"), rid: z2.string().min(1).max(100), by: z2.string().min(1), text: z2.string().min(1).max(BRIEF_MAX) });
+var HandoverShowSchema = z2.object({ type: z2.literal("handover.show"), rid: z2.string().min(1).max(100), by: z2.string().min(1) });
+var SessionHandoverResultSchema = z2.object({ type: z2.literal("session.handover.result"), rid: z2.string(), ok: z2.boolean(), reason: z2.string().optional() });
+var HandoverResultSchema = z2.object({ type: z2.literal("handover.result"), rid: z2.string(), text: z2.string().optional(), reason: z2.string().optional() });
 
 // ../protocol/src/session.ts
-import { z as z2 } from "zod";
-var ToolSchema = z2.enum(["claude", "codex", "cursor", "omp"]);
-var OmpApprovalSchema = z2.enum(["always-ask", "write", "yolo"]);
-var AutonomySchema = z2.enum(["ask", "edits", "auto"]);
+import { z as z3 } from "zod";
+var ToolSchema = z3.enum(["claude", "codex", "cursor", "omp"]);
+var OmpApprovalSchema = z3.enum(["always-ask", "write", "yolo"]);
+var AutonomySchema = z3.enum(["ask", "edits", "auto"]);
 function autonomyArgs(tool, autonomy) {
   if (!autonomy || autonomy === "ask") return [];
   switch (tool) {
@@ -53,97 +219,95 @@ function autonomyArgs(tool, autonomy) {
 function ompApprovalFor(autonomy) {
   return autonomy === "auto" ? "yolo" : autonomy ? "always-ask" : void 0;
 }
-var BackendSchema = z2.enum(["tmux", "omp-rpc"]);
-var SessionStateSchema = z2.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
-var AskQuestionSchema = z2.object({
-  id: z2.string(),
-  question: z2.string(),
-  header: z2.string().optional(),
-  multi: z2.boolean().optional(),
-  options: z2.array(z2.object({ label: z2.string(), description: z2.string().optional() }))
-});
-var PendingSchema = z2.object({
-  kind: z2.enum(["question", "permission", "plan", "diff"]),
-  text: z2.string(),
+var BackendSchema = z3.enum(["tmux", "omp-rpc"]);
+var SessionStateSchema = z3.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
+var AskQuestionSchema = z3.object({
+  id: z3.string(),
+  question: z3.string(),
+  header: z3.string().optional(),
+  multi: z3.boolean().optional(),
+  options: z3.array(z3.object({ label: z3.string(), description: z3.string().optional() }))
+});
+var PendingSchema = z3.object({
+  kind: z3.enum(["question", "permission", "plan", "diff"]),
+  text: z3.string(),
   /** What to review in full before deciding, when `text` is only its summary: a plan's markdown. */
-  body: z2.string().optional(),
-  tool: z2.string().optional(),
-  options: z2.array(z2.string()).optional(),
+  body: z3.string().optional(),
+  tool: z3.string().optional(),
+  options: z3.array(z3.string()).optional(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z2.array(z2.string()).optional(),
+  optionDetails: z3.array(z3.string()).optional(),
   /** `rpc`: the harness's own protocol asked (OMP): answered on its request id, never by typing. */
-  source: z2.enum(["hook", "pane", "rpc"]),
+  source: z3.enum(["hook", "pane", "rpc"]),
   /** OMP: every question of one `ask` call, answered together with `session.answer`; `requestId` is the dialog it answers. */
-  questions: z2.array(AskQuestionSchema).optional(),
-  requestId: z2.string().optional(),
+  questions: z3.array(AskQuestionSchema).optional(),
+  requestId: z3.string().optional(),
   /** Set when the request comes from a helper (subagent): it is routed through its parent. */
-  helperId: z2.string().optional(),
+  helperId: z3.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 = z2.object({
-  text: z2.string(),
-  at: z2.string().datetime(),
+var ReplySchema = z3.object({
+  text: z3.string(),
+  at: z3.string().datetime(),
   /** The reply is a plan the agent proposes (Codex Plan mode): nothing in it is done yet. */
-  plan: z2.boolean().optional()
+  plan: z3.boolean().optional()
 });
-var HelperSchema = z2.object({
-  id: z2.string(),
-  kind: z2.string(),
-  task: z2.string(),
+var HelperSchema = z3.object({
+  id: z3.string(),
+  kind: z3.string(),
+  task: z3.string(),
   state: SessionStateSchema,
   /** When this helper finished; retained across daemon restarts until its five-minute expiry. */
-  finishedAt: z2.string().datetime().optional()
+  finishedAt: z3.string().datetime().optional()
 });
-var TopicSourceSchema = z2.enum(["user", "pane", "prompt"]);
-var SessionSchema = z2.object({
+var TopicSourceSchema = z3.enum(["user", "pane", "prompt"]);
+var SessionRigSchema = z3.object({ machine: z3.string(), rigId: z3.string(), rigName: z3.string(), seat: z3.string(), pod: z3.string(), member: z3.string() });
+var SessionSchema = z3.object({
   /** Origin is annotated by the overlay, never used as an unqualified session id on the wire. */
-  machineId: z2.string().optional(),
-  machineName: z2.string().optional(),
-  repoId: z2.string().optional(),
+  machineId: z3.string().optional(),
+  machineName: z3.string().optional(),
+  repoId: z3.string().optional(),
   /** Annotated by the fleet when its machine is unreachable and the last snapshot is kept (keepStale, spec 2026-10-14 §6). */
-  offline: z2.boolean().optional(),
-  id: z2.string().min(1),
-  name: z2.string().min(1),
+  offline: z3.boolean().optional(),
+  /** The permanent Ledge brain session (Lot 7). */
+  brain: z3.literal(true).optional(),
+  id: z3.string().min(1),
+  name: z3.string().min(1),
   tool: ToolSchema,
-  cwd: z2.string(),
-  project: z2.string(),
-  title: z2.string(),
+  cwd: z3.string(),
+  project: z3.string(),
+  title: z3.string(),
   /** One line saying what the session is about (spec 2026-10-11 §3). */
-  topic: z2.string().optional(),
+  topic: z3.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: z2.string().optional(),
-  repoPath: z2.string().optional(),
-  branch: z2.string().optional(),
-  worktree: z2.boolean().optional(),
+  repo: z3.string().optional(),
+  repoPath: z3.string().optional(),
+  branch: z3.string().optional(),
+  worktree: z3.boolean().optional(),
   /** The folder the agent works in now, as its last hook reported it: `cwd` stays where it started, this follows a worktree it entered. */
-  workdir: z2.string().optional(),
-  tmuxSession: z2.string().nullable(),
+  workdir: z3.string().optional(),
+  tmuxSession: z3.string().nullable(),
   /** Left out for a tmux session. `omp-rpc`: no pane, nothing to attach to; the daemon holds the process (see `agentSessionFile`). */
   backend: BackendSchema.optional(),
   state: SessionStateSchema,
   pending: PendingSchema.optional(),
-  helpers: z2.array(HelperSchema).default([]),
+  helpers: z3.array(HelperSchema).default([]),
   /** OMP: the instructions waiting in its own queue (typed while it works), as it reports them; left out when none. */
-  queue: z2.array(z2.object({ text: z2.string(), mode: z2.enum(["steer", "follow_up"]) })).optional(),
+  queue: z3.array(z3.object({ text: z3.string(), mode: z3.enum(["steer", "follow_up"]) })).optional(),
   lastReply: ReplySchema.optional(),
   /** The last message this session sent to another agent: its tool_use_id, the address, the peer's Ledge session id, a one-line summary. */
-  lastMessage: z2.object({ id: z2.string(), to: z2.string(), peer: z2.string().optional(), summary: z2.string(), at: z2.string().datetime() }).optional(),
-  startedAt: z2.string().datetime(),
-  lastActivityAt: z2.string().datetime(),
-  lastHookAt: z2.string().datetime().optional(),
+  lastMessage: z3.object({ id: z3.string(), to: z3.string(), peer: z3.string().optional(), summary: z3.string(), at: z3.string().datetime() }).optional(),
+  startedAt: z3.string().datetime(),
+  lastActivityAt: z3.string().datetime(),
+  lastHookAt: z3.string().datetime().optional(),
   /** The model and effort Ledge launched the agent with (#58); left out, the agent's own default. */
-  model: z2.string().optional(),
-  effort: z2.string().optional(),
+  model: z3.string().optional(),
+  effort: z3.string().optional(),
   /** OMP: the approval mode it was launched with, kept by a resume; left out, `always-ask`. */
   approval: OmpApprovalSchema.optional(),
-  /** The role it was launched with or took in a team (spec 2026-10-25 roles §3.3): its id, its label as it was then. */
-  role: z2.string().optional(),
-  roleLabel: z2.string().optional(),
-  /** The live team it sits in (`team-…`); left out, the project's common table. */
-  team: z2.string().optional(),
-  /** Its role's autonomy, as launched (kept by a resume); left out, `ask`. */
+  /** Its autonomy, as launched (kept by a resume); left out, `ask`. */
   autonomy: AutonomySchema.optional(),
   /** Its context as its agent last reported it, after a turn (context handover spec §3.1); left out, not measured. */
   context: ContextSchema.optional(),
@@ -152,21 +316,23 @@ var SessionSchema = z2.object({
   /** The session it relieves, when it is a relief. */
   relieves: RelievesSchema.optional(),
   /** A model change asked while the agent worked (`session.model`), applied at its next free moment; a field left out is the agent's default. */
-  modelNext: z2.object({ model: z2.string().optional(), effort: z2.string().optional() }).optional(),
+  modelNext: z3.object({ model: z3.string().optional(), effort: z3.string().optional() }).optional(),
   /** The agent's own session id when Ledge chose it at launch (Claude Code `--session-id`). */
-  agentSessionId: z2.string().optional(),
+  agentSessionId: z3.string().optional(),
   /** OMP: the exact journal file of the conversation, what a resume names (never "the latest of the folder"). */
-  agentSessionFile: z2.string().optional(),
+  agentSessionFile: z3.string().optional(),
   /** The agent's transcript: the latest one a hook named (it follows /clear and --resume), else the one the launch implies. */
-  transcriptPath: z2.string().optional(),
-  exitCode: z2.number().int().nullable().optional(),
-  exitedAt: z2.string().datetime().optional(),
-  lastError: z2.string().optional(),
-  source: z2.enum(["launcher", "hook_only"]),
+  transcriptPath: z3.string().optional(),
+  exitCode: z3.number().int().nullable().optional(),
+  exitedAt: z3.string().datetime().optional(),
+  lastError: z3.string().optional(),
+  source: z3.enum(["launcher", "hook_only"]),
   /** When the session was put in the archive (session management): set, it leaves the live list and waits to be restored, resumed or deleted. */
-  archivedAt: z2.string().datetime().optional(),
+  archivedAt: z3.string().datetime().optional(),
   /** When the session was last taken out of the archive: the poller's retirement clock restarts from it, not from `exitedAt`. */
-  restoredAt: z2.string().datetime().optional()
+  restoredAt: z3.string().datetime().optional(),
+  /** The OpenRig seat this session runs in (paired from the hook's `openrig.sessionName`). */
+  rig: SessionRigSchema.optional()
 });
 function backendOf(s) {
   return s.backend ?? "tmux";
@@ -175,346 +341,21 @@ function isArchived(s) {
   return s.archivedAt !== void 0;
 }
 
-// ../protocol/src/teams.ts
-import { z as z7 } from "zod";
-
-// ../protocol/src/models.ts
-import { z as z3 } from "zod";
-var ModelIdSchema = z3.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
-var EffortSchema = z3.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
-var ModelChoiceSchema = z3.object({
-  id: ModelIdSchema,
-  label: z3.string(),
-  description: z3.string().optional(),
-  efforts: z3.array(EffortSchema).optional(),
-  defaultEffort: EffortSchema.optional(),
-  isDefault: z3.boolean().optional()
-});
-var ModelsListSchema = z3.object({
-  type: z3.literal("models.list"),
-  requestId: z3.string().min(1).max(100),
-  tool: ToolSchema,
-  machineId: z3.string().optional()
-});
-var ModelsListingSchema = z3.object({
-  type: z3.literal("models.listing"),
-  requestId: z3.string(),
-  tool: ToolSchema,
-  models: z3.array(ModelChoiceSchema),
-  error: z3.string().optional()
-});
-var ModelRefusalSchema = z3.enum(["not_launched", "ended", "no_conversation", "not_running", "effort_in_model", "restart_failed", "refused"]);
-var SessionModelAcceptedSchema = z3.object({ type: z3.literal("session.model.accepted"), id: z3.string(), when: z3.enum(["now", "turn", "none"]) });
-
-// ../protocol/src/projects.ts
-import { z as z6 } from "zod";
-
-// ../protocol/src/machines.ts
-import { z as z5 } from "zod";
-
-// ../protocol/src/ssh.ts
-import { z as z4 } from "zod";
-var SshAliasSchema = z4.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
-
-// ../protocol/src/machines.ts
-var MachineIdSchema = z5.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
-var MachineSchema = z5.object({
-  id: MachineIdSchema,
-  label: z5.string().trim().min(1).max(80),
-  ssh: SshAliasSchema.optional()
-});
-var MachinesSchema = z5.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/projects.ts
-var PROJECT_COLORS = { blue: "#3b82f6", green: "#10b981", amber: "#f59e0b", violet: "#8b5cf6", teal: "#14b8a6", pink: "#ec4899", red: "#ef4444", slate: "#64748b" };
-var ProjectColorSchema = z6.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
-var ProjectIdSchema = z6.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 = z6.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
-var RepoSchema = z6.object({ machine: MachineIdSchema, path: PathSchema });
-var ProjectSchema = z6.object({
-  id: ProjectIdSchema,
-  name: z6.string().trim().min(1).max(80),
-  color: ProjectColorSchema,
-  description: z6.string().max(500).default(""),
-  repos: z6.array(RepoSchema).max(50)
-});
-var RuleSchema = z6.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 = z6.object({ projects: z6.array(ProjectSchema).max(100), rules: z6.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/teams.ts
-var RoleIdSchema = z7.string().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/);
-var ROLE_LABEL_MAX = 40;
-var ROLE_PROMPT_MAX = 8e3;
-var DefinitionHashSchema = z7.string().regex(/^[0-9a-f]{16}$/);
-var RoleSchema = z7.object({
-  id: RoleIdSchema,
-  label: z7.string().min(1).max(ROLE_LABEL_MAX),
-  prompt: z7.string().max(ROLE_PROMPT_MAX),
-  tool: ToolSchema.optional(),
-  model: ModelIdSchema.optional(),
-  effort: EffortSchema.optional(),
-  autonomy: AutonomySchema.optional(),
-  source: z7.enum(["repo", "home"]),
-  path: z7.string(),
-  shadows: z7.string().optional(),
-  /** 16 hex chars of the file's text: what a write or delete must name as its base (absent from older daemons). */
-  hash: DefinitionHashSchema.optional()
-});
-var DefinitionProblemSchema = z7.object({ path: z7.string(), reason: z7.string() });
-var TEAM_SEATS_MAX = 8;
-var SeatSchema = z7.object({
-  role: RoleIdSchema,
-  tool: ToolSchema.optional(),
-  model: ModelIdSchema.optional(),
-  effort: EffortSchema.optional(),
-  name: z7.string().min(1).max(40).optional()
-});
-var uniqueRoles = (seats) => new Set(seats.map((s) => s.role)).size === seats.length;
-var SeatsSchema = z7.array(SeatSchema).min(1).max(TEAM_SEATS_MAX).refine(uniqueRoles, "a role twice in one team");
-var TeamNameSchema = z7.string().trim().min(1).max(60);
-var TemplateIdSchema = z7.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/);
-var TeamTemplateSchema = z7.object({ id: z7.string().min(1).max(64), name: TeamNameSchema, seats: SeatsSchema, source: z7.enum(["repo", "home"]), path: z7.string(), hash: DefinitionHashSchema.optional() });
-var TeamIdSchema = z7.string().regex(/^team-[0-9a-f]{4,8}$/);
-var TeamStateSchema = z7.enum(["active", "resting", "dissolved"]);
-var TeamSchema = z7.object({
-  id: TeamIdSchema,
-  name: TeamNameSchema,
-  template: z7.string().optional(),
-  project: z7.string().nullable(),
-  machine: z7.string(),
-  cwd: z7.string(),
-  state: TeamStateSchema,
-  /** A live seat: `tool`, `model` and `effort` are what it was composed with over the role's defaults; `leaving` marks a seat removed
-   *  from the composition that finishes its turn and then is closed. */
-  seats: z7.array(z7.object({
-    role: RoleIdSchema,
-    sessionId: z7.string().nullable(),
-    tool: ToolSchema.optional(),
-    model: ModelIdSchema.optional(),
-    effort: EffortSchema.optional(),
-    leaving: z7.literal(true).optional()
-  })).max(TEAM_SEATS_MAX * 2),
-  createdAt: z7.string(),
-  updatedAt: z7.string(),
-  restingAt: z7.string().optional(),
-  dissolvedAt: z7.string().optional()
-});
-var RolesListSchema = z7.object({ type: z7.literal("roles.list"), cwd: z7.string().min(1).optional(), requestId: z7.string().max(100).optional(), machineId: z7.string().optional() });
-var RolesListingSchema = z7.object({
-  type: z7.literal("roles.listing"),
-  requestId: z7.string().optional(),
-  roles: z7.array(RoleSchema),
-  templates: z7.array(TeamTemplateSchema).default([]),
-  problems: z7.array(DefinitionProblemSchema),
-  /** Set by the fleet when the project's machine could not answer (#99): 'offline', or 'outdated' for a daemon without roles.list. */
-  error: z7.string().optional()
-});
-var TeamLaunchSchema = z7.object({
-  type: z7.literal("team.launch"),
-  rid: z7.string().min(1).max(100),
-  cwd: z7.string().min(1).optional(),
-  template: z7.string().min(1).max(64).optional(),
-  seats: SeatsSchema.optional(),
-  name: TeamNameSchema.optional(),
-  qid: z7.string().min(1).optional(),
-  machineId: z7.string().optional(),
-  /** The project's name, for a client that holds no path (the phone): the daemon resolves its folder. */
-  project: ProjectIdSchema.optional()
-});
-var TeamJoinSchema = z7.object({ type: z7.literal("team.join"), team: TeamIdSchema, session: z7.string().min(1), role: RoleIdSchema });
-var TeamLeaveSchema = z7.object({ type: z7.literal("team.leave"), team: TeamIdSchema, session: z7.string().min(1) });
-var TeamResumeSchema = z7.object({ type: z7.literal("team.resume"), team: TeamIdSchema });
-var TeamDissolveSchema = z7.object({ type: z7.literal("team.dissolve"), team: TeamIdSchema });
-var TeamSaveSchema = z7.object({ type: z7.literal("team.save"), rid: z7.string().min(1).max(100), name: TeamNameSchema, seats: SeatsSchema, qid: z7.string().min(1).optional() });
-var DefinitionScopeSchema = z7.enum(["home", "repo"]);
-var RoleDraftSchema = RoleSchema.pick({ id: true, label: true, prompt: true, tool: true, model: true, effort: true, autonomy: true });
-var DefinitionCodeSchema = z7.enum(["changed", "exists", "missing", "unknown_project", "invalid"]);
-var scopeFields = { rid: z7.string().min(1).max(100), scope: DefinitionScopeSchema, project: ProjectIdSchema.optional() };
-var scopeIssue = (m) => m.scope === void 0 || m.scope === "repo" === (m.project !== void 0) ? null : "a repo scope names a project, a home scope none";
-var DefinitionBaseSchema = DefinitionHashSchema;
-var DefinitionsListSchema = z7.object({ type: z7.literal("definitions.list"), requestId: z7.string().max(100).optional() });
-var RoleWriteSchema = z7.object({ type: z7.literal("role.write"), ...scopeFields, role: RoleDraftSchema, base: DefinitionBaseSchema.nullable() });
-var RoleDeleteSchema = z7.object({ type: z7.literal("role.delete"), ...scopeFields, id: RoleIdSchema, base: DefinitionBaseSchema });
-var TemplateWriteSchema = z7.object({
-  type: z7.literal("template.write"),
-  ...scopeFields,
-  id: TemplateIdSchema.optional(),
-  name: TeamNameSchema,
-  seats: SeatsSchema,
-  base: DefinitionBaseSchema.nullable()
-});
-var TemplateDeleteSchema = z7.object({ type: z7.literal("template.delete"), ...scopeFields, id: TemplateIdSchema, base: DefinitionBaseSchema });
-var TeamComposeSchema = z7.object({ type: z7.literal("team.compose"), rid: z7.string().min(1).max(100), team: TeamIdSchema, seats: SeatsSchema });
-var TeamSeatSchema = z7.object({ type: z7.literal("team.seat"), rid: z7.string().min(1).max(100), team: TeamIdSchema, role: RoleIdSchema, action: z7.enum(["start", "restart"]) });
-var DefinitionsListingSchema = z7.object({
-  type: z7.literal("definitions.listing"),
-  requestId: z7.string().optional(),
-  scopes: z7.array(z7.object({
-    scope: DefinitionScopeSchema,
-    project: z7.string().nullable(),
-    roles: z7.array(RoleSchema),
-    templates: z7.array(TeamTemplateSchema),
-    problems: z7.array(DefinitionProblemSchema)
-  }))
-});
-var DefinitionResultSchema = z7.object({ type: z7.literal("definition.result"), rid: z7.string(), id: z7.string().optional(), hash: DefinitionHashSchema.optional(), code: DefinitionCodeSchema.optional(), reason: z7.string().optional() });
-var SeatModelOutcomeSchema = z7.object({ role: z7.string(), session: z7.string(), when: z7.enum(["now", "turn"]).optional(), code: ModelRefusalSchema.optional() });
-var TeamChangedSchema = z7.object({ type: z7.literal("team.changed"), rid: z7.string(), team: TeamSchema.optional(), reason: z7.string().optional(), models: z7.array(SeatModelOutcomeSchema).max(16).optional() });
-var TeamsMessageSchema = z7.object({ type: z7.literal("teams"), teams: z7.array(TeamSchema) });
-var TeamUpdatedSchema = z7.object({ type: z7.literal("team.updated"), team: TeamSchema });
-var TeamLaunchedSchema = z7.object({ type: z7.literal("team.launched"), rid: z7.string(), team: TeamSchema });
-var TeamFailedSchema = z7.object({ type: z7.literal("team.failed"), rid: z7.string(), reason: z7.string(), team: TeamSchema.optional() });
-var TeamSavedSchema = z7.object({ type: z7.literal("team.saved"), rid: z7.string(), path: z7.string().optional(), reason: z7.string().optional() });
-var isTeamLive = (t) => t.state !== "dissolved";
-
-// ../protocol/src/tasks.ts
-import { z as z8 } from "zod";
-var TASK_TITLE_MAX = 200;
-var TASK_TEXT_MAX = 2e4;
-var LEDGE_GIVER = "ledge";
-var TASK_OPS = ["give", "take", "pass", "done", "refuse", "cancel", "drop"];
-var TRANSMISSION_OPS = ["give", "pass", "done", "refuse", "cancel"];
-var TaskLogEntrySchema = z8.object({
-  at: z8.string(),
-  by: z8.string(),
-  what: z8.string(),
-  op: z8.enum(TASK_OPS).optional(),
-  from: z8.string().optional(),
-  to: z8.string().optional(),
-  fromName: z8.string().optional(),
-  toName: z8.string().optional(),
-  note: z8.string().optional()
-});
-var TaskSchema = z8.object({
-  id: z8.string(),
-  title: z8.string(),
-  text: z8.string().optional(),
-  giver: z8.string(),
-  giverName: z8.string(),
-  owner: z8.string(),
-  ownerName: z8.string(),
-  state: z8.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z8.string().optional(),
-  /** The live team its owner sat in when it was given (or passed), so a team's tasks can be listed. */
-  team: z8.string().optional(),
-  /** A task Ledge gave and the user put away from « À toi » once closed. */
-  seen: z8.boolean().optional(),
-  at: z8.string(),
-  updatedAt: z8.string(),
-  log: z8.array(TaskLogEntrySchema)
-});
-var handOver = (op) => TRANSMISSION_OPS.includes(op ?? "");
-function transmissions(t) {
-  return t.log.flatMap((e, index) => handOver(e.op) && e.from !== void 0 && e.to !== void 0 ? [{ index, at: e.at, op: e.op, from: e.from, to: e.to, fromName: e.fromName ?? "", toName: e.toName ?? "", ...e.note !== void 0 ? { note: e.note } : {} }] : []);
-}
-var givenByLedge = (t) => t.giver === LEDGE_GIVER;
-var taskClosed = (t) => t.state === "done" || t.state === "refused" || t.state === "dropped";
-var TaskCmdSchema = z8.object({
-  type: z8.literal("task.cmd"),
-  rid: z8.string().min(1),
-  by: z8.string().min(1),
-  op: z8.enum(["give", "take", "done", "refuse", "pass", "show", "list", "seen", "cancel"]),
-  task: z8.string().min(1).max(40).optional(),
-  to: z8.string().min(1).optional(),
-  title: z8.string().min(1).max(TASK_TITLE_MAX).optional(),
-  text: z8.string().max(TASK_TEXT_MAX).optional(),
-  all: z8.boolean().optional(),
-  team: z8.string().min(1).max(40).optional(),
-  qid: z8.string().min(1).optional(),
-  row: z8.number().int().min(0).max(7).optional()
-});
-var TaskUpdatedSchema = z8.object({ type: z8.literal("task.updated"), task: TaskSchema });
-var TaskResultSchema = z8.object({
-  type: z8.literal("task.result"),
-  rid: z8.string(),
-  task: TaskSchema.optional(),
-  tasks: z8.array(TaskSchema).optional(),
-  reason: z8.string().optional()
-});
-
 // ../protocol/src/actions.ts
-import { z as z11 } from "zod";
+import { z as z7 } from "zod";
 
 // ../protocol/src/proposal.ts
-import { z as z9 } from "zod";
-var ProposalBlockSchema = z9.object({ cwd: z9.string().trim().min(1), prompt: z9.string().optional() });
-var RelayBlockSchema = z9.object({ session: z9.string().trim().min(1), text: z9.string().trim().min(1) });
-var ProjectBlockSchema = z9.object({
-  name: z9.string().trim().min(1).max(80),
-  description: z9.string().max(500).optional(),
-  repos: z9.array(z9.object({ path: z9.string().min(1).max(4096), why: z9.string().trim().min(1).max(200) })).min(1).max(50),
-  addTo: z9.string().trim().max(80).optional()
-});
-var CloseBlockSchema = z9.object({ session: z9.string().trim().min(1) });
-var TeamBlockSchema = z9.object({
-  cwd: z9.string().trim().min(1),
-  template: z9.string().trim().min(1).max(64).optional(),
-  name: z9.string().trim().min(1).max(60).optional(),
-  seats: z9.array(z9.object({ role: z9.string().trim().min(1).max(40), tool: z9.enum(["claude", "codex", "cursor", "omp"]).optional(), model: z9.string().max(200).optional(), effort: z9.string().max(20).optional(), name: z9.string().max(40).optional() })).min(1).max(8).optional()
-}).refine((b) => !!b.template || !!b.seats?.length, "a template or seats");
-var TaskBlockSchema = z9.object({
-  to: z9.string().trim().min(1).max(80),
-  team: z9.string().trim().max(40).optional(),
-  title: z9.string().trim().min(1).max(200),
-  text: z9.string().max(2e4).optional()
-});
-var BLOCK = /```ledge-(session|relay|project|close|team|task|action)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
+import { z as z4 } from "zod";
+var ProposalBlockSchema = z4.object({ cwd: z4.string().trim().min(1), prompt: z4.string().optional() });
+var RelayBlockSchema = z4.object({ session: z4.string().trim().min(1), text: z4.string().trim().min(1) });
+var ProjectBlockSchema = z4.object({
+  name: z4.string().trim().min(1).max(80),
+  description: z4.string().max(500).optional(),
+  repos: z4.array(z4.object({ path: z4.string().min(1).max(4096), why: z4.string().trim().min(1).max(200) })).min(1).max(50),
+  addTo: z4.string().trim().max(80).optional()
+});
+var CloseBlockSchema = z4.object({ session: z4.string().trim().min(1) });
+var BLOCK = /```ledge-(session|relay|project|close|action)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
 function extractProposal(answer) {
   const found = [];
   const text2 = answer.replace(BLOCK, (_m, kind, body) => {
@@ -540,22 +381,6 @@ function parseCloseBlock(raw) {
     return null;
   }
 }
-function parseTeamBlock(raw) {
-  try {
-    const r = TeamBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseTaskBlock(raw) {
-  try {
-    const r = TaskBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
 function parseProjectBlock(raw) {
   try {
     const r = ProjectBlockSchema.safeParse(JSON.parse(raw));
@@ -565,9 +390,37 @@ function parseProjectBlock(raw) {
   }
 }
 
+// ../protocol/src/models.ts
+import { z as z5 } from "zod";
+var ModelIdSchema = z5.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
+var EffortSchema = z5.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
+var ModelChoiceSchema = z5.object({
+  id: ModelIdSchema,
+  label: z5.string(),
+  description: z5.string().optional(),
+  efforts: z5.array(EffortSchema).optional(),
+  defaultEffort: EffortSchema.optional(),
+  isDefault: z5.boolean().optional()
+});
+var ModelsListSchema = z5.object({
+  type: z5.literal("models.list"),
+  requestId: z5.string().min(1).max(100),
+  tool: ToolSchema,
+  machineId: z5.string().optional()
+});
+var ModelsListingSchema = z5.object({
+  type: z5.literal("models.listing"),
+  requestId: z5.string(),
+  tool: ToolSchema,
+  models: z5.array(ModelChoiceSchema),
+  error: z5.string().optional()
+});
+var ModelRefusalSchema = z5.enum(["not_launched", "ended", "no_conversation", "not_running", "effort_in_model", "restart_failed", "refused"]);
+var SessionModelAcceptedSchema = z5.object({ type: z5.literal("session.model.accepted"), id: z5.string(), when: z5.enum(["now", "turn", "none"]) });
+
 // ../protocol/src/decisions.ts
-import { z as z10 } from "zod";
-var DecisionSchema = z10.enum(["accept", "deny", "always"]);
+import { z as z6 } from "zod";
+var DecisionSchema = z6.enum(["accept", "deny", "always"]);
 var NOTE_MAX = 4e3;
 var NOTE_NOT_TYPED = "note_not_typed";
 var DECISION_OFFERS = {
@@ -597,33 +450,22 @@ function pendingKey(p) {
 }
 
 // ../protocol/src/actions.ts
-var ActionRiskSchema = z11.enum(["read", "reversible", "destructive"]);
+var ActionRiskSchema = z7.enum(["read", "reversible", "destructive"]);
 var ACTION_IDS = [
   "session.launch",
   "session.relay",
   "session.close",
   "project.propose",
-  "team.launch",
-  "task.give",
   "session.model",
   "session.interrupt",
   "session.archive",
   "session.restore",
   "session.resume",
-  "session.decide",
-  "team.join",
-  "team.leave",
-  "team.resume",
-  "team.dissolve",
-  "team.save",
-  "task.cancel",
-  "task.pass"
+  "session.decide"
 ];
-var ActionIdSchema = z11.enum(ACTION_IDS);
+var ActionIdSchema = z7.enum(ACTION_IDS);
 var def = (d) => d;
-var SessionRef = z11.string().trim().min(1).max(80);
-var TeamRef = z11.string().trim().min(1).max(60);
-var TaskRef = z11.string().trim().min(1).max(40);
+var SessionRef = z7.string().trim().min(1).max(80);
 var LaunchArgs = ProposalBlockSchema.extend({ model: ModelIdSchema.optional(), effort: EffortSchema.optional() });
 var ACTIONS = [
   def({
@@ -671,44 +513,20 @@ var ACTIONS = [
     when: "seulement si l'utilisateur demande explicitement de cr\xE9er ou de compl\xE9ter un projet : lis projects.md, ne cite que des chemins absolus lus dans sessions.md, folders.md ou projects.md, jamais un d\xE9p\xF4t qui appartient d\xE9j\xE0 \xE0 un projet ; ta r\xE9ponse dit le nom, chaque d\xE9p\xF4t et pourquoi",
     example: { name: "Facturation", description: "Le service et son front", repos: [{ path: "/home/alice/projets/billing-api", why: "le service" }] }
   }),
-  def({
-    id: "team.launch",
-    args: TeamBlockSchema,
-    card: "team",
-    phone: "launch",
-    risk: "reversible",
-    max: 1,
-    cli: "ledge team up <mod\xE8le> --cwd <dossier>",
-    summary: "monter une \xE9quipe dans un dossier : un mod\xE8le de teams.md (template), ou des si\xE8ges (r\xF4le de roles.md, agent, et si demand\xE9 model, effort)",
-    when: "quand l'utilisateur demande explicitement de monter, lancer ou composer une \xE9quipe, avec la m\xEAme r\xE8gle de dossier s\xFBr qu'une session ; 8 si\xE8ges au plus, un r\xF4le une seule fois, seulement des r\xF4les de roles.md disponibles dans ce dossier (s'il en manque un, dis lequel et le fichier \xE0 \xE9crire, ~/.ledge/roles/<id>.md). Ne choisis jamais l'autonomie : c'est celle du r\xF4le",
-    example: { cwd: "/home/alice/projets/api", name: "api", seats: [{ role: "dev-back", tool: "claude" }, { role: "rev-back", tool: "codex" }] }
-  }),
-  def({
-    id: "task.give",
-    args: TaskBlockSchema,
-    card: "task",
-    phone: null,
-    risk: "reversible",
-    max: 8,
-    cli: 'ledge task give <session|@r\xF4le> "<titre>" "<d\xE9tail>"',
-    summary: "confier une t\xE2che \xE0 une session, ou \xE0 un @r\xF4le d'une \xE9quipe (team : son id dans teams.md ; sans team, un si\xE8ge de l'\xE9quipe propos\xE9e dans la m\xEAme r\xE9ponse)",
-    when: "quand l'utilisateur demande explicitement de confier une t\xE2che, ou juste apr\xE8s team.launch quand il a dit ce que l'\xE9quipe doit faire. Une fois l'\xE9quipe lanc\xE9e, ne propose rien pour ce que les si\xE8ges se confient entre eux",
-    example: { to: "@dev-back", title: "Pagination de /invoices", text: "Ajoute la pagination par curseur et ses tests" }
-  }),
   def({
     id: "session.model",
     card: "generic",
     phone: null,
     risk: "reversible",
     max: 8,
-    args: z11.object({ session: SessionRef, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+    args: z7.object({ session: SessionRef, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
     summary: "changer le mod\xE8le et l'effort d'une session en cours (null : le d\xE9faut de l'agent) ; elle red\xE9marre sur la m\xEAme conversation, \xE0 son prochain moment libre",
     when: "quand l'utilisateur demande de passer une session sur un autre mod\xE8le ou un autre effort",
     example: { session: "Nova", model: "claude-opus-5-5", effort: "high" }
   }),
   def({
     id: "session.interrupt",
-    args: z11.object({ session: SessionRef }),
+    args: z7.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -719,7 +537,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.archive",
-    args: z11.object({ session: SessionRef }),
+    args: z7.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -730,7 +548,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.restore",
-    args: z11.object({ session: SessionRef }),
+    args: z7.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -741,7 +559,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.resume",
-    args: z11.object({ session: SessionRef }),
+    args: z7.object({ session: SessionRef }),
     card: "generic",
     phone: "act",
     risk: "reversible",
@@ -755,102 +573,22 @@ var ACTIONS = [
     card: "generic",
     phone: "act",
     max: 1,
-    args: z11.object({ session: SessionRef, decision: z11.enum(["accept", "deny"]), note: z11.string().trim().min(1).max(NOTE_MAX).optional() }),
+    args: z7.object({ session: SessionRef, decision: z7.enum(["accept", "deny"]), note: z7.string().trim().min(1).max(NOTE_MAX).optional() }),
     risk: (a) => a.decision === "accept" ? "destructive" : "reversible",
     summary: "accepter ou refuser la demande en attente d'une session (permission, diff ou plan), note possible avec un refus ; jamais \xAB toujours \xBB",
     when: "seulement quand l'utilisateur demande explicitement d'accepter ou de refuser la demande d'une session pr\xE9cise, et que sessions.md montre une demande en attente pour elle ; cite la demande telle quelle dans ta r\xE9ponse",
     example: { session: "Nova", decision: "deny", note: "Pas sur main : cr\xE9e une branche" }
-  }),
-  def({
-    id: "team.join",
-    args: z11.object({ team: TeamRef, session: SessionRef, role: RoleIdSchema }),
-    card: "generic",
-    phone: null,
-    risk: "reversible",
-    max: 8,
-    summary: "faire entrer une session dans une \xE9quipe en cours, \xE0 un r\xF4le de roles.md",
-    when: "quand l'utilisateur demande d'ajouter une session existante \xE0 une \xE9quipe",
-    example: { team: "team-3fa2", session: "Nova", role: "dev-back" }
-  }),
-  def({
-    id: "team.leave",
-    args: z11.object({ team: TeamRef, session: SessionRef }),
-    card: "generic",
-    phone: null,
-    risk: "reversible",
-    max: 8,
-    summary: "faire sortir une session d'une \xE9quipe (la session continue)",
-    when: "quand l'utilisateur demande de retirer une session d'une \xE9quipe",
-    example: { team: "team-3fa2", session: "Nova" }
-  }),
-  def({
-    id: "team.resume",
-    args: z11.object({ team: TeamRef }),
-    card: "generic",
-    phone: "act",
-    risk: "reversible",
-    max: 1,
-    summary: "reprendre une \xE9quipe au repos : chaque si\xE8ge reprend sa conversation",
-    when: "quand l'utilisateur demande de reprendre ou relancer une \xE9quipe au repos",
-    example: { team: "team-3fa2" }
-  }),
-  def({
-    id: "team.dissolve",
-    args: z11.object({ team: TeamRef }),
-    card: "generic",
-    phone: "act",
-    risk: "destructive",
-    max: 1,
-    cli: "ledge team dissolve <\xE9quipe>",
-    summary: "dissoudre une \xE9quipe : elle dispara\xEEt, ses sessions restent ; irr\xE9versible",
-    when: "seulement quand l'utilisateur demande explicitement de dissoudre une \xE9quipe pr\xE9cise",
-    example: { team: "team-3fa2" }
-  }),
-  def({
-    id: "team.save",
-    args: z11.object({ team: TeamRef, name: TeamNameSchema }),
-    card: "generic",
-    phone: null,
-    risk: "reversible",
-    max: 1,
-    summary: "enregistrer une \xE9quipe en cours comme mod\xE8le (~/.ledge/teams/<nom>.yaml)",
-    when: "quand l'utilisateur demande d'enregistrer ou de garder la composition d'une \xE9quipe",
-    example: { team: "team-3fa2", name: "api" }
-  }),
-  def({
-    id: "task.cancel",
-    args: z11.object({ task: TaskRef, reason: z11.string().trim().min(1).max(500).optional() }),
-    card: "generic",
-    phone: "act",
-    risk: "destructive",
-    max: 8,
-    summary: "annuler une t\xE2che ouverte ou prise ; la session qui la tient est pr\xE9venue ; irr\xE9versible",
-    when: "seulement quand l'utilisateur demande explicitement d'annuler une t\xE2che de tasks.md",
-    example: { task: "t91b0d4", reason: "Plus n\xE9cessaire" }
-  }),
-  def({
-    id: "task.pass",
-    args: z11.object({ task: TaskRef, to: SessionRef, note: z11.string().trim().min(1).max(TASK_TEXT_MAX).optional() }),
-    card: "generic",
-    phone: null,
-    risk: "reversible",
-    max: 8,
-    summary: "passer une t\xE2che de tasks.md \xE0 une autre session (elle redevient ouverte)",
-    when: "quand l'utilisateur demande de r\xE9assigner ou de passer une t\xE2che \xE0 une autre session",
-    example: { task: "t91b0d4", to: "Bix" }
   })
 ];
 var byId = new Map(ACTIONS.map((a) => [a.id, a]));
-var actionById = (id) => byId.get(id);
+var actionById = (id2) => byId.get(id2);
 var riskOf = (a, args) => typeof a.risk === "function" ? a.risk(args) : a.risk;
-var ActionBlockSchema = z11.object({ action: z11.string().trim().min(1).max(40), args: z11.record(z11.unknown()).default({}) });
+var ActionBlockSchema = z7.object({ action: z7.string().trim().min(1).max(40), args: z7.record(z7.unknown()).default({}) });
 var LEGACY_FENCE_ACTION = {
   session: "session.launch",
   relay: "session.relay",
   close: "session.close",
-  project: "project.propose",
-  team: "team.launch",
-  task: "task.give"
+  project: "project.propose"
 };
 function parseActionBlock(kind, raw) {
   let json;
@@ -859,21 +597,21 @@ function parseActionBlock(kind, raw) {
   } catch {
     return { error: "invalid JSON" };
   }
-  let id;
+  let id2;
   let args;
   if (kind === "action") {
     const b = ActionBlockSchema.safeParse(json);
     if (!b.success) return { error: "not an {action, args} object" };
-    id = b.data.action;
+    id2 = b.data.action;
     args = b.data.args;
   } else {
-    id = LEGACY_FENCE_ACTION[kind];
+    id2 = LEGACY_FENCE_ACTION[kind];
     args = json;
   }
-  const action = actionById(id);
-  if (!action) return { error: `unknown action ${id}` };
+  const action = actionById(id2);
+  if (!action) return { error: `unknown action ${id2}` };
   const parsed = action.args.safeParse(args);
-  if (!parsed.success) return { error: `invalid args for ${id}: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"} ${i.message}`).join("; ")}` };
+  if (!parsed.success) return { error: `invalid args for ${id2}: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"} ${i.message}`).join("; ")}` };
   return { action, args: parsed.data };
 }
 var NEVER_PROPOSED = [
@@ -885,123 +623,89 @@ var NEVER_PROPOSED = [
   "r\xE9pondre \xAB toujours \xBB \xE0 une demande, ou r\xE9pondre aux questions \xE0 choix d'OMP"
 ];
 
-// ../protocol/src/messages.ts
-import { z as z21 } from "zod";
+// ../protocol/src/openrig.ts
+import { z as z10 } from "zod";
 
 // ../protocol/src/chat.ts
-import { z as z13 } from "zod";
+import { z as z9 } from "zod";
 
 // ../protocol/src/attachments.ts
-import { z as z12 } from "zod";
+import { z as z8 } from "zod";
 var ATTACHMENT_ID = /^[0-9a-f]{64}$/;
-var AttachmentIdSchema = z12.string().regex(ATTACHMENT_ID);
+var AttachmentIdSchema = z8.string().regex(ATTACHMENT_ID);
 var IMAGE_MIMES = ["image/webp", "image/jpeg", "image/png", "image/gif"];
-var ImageMimeSchema = z12.enum(IMAGE_MIMES);
+var ImageMimeSchema = z8.enum(IMAGE_MIMES);
 var ATTACHMENT_MAX = 4e5;
 var ATTACHMENT_LOCAL_MAX = 2e6;
 var PREVIEW_MAX = 4e4;
 var ATTACHMENTS_MAX = 5;
 var b64Max = (bytes) => Math.ceil(bytes / 3) * 4;
-var AttachmentRefSchema = z12.object({
+var AttachmentRefSchema = z8.object({
   id: AttachmentIdSchema,
   mime: ImageMimeSchema,
-  width: z12.number().int().positive(),
-  height: z12.number().int().positive(),
-  bytes: z12.number().int().positive(),
-  preview: z12.boolean()
+  width: z8.number().int().positive(),
+  height: z8.number().int().positive(),
+  bytes: z8.number().int().positive(),
+  preview: z8.boolean()
 });
-var ImageUploadSchema = z12.object({
+var ImageUploadSchema = z8.object({
   mime: ImageMimeSchema,
-  data: z12.string().min(1).max(b64Max(ATTACHMENT_LOCAL_MAX)),
-  preview: z12.object({ mime: ImageMimeSchema, data: z12.string().min(1).max(b64Max(PREVIEW_MAX)) }).optional()
-});
-var AttachmentErrorReasonSchema = z12.enum(["too_large", "not_image", "unreadable", "not_found", "offline"]);
-var requestId = z12.string().min(1).max(100);
-var AttachmentPutSchema = z12.object({ type: z12.literal("attachment.put"), requestId, id: z12.string().optional(), image: ImageUploadSchema });
-var AttachmentGetSchema = z12.object({ type: z12.literal("attachment.get"), requestId, attachment: AttachmentIdSchema, preview: z12.boolean().optional(), id: z12.string().optional(), machine: z12.string().optional() });
-var AttachmentStoredSchema = z12.object({ type: z12.literal("attachment.stored"), requestId, ref: AttachmentRefSchema });
-var AttachmentDataSchema = z12.object({ type: z12.literal("attachment.data"), requestId, attachment: AttachmentIdSchema, mime: ImageMimeSchema, data: z12.string() });
-var AttachmentErrorSchema = z12.object({ type: z12.literal("attachment.error"), requestId, reason: AttachmentErrorReasonSchema });
+  data: z8.string().min(1).max(b64Max(ATTACHMENT_LOCAL_MAX)),
+  preview: z8.object({ mime: ImageMimeSchema, data: z8.string().min(1).max(b64Max(PREVIEW_MAX)) }).optional()
+});
+var AttachmentErrorReasonSchema = z8.enum(["too_large", "not_image", "unreadable", "not_found", "offline"]);
+var requestId = z8.string().min(1).max(100);
+var AttachmentPutSchema = z8.object({ type: z8.literal("attachment.put"), requestId, id: z8.string().optional(), image: ImageUploadSchema });
+var AttachmentGetSchema = z8.object({ type: z8.literal("attachment.get"), requestId, attachment: AttachmentIdSchema, preview: z8.boolean().optional(), id: z8.string().optional(), machine: z8.string().optional() });
+var AttachmentStoredSchema = z8.object({ type: z8.literal("attachment.stored"), requestId, ref: AttachmentRefSchema });
+var AttachmentDataSchema = z8.object({ type: z8.literal("attachment.data"), requestId, attachment: AttachmentIdSchema, mime: ImageMimeSchema, data: z8.string() });
+var AttachmentErrorSchema = z8.object({ type: z8.literal("attachment.error"), requestId, reason: AttachmentErrorReasonSchema });
 
 // ../protocol/src/chat.ts
-var ChatStepSchema = z13.object({
-  kind: z13.enum(["sessions", "pane", "reply", "git", "repo"]),
-  id: z13.string().optional(),
-  name: z13.string().optional(),
-  path: z13.string().optional()
-});
-var ChatProposalSchema = z13.object({
-  cwd: z13.string().min(1),
-  project: z13.string(),
-  prompt: z13.string().optional(),
+var ChatStepSchema = z9.object({
+  kind: z9.enum(["sessions", "pane", "reply", "git", "repo"]),
+  id: z9.string().optional(),
+  name: z9.string().optional(),
+  path: z9.string().optional()
+});
+var ChatProposalSchema = z9.object({
+  cwd: z9.string().min(1),
+  project: z9.string(),
+  prompt: z9.string().optional(),
   tool: ToolSchema,
   /** What Ledge proposed on the card's picker (spec 2026-10-26 action registry §4), the agent's own default when left out. */
   model: ModelIdSchema.optional(),
   effort: EffortSchema.optional(),
-  launchedId: z13.string().optional(),
-  error: z13.string().optional()
+  launchedId: z9.string().optional(),
+  error: z9.string().optional()
 });
 var MAX_PROPOSALS = 8;
-var ChatProposalsSchema = z13.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
-var ChatRelaySchema = z13.object({
-  id: z13.string().min(1),
-  name: z13.string(),
+var ChatProposalsSchema = z9.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
+var ChatRelaySchema = z9.object({
+  id: z9.string().min(1),
+  name: z9.string(),
   tool: ToolSchema,
-  text: z13.string().min(1),
-  status: z13.enum(["queued", "sent"]).optional(),
-  sentAt: z13.string().datetime().optional(),
-  error: z13.string().optional()
-});
-var ChatCloseSchema = z13.object({
-  id: z13.string().min(1),
-  name: z13.string(),
+  text: z9.string().min(1),
+  status: z9.enum(["queued", "sent"]).optional(),
+  sentAt: z9.string().datetime().optional(),
+  error: z9.string().optional()
+});
+var ChatCloseSchema = z9.object({
+  id: z9.string().min(1),
+  name: z9.string(),
   tool: ToolSchema,
-  closedAt: z13.string().datetime().optional(),
-  how: z13.enum(["exit", "killed"]).optional(),
-  error: z13.string().optional()
-});
-var ChatClosesSchema = z13.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
-var ChatProjectProposalSchema = z13.object({
-  name: z13.string().min(1).max(80),
-  description: z13.string().max(500).optional(),
-  repos: z13.array(z13.object({ path: z13.string().min(1).max(4096), why: z13.string().min(1).max(200) })).min(1).max(50),
-  addTo: z13.string().min(1).max(80).optional()
-});
-var ChatTeamSeatSchema = z13.object({
-  role: z13.string().min(1),
-  label: z13.string(),
-  tool: ToolSchema,
-  model: z13.string().optional(),
-  effort: z13.string().optional(),
-  autonomy: AutonomySchema.optional(),
-  name: z13.string().optional()
-});
-var ChatTeamProposalSchema = z13.object({
-  cwd: z13.string().min(1),
-  project: z13.string(),
-  projectName: z13.string().optional(),
-  name: z13.string().min(1),
-  template: z13.string().optional(),
-  seats: z13.array(ChatTeamSeatSchema).min(1).max(8),
-  teamId: z13.string().optional(),
-  launchedAt: z13.string().datetime().optional(),
-  error: z13.string().optional(),
-  savedPath: z13.string().optional()
-});
-var ChatTaskProposalSchema = z13.object({
-  to: z13.string().min(1),
-  toName: z13.string().optional(),
-  team: z13.string().optional(),
-  title: z13.string().min(1).max(200),
-  text: z13.string().max(2e4).optional(),
-  taskId: z13.string().optional(),
-  ownerName: z13.string().optional(),
-  state: z13.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  givenAt: z13.string().datetime().optional(),
-  error: z13.string().optional()
-});
-var ChatTasksSchema = z13.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
-var ActionVarsSchema = z13.record(z13.string().max(40), z13.string().max(300));
+  closedAt: z9.string().datetime().optional(),
+  how: z9.enum(["exit", "killed"]).optional(),
+  error: z9.string().optional()
+});
+var ChatClosesSchema = z9.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
+var ChatProjectProposalSchema = z9.object({
+  name: z9.string().min(1).max(80),
+  description: z9.string().max(500).optional(),
+  repos: z9.array(z9.object({ path: z9.string().min(1).max(4096), why: z9.string().min(1).max(200) })).min(1).max(50),
+  addTo: z9.string().min(1).max(80).optional()
+});
+var ActionVarsSchema = z9.record(z9.string().max(40), z9.string().max(300));
 var DETAIL_MAX = 4e3;
 var ACTION_ERROR_CODES = [
   "unknown",
@@ -1016,98 +720,381 @@ var ACTION_ERROR_CODES = [
   "no_request",
   "in_session",
   "no_note",
-  "member",
-  "not_member",
-  "unknown_role",
-  "not_resting",
-  "dissolved",
-  "no_seat",
-  "closed",
-  "holder",
   "changed",
   "cut",
   "failed"
 ];
-var ChatActionStateSchema = z13.enum(["running", "done", "denied", "failed", "refused"]);
-var ChatActionSchema = z13.object({
-  action: z13.string().min(1).max(40),
-  args: z13.record(z13.unknown()),
-  summary: z13.string().min(1).max(300),
+var ChatActionStateSchema = z9.enum(["running", "done", "denied", "failed", "refused"]);
+var ChatActionSchema = z9.object({
+  action: z9.string().min(1).max(40),
+  args: z9.record(z9.unknown()),
+  summary: z9.string().min(1).max(300),
   vars: ActionVarsSchema.optional(),
-  detail: z13.string().max(DETAIL_MAX).optional(),
-  detailCut: z13.literal(true).optional(),
+  detail: z9.string().max(DETAIL_MAX).optional(),
+  detailCut: z9.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z13.string().optional(),
-  team: z13.string().optional(),
+  session: z9.string().optional(),
   state: ChatActionStateSchema.optional(),
-  doneAt: z13.string().datetime().optional(),
-  error: z13.string().optional(),
-  code: z13.string().max(40).optional()
-});
-var ChatActionsSchema = z13.array(ChatActionSchema).min(1).max(MAX_PROPOSALS);
-var ChatTurnSchema = z13.object({
-  machineId: z13.string().optional(),
-  machineName: z13.string().optional(),
-  choices: z13.array(z13.object({ id: z13.string(), label: z13.string() })).optional(),
-  qid: z13.string().min(1),
-  question: z13.string(),
-  askedAt: z13.string().datetime(),
-  steps: z13.array(ChatStepSchema),
-  answer: z13.string().optional(),
-  answeredAt: z13.string().datetime().optional(),
-  error: z13.string().optional(),
+  doneAt: z9.string().datetime().optional(),
+  error: z9.string().optional(),
+  code: z9.string().max(40).optional()
+});
+var ChatActionsSchema = z9.array(ChatActionSchema).min(1).max(MAX_PROPOSALS);
+var ChatRigLaunchSchema = z9.object({
+  spec: z9.string().min(1).max(200).optional(),
+  goal: z9.string().min(1).max(8e3),
+  project: z9.string().min(1).optional(),
+  off: z9.string().min(1).max(40).optional(),
+  machine: z9.string().min(1).optional()
+});
+var ChatTurnSchema = z9.object({
+  machineId: z9.string().optional(),
+  machineName: z9.string().optional(),
+  choices: z9.array(z9.object({ id: z9.string(), label: z9.string() })).optional(),
+  qid: z9.string().min(1),
+  question: z9.string(),
+  askedAt: z9.string().datetime(),
+  steps: z9.array(ChatStepSchema),
+  answer: z9.string().optional(),
+  answeredAt: z9.string().datetime().optional(),
+  error: z9.string().optional(),
   proposal: ChatProposalSchema.optional(),
   proposals: ChatProposalsSchema.optional(),
   relay: ChatRelaySchema.optional(),
   closes: ChatClosesSchema.optional(),
   projectProposal: ChatProjectProposalSchema.optional(),
-  team: ChatTeamProposalSchema.optional(),
-  tasks: ChatTasksSchema.optional(),
   actions: ChatActionsSchema.optional(),
-  ignoredAt: z13.string().datetime().optional(),
-  attachments: z13.array(AttachmentRefSchema).optional()
+  rigLaunch: ChatRigLaunchSchema.optional(),
+  ignoredAt: z9.string().datetime().optional(),
+  attachments: z9.array(AttachmentRefSchema).optional()
 });
 var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
 
+// ../protocol/src/openrig.ts
+var MandateCategorySchema = z10.enum(["git", "tests", "context", "code", "design", "architecture", "critical"]);
+var ALWAYS_USER = ["design", "architecture", "critical"];
+var MANDATE_CATEGORY_LABEL = {
+  git: { fr: "Git et branches", en: "Git and branches" },
+  tests: { fr: "Tests et relectures", en: "Tests and reviews" },
+  context: { fr: "Contexte et rel\xE8ves", en: "Context and handovers" },
+  code: { fr: "Petits choix de code", en: "Small code choices" },
+  design: { fr: "Design", en: "Design" },
+  architecture: { fr: "Architecture", en: "Architecture" },
+  critical: { fr: "Critique", en: "Critical" }
+};
+var OpenRigStateSchema = z10.enum(["absent", "stopped", "starting", "running", "unsupported", "error", "unreachable"]);
+var OpenRigStatusSchema = z10.object({
+  machine: z10.string(),
+  state: OpenRigStateSchema,
+  version: z10.string().optional(),
+  human: z10.enum(["registered", "missing", "failed"]).optional(),
+  detail: z10.string().optional(),
+  install: z10.string().optional()
+});
+var SeatStateSchema = z10.enum(["starting", "trust", "attention", "ready", "working", "idle", "stopped", "crashed", "unreachable"]);
+var RigSeatSchema = z10.object({
+  ref: z10.string(),
+  // OpenRig session name: "dev-build@starter"
+  address: z10.string(),
+  // "@build"
+  name: z10.string(),
+  runtime: z10.string(),
+  model: z10.string().optional(),
+  state: SeatStateSchema,
+  contextPct: z10.number().min(0).max(100).optional(),
+  sessionId: z10.string().optional()
+});
+var RigRepoSchema = z10.object({
+  path: z10.string(),
+  name: z10.string(),
+  branch: z10.string().optional(),
+  remote: z10.string().optional(),
+  modified: z10.number().int().min(0),
+  by: z10.string().optional(),
+  how: z10.enum(["cloned", "opened", "created"]).optional()
+});
+var RigLifecycleSchema = z10.enum(["launching", "running", "partial", "stopped", "unreachable"]);
+var RIG_NAME = /^[a-z0-9][a-z0-9-]{0,39}$/;
+var RigLaunchInfoSchema = z10.object({
+  planId: z10.string(),
+  goal: z10.string(),
+  lead: z10.string(),
+  startedAt: z10.string().datetime(),
+  goalSentAt: z10.string().datetime().optional(),
+  lateNotice: z10.boolean().optional()
+});
+var RigSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
+  machine: z10.string(),
+  spec: z10.string().optional(),
+  cwd: z10.string(),
+  projectId: z10.string().nullable(),
+  offProject: z10.boolean(),
+  branch: z10.string().optional(),
+  lifecycle: RigLifecycleSchema,
+  kernel: z10.boolean(),
+  seats: z10.array(RigSeatSchema),
+  repos: z10.array(RigRepoSchema),
+  launch: RigLaunchInfoSchema.optional()
+});
+var EscalationQuestionSchema = z10.object({
+  id: z10.string(),
+  question: z10.string(),
+  options: z10.array(z10.object({ id: z10.string(), label: z10.string(), recommended: z10.boolean().optional() })).min(2).max(4)
+});
+var EscalationStateSchema = z10.enum(["pending", "grace", "answered", "closed"]);
+var EscalationSchema = z10.object({
+  id: z10.string(),
+  // OpenRig qitemId, or "ask-<id>" for `ledge ask`
+  source: z10.enum(["rig", "operator", "ask"]),
+  machine: z10.string(),
+  rigId: z10.string().optional(),
+  from: z10.string(),
+  // seat ref, or the Ledge session name for `ask`
+  intent: z10.enum(["decision", "update"]),
+  summary: z10.string(),
+  detail: z10.string().optional(),
+  evidenceRef: z10.string().optional(),
+  questions: z10.array(EscalationQuestionSchema).max(4),
+  replyTo: z10.string().optional(),
+  createdAt: z10.string().datetime(),
+  state: EscalationStateSchema,
+  graceUntil: z10.string().datetime().optional(),
+  correcting: z10.string().optional(),
+  // id of the decision being corrected (Revenir dessus)
+  category: MandateCategorySchema.optional(),
+  advice: z10.string().optional(),
+  answer: z10.object({
+    by: z10.enum(["ledge", "user"]),
+    answers: z10.record(z10.string()),
+    at: z10.string().datetime(),
+    rule: z10.string().optional(),
+    delivery: z10.enum(["queued", "sent"]).optional()
+  }).optional()
+});
+var ExchangeSchema = z10.object({
+  id: z10.string(),
+  machine: z10.string(),
+  rigId: z10.string(),
+  from: z10.string(),
+  to: z10.string(),
+  kind: z10.enum(["message", "task", "handoff", "ledge"]),
+  text: z10.string(),
+  at: z10.string().datetime()
+});
+var EXCHANGES_MAX = 200;
+var EXCHANGE_GROUP_MS = 6e5;
+var THREAD_PAGE = 50;
+var LedgeDecisionSchema = z10.object({
+  id: z10.string(),
+  escalationId: z10.string(),
+  by: z10.enum(["ledge", "user"]),
+  category: MandateCategorySchema.optional(),
+  // absent: a user answer on an uncategorised escalation (never guessed)
+  summary: z10.string(),
+  answers: z10.record(z10.string()),
+  rule: z10.string().optional(),
+  from: z10.string().optional(),
+  rigId: z10.string().optional(),
+  // the seat and rig the decision was for
+  why: z10.string().optional(),
+  at: z10.string().datetime(),
+  revisitedBy: z10.string().optional()
+});
+var LedgeRuleSchema = z10.object({
+  id: z10.string(),
+  text: z10.string(),
+  category: MandateCategorySchema,
+  since: z10.string(),
+  from: z10.string(),
+  appliedCount: z10.number().int().min(0),
+  status: z10.enum(["active", "proposed"])
+});
+var LedgeThreadItemSchema = z10.discriminatedUnion("kind", [
+  z10.object({
+    kind: z10.literal("user"),
+    id: z10.string(),
+    at: z10.string().datetime(),
+    text: z10.string(),
+    to: z10.string().optional(),
+    // to = "@build"
+    qid: z10.string().optional()
+  }),
+  z10.object({
+    kind: z10.literal("ledge"),
+    id: z10.string(),
+    at: z10.string().datetime(),
+    text: z10.string(),
+    qid: z10.string().optional(),
+    pending: z10.literal(true).optional()
+  }),
+  z10.object({ kind: z10.literal("escalation"), id: z10.string(), at: z10.string().datetime(), escalationId: z10.string() }),
+  z10.object({ kind: z10.literal("decided"), id: z10.string(), at: z10.string().datetime(), decisionId: z10.string() }),
+  z10.object({
+    kind: z10.literal("exchanges"),
+    id: z10.string(),
+    at: z10.string().datetime(),
+    machine: z10.string(),
+    rigId: z10.string(),
+    from: z10.string().datetime(),
+    to: z10.string().datetime(),
+    exchangeIds: z10.array(z10.string())
+  }),
+  z10.object({ kind: z10.literal("card"), id: z10.string(), at: z10.string().datetime(), action: ChatActionSchema })
+  // existing action card
+]);
+var BrainStatusSchema = z10.object({
+  state: z10.enum(["off", "starting", "on", "down"]),
+  tool: ToolSchema,
+  contextPct: z10.number().optional(),
+  sessionId: z10.string().optional(),
+  enabled: z10.boolean().nullable().optional(),
+  // null: the user was never asked
+  restarts: z10.number().int().min(0).optional(),
+  reason: z10.string().optional()
+});
+var RigLaunchWhereSchema = z10.discriminatedUnion("kind", [
+  z10.object({ kind: z10.literal("project"), projectId: z10.string(), repo: z10.string(), branch: z10.string(), copy: z10.boolean() }),
+  z10.object({ kind: z10.literal("off-project"), name: z10.string() })
+]);
+var RigPlanSchema = z10.object({
+  id: z10.string(),
+  machine: z10.string(),
+  spec: z10.string(),
+  goal: z10.string(),
+  where: RigLaunchWhereSchema,
+  cwd: z10.string(),
+  seats: z10.array(z10.object({ address: z10.string(), runtime: z10.string(), model: z10.string().optional(), autonomy: z10.string() })),
+  writes: z10.array(z10.string()),
+  command: z10.string(),
+  required: z10.boolean()
+});
+var RigVerbSchema = z10.enum(["up", "down", "restore", "restart", "stop", "handover"]);
+var RIG_RESULT_CODES = ["rig_managed", "already_answered", "openrig_down", "unsupported", "mandate", "unreachable", "failed", "invalid"];
+var RigResultCodeSchema = z10.enum(RIG_RESULT_CODES);
+var BRAIN_OPS = ["say", "decide", "ask", "rig", "send", "propose", "remember", "who", "rigs", "escalations", "rules", "handover"];
+var BRAIN_RESULT_CODES = ["not_brain", "identity", "mandate", "grace", "invalid", "refused", "already_answered", "failed", "unreachable", "openrig_down"];
+var BrainResultCodeSchema = z10.enum(BRAIN_RESULT_CODES);
+var BRAIN_STOPPED_TEXT = "Ledge est arr\xEAt\xE9 \xB7 D\xE9marrer";
+var OpenRigStatusMessageSchema = z10.object({ type: z10.literal("openrig.status"), status: OpenRigStatusSchema });
+var RigSnapshotSchema = z10.object({ type: z10.literal("rig.snapshot"), machine: z10.string(), rigs: z10.array(RigSchema) });
+var RigUpdatedSchema = z10.object({ type: z10.literal("rig.updated"), rig: RigSchema });
+var RigRemovedSchema = z10.object({ type: z10.literal("rig.removed"), machine: z10.string(), rigId: z10.string() });
+var RigExchangeSchema = z10.object({ type: z10.literal("rig.exchange"), exchange: ExchangeSchema });
+var RigExchangesSchema = z10.object({ type: z10.literal("rig.exchanges"), machine: z10.string(), rigId: z10.string(), items: z10.array(ExchangeSchema) });
+var EscalationUpdatedSchema = z10.object({ type: z10.literal("escalation.updated"), escalation: EscalationSchema });
+var EscalationRemovedSchema = z10.object({ type: z10.literal("escalation.removed"), id: z10.string() });
+var LedgeThreadItemMessageSchema = z10.object({ type: z10.literal("ledge.thread.item"), item: LedgeThreadItemSchema });
+var LedgeThreadHistorySchema = z10.object({ type: z10.literal("ledge.thread.history"), items: z10.array(LedgeThreadItemSchema), before: z10.string().optional() });
+var DecisionsMessageSchema = z10.object({ type: z10.literal("decisions"), items: z10.array(LedgeDecisionSchema) });
+var RulesMessageSchema = z10.object({ type: z10.literal("rules"), items: z10.array(LedgeRuleSchema) });
+var MandateMessageSchema = z10.object({ type: z10.literal("mandate"), text: z10.string(), path: z10.string() });
+var BrainStatusMessageSchema = z10.object({ type: z10.literal("brain.status"), status: BrainStatusSchema });
+var RigPlanMessageSchema = z10.object({ type: z10.literal("rig.plan"), rid: z10.string(), plan: RigPlanSchema });
+var BrainResultSchema = z10.object({ type: z10.literal("brain.result"), rid: z10.string(), ok: z10.boolean(), line: z10.string(), code: BrainResultCodeSchema.optional() });
+var BrainDelegateClaimSchema = z10.object({ type: z10.literal("brain.delegate.claim"), rid: z10.string().min(1).max(100), id: z10.string().min(1).max(200) });
+var BrainDelegateDecideSchema = z10.object({ type: z10.literal("brain.delegate.decide"), rid: z10.string().min(1).max(100), id: z10.string().min(1).max(200), token: z10.string().min(1).max(100), answers: z10.record(z10.string().max(8e3)), category: MandateCategorySchema });
+var BrainDelegateQuerySchema = z10.object({ type: z10.literal("brain.delegate.query"), rid: z10.string().min(1).max(100), operation: z10.string().min(1).max(100), token: z10.string().min(1).max(100) });
+var BrainDelegateReleaseSchema = z10.object({ type: z10.literal("brain.delegate.release"), rid: z10.string().min(1).max(100), id: z10.string().min(1).max(200), token: z10.string().min(1).max(100), advice: z10.string().max(8e3).optional(), category: MandateCategorySchema.optional() });
+var BrainDelegateResultSchema = z10.object({ type: z10.literal("brain.delegate.result"), rid: z10.string().min(1).max(100), ok: z10.boolean(), token: z10.string().optional(), graceUntil: z10.string().datetime().optional(), status: z10.enum(["applied"]).optional(), code: z10.string().optional(), reason: z10.string().optional() });
+var RigResultSchema = z10.object({ type: z10.literal("rig.result"), rid: z10.string(), ok: z10.boolean(), confirmed: z10.literal(true).optional(), code: RigResultCodeSchema.optional(), reason: z10.string().optional() });
+var RigActSchema = z10.object({ type: z10.literal("rig.act"), rid: z10.string(), machine: z10.string(), rigId: z10.string().optional(), seatRef: z10.string().optional(), verb: RigVerbSchema });
+var RigPrepareSchema = z10.object({ type: z10.literal("rig.prepare"), rid: z10.string(), machine: z10.string(), spec: z10.string(), goal: z10.string().max(8e3), where: RigLaunchWhereSchema });
+var RigLaunchSchema = z10.object({ type: z10.literal("rig.launch"), rid: z10.string(), planId: z10.string() });
+var RigAdoptSchema = z10.object({ type: z10.literal("rig.adopt"), rid: z10.string(), machine: z10.string(), rigId: z10.string(), projectId: z10.string() });
+var RigSendSchema = z10.object({ type: z10.literal("rig.send"), rid: z10.string(), machine: z10.string(), seatRef: z10.string(), text: z10.string() });
+var RigSpecSeatSchema = z10.object({
+  address: z10.string(),
+  member: z10.string(),
+  pod: z10.string(),
+  runtime: z10.string(),
+  model: z10.string().optional(),
+  effort: z10.string().optional(),
+  profile: z10.string().optional()
+});
+var RigSpecInfoSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
+  summary: z10.string().optional(),
+  source: z10.enum(["builtin", "library", "registry"]),
+  path: z10.string().optional(),
+  seats: z10.array(RigSpecSeatSchema)
+});
+var RigSpecsRequestSchema = z10.object({ type: z10.literal("rig.specs.request"), requestId: z10.string(), machineId: z10.string().optional() });
+var RigSpecsSchema = z10.object({
+  type: z10.literal("rig.specs"),
+  requestId: z10.string(),
+  machine: z10.string(),
+  specs: z10.array(RigSpecInfoSchema),
+  error: z10.enum(["openrig_down", "unsupported", "failed"]).optional()
+});
+var RigExchangesRequestSchema = z10.object({ type: z10.literal("rig.exchanges.request"), machine: z10.string(), rigId: z10.string() });
+var EscalationAnswerSchema = z10.object({ type: z10.literal("escalation.answer"), rid: z10.string(), id: z10.string(), answers: z10.record(z10.string()), by: z10.literal("user") });
+var LedgeSaySchema = z10.object({ type: z10.literal("ledge.say"), rid: z10.string(), text: z10.string(), about: z10.string().optional() });
+var LedgeThreadRequestSchema = z10.object({ type: z10.literal("ledge.thread.request"), before: z10.string().optional() });
+var MandateUpdateSchema = z10.object({ type: z10.literal("mandate.update"), rid: z10.string(), text: z10.string() });
+var RuleSetSchema = z10.object({ type: z10.literal("rule.set"), rid: z10.string(), id: z10.string(), status: z10.enum(["active", "rejected"]) });
+var DecisionRevisitSchema = z10.object({ type: z10.literal("decision.revisit"), rid: z10.string(), id: z10.string(), text: z10.string().optional() });
+var CategoryEscalateSchema = z10.object({ type: z10.literal("category.escalate"), rid: z10.string(), category: MandateCategorySchema });
+var BrainSetSchema = z10.object({
+  type: z10.literal("brain.set"),
+  rid: z10.string(),
+  enabled: z10.boolean(),
+  tool: ToolSchema.optional(),
+  first: z10.literal(true).optional()
+});
+var BrainCmdSchema = z10.object({
+  type: z10.literal("brain.cmd"),
+  rid: z10.string(),
+  by: z10.string(),
+  key: z10.string(),
+  op: z10.enum(BRAIN_OPS),
+  args: z10.array(z10.string()).max(40)
+});
+
+// ../protocol/src/messages.ts
+import { z as z21 } from "zod";
+
 // ../protocol/src/repos.ts
-import { z as z14 } from "zod";
-var ReposInspectSchema = z14.object({
-  type: z14.literal("repos.inspect"),
-  requestId: z14.string().min(1).max(100),
-  paths: z14.array(z14.string().min(1)).min(1).max(50),
-  machineId: z14.string().optional()
-});
-var RepoInfoSchema = z14.object({ path: z14.string(), exists: z14.boolean(), branch: z14.string().nullable() });
-var ReposInfoSchema = z14.object({ type: z14.literal("repos.info"), requestId: z14.string(), repos: z14.array(RepoInfoSchema) });
+import { z as z11 } from "zod";
+var ReposInspectSchema = z11.object({
+  type: z11.literal("repos.inspect"),
+  requestId: z11.string().min(1).max(100),
+  paths: z11.array(z11.string().min(1)).min(1).max(50),
+  machineId: z11.string().optional()
+});
+var RepoInfoSchema = z11.object({ path: z11.string(), exists: z11.boolean(), branch: z11.string().nullable() });
+var ReposInfoSchema = z11.object({ type: z11.literal("repos.info"), requestId: z11.string(), repos: z11.array(RepoInfoSchema) });
 
 // ../protocol/src/scan.ts
-import { z as z15 } from "zod";
-var ReposScanSchema = z15.object({ type: z15.literal("repos.scan"), requestId: z15.string().min(1).max(100), machineId: z15.string().optional() });
-var FoundRepoSchema = z15.object({ path: z15.string(), branch: z15.string().nullable(), remote: z15.string().optional(), manifest: z15.string().max(200).optional() });
-var ReposFoundSchema = z15.object({ type: z15.literal("repos.found"), requestId: z15.string(), repos: z15.array(FoundRepoSchema).max(500), truncated: z15.boolean(), error: z15.string().optional() });
+import { z as z12 } from "zod";
+var ReposScanSchema = z12.object({ type: z12.literal("repos.scan"), requestId: z12.string().min(1).max(100), machineId: z12.string().optional() });
+var FoundRepoSchema = z12.object({ path: z12.string(), branch: z12.string().nullable(), remote: z12.string().optional(), manifest: z12.string().max(200).optional() });
+var ReposFoundSchema = z12.object({ type: z12.literal("repos.found"), requestId: z12.string(), repos: z12.array(FoundRepoSchema).max(500), truncated: z12.boolean(), error: z12.string().optional() });
 
 // ../protocol/src/documents.ts
-import { z as z16 } from "zod";
+import { z as z13 } from "zod";
 var DOCUMENT_MAX_BYTES = 1048576;
-var path = z16.string().min(1).max(4096);
-var requestId2 = z16.string().min(1);
-var DocumentReadSchema = z16.object({
-  type: z16.literal("document.read"),
+var path = z13.string().min(1).max(4096);
+var requestId2 = z13.string().min(1);
+var DocumentReadSchema = z13.object({
+  type: z13.literal("document.read"),
   requestId: requestId2,
   path,
-  machineId: z16.string().optional(),
-  sessionId: z16.string().min(1).optional(),
+  machineId: z13.string().optional(),
+  sessionId: z13.string().min(1).optional(),
   basePath: path.optional()
 });
-var DocumentContentSchema = z16.object({
-  type: z16.literal("document.content"),
+var DocumentContentSchema = z13.object({
+  type: z13.literal("document.content"),
   requestId: requestId2,
   path,
-  text: z16.string(),
-  bytes: z16.number().int().nonnegative(),
-  modifiedAt: z16.string().datetime()
+  text: z13.string(),
+  bytes: z13.number().int().nonnegative(),
+  modifiedAt: z13.string().datetime()
 });
-var DocumentErrorCodeSchema = z16.enum([
+var DocumentErrorCodeSchema = z13.enum([
   "not_found",
   "not_file",
   "unsupported_path",
@@ -1119,62 +1106,155 @@ var DocumentErrorCodeSchema = z16.enum([
   "session_missing",
   "read_failed"
 ]);
-var DocumentErrorSchema = z16.object({
-  type: z16.literal("document.error"),
+var DocumentErrorSchema = z13.object({
+  type: z13.literal("document.error"),
   requestId: requestId2,
   path,
   code: DocumentErrorCodeSchema
 });
 
 // ../protocol/src/routing.ts
-import { z as z17 } from "zod";
-var MachineInventorySchema = z17.object({
-  id: z17.string().min(1).max(80),
-  label: z17.string().min(1).max(120),
-  online: z17.boolean(),
-  local: z17.boolean(),
-  sessions: z17.array(z17.object({ id: z17.string(), name: z17.string(), project: z17.string(), cwd: z17.string(), topic: z17.string().optional(), state: z17.string(), readOnly: z17.boolean() })).max(500),
-  folders: z17.array(z17.object({ project: z17.string(), cwd: z17.string() })).max(100)
-});
-var RoutingContextSchema = z17.object({
-  machines: z17.array(MachineInventorySchema).min(1).max(20),
-  history: z17.array(z17.object({ question: z17.string().max(2e4), answer: z17.string().max(2e4).optional(), machineId: z17.string().optional() })).max(50)
-});
-var RouteResultSchema = z17.object({
+import { z as z14 } from "zod";
+var MachineInventorySchema = z14.object({
+  id: z14.string().min(1).max(80),
+  label: z14.string().min(1).max(120),
+  online: z14.boolean(),
+  local: z14.boolean(),
+  sessions: z14.array(z14.object({ id: z14.string(), name: z14.string(), project: z14.string(), cwd: z14.string(), topic: z14.string().optional(), state: z14.string(), readOnly: z14.boolean() })).max(500),
+  folders: z14.array(z14.object({ project: z14.string(), cwd: z14.string() })).max(100)
+});
+var RoutingContextSchema = z14.object({
+  machines: z14.array(MachineInventorySchema).min(1).max(20),
+  history: z14.array(z14.object({ question: z14.string().max(2e4), answer: z14.string().max(2e4).optional(), machineId: z14.string().optional() })).max(50)
+});
+var RouteResultSchema = z14.object({
   /** Null means an answer or a clarification, never an implicit local destination. */
-  machineId: z17.string().nullable(),
-  text: z17.string().min(1).max(2e4),
-  choices: z17.array(z17.string()).max(20).optional()
+  machineId: z14.string().nullable(),
+  text: z14.string().min(1).max(2e4),
+  choices: z14.array(z14.string()).max(20).optional()
+});
+
+// ../protocol/src/ssh.ts
+import { z as z15 } from "zod";
+var SshAliasSchema = z15.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
+
+// ../protocol/src/machines.ts
+import { z as z16 } from "zod";
+var MachineIdSchema = z16.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var MachineSchema = z16.object({
+  id: MachineIdSchema,
+  label: z16.string().trim().min(1).max(80),
+  ssh: SshAliasSchema.optional()
+});
+var MachinesSchema = z16.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 z18 } from "zod";
-var IslandScaleSchema = z18.union([z18.literal("auto"), z18.literal(1), z18.literal(1.25), z18.literal(1.5), z18.literal(2)]);
-var IslandPrefsSchema = z18.object({
+import { z as z17 } from "zod";
+var IslandScaleSchema = z17.union([z17.literal("auto"), z17.literal(1), z17.literal(1.25), z17.literal(1.5), z17.literal(2)]);
+var IslandPrefsSchema = z17.object({
   /** Shown at the top of the screen; hidden, Desktop still notifies. */
-  visible: z18.boolean(),
+  visible: z17.boolean(),
   /** `primary` (whichever it is after a reconfiguration), or a monitor's id as the shell lists it (`list_monitors`: the OS
    *  name, `#index` without one). `second`, written by older fronts, is the first monitor that is not the primary. */
-  screen: z18.string().trim().min(1).max(200),
-  position: z18.enum(["center", "left", "right"]),
+  screen: z17.string().trim().min(1).max(200),
+  position: z17.enum(["center", "left", "right"]),
   /** A strip under a maximised window. */
-  discreet: z18.boolean(),
+  discreet: z17.boolean(),
   islandScale: IslandScaleSchema,
   panelScale: IslandScaleSchema,
   /** What the island shows besides asks and questions, which it always shows. */
-  shows: z18.object({
+  shows: z17.object({
     /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
-    quick: z18.boolean(),
+    quick: z17.boolean(),
     /** The 6 s bubble when an agent finishes. */
-    finished: z18.boolean(),
+    finished: z17.boolean(),
     /** An agent's sentence in a bubble. */
-    say: z18.boolean(),
+    say: z17.boolean(),
     /** The sub-agents next to their main agent. */
-    helpers: z18.boolean()
+    helpers: z17.boolean()
   }),
   /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
-  shortcut: z18.string().trim().min(1).max(40)
+  shortcut: z17.string().trim().min(1).max(40)
+});
+
+// ../protocol/src/projects.ts
+import { z as z18 } from "zod";
+var PROJECT_COLORS = { blue: "#3b82f6", green: "#10b981", amber: "#f59e0b", violet: "#8b5cf6", teal: "#14b8a6", pink: "#ec4899", red: "#ef4444", slate: "#64748b" };
+var ProjectColorSchema = z18.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
+var ProjectIdSchema = z18.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 = z18.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
+var RepoSchema = z18.object({ machine: MachineIdSchema, path: PathSchema });
+var ProjectSchema = z18.object({
+  id: ProjectIdSchema,
+  name: z18.string().trim().min(1).max(80),
+  color: ProjectColorSchema,
+  description: z18.string().max(500).default(""),
+  repos: z18.array(RepoSchema).max(50),
+  /** Ids of the OpenRig rigs filed in this project (a rig lives in one project at most). */
+  rigs: z18.array(z18.string().min(1).max(200)).max(200).default([])
+});
+var RuleSchema = z18.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(), rigIds = /* @__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 key2 = `${repo.machine}
+${repo.path}`;
+      if (repos.has(key2)) out.push({ code: "duplicate_repo", path: ["projects", i, "repos", j] });
+      repos.add(key2);
+    });
+    project.rigs.forEach((rig, j) => {
+      if (rigIds.has(rig)) out.push({ code: "duplicate_rig", path: ["projects", i, "rigs", j] });
+      rigIds.add(rig);
+    });
+  });
+  p.rules.forEach((rule, i) => {
+    const key2 = `${rule.machine}
+${rule.path}`;
+    if (rules.has(key2)) out.push({ code: "duplicate_rule", path: ["rules", i] });
+    rules.add(key2);
+    if (!ids.has(rule.project)) out.push({ code: "unknown_project", path: ["rules", i, "project"] });
+  });
+  return out;
+}
+var ProjectsSchema = z18.object({ projects: z18.array(ProjectSchema).max(100), rules: z18.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 known2 = 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 && known2.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 z19 } from "zod";
@@ -1203,13 +1283,6 @@ var ThreadItemSchema = z19.discriminatedUnion("kind", [
     kind: z19.literal("notice"),
     ...base,
     notice: z19.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
-    /** An `other` notice from Ledge: `task`, the task a `<ledge-task>` is about; `team`, the team a `<ledge-notice team>` seated the
-     *  session in (roles spec §3.3). An older front, which knows neither, shows it as any other notice. */
-    task: z19.string().optional(),
-    team: z19.string().optional(),
-    /** A task this session handed over (`outgoing`), and how (issue #92). */
-    taskOp: z19.enum(TRANSMISSION_OPS).optional(),
-    outgoing: z19.literal(true).optional(),
     name: z19.string().optional(),
     peer: z19.string().optional(),
     time: z19.string().optional(),
@@ -1272,7 +1345,7 @@ var MobileStateSchema = z20.object({
 
 // ../protocol/src/messages.ts
 var PROTOCOL_PORT = 47831;
-var RefusalCodeSchema = z21.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid", "attachment_missing", "attachments_not_accepted"]);
+var RefusalCodeSchema = z21.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid", "attachment_missing", "attachments_not_accepted", "rig_managed"]);
 var SessionEventSchema = z21.object({
   name: z21.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
   at: z21.string().datetime(),
@@ -1341,8 +1414,15 @@ var DaemonInfoSchema = z21.object({
   /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
   home: z21.string().optional(),
   mobile: z21.boolean().optional(),
-  /** Knows roles, teams and tasks given by Ledge (spec 2026-10-25 roles). */
-  teams: z21.boolean().optional()
+  /** Knows `ask.create` / `ask.answer`: a session's decision for the user (`ledge ask`). */
+  asks: z21.boolean().optional(),
+  /** Reads OpenRig (rigs, escalations, exchanges) through its local bridge. */
+  openrig: z21.boolean().optional(),
+  /** Takes color-preview subscriptions. */
+  colorPreview: z21.boolean().optional(),
+  /** Relays rigs of remote machines. */
+  openrigFleet: z21.boolean().optional(),
+  brainDelegate: z21.boolean().optional()
 });
 var UpdateFailureSchema = z21.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
 var ServerMessageSchema = z21.discriminatedUnion("type", [
@@ -1361,6 +1441,8 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
    *  from daemons older than the auto-update. */
   z21.object({ type: z21.literal("snapshot"), sessions: z21.array(SessionSchema), recents: z21.array(RecentSchema).optional(), launcher: z21.array(z21.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
   z21.object({ type: z21.literal("session.updated"), session: SessionSchema }),
+  /** Ephemeral office bubble; never included in snapshots or phone relay. */
+  z21.object({ type: z21.literal("session.thought"), id: z21.string(), text: z21.string().max(80), at: z21.string().datetime() }),
   /** OMP: the instructions taken back from its queue by an interrupt that restores it; the asker puts them back in its draft. */
   z21.object({
     type: z21.literal("session.queue.restored"),
@@ -1372,6 +1454,8 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
   }),
   z21.object({ type: z21.literal("session.removed"), id: z21.string() }),
   z21.object({ type: z21.literal("session.preview"), id: z21.string(), lines: z21.array(z21.string()) }),
+  /** The session's terminal in color (SGR codes kept), sent only to the client that subscribed to it. */
+  z21.object({ type: z21.literal("session.preview.color"), id: z21.string(), lines: z21.array(z21.string()) }),
   /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
   z21.object({ type: z21.literal("session.thread"), id: z21.string(), items: z21.array(ThreadItemSchema) }),
   z21.object({ type: z21.literal("session.thread.item"), id: z21.string(), item: ThreadItemSchema }),
@@ -1397,7 +1481,7 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
   /** The chat (spec 2026-10-11 §5): what Ledge reads, its words as they come, the final text, or why it stopped; the day's turns after each snapshot. */
   z21.object({ type: z21.literal("chat.step"), qid: z21.string(), step: ChatStepSchema }),
   z21.object({ type: z21.literal("chat.delta"), qid: z21.string(), text: z21.string() }),
-  z21.object({ type: z21.literal("chat.done"), qid: z21.string(), text: z21.string(), at: z21.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional(), team: ChatTeamProposalSchema.optional(), tasks: ChatTasksSchema.optional(), actions: ChatActionsSchema.optional() }),
+  z21.object({ type: z21.literal("chat.done"), qid: z21.string(), text: z21.string(), at: z21.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional(), actions: ChatActionsSchema.optional() }),
   /** What a `chat.act` applied: the rows done, and the one that failed with why (the rows after it stay proposed). */
   z21.object({ type: z21.literal("chat.acted"), rid: z21.string(), qid: z21.string(), done: z21.array(z21.number().int().min(0)), failed: z21.array(z21.object({
     row: z21.number().int().min(0),
@@ -1407,7 +1491,7 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
   })) }),
   /** What an `action.run` came to: `row` the action as the daemon resolved it (its summary, its risk); `reason` why it was not
    *  done, with `code` (`refused`: not possible now; `agent`: a session may not run it; `confirm_required`: destructive, ask
-   *  again; `failed`: the handler turned it down; a free string, as an `error`'s); `path` the template a `team.save` wrote. */
+   *  again; `failed`: the handler turned it down; a free string, as an `error`'s); `path` a file the action wrote. */
   z21.object({ type: z21.literal("action.result"), rid: z21.string(), action: z21.string().min(1).max(40), row: ChatActionSchema.optional(), reason: z21.string().optional(), code: z21.string().optional(), path: z21.string().optional() }),
   z21.object({ type: z21.literal("chat.error"), qid: z21.string(), message: z21.string() }),
   z21.object({ type: z21.literal("chat.history"), turns: z21.array(ChatTurnSchema) }),
@@ -1427,20 +1511,31 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
   z21.object({ type: z21.literal("message.ack"), rid: z21.string(), outcome: z21.enum(["accepted", "queued", "native", "refused"]), reason: z21.string().optional() }),
   /** The answer to a `message.read`: the body with its sender, target and time, or the refusal's `reason`. */
   z21.object({ type: z21.literal("message.body"), id: z21.string(), from: z21.string().optional(), to: z21.string().optional(), at: z21.string().optional(), text: z21.string().optional(), reason: z21.string().optional() }),
-  TaskResultSchema,
   SessionHandoverResultSchema,
   ContextPrefsMessageSchema,
   HandoverResultSchema,
-  TaskUpdatedSchema,
-  RolesListingSchema,
-  TeamsMessageSchema,
-  TeamUpdatedSchema,
-  TeamLaunchedSchema,
-  TeamFailedSchema,
-  TeamSavedSchema,
-  DefinitionsListingSchema,
-  DefinitionResultSchema,
-  TeamChangedSchema,
+  AsksMessageSchema,
+  AskUpdatedSchema,
+  AskResultSchema,
+  OpenRigStatusMessageSchema,
+  RigSnapshotSchema,
+  RigUpdatedSchema,
+  RigRemovedSchema,
+  RigExchangeSchema,
+  RigExchangesSchema,
+  RigSpecsSchema,
+  EscalationUpdatedSchema,
+  EscalationRemovedSchema,
+  LedgeThreadItemMessageSchema,
+  LedgeThreadHistorySchema,
+  DecisionsMessageSchema,
+  RulesMessageSchema,
+  MandateMessageSchema,
+  BrainStatusMessageSchema,
+  RigPlanMessageSchema,
+  RigResultSchema,
+  BrainResultSchema,
+  BrainDelegateResultSchema,
   z21.object({
     type: z21.literal("error"),
     message: z21.string(),
@@ -1483,10 +1578,6 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
     effort: EffortSchema.optional(),
     /** OMP only: its approval mode, `always-ask` when left out. */
     approval: OmpApprovalSchema.optional(),
-    /** A role (spec 2026-10-25 roles §3.4): its prompt reaches the agent at every start, its defaults fill what is left out. */
-    role: RoleIdSchema.optional(),
-    /** A live team the new session joins at once, in `role`. */
-    team: TeamIdSchema.optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
     machineId: z21.string().optional()
   }),
@@ -1574,10 +1665,20 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
   z21.object({ type: z21.literal("session.delete"), id: z21.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. */
   z21.object({ type: z21.literal("session.rename"), id: z21.string(), topic: z21.string().max(500) }),
+  /** The one session this client follows in color; `id: null` follows none. */
+  z21.object({ type: z21.literal("session.preview.subscribe"), id: z21.string().nullable(), color: z21.literal(true) }),
   z21.object({ type: z21.literal("session.thread"), id: z21.string() }),
   z21.object({ type: z21.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). */
-  z21.object({ type: z21.literal("session.event"), id: z21.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z21.string().optional() }),
+  z21.object({
+    type: z21.literal("session.event"),
+    id: z21.string(),
+    event: SessionEventSchema,
+    agent: ToolSchema.optional(),
+    cwd: z21.string().optional(),
+    /** The OpenRig seat a hook ran in: its session name (`dev-build@starter`) and node id, what pairs the session with its seat. */
+    openrig: z21.object({ sessionName: z21.string().min(1).max(200), nodeId: z21.string().max(200).optional() }).optional()
+  }),
   z21.object({ type: z21.literal("session.unregister"), id: z21.string(), exitCode: z21.number().int().nullable() }),
   z21.object({ type: z21.literal("snapshot.request") }),
   z21.object({ type: z21.literal("chat.ask"), qid: z21.string().min(1), text: z21.string(), images: z21.array(ImageUploadSchema).max(ATTACHMENTS_MAX).optional(), tool: ToolSchema.optional() }),
@@ -1607,29 +1708,33 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
   z21.object({ type: z21.literal("session.message"), rid: z21.string().min(1), from: z21.string().min(1), to: z21.string().min(1), text: z21.string().min(1).max(MESSAGE_MAX), summary: z21.string().max(SUMMARY_MAX).optional(), intercept: z21.boolean().optional() }),
   /** `ledge read <id>`: a message's whole body, for its receiver or its sender (`by`, a session id). */
   z21.object({ type: z21.literal("message.read"), id: z21.string().min(1).max(40), by: z21.string().min(1) }),
-  TaskCmdSchema,
+  AskCreateSchema,
+  AskAnswerSchema,
   SessionHandoverSchema,
   ContextSetSchema,
   HandoverBriefSchema,
   HandoverShowSchema,
-  RolesListSchema,
-  TeamLaunchSchema,
-  TeamJoinSchema,
-  TeamLeaveSchema,
-  TeamResumeSchema,
-  TeamDissolveSchema,
-  TeamSaveSchema,
-  DefinitionsListSchema,
-  RoleWriteSchema,
-  RoleDeleteSchema,
-  TemplateWriteSchema,
-  TemplateDeleteSchema,
-  TeamComposeSchema,
-  TeamSeatSchema
-]).superRefine((m, ctx) => {
-  const issue = "scope" in m ? scopeIssue(m) : null;
-  if (issue) ctx.addIssue({ code: z21.ZodIssueCode.custom, message: issue, path: ["project"] });
-});
+  RigActSchema,
+  RigPrepareSchema,
+  RigLaunchSchema,
+  RigAdoptSchema,
+  RigSendSchema,
+  RigExchangesRequestSchema,
+  RigSpecsRequestSchema,
+  EscalationAnswerSchema,
+  LedgeSaySchema,
+  LedgeThreadRequestSchema,
+  MandateUpdateSchema,
+  RuleSetSchema,
+  DecisionRevisitSchema,
+  CategoryEscalateSchema,
+  BrainSetSchema,
+  BrainCmdSchema,
+  BrainDelegateClaimSchema,
+  BrainDelegateDecideSchema,
+  BrainDelegateReleaseSchema,
+  BrainDelegateQuerySchema
+]);
 function parseClientMessage(raw) {
   return ClientMessageSchema.parse(raw);
 }
@@ -1802,9 +1907,61 @@ var MeResponseSchema = z23.object({
 // ../protocol/src/phone.ts
 import { z as z26 } from "zod";
 
-// ../protocol/src/push.ts
+// ../protocol/src/phoneOpenrig.ts
 import { z as z24 } from "zod";
-var B64U = z24.string().regex(/^[A-Za-z0-9_-]*$/);
+var id = z24.string().min(1).max(120);
+var key = z24.string().min(1).max(64);
+var at = z24.string().datetime();
+var op = z24.string().uuid();
+var messageMax = 2e4;
+var toolTextMax = 2048;
+var PhoneRigSeatSchema = z24.object({ ref: id, address: id, name: z24.string().max(80), runtime: z24.string().max(80), model: z24.string().max(120).optional(), state: SeatStateSchema, contextPct: z24.number().min(0).max(100).optional(), sessionId: id.optional() }).strict();
+var PhoneRigSchema = z24.object({ key, name: z24.string().max(80), spec: z24.string().max(80).optional(), project: z24.string().max(80).nullable(), offProject: z24.boolean(), branch: z24.string().max(200).optional(), lifecycle: RigLifecycleSchema, kernel: z24.boolean(), seats: z24.array(PhoneRigSeatSchema).max(16), repos: z24.number().int().nonnegative(), launch: z24.object({ planId: id, goal: z24.string().max(600), lead: id, startedAt: at, goalSentAt: at.optional(), lateNotice: z24.literal(true).optional() }).strict().optional() }).strict();
+var PhoneExchangeSchema = z24.object({ id, rigKey: key, from: id, to: id, kind: z24.enum(["message", "task", "handoff", "ledge"]), text: z24.string().max(toolTextMax), at, cut: z24.literal(true).optional() }).strict();
+var PhoneQuestionSchema = z24.object({ id, question: z24.string().max(toolTextMax), options: z24.array(z24.object({ id, label: z24.string().max(200), recommended: z24.boolean().optional() }).strict()).min(2).max(4) }).strict();
+var PhoneEscalationSchema = z24.object({ id, source: z24.enum(["rig", "operator", "ask"]), rigKey: key.optional(), rigName: z24.string().max(60).optional(), from: id, intent: z24.enum(["decision", "update"]), summary: z24.string().max(toolTextMax), detail: z24.string().max(toolTextMax).optional(), questions: z24.array(PhoneQuestionSchema).max(4), createdAt: at, state: z24.enum(["pending", "grace", "answered", "closed"]), graceUntil: at.optional(), correcting: id.optional(), category: MandateCategorySchema.optional(), advice: z24.string().max(toolTextMax).optional(), rules: z24.array(z24.object({ text: z24.string().max(200), since: z24.string().max(10) }).strict()).max(5).optional(), answer: z24.object({ by: z24.enum(["ledge", "user"]), answers: z24.record(z24.string().max(120), z24.string().max(messageMax)), at, rule: id.optional(), delivery: z24.enum(["queued", "sent"]).optional() }).strict().optional() }).strict();
+var PhoneLedgeDecisionSchema = z24.object({ id, escalationId: id, by: z24.enum(["ledge", "user"]), category: MandateCategorySchema.optional(), summary: z24.string().max(toolTextMax), answers: z24.record(z24.string().max(120), z24.string().max(messageMax)), rule: id.optional(), from: id.optional(), rigName: z24.string().max(60).optional(), why: z24.string().max(toolTextMax).optional(), at, revisitedBy: id.optional() }).strict();
+var PhoneRigPlanSchema = z24.object({ id, spec: z24.string().max(80), goal: z24.string().max(600), where: z24.discriminatedUnion("kind", [z24.object({ kind: z24.literal("project"), project: z24.string().max(80), branch: z24.string().max(200), copy: z24.boolean() }).strict(), z24.object({ kind: z24.literal("off-project"), name: z24.string().max(80) }).strict()]), seats: z24.array(z24.object({ address: id, runtime: z24.string().max(80), model: z24.string().max(120).optional(), autonomy: z24.string().max(80) }).strict()).max(16), writes: z24.array(z24.string().max(200)).max(40), required: z24.boolean(), launchedRigKey: key.optional(), launchedAt: at.optional() }).strict();
+var PhoneThreadItemSchema = z24.discriminatedUnion("kind", [
+  z24.object({ kind: z24.literal("user"), id, at, text: z24.string().max(toolTextMax), to: id.optional(), qid: id.optional() }).strict(),
+  z24.object({ kind: z24.literal("ledge"), id, at, text: z24.string().max(toolTextMax), qid: id.optional(), pending: z24.literal(true).optional() }).strict(),
+  z24.object({ kind: z24.literal("escalation"), id, at, escalation: PhoneEscalationSchema }).strict(),
+  z24.object({ kind: z24.literal("decided"), id, at, decision: PhoneLedgeDecisionSchema }).strict(),
+  z24.object({ kind: z24.literal("exchanges"), id, at, rigKey: key, rigName: z24.string().max(60), from: at, to: at, count: z24.number().int().min(1), items: z24.array(PhoneExchangeSchema).max(20) }).strict(),
+  z24.object({ kind: z24.literal("card"), id, at, action: z24.lazy(() => PhoneChatActionSchema) }).strict(),
+  z24.object({ kind: z24.literal("plan"), id, at, plan: PhoneRigPlanSchema }).strict()
+]);
+var PhoneRigActSchema = z24.object({ type: z24.literal("rig.act"), op, key, verb: z24.enum(["down", "restart"]), seatRef: id.optional(), assertion: z24.lazy(() => AssertionSchema).optional() }).strict();
+var PhoneRigLaunchSchema = z24.object({ type: z24.literal("rig.launch"), op, planId: id, assertion: z24.lazy(() => AssertionSchema).optional() }).strict();
+var PhoneEscalationAnswerSchema = z24.object({ type: z24.literal("escalation.answer"), op, id, answers: z24.record(z24.string().max(64), z24.string().max(messageMax)).refine((value) => Object.keys(value).length <= 4) }).strict();
+var rigSubject = (m) => m.type === "rig.launch" ? `launch@${m.planId}` : `${m.verb}@${m.key}${m.seatRef ? `/${m.seatRef}` : ""}`;
+var phoneOpenRigClientMessages = [
+  z24.object({ type: z24.literal("ledge.say"), op, text: z24.string().trim().min(1).max(messageMax), about: id.optional() }).strict(),
+  z24.object({ type: z24.literal("ledge.thread.request"), before: id.optional() }).strict(),
+  PhoneEscalationAnswerSchema,
+  z24.object({ type: z24.literal("answer.receipt.request"), answer: PhoneEscalationAnswerSchema }).strict(),
+  z24.object({ type: z24.literal("decision.revisit"), op, id, text: z24.string().max(messageMax).optional() }).strict(),
+  z24.object({ type: z24.literal("rig.exchanges.request"), key }).strict(),
+  z24.object({ type: z24.literal("rig.prepare"), op, goal: z24.string().trim().min(1).max(600), spec: z24.string().max(64).optional(), project: z24.string().max(80).nullable() }).strict(),
+  PhoneRigLaunchSchema,
+  PhoneRigActSchema
+];
+var phoneOpenRigServerMessages = [
+  z24.object({ type: z24.literal("answer.receipt"), op, status: z24.enum(["received", "applied", "unknown"]) }).strict(),
+  z24.object({ type: z24.literal("rig.updated"), rig: PhoneRigSchema }).strict(),
+  z24.object({ type: z24.literal("rig.removed"), key }).strict(),
+  z24.object({ type: z24.literal("rig.exchanges"), key, items: z24.array(PhoneExchangeSchema).max(EXCHANGES_MAX), cut: z24.literal(true).optional() }).strict(),
+  z24.object({ type: z24.literal("escalation.updated"), escalation: PhoneEscalationSchema }).strict(),
+  z24.object({ type: z24.literal("escalation.removed"), id }).strict(),
+  z24.object({ type: z24.literal("ledge.thread.item"), item: PhoneThreadItemSchema }).strict(),
+  z24.object({ type: z24.literal("ledge.thread.history"), items: z24.array(PhoneThreadItemSchema).max(THREAD_PAGE), before: id.optional() }).strict(),
+  z24.object({ type: z24.literal("decisions"), items: z24.array(PhoneLedgeDecisionSchema).max(50) }).strict(),
+  z24.object({ type: z24.literal("rig.plan"), plan: PhoneRigPlanSchema }).strict()
+];
+
+// ../protocol/src/push.ts
+import { z as z25 } from "zod";
+var B64U = z25.string().regex(/^[A-Za-z0-9_-]*$/);
 var PUSH_HOSTS = ["*.push.apple.com", "fcm.googleapis.com", "updates.push.services.mozilla.com", "*.notify.windows.com"];
 function pushEndpointAllowed(url) {
   let u;
@@ -1821,76 +1978,34 @@ function pushEndpointAllowed(url) {
     return host.length > suffix.length && host.endsWith(suffix);
   });
 }
-var PushSendSchema = z24.object({
-  endpoint: z24.string().url().max(1024),
+var PushSendSchema = z25.object({
+  endpoint: z25.string().url().max(1024),
   body: B64U.max(5462),
-  ttl: z24.number().int().min(0).max(86400),
-  urgency: z24.enum(["normal", "high"]),
-  topic: z24.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
-});
-var PushSendResultSchema = z24.object({
-  result: z24.enum(["sent", "gone", "failed"]),
-  status: z24.number().int().optional()
-});
-var PushSubscriptionSchema = z24.object({
-  endpoint: z24.string().url().max(1024).refine(pushEndpointAllowed),
-  keys: z24.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
-});
-var PushPayloadSchema = z24.object({
-  v: z24.literal(1),
-  kind: z24.enum(["request", "question", "finished", "chat"]),
-  title: z24.string().max(80),
-  body: z24.string().max(120),
-  url: z24.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
-  badge: z24.number().int().min(0).max(999),
-  tag: z24.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+  ttl: z25.number().int().min(0).max(86400),
+  urgency: z25.enum(["normal", "high"]),
+  topic: z25.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+});
+var PushSendResultSchema = z25.object({
+  result: z25.enum(["sent", "gone", "failed"]),
+  status: z25.number().int().optional()
+});
+var PushSubscriptionSchema = z25.object({
+  endpoint: z25.string().url().max(1024).refine(pushEndpointAllowed),
+  keys: z25.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
+});
+var PushPayloadSchema = z25.object({
+  v: z25.literal(1),
+  kind: z25.enum(["request", "question", "finished", "chat", "escalation", "decided"]),
+  escalationId: z25.string().min(1).max(120).optional(),
+  count: z25.number().int().min(1).max(999).optional(),
+  actions: z25.array(z25.object({ qId: z25.string().min(1).max(64), optId: z25.string().min(1).max(64), label: z25.string().max(40) }).strict()).max(2).optional(),
+  title: z25.string().max(80),
+  body: z25.string().max(120),
+  url: z25.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
+  badge: z25.number().int().min(0).max(999),
+  tag: z25.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
 });
 
-// ../protocol/src/phoneTeams.ts
-import { z as z25 } from "zod";
-var scope = DefinitionScopeSchema;
-var PhoneSeatsSchema = z25.array(SeatSchema.strict()).min(1).max(TEAM_SEATS_MAX).refine(uniqueRoles, "a role twice in one team");
-var PhoneRoleDraftSchema = RoleDraftSchema.strict();
-var projectName = z25.string().max(80).nullable();
-var PhoneRoleSchema = z25.object({
-  id: RoleIdSchema,
-  label: z25.string().min(1).max(ROLE_LABEL_MAX),
-  prompt: z25.string().max(ROLE_PROMPT_MAX),
-  cut: z25.literal(true).optional(),
-  tool: ToolSchema.optional(),
-  model: ModelIdSchema.optional(),
-  effort: EffortSchema.optional(),
-  autonomy: AutonomySchema.optional(),
-  scope,
-  project: projectName,
-  hash: DefinitionHashSchema,
-  shadows: z25.literal(true).optional(),
-  shadowed: z25.literal(true).optional(),
-  shadowedIn: z25.array(z25.string().max(80)).min(1).max(8).optional()
-}).strict();
-var PhoneTemplateSchema = z25.object({ id: TemplateIdSchema, name: TeamNameSchema, seats: PhoneSeatsSchema, scope, project: projectName, hash: DefinitionHashSchema }).strict();
-var PhoneProblemSchema = z25.object({ file: z25.string().max(80), scope, project: projectName, reason: z25.string().max(200) }).strict();
-var PhoneCatalogSchema = z25.object({
-  /** The names of the projects with a local repository: the ones a « Dépôt » scope or a « Lever » can name. */
-  projects: z25.array(z25.string().max(80)).max(50),
-  roles: z25.array(PhoneRoleSchema).max(200),
-  templates: z25.array(PhoneTemplateSchema).max(100),
-  problems: z25.array(PhoneProblemSchema).max(50)
-}).strict();
-var TEAMS_OPERATION_TYPES = ["role.write", "role.delete", "template.write", "template.delete", "team.launch", "team.compose", "team.seat", "team.dissolve"];
-var isTeamsOperation = (m) => TEAMS_OPERATION_TYPES.includes(m.type);
-function canonicalJson(v) {
-  const sort = (x) => {
-    if (Array.isArray(x)) return x.map(sort);
-    if (x !== null && typeof x === "object") {
-      const o = x;
-      return Object.fromEntries(Object.keys(o).sort().filter((k) => o[k] !== void 0).map((k) => [k, sort(o[k])]));
-    }
-    return x;
-  };
-  return JSON.stringify(sort(v));
-}
-
 // ../protocol/src/phone.ts
 var PHONE_PROTOCOL = 1;
 var PAD_TIERS = [1024, 4096, 16384, 65536, 262144, 655360];
@@ -1928,7 +2043,7 @@ var RiskSchema = z26.enum(["low", "high"]);
 var RiskReasonSchema = z26.enum(["question", "read_only_command", "edit_inside_folder", "pushes", "destroys", "deploys", "publishes", "pipes_to_shell", "network", "writes_outside_folder", "sensitive_path", "unsafe_flag", "shell_syntax", "script", "plan", "unknown"]);
 var OperationIdSchema = z26.string().uuid();
 var OperationStatusSchema = z26.enum(["received", "applied", "rejected", "failed"]);
-var OperationReasonSchema = z26.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired", "changed", "exists", "unknown_project", "seat_failed", "scheduled", ...ModelRefusalSchema.options]);
+var OperationReasonSchema = z26.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired", "scheduled", ...ModelRefusalSchema.options, ...RIG_RESULT_CODES]);
 var CapabilitiesSchema = z26.object({
   /** A question can be answered in free text. */
   freeTextAnswer: z26.boolean(),
@@ -1961,19 +2076,21 @@ var PhoneSessionSchema = SwitchableSessionSchema.pick({
   effort: true,
   modelNext: true,
   canSwitch: true,
-  /** Its role and its live team (ledge home spec §2.4): the agents screen groups a project's sessions by table. */
-  role: true,
-  roleLabel: true,
-  team: true,
   /** Its context and its relief (context handover spec §3.2): the phone shows the gauge; the relief is started from the PC. */
   context: true,
-  relieves: true
+  relieves: true,
+  /** When it ended: « Terminée · à 18:42 » in the list. */
+  exitedAt: true
 }).extend({
   pending: PhonePendingSchema.optional(),
   unread: z26.boolean(),
   handover: z26.object({ state: HandoverStateSchema, toName: z26.string().max(80).optional() }).strict().optional(),
   /** Absent: the agent has no checklist. */
-  checklist: PhoneChecklistSummarySchema.optional()
+  checklist: PhoneChecklistSummarySchema.optional(),
+  /** Started without Ledge (`hook_only`): the phone can neither close nor resume it. */
+  readOnly: z26.literal(true).optional(),
+  rig: z26.object({ rigName: z26.string().max(80), seat: z26.string().max(120) }).strict().optional(),
+  brain: z26.literal(true).optional()
 });
 var B64U2 = z26.string().regex(/^[A-Za-z0-9_-]*$/);
 var CredentialSchema = z26.object({
@@ -1990,8 +2107,7 @@ var AssertionSchema = z26.object({
   authenticatorData: B64U2.max(4096),
   signature: B64U2.max(1024)
 });
-var TeamsDigestSchema = z26.string().regex(/^[0-9a-f]{64}$/);
-var ConfirmPurposeSchema = z26.enum(["register", "decide", "launch", "close", "act", "define", "team", "pc"]);
+var ConfirmPurposeSchema = z26.enum(["register", "decide", "launch", "close", "act", "pc", "rig"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
 var PhoneChatProposalSchema = z26.object({
   project: z26.string().max(80),
@@ -2009,33 +2125,15 @@ var PhoneChatRelaySchema = z26.object({
   sentAt: z26.string().datetime().optional(),
   failed: z26.literal(true).optional()
 }).strict();
+var CloseHowSchema = z26.enum(["exit", "killed"]);
 var PhoneChatCloseSchema = z26.object({
   id: z26.string().min(1),
   name: z26.string(),
   tool: ToolSchema,
-  how: z26.enum(["exit", "killed"]).optional(),
+  how: CloseHowSchema.optional(),
   closedAt: z26.string().datetime().optional(),
   failed: z26.literal(true).optional()
 }).strict();
-var PhoneChatTeamSchema = z26.object({
-  project: z26.string().max(80),
-  name: z26.string().max(60),
-  template: z26.string().max(64).optional(),
-  seats: z26.array(z26.object({ role: z26.string().max(40), label: z26.string().max(40), tool: ToolSchema, model: z26.string().max(200).optional(), effort: z26.string().max(20).optional(), autonomy: AutonomySchema.optional() }).strict()).min(1).max(8),
-  teamId: z26.string().max(40).optional(),
-  launchedAt: z26.string().datetime().optional(),
-  failed: z26.literal(true).optional()
-}).strict();
-var PhoneChatTaskSchema = z26.object({
-  to: z26.string().max(80),
-  toName: z26.string().max(80).optional(),
-  title: z26.string().max(200),
-  text: z26.string().max(TOOL_TEXT_MAX).optional(),
-  taskId: z26.string().max(40).optional(),
-  ownerName: z26.string().max(80).optional(),
-  state: z26.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  failed: z26.literal(true).optional()
-}).strict();
 var PhoneChatActionSchema = z26.object({
   action: z26.string().min(1).max(40),
   summary: z26.string().max(300),
@@ -2044,46 +2142,10 @@ var PhoneChatActionSchema = z26.object({
   detailCut: z26.literal(true).optional(),
   risk: ActionRiskSchema,
   session: z26.string().max(100).optional(),
-  team: z26.string().max(40).optional(),
   state: ChatActionStateSchema.optional(),
   doneAt: z26.string().datetime().optional(),
   code: z26.string().max(40).optional()
 }).strict();
-var PhoneTeamSchema = z26.object({
-  id: z26.string().max(40),
-  name: z26.string().max(60),
-  project: z26.string().max(80).nullable(),
-  state: z26.enum(["active", "resting"]),
-  template: z26.string().max(64).optional(),
-  /** Absent from a daemon older than the phone: the phone then says no start time. */
-  createdAt: z26.string().optional(),
-  /** `tool`, `model` and `effort` are what the seat was composed with; `leaving` is a seat that finishes its turn and is then closed. */
-  seats: z26.array(z26.object({
-    role: z26.string().max(40),
-    sessionId: z26.string().max(100).nullable(),
-    tool: ToolSchema.optional(),
-    model: ModelIdSchema.optional(),
-    effort: EffortSchema.optional(),
-    leaving: z26.literal(true).optional()
-  }).strict()).max(16),
-  done: z26.number().int().min(0),
-  given: z26.number().int().min(0)
-}).strict();
-var PhoneTaskSchema = z26.object({
-  id: z26.string().max(40),
-  title: z26.string().max(200),
-  owner: z26.string().max(100),
-  ownerName: z26.string().max(80),
-  ownerRole: z26.string().max(40).optional(),
-  team: z26.string().max(40).optional(),
-  teamName: z26.string().max(60).optional(),
-  state: z26.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z26.string().max(TOOL_TEXT_MAX).optional(),
-  cut: z26.literal(true).optional(),
-  at: z26.string(),
-  updatedAt: z26.string(),
-  seen: z26.literal(true).optional()
-}).strict();
 var ChatErrorCodeSchema = z26.enum(["busy", "timeout", "cancelled", "failed"]);
 var PhoneChatTurnSchema = z26.object({
   qid: OperationIdSchema,
@@ -2097,8 +2159,6 @@ var PhoneChatTurnSchema = z26.object({
   relay: PhoneChatRelaySchema.optional(),
   closes: z26.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
   cut: z26.literal(true).optional(),
-  team: PhoneChatTeamSchema.optional(),
-  tasks: z26.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
   actions: z26.array(PhoneChatActionSchema).min(1).max(MAX_PROPOSALS).optional(),
   ignoredAt: z26.string().datetime().optional(),
   attachments: z26.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
@@ -2107,30 +2167,32 @@ var CHAT_HISTORY_BUDGET = 393216;
 var sessionId = z26.string().min(1).max(100);
 var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z26.string().min(1).max(64) });
 var CardRowsSchema = z26.array(z26.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
-var teamsOp = { op: OperationIdSchema, assertion: AssertionSchema.optional() };
+var signedOp = { op: OperationIdSchema, assertion: AssertionSchema.optional() };
 var PcActionSchema = z26.enum(["update", "restart"]);
 var pcSubject = (action, version) => action === "update" ? `update@${version ?? ""}` : "restart";
-var teamsScope = { scope: DefinitionScopeSchema, project: z26.string().min(1).max(80).optional() };
 var PhoneClientMessageSchema = z26.discriminatedUnion("type", [
   z26.object({ type: z26.literal("snapshot.request") }),
+  ...phoneOpenRigClientMessages,
   z26.object({ type: z26.literal("session.thread"), id: sessionId }),
   /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
   z26.object({ type: z26.literal("session.pending"), id: sessionId }),
   /** The session whose terminal the phone shows; null when it shows none. */
   z26.object({ type: z26.literal("session.watch"), id: sessionId.nullable() }),
   z26.object({ type: z26.literal("session.read"), id: sessionId, at: z26.string().datetime() }),
-  /** Asks for a challenge. One object for both purposes: the gateway refuses a `decide` without `id` and `expect`. */
+  /**
+   * Asks for a challenge. One object for every purpose: the gateway refuses a `decide` without `id` and `expect`. A `close`
+   * or `act` names a turn of the chat (`qid`) or a session (`id`, for `session.close` and `session.resume`).
+   */
   z26.object({
     type: z26.literal("confirm.prepare"),
     purpose: ConfirmPurposeSchema,
     id: sessionId.optional(),
     expect: PhoneExpectSchema.optional(),
     qid: OperationIdSchema.optional(),
-    /** sha256 of the `define` or `team` operation the challenge is for (`teamsDigest`). */
-    digest: TeamsDigestSchema.optional(),
     /** A `pc` challenge: what it is for, and for an update the version it covers. */
     action: PcActionSchema.optional(),
-    version: z26.string().regex(SEMVER).optional()
+    version: z26.string().regex(SEMVER).optional(),
+    rig: z26.discriminatedUnion("type", [PhoneRigLaunchSchema, PhoneRigActSchema]).optional()
   }),
   z26.object({ type: z26.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
   z26.object({
@@ -2165,6 +2227,10 @@ var PhoneClientMessageSchema = z26.discriminatedUnion("type", [
     expect: PhoneExpectSchema
   }),
   z26.object({ type: z26.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  /** Ends a live session as `/exit` would, killed as a last resort; answered with its `how`. Passkey, purpose `close`, over the session. */
+  z26.object({ type: z26.literal("session.close"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
+  /** Starts an ended session again on its conversation. Passkey, purpose `act`, over the session. */
+  z26.object({ type: z26.literal("session.resume"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
   /** Changes a live session's model and effort, `null` for the agent's own default; answered by `operation.result` and, when refused, `session.model.failed`. */
   z26.object({ type: z26.literal("session.model"), op: OperationIdSchema, id: sessionId, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** The models an agent offers on the PC. */
@@ -2185,10 +2251,6 @@ var PhoneClientMessageSchema = z26.discriminatedUnion("type", [
   z26.object({ type: z26.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
   z26.object({ type: z26.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
   z26.object({ type: z26.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
-  /** The turn's team card (roles spec §3.8): launched like a session card, with the device check (purpose `launch`, the turn). */
-  z26.object({ type: z26.literal("chat.team"), op: OperationIdSchema, qid: OperationIdSchema, assertion: AssertionSchema.optional() }),
-  /** A row of the turn's task card: given by Ledge. */
-  z26.object({ type: z26.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z26.number().int().min(0).max(MAX_PROPOSALS - 1) }),
   /** Rows of the turn's generic card (action registry spec §5): `confirmed` as the local `chat.act`; a row whose action asks
    *  for a device check (`phone`) needs one assertion, purpose `act`, over the turn. */
   z26.object({
@@ -2203,33 +2265,13 @@ var PhoneClientMessageSchema = z26.discriminatedUnion("type", [
   }),
   /** « Ignorer » the turn's cards, or `undo` (« Revoir »), as the local `chat.ignore`. */
   z26.object({ type: z26.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z26.literal(true).optional() }),
-  /** « Reprendre » a resting team. */
-  z26.object({ type: z26.literal("team.resume"), op: OperationIdSchema, team: z26.string().min(1).max(40) }),
-  /** Puts a closed task Ledge gave away from « À traiter ». */
-  z26.object({ type: z26.literal("task.seen"), op: OperationIdSchema, task: z26.string().min(1).max(40) }),
   /** Whether the phone's app is in front: a device that is visible gets no push. */
   z26.object({ type: z26.literal("presence"), visible: z26.boolean() }),
-  /** The roles, templates and problems of every scope the phone may name; then one role whole, when the catalog cut its prompt. */
-  z26.object({ type: z26.literal("teams.catalog") }),
-  z26.object({ type: z26.literal("teams.role"), ...teamsScope, id: RoleIdSchema }).strict(),
-  /** `base` is the hash the phone was shown, null to create. */
-  z26.object({ type: z26.literal("role.write"), ...teamsOp, ...teamsScope, role: PhoneRoleDraftSchema, base: DefinitionHashSchema.nullable() }).strict(),
-  z26.object({ type: z26.literal("role.delete"), ...teamsOp, ...teamsScope, id: RoleIdSchema, base: DefinitionHashSchema }).strict(),
-  /** No `id`: create, the id comes from the name. */
-  z26.object({ type: z26.literal("template.write"), ...teamsOp, ...teamsScope, id: TemplateIdSchema.optional(), name: TeamNameSchema, seats: PhoneSeatsSchema, base: DefinitionHashSchema.nullable() }).strict(),
-  z26.object({ type: z26.literal("template.delete"), ...teamsOp, ...teamsScope, id: TemplateIdSchema, base: DefinitionHashSchema }).strict(),
-  z26.object({ type: z26.literal("team.launch"), ...teamsOp, project: z26.string().min(1).max(80), name: TeamNameSchema, seats: PhoneSeatsSchema, template: z26.string().min(1).max(64).optional() }).strict(),
-  z26.object({ type: z26.literal("team.compose"), ...teamsOp, team: TeamIdSchema, seats: PhoneSeatsSchema }).strict(),
-  z26.object({ type: z26.literal("team.seat"), ...teamsOp, team: TeamIdSchema, role: RoleIdSchema, action: z26.enum(["start", "restart"]) }).strict(),
-  z26.object({ type: z26.literal("team.dissolve"), ...teamsOp, team: TeamIdSchema }).strict(),
   /** Installs `version` on the PC, then restarts its daemon; the phone asks for its own build's version. Passkey, purpose `pc`. */
-  z26.object({ type: z26.literal("daemon.update"), ...teamsOp, version: z26.string().regex(SEMVER) }).strict(),
+  z26.object({ type: z26.literal("daemon.update"), ...signedOp, version: z26.string().regex(SEMVER) }).strict(),
   /** Restarts the PC's daemon without installing anything. Passkey, purpose `pc`. */
-  z26.object({ type: z26.literal("daemon.restart"), ...teamsOp }).strict()
-]).superRefine((m, ctx) => {
-  const issue = "scope" in m ? scopeIssue(m) : null;
-  if (issue) ctx.addIssue({ code: z26.ZodIssueCode.custom, message: issue, path: ["project"] });
-});
+  z26.object({ type: z26.literal("daemon.restart"), ...signedOp }).strict()
+]);
 var PhoneModelChoiceSchema = z26.object({
   id: ModelChoiceSchema.shape.id.max(120),
   label: z26.string().max(80),
@@ -2238,30 +2280,31 @@ var PhoneModelChoiceSchema = z26.object({
   defaultEffort: EffortSchema.optional(),
   isDefault: z26.boolean().optional()
 }).strict();
-var PhoneSeatModelSchema = z26.object({ role: z26.string().max(40), session: sessionId, status: z26.enum(["applied", "scheduled", "refused"]), reason: ModelRefusalSchema.optional() });
 var PhoneServerMessageSchema = z26.discriminatedUnion("type", [
   z26.object({ type: z26.literal("snapshot"), protocol: z26.literal(PHONE_PROTOCOL), sessions: z26.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z26.object({
     version: z26.string(),
     name: z26.string().max(40),
     boot: z26.string().uuid().optional(),
-    teams: z26.literal(true).optional(),
     /** The daemon takes `session.model`. */
     models: z26.literal(true).optional(),
     /** The daemon sends `session.checklist` and a session's `checklist` summary. */
     checklist: z26.literal(true).optional(),
     /** `update`: the daemon can install a version and restart (npm, systemd); `restart`: it can restart (systemd). */
     update: z26.literal(true).optional(),
-    restart: z26.literal(true).optional()
-  }), device: z26.object({ confirm: z26.boolean(), push: z26.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z26.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+    restart: z26.literal(true).optional(),
+    /** The daemon takes `session.close` and `session.resume`. */
+    sessionClose: z26.literal(true).optional(),
+    openrig: z26.literal(true).optional(),
+    answerReceipts: z26.literal(true).optional()
+  }), openrigStatus: z26.object({ state: z26.enum(["absent", "stopped", "starting", "running", "unsupported", "error", "unreachable"]), version: z26.string().max(80).optional() }).strict().optional(), rigs: z26.array(PhoneRigSchema).max(40).optional(), escalations: z26.array(PhoneEscalationSchema).max(40).optional(), decisionsToday: z26.array(PhoneLedgeDecisionSchema).max(50).optional(), projects: z26.array(z26.object({ id: z26.string().min(1).max(80), name: z26.string().min(1).max(80), hasLocalRepo: z26.boolean() }).strict()).max(100).optional(), device: z26.object({ confirm: z26.boolean(), push: z26.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z26.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+  ...phoneOpenRigServerMessages,
   z26.object({
     type: z26.literal("confirm.challenge"),
     purpose: ConfirmPurposeSchema,
     challenge: B64U2.max(64),
     rpId: z26.string().max(253),
     credentialId: B64U2.max(1366).optional(),
-    expiresInMs: z26.number().int().positive(),
-    /** Echoed from the `confirm.prepare` of a `define` or `team` challenge, so the phone matches each challenge to its own call. Absent from an older gateway. */
-    digest: TeamsDigestSchema.optional()
+    expiresInMs: z26.number().int().positive()
   }),
   z26.object({ type: z26.literal("session.updated"), session: PhoneSessionSchema }),
   z26.object({ type: z26.literal("session.removed"), id: z26.string() }),
@@ -2273,7 +2316,14 @@ var PhoneServerMessageSchema = z26.discriminatedUnion("type", [
   /** `cut`: the ids of the items shortened; `more`: older items were left out. */
   z26.object({ type: z26.literal("session.thread"), id: z26.string(), items: z26.array(ThreadItemSchema), cut: z26.array(z26.string()), more: z26.boolean() }),
   z26.object({ type: z26.literal("session.thread.item"), id: z26.string(), item: ThreadItemSchema, cut: z26.literal(true).optional() }),
-  z26.object({ type: z26.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional(), models: z26.array(PhoneSeatModelSchema).max(16).optional() }),
+  z26.object({
+    type: z26.literal("operation.result"),
+    op: OperationIdSchema,
+    status: OperationStatusSchema,
+    reason: OperationReasonSchema.optional(),
+    /** How an applied `session.close` ended the agent: `killed` when it had to be forced. */
+    how: CloseHowSchema.optional()
+  }),
   /** The models an agent offers; `error`: it could not be asked, `models` is then what Ledge knows without it. */
   z26.object({ type: z26.literal("models.listing"), tool: ToolSchema, models: z26.array(PhoneModelChoiceSchema).max(40), error: z26.literal(true).optional() }),
   /** A model change that was accepted and then failed (the agent could not restart). */
@@ -2284,30 +2334,26 @@ var PhoneServerMessageSchema = z26.discriminatedUnion("type", [
   z26.object({ type: z26.literal("chat.delta"), qid: OperationIdSchema, text: z26.string().max(THREAD_TEXT_MAX) }),
   z26.object({ type: z26.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
   z26.object({ type: z26.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
-  z26.object({ type: z26.literal("teams.catalog"), catalog: PhoneCatalogSchema }),
   /** The daemon updating or restarting itself, whoever asked: npm runs, then the service restarts (the link drops right after). */
   z26.object({ type: z26.literal("daemon.progress"), version: z26.string().max(40), step: z26.enum(["installing", "restarting"]) }),
   /** Nothing was changed. Never npm's output nor a command: both hold the PC's paths. */
   z26.object({ type: z26.literal("daemon.failed"), version: z26.string().max(40), reason: UpdateFailureSchema }),
-  z26.object({ type: z26.literal("teams.role"), role: PhoneRoleSchema }),
-  /** The live teams, after each snapshot and on every change. */
-  z26.object({ type: z26.literal("teams"), teams: z26.array(PhoneTeamSchema).max(50) }),
-  /** The tasks Ledge gave, open or closed lately, after each snapshot; then each change. */
-  z26.object({ type: z26.literal("tasks"), tasks: z26.array(PhoneTaskSchema).max(200) }),
-  z26.object({ type: z26.literal("task.updated"), task: PhoneTaskSchema }),
   AttachmentStoredSchema,
   AttachmentDataSchema,
   AttachmentErrorSchema,
   /** Never carries free text. */
   z26.object({ type: z26.literal("error"), code: z26.enum(["invalid", "unknown_session", "too_large"]), request: z26.string().max(40).optional() })
 ]);
-var teamsPurpose = (type) => type.startsWith("team.") ? "team" : "define";
-var DIGEST_OP = "00000000-0000-4000-8000-000000000000";
-async function teamsDigest(m) {
-  const { op: _op, assertion: _assertion, ...raw } = m;
-  const { op: _parsedOp, assertion: _parsedAssertion, ...rest } = PhoneClientMessageSchema.parse({ ...raw, op: DIGEST_OP });
-  const bytes = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonicalJson(rest))));
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+function canonicalJson(v) {
+  const sort = (x) => {
+    if (Array.isArray(x)) return x.map(sort);
+    if (x !== null && typeof x === "object") {
+      const o = x;
+      return Object.fromEntries(Object.keys(o).sort().filter((k) => o[k] !== void 0).map((k) => [k, sort(o[k])]));
+    }
+    return x;
+  };
+  return JSON.stringify(sort(v));
 }
 
 // ../protocol/src/todos.ts
@@ -2364,130 +2410,56 @@ function latestTodos(items, helperId) {
 }
 var doneCount = (todos) => todos.filter((x) => x.status === "completed").length;
 
-// src/auth.ts
-import { createHash, createHmac, 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;
+// ../protocol/src/mandate.ts
+var SELF_TITLE = "ledge tranche seul";
+var USER_TITLE = "te revient toujours";
+var isAlways = (id2) => ALWAYS_USER.includes(id2);
+function mandateEntries(text2) {
+  const out = { self: [], user: [], always: [], readable: false };
+  let list = null;
+  for (const raw of text2.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("#")) {
+      const title = line.replace(/^#+\s*/, "").toLowerCase();
+      list = title.startsWith(SELF_TITLE) ? "self" : title.startsWith(USER_TITLE) ? "user" : null;
+      if (list) out.readable = true;
+      continue;
     }
-    await writeFile(file, `${token}
-`, { mode: 384 });
+    const item = /^[-*]\s+(.+)$/.exec(line)?.[1];
+    if (!list || !item) continue;
+    const m = /^(\S+)\s+:\s+(.+)$/.exec(item);
+    const entry = { id: m?.[1], said: (m?.[2] ?? item).trim() };
+    if (list === "self" && entry.id && isAlways(entry.id)) out.always.push(entry);
+    else out[list].push(entry);
   }
-  await unlink(tmp).catch(() => {
-  });
-  await lockTokenFile(file);
-  const stored = await readTokenFile(file);
-  if (!stored) throw new Error("daemon token was not stored");
-  return stored;
-}
-var SESSION_KEY_VAR = "LEDGE_SESSION_KEY";
-function sessionKey(id, token = readDaemonToken()) {
-  return token ? createHmac("sha256", token).update(`ledge-session:${id}`).digest("hex") : void 0;
+  return out;
 }
-function readDaemonToken() {
-  try {
-    const raw = readFileSync(paths().token, "utf8").trim();
-    return isDaemonToken(raw) ? raw : void 0;
-  } catch {
-    return void 0;
-  }
+var known = (id2) => {
+  const r = MandateCategorySchema.safeParse(id2);
+  return r.success ? r.data : null;
+};
+function parseMandate(text2) {
+  const e = mandateEntries(text2);
+  if (!e.readable) return { self: [], user: [], readable: false };
+  const uniq = (xs) => [...new Set(xs.filter((x) => x !== null))];
+  const user = uniq([...e.user, ...e.always].map((x) => known(x.id)));
+  return { self: uniq(e.self.map((x) => known(x.id))).filter((c) => !user.includes(c)), user, readable: true };
 }
 
 export {
+  tokenEquals,
+  hostAllowed,
+  requestAuthorized,
+  selectDaemonProtocol,
+  ensureDaemonToken,
+  SESSION_KEY_VAR,
+  sessionKey,
+  readDaemonToken,
+  ASK_QUESTION_MAX,
+  ASK_OPTIONS_MAX,
+  ASK_ANSWER_MAX,
+  AskSchema,
+  askShown,
   ATTACHMENT_ID,
   ATTACHMENT_MAX,
   ATTACHMENT_LOCAL_MAX,
@@ -2498,6 +2470,7 @@ export {
   CONTEXT_NEAR_MIN,
   CONTEXT_NEAR_MAX,
   ContextPrefsSchema,
+  contextShare,
   contextNear,
   BRIEF_MAX,
   ToolSchema,
@@ -2512,34 +2485,12 @@ export {
   extractProposal,
   parseRelayBlock,
   parseCloseBlock,
-  parseTeamBlock,
-  parseTaskBlock,
   parseProjectBlock,
-  SshAliasSchema,
-  MachinesSchema,
-  PROJECT_COLORS,
-  ProjectsSchema,
-  DEFAULT_PROJECTS,
-  projectOf,
-  RoleIdSchema,
-  ROLE_LABEL_MAX,
-  ROLE_PROMPT_MAX,
-  RoleSchema,
-  SeatsSchema,
-  TeamNameSchema,
-  TemplateIdSchema,
-  TeamSchema,
-  isTeamLive,
   NOTE_MAX,
   NOTE_NOT_TYPED,
   offers,
   pendingKey,
-  TASK_TITLE_MAX,
-  TASK_TEXT_MAX,
-  LEDGE_GIVER,
-  transmissions,
-  givenByLedge,
-  taskClosed,
+  ActionIdSchema,
   ACTIONS,
   actionById,
   riskOf,
@@ -2552,10 +2503,29 @@ export {
   ChatTurnSchema,
   proposalRows,
   DOCUMENT_MAX_BYTES,
+  SshAliasSchema,
+  MachinesSchema,
   IslandPrefsSchema,
+  PROJECT_COLORS,
+  ProjectsSchema,
+  DEFAULT_PROJECTS,
+  projectOf,
   RouteResultSchema,
   DEFAULT_RELAY_URL,
   MobileConfigSchema,
+  MandateCategorySchema,
+  ALWAYS_USER,
+  MANDATE_CATEGORY_LABEL,
+  RIG_NAME,
+  EscalationSchema,
+  EXCHANGES_MAX,
+  EXCHANGE_GROUP_MS,
+  THREAD_PAGE,
+  LedgeDecisionSchema,
+  LedgeRuleSchema,
+  LedgeThreadItemSchema,
+  BRAIN_OPS,
+  BRAIN_STOPPED_TEXT,
   PROTOCOL_PORT,
   RefusalCodeSchema,
   RecentSchema,
@@ -2575,15 +2545,12 @@ export {
   RELAY_CLOSE_SIGNED_OUT,
   DeviceStartResponseSchema,
   DevicePollResponseSchema,
+  rigSubject,
   pushEndpointAllowed,
   PushSendResultSchema,
   PushPayloadSchema,
-  PhoneRoleSchema,
-  PhoneTemplateSchema,
-  TEAMS_OPERATION_TYPES,
-  isTeamsOperation,
-  canonicalJson,
   PHONE_PROTOCOL,
+  PLAIN_MAX,
   padPlain,
   THREAD_ITEMS_MAX,
   THREAD_BUDGET,
@@ -2599,17 +2566,10 @@ export {
   pcSubject,
   PhoneClientMessageSchema,
   PhoneModelChoiceSchema,
-  teamsPurpose,
-  teamsDigest,
+  canonicalJson,
   TODO_TOOLS,
   latestTodos,
   doneCount,
-  tokenEquals,
-  hostAllowed,
-  requestAuthorized,
-  selectDaemonProtocol,
-  ensureDaemonToken,
-  SESSION_KEY_VAR,
-  sessionKey,
-  readDaemonToken
+  mandateEntries,
+  parseMandate
 };