@paradow/ledge 0.32.0 → 0.34.0

package/dist/cli/{chunk-2BLPGRLO.js → chunk-IWY7DSSO.js}

@@ -1,6 +1,6 @@
 import {
   paths
-} from "./chunk-HOOHS3MX.js";
+} from "./chunk-53ISXX2R.js";
 
 // ../protocol/src/handover.ts
 import { z } from "zod";
@@ -19,7 +19,7 @@ var HandoverSchema = z.object({
   to: z.string().optional(),
   toName: z.string().optional(),
   reason: z.string().optional(),
-  /** Started by Ledge itself (a seat working without asking), not by the user. */
+  /** Started by Ledge itself (a session working without asking), not by the user. */
   auto: z.literal(true).optional()
 });
 var RelievesSchema = z.object({ id: z.string(), name: z.string(), at: z.string().datetime() });
@@ -36,23 +36,6 @@ var HandoverResultSchema = z.object({ type: z.literal("handover.result"), rid: z
 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"]);
-function autonomyArgs(tool, autonomy) {
-  if (!autonomy || autonomy === "ask") return [];
-  switch (tool) {
-    case "claude":
-      return ["--permission-mode", autonomy === "edits" ? "acceptEdits" : "auto"];
-    case "codex":
-      return autonomy === "edits" ? ["--ask-for-approval", "on-request"] : ["--ask-for-approval", "never", "--sandbox", "workspace-write"];
-    case "cursor":
-      return autonomy === "auto" ? ["--force"] : [];
-    case "omp":
-      return [];
-  }
-}
-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({
@@ -119,6 +102,8 @@ var SessionSchema = z2.object({
   worktree: z2.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(),
+  /** The OpenRig seat this agent is: its session name (`dev-build@starter`), its rig, and its role (`dev.build`) once OpenRig named it. */
+  rig: z2.object({ seat: z2.string(), name: z2.string(), role: z2.string().optional() }).optional(),
   tmuxSession: z2.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(),
@@ -138,17 +123,6 @@ var SessionSchema = z2.object({
   effort: z2.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(),
-  /** The name of the team it was last taken out of (a leave, a dissolution, a seat in another team): a refused `@role` says so. */
-  teamLeft: z2.string().optional(),
-  /** Its team as it was last told it (`seatKey`): its next turn is told again when the team has changed since. */
-  teamSeen: z2.string().optional(),
-  /** Its role's 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(),
   /** Its relief by a fresh session (§3.3): asked, launched, done or failed. */
@@ -166,7 +140,10 @@ var SessionSchema = z2.object({
   exitCode: z2.number().int().nullable().optional(),
   exitedAt: z2.string().datetime().optional(),
   lastError: z2.string().optional(),
-  source: z2.enum(["launcher", "hook_only"]),
+  /** `launcher`: Ledge launched it; `hook_only`: only its hooks are known (read-only); `rig`: an OpenRig seat Ledge follows through
+   *  its tmux pane on the user's default server, answered like its own, whose life stays OpenRig's (no close, kill, resume, model). */
+  // A kind a newer daemon adds reads as read-only here, never as a snapshot thrown away whole (« hors ligne »).
+  source: z2.enum(["launcher", "hook_only", "rig"]).catch("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(),
   /** When the session was last taken out of the archive: the poller's retirement clock restarts from it, not from `exitedAt`. */
@@ -179,290 +156,39 @@ 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, `name` the bot name it asks
-   *  for (its template's or its composition's); `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(),
-    name: SeatSchema.shape.name,
-    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(), base: DefinitionHashSchema.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(), code: z7.enum(["exists", "changed"]).optional() });
-var isTeamLive = (t) => t.state !== "dissolved";
-
 // ../protocol/src/tasks.ts
-import { z as z8 } from "zod";
+import { z as z3 } 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(),
+var TaskLogEntrySchema = z3.object({
+  at: z3.string(),
+  by: z3.string(),
+  what: z3.string(),
+  op: z3.enum(TASK_OPS).optional(),
+  from: z3.string().optional(),
+  to: z3.string().optional(),
+  fromName: z3.string().optional(),
+  toName: z3.string().optional(),
+  note: z3.string().optional()
+});
+var TaskSchema = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  text: z3.string().optional(),
+  giver: z3.string(),
+  giverName: z3.string(),
+  owner: z3.string(),
+  ownerName: z3.string(),
+  state: z3.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z3.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)
+  seen: z3.boolean().optional(),
+  at: z3.string(),
+  updatedAt: z3.string(),
+  log: z3.array(TaskLogEntrySchema)
 });
 var handOver = (op) => TRANSMISSION_OPS.includes(op ?? "");
 function transmissions(t) {
@@ -471,56 +197,48 @@ function transmissions(t) {
 var givenByLedge = (t) => t.giver === LEDGE_GIVER;
 var taskClosed = (t) => t.state === "done" || t.state === "refused" || t.state === "dropped";
 var openDecision = (t) => t.owner === LEDGE_GIVER && !taskClosed(t);
-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(),
+var TaskCmdSchema = z3.object({
+  type: z3.literal("task.cmd"),
+  rid: z3.string().min(1),
+  by: z3.string().min(1),
+  op: z3.enum(["give", "take", "done", "refuse", "pass", "show", "list", "seen", "cancel"]),
+  task: z3.string().min(1).max(40).optional(),
+  to: z3.string().min(1).optional(),
+  title: z3.string().min(1).max(TASK_TITLE_MAX).optional(),
+  text: z3.string().max(TASK_TEXT_MAX).optional(),
+  all: z3.boolean().optional(),
+  qid: z3.string().min(1).optional(),
+  row: z3.number().int().min(0).max(7).optional()
+});
+var TaskUpdatedSchema = z3.object({ type: z3.literal("task.updated"), task: TaskSchema });
+var TaskResultSchema = z3.object({
+  type: z3.literal("task.result"),
+  rid: z3.string(),
   task: TaskSchema.optional(),
-  tasks: z8.array(TaskSchema).optional(),
-  reason: z8.string().optional()
+  tasks: z3.array(TaskSchema).optional(),
+  reason: z3.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 TaskBlockSchema = z4.object({
+  to: z4.string().trim().min(1).max(80),
+  title: z4.string().trim().min(1).max(200),
+  text: z4.string().max(2e4).optional()
+});
+var BLOCK = /```ledge-(session|relay|project|close|task|action)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
 function extractProposal(answer) {
   const found = [];
   const text2 = answer.replace(BLOCK, (_m, kind, body) => {
@@ -546,14 +264,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));
@@ -571,9 +281,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 = {
@@ -603,13 +341,12 @@ 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",
@@ -617,20 +354,14 @@ var ACTION_IDS = [
   "session.restore",
   "session.resume",
   "session.decide",
-  "team.join",
-  "team.leave",
-  "team.resume",
-  "team.dissolve",
-  "team.save",
   "task.cancel",
   "task.pass",
   "task.answer"
 ];
-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 TaskRef = z7.string().trim().min(1).max(40);
 var LaunchArgs = ProposalBlockSchema.extend({ model: ModelIdSchema.optional(), effort: EffortSchema.optional() });
 var ACTIONS = [
   def({
@@ -678,18 +409,6 @@ 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,
@@ -697,10 +416,10 @@ var ACTIONS = [
     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" }
+    cli: 'ledge task give <session> "<titre>" "<d\xE9tail>"',
+    summary: "confier une t\xE2che \xE0 une session (son id ou son nom, tels que sessions.md les donne)",
+    when: "quand l'utilisateur demande explicitement de confier une t\xE2che \xE0 une session ; ne propose rien pour ce que les sessions se confient entre elles",
+    example: { to: "Nova", title: "Pagination de /invoices", text: "Ajoute la pagination par curseur et ses tests" }
   }),
   def({
     id: "session.model",
@@ -708,14 +427,14 @@ var ACTIONS = [
     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",
@@ -726,7 +445,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.archive",
-    args: z11.object({ session: SessionRef }),
+    args: z7.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -737,7 +456,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.restore",
-    args: z11.object({ session: SessionRef }),
+    args: z7.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -748,7 +467,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.resume",
-    args: z11.object({ session: SessionRef }),
+    args: z7.object({ session: SessionRef }),
     card: "generic",
     phone: "act",
     risk: "reversible",
@@ -762,71 +481,15 @@ 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: 8,
-    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() }),
+    args: z7.object({ task: TaskRef, reason: z7.string().trim().min(1).max(500).optional() }),
     card: "generic",
     phone: "act",
     risk: "destructive",
@@ -837,7 +500,7 @@ var ACTIONS = [
   }),
   def({
     id: "task.pass",
-    args: z11.object({ task: TaskRef, to: SessionRef, note: z11.string().trim().min(1).max(TASK_TEXT_MAX).optional() }),
+    args: z7.object({ task: TaskRef, to: SessionRef, note: z7.string().trim().min(1).max(TASK_TEXT_MAX).optional() }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -848,7 +511,7 @@ var ACTIONS = [
   }),
   def({
     id: "task.answer",
-    args: z11.object({ task: TaskRef, answer: z11.string().trim().min(1).max(TASK_TEXT_MAX) }),
+    args: z7.object({ task: TaskRef, answer: z7.string().trim().min(1).max(TASK_TEXT_MAX) }),
     card: "generic",
     phone: "act",
     risk: "destructive",
@@ -861,13 +524,12 @@ var ACTIONS = [
 var byId = new Map(ACTIONS.map((a) => [a.id, a]));
 var actionById = (id) => byId.get(id);
 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"
 };
 function parseActionBlock(kind, raw) {
@@ -903,126 +565,345 @@ var NEVER_PROPOSED = [
   "r\xE9pondre \xAB toujours \xBB \xE0 une demande, ou r\xE9pondre aux questions \xE0 choix d'OMP"
 ];
 
+// ../protocol/src/openrig.ts
+import { z as z8 } from "zod";
+var RigNameSchema = z8.string().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a rig name");
+var RigSeatNameSchema = z8.string().min(3).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a seat");
+var SeatPermissionsSchema = z8.enum(["inherit", "floor", "auto", "full_bypass"]);
+var KERNEL_RIG = "kernel";
+var RigSeatSchema = z8.object({
+  logicalId: z8.string(),
+  session: z8.string(),
+  runtime: z8.string(),
+  model: z8.string().nullable(),
+  sessionStatus: z8.string(),
+  lifecycleState: z8.string(),
+  activity: z8.string(),
+  stopped: z8.boolean(),
+  work: z8.number().int().min(0)
+});
+var RigSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  status: z8.string(),
+  lifecycleState: z8.string(),
+  seats: z8.number().int().min(0),
+  running: z8.number().int().min(0),
+  attention: z8.number().int().min(0),
+  uptime: z8.string().nullable(),
+  snapshot: z8.string().nullable(),
+  nodes: z8.array(RigSeatSchema)
+});
+var RigDaemonStateSchema = z8.enum(["running", "stopped", "stale", "unknown"]);
+var RigKernelStateSchema = z8.enum(["ready", "starting", "stopped", "skipped", "absent", "unknown"]);
+var OpenRigStateSchema = z8.object({
+  installed: z8.boolean(),
+  version: z8.string().optional(),
+  daemon: z8.object({ state: RigDaemonStateSchema, pid: z8.number().int().optional(), port: z8.number().int().optional(), message: z8.string().optional() }),
+  kernel: z8.object({ state: RigKernelStateSchema }),
+  rigs: z8.array(RigSchema),
+  /** When it was read (ISO). */
+  at: z8.string()
+});
+var OpenRigActionSchema = z8.discriminatedUnion("kind", [
+  /** `restore` `last`: `rig start --last` (the rigs that were running come back); `none`: `rig daemon start`. */
+  z8.object({ kind: z8.literal("daemon.start"), restore: z8.enum(["last", "none"]).optional(), noKernel: z8.boolean().optional() }),
+  z8.object({ kind: z8.literal("daemon.stop") }),
+  z8.object({ kind: z8.literal("daemon.restart"), restore: z8.enum(["last", "none"]).optional() }),
+  z8.object({ kind: z8.literal("kernel.start") }),
+  z8.object({ kind: z8.literal("kernel.stop") }),
+  z8.object({ kind: z8.literal("kernel.restart") }),
+  z8.object({ kind: z8.literal("rig.start"), rig: RigNameSchema }),
+  z8.object({ kind: z8.literal("rig.stop"), rig: RigNameSchema, snapshot: z8.boolean().optional(), force: z8.boolean().optional(), delete: z8.boolean().optional() }),
+  z8.object({ kind: z8.literal("rig.restart"), rig: RigNameSchema }),
+  /** A seat's settings (docs/mockups/ledge-openrig-groups.html, view 2). `runtime`: moves it now to the other harness (a successor
+   *  takes its context, `rig seat set-runtime`), `model` and `effort` going with it; without it, `model`, `effort` and `permissions`
+   *  apply at its next resume. `dryRun`: the move's plan only. */
+  z8.object({
+    kind: z8.literal("seat.set"),
+    seat: RigSeatNameSchema,
+    runtime: z8.enum(["claude-code", "codex"]).optional(),
+    model: ModelIdSchema.optional(),
+    effort: EffortSchema.optional(),
+    permissions: SeatPermissionsSchema.optional(),
+    dryRun: z8.boolean().optional()
+  })
+]);
+var OpenRigStatusSchema = z8.object({ type: z8.literal("openrig.status"), requestId: z8.string().min(1).max(100), machineId: z8.string().optional() });
+var OpenRigActSchema = z8.object({ type: z8.literal("openrig.act"), requestId: z8.string().min(1).max(100), action: OpenRigActionSchema, machineId: z8.string().optional() });
+var OpenRigUnreachableSchema = z8.enum(["offline", "outdated"]);
+var OpenRigStateMessageSchema = z8.object({
+  type: z8.literal("openrig.state"),
+  requestId: z8.string().optional(),
+  machineId: z8.string().optional(),
+  state: OpenRigStateSchema.optional(),
+  error: OpenRigUnreachableSchema.optional()
+});
+var OpenRigDoneSchema = z8.object({
+  type: z8.literal("openrig.done"),
+  requestId: z8.string(),
+  machineId: z8.string().optional(),
+  ok: z8.boolean(),
+  commands: z8.array(z8.string()),
+  output: z8.string().optional(),
+  error: z8.string().optional()
+});
+function rigCommands(a) {
+  const start = (restore, noKernel) => restore === "last" ? ["start", "--last", "--json"] : ["daemon", "start", ...noKernel ? ["--no-kernel"] : []];
+  const up = (rig) => ["up", rig, "--existing", "--yes", "--json"];
+  const down = (rig, o = {}) => ["down", rig, ...o.snapshot ? ["--snapshot"] : [], ...o.force ? ["--force"] : [], ...o.delete ? ["--delete"] : [], "--json"];
+  switch (a.kind) {
+    case "daemon.start":
+      return [start(a.restore, a.noKernel)];
+    case "daemon.stop":
+      return [["daemon", "stop"]];
+    case "daemon.restart":
+      return [["daemon", "stop"], start(a.restore)];
+    case "kernel.start":
+      return [up(KERNEL_RIG)];
+    case "kernel.stop":
+      return [down(KERNEL_RIG)];
+    case "kernel.restart":
+      return [down(KERNEL_RIG, { snapshot: true }), up(KERNEL_RIG)];
+    case "rig.start":
+      return [up(a.rig)];
+    case "rig.stop":
+      return [down(a.rig, a)];
+    case "rig.restart":
+      return [down(a.rig, { snapshot: true }), up(a.rig)];
+    case "seat.set": {
+      const why = ["--reason", "Ledge"];
+      if (a.runtime) return [[
+        "seat",
+        "set-runtime",
+        a.seat,
+        "--runtime",
+        a.runtime,
+        ...a.model ? ["--model", a.model] : [],
+        ...a.effort ? ["--effort", a.effort] : [],
+        ...a.permissions && a.permissions !== "inherit" ? ["--permission-mode", a.permissions] : [],
+        ...a.dryRun ? ["--dry-run"] : [],
+        ...why
+      ]];
+      return [
+        ...a.model ? [["seat", "set-model", a.seat, "--model", a.model, ...why, "--json"]] : [],
+        ...a.effort ? [["seat", "set-effort", a.seat, "--effort", a.effort, ...why, "--json"]] : [],
+        ...a.permissions ? [["seat", "set-permissions", a.seat, "--mode", a.permissions, ...why, "--json"]] : []
+      ];
+    }
+  }
+}
+var showRigCommand = (args) => ["rig", ...args.filter((x) => x !== "--json")].join(" ");
+var RigSpecMemberSchema = z8.object({
+  id: z8.string(),
+  runtime: z8.string(),
+  model: z8.string().optional(),
+  agent: z8.string(),
+  /** Its `permission_policy`, as written. */
+  policy: z8.string().optional()
+});
+var RigSpecPodSchema = z8.object({ id: z8.string(), label: z8.string().optional(), members: z8.array(RigSpecMemberSchema) });
+var RigSpecSchema = z8.object({
+  name: z8.string(),
+  source: z8.string(),
+  summary: z8.string().optional(),
+  path: z8.string(),
+  /** The rig's `permission_policy`, as written (`builtin:auto`, a file…). */
+  policy: z8.string().optional(),
+  pods: z8.array(RigSpecPodSchema),
+  edges: z8.number().int().min(0)
+});
+var OpenRigSpecsSchema = z8.object({ type: z8.literal("openrig.specs"), requestId: z8.string().min(1).max(100), machineId: z8.string().optional() });
+var OpenRigSpecListSchema = z8.object({
+  type: z8.literal("openrig.specList"),
+  requestId: z8.string(),
+  machineId: z8.string().optional(),
+  specs: z8.array(RigSpecSchema),
+  error: z8.string().optional()
+});
+var RigRoleSchema = z8.string().min(3).max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*\.[A-Za-z0-9][A-Za-z0-9_-]*$/, "not a role");
+var RuntimeSchema = z8.enum(["claude-code", "codex"]);
+var RigPolicySchema = z8.enum(["auto", "standard", "open", "yolo", "locked"]);
+var RIG_POLICIES = RigPolicySchema.options;
+var RigLaunchSchema = z8.object({
+  spec: RigNameSchema,
+  cwd: z8.string().min(1).max(4096),
+  name: RigNameSchema,
+  seats: z8.record(RigRoleSchema, z8.number().int().min(0).max(9)).optional(),
+  runtimes: z8.record(RigRoleSchema, RuntimeSchema).optional(),
+  models: z8.record(RigRoleSchema, z8.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/)).optional(),
+  delegation: z8.enum(["pairs", "all"]).optional(),
+  save: z8.boolean().optional(),
+  plan: z8.boolean().optional(),
+  /** The rig's permission policy, in place of the spec's; `policies`: a role's, over the rig's. */
+  policy: RigPolicySchema.optional(),
+  policies: z8.record(RigRoleSchema, RigPolicySchema).optional(),
+  /** Accept the harnesses' first-launch warnings (`rig up --non-interruptive`), so a bypassing seat does not stop on Claude's dialog. */
+  nonInterruptive: z8.boolean().optional()
+});
+var OpenRigLaunchSchema = z8.object({ type: z8.literal("openrig.launch"), requestId: z8.string().min(1).max(100), launch: RigLaunchSchema, machineId: z8.string().optional() });
+var OpenRigLaunchedSchema = z8.object({
+  type: z8.literal("openrig.launched"),
+  requestId: z8.string(),
+  machineId: z8.string().optional(),
+  ok: z8.boolean(),
+  plan: z8.boolean(),
+  commands: z8.array(z8.string()),
+  yaml: z8.string().optional(),
+  seats: z8.number().int().optional(),
+  output: z8.string().optional(),
+  error: z8.string().optional(),
+  /** What `rig up --plan` concluded: its status (`planned`…), its errors and its warnings (one per seat without a permission policy…). */
+  check: z8.object({ status: z8.string(), errors: z8.array(z8.string()), warnings: z8.array(z8.string()) }).optional()
+});
+var roleOf = (logicalId) => logicalId.replace(/-\d+$/, "");
+var copyOf = (logicalId) => {
+  const m = /-(\d+)$/.exec(logicalId);
+  return m ? Number(m[1]) : 1;
+};
+function seatsByRole(nodes) {
+  const out = /* @__PURE__ */ new Map();
+  for (const n of nodes) out.set(roleOf(n.logicalId), [...out.get(roleOf(n.logicalId)) ?? [], n.logicalId]);
+  for (const [role, ids] of out) out.set(role, ids.sort((a, b) => copyOf(a) - copyOf(b)));
+  return out;
+}
+function seatPlan(nodes, seats) {
+  const by = seatsByRole(nodes);
+  const add = [], remove = [];
+  for (const [role, want] of Object.entries(seats)) {
+    const have = by.get(role) ?? [];
+    if (have.length === 0) continue;
+    if (want < have.length) {
+      remove.push(...have.slice(want).reverse());
+      continue;
+    }
+    const [pod, member] = role.split(".");
+    let next = Math.max(...have.map(copyOf));
+    for (let i = have.length; i < want; i++) add.push({ role, pod, id: `${member}-${++next}`, from: have[0] });
+  }
+  return { add, remove };
+}
+var OpenRigSeatsSchema = z8.object({
+  type: z8.literal("openrig.seats"),
+  requestId: z8.string().min(1).max(100),
+  machineId: z8.string().optional(),
+  rig: RigNameSchema,
+  seats: z8.record(RigRoleSchema, z8.number().int().min(0).max(9)),
+  /** How the added seats are linked, where OpenRig can add links to a running rig (0.7+): like a launch's. */
+  delegation: z8.enum(["pairs", "all"]).optional()
+});
+var OpenRigReseatedSchema = z8.object({
+  type: z8.literal("openrig.reseated"),
+  requestId: z8.string(),
+  machineId: z8.string().optional(),
+  ok: z8.boolean(),
+  commands: z8.array(z8.string()),
+  added: z8.array(z8.string()),
+  removed: z8.array(z8.string()),
+  output: z8.string().optional(),
+  error: z8.string().optional(),
+  /** The links ensured between the seats; `linksUnsupported`: this OpenRig cannot add links to a running rig (before 0.7). */
+  links: z8.number().int().optional(),
+  linksUnsupported: z8.boolean().optional()
+});
+
 // ../protocol/src/messages.ts
 import { z as z21 } from "zod";
 
 // ../protocol/src/chat.ts
-import { z as z13 } from "zod";
+import { z as z10 } from "zod";
 
 // ../protocol/src/attachments.ts
-import { z as z12 } from "zod";
+import { z as z9 } from "zod";
 var ATTACHMENT_ID = /^[0-9a-f]{64}$/;
-var AttachmentIdSchema = z12.string().regex(ATTACHMENT_ID);
+var AttachmentIdSchema = z9.string().regex(ATTACHMENT_ID);
 var IMAGE_MIMES = ["image/webp", "image/jpeg", "image/png", "image/gif"];
-var ImageMimeSchema = z12.enum(IMAGE_MIMES);
+var ImageMimeSchema = z9.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 = z9.object({
   id: AttachmentIdSchema,
   mime: ImageMimeSchema,
-  width: z12.number().int().positive(),
-  height: z12.number().int().positive(),
-  bytes: z12.number().int().positive(),
-  preview: z12.boolean()
+  width: z9.number().int().positive(),
+  height: z9.number().int().positive(),
+  bytes: z9.number().int().positive(),
+  preview: z9.boolean()
 });
-var ImageUploadSchema = z12.object({
+var ImageUploadSchema = z9.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: z9.string().min(1).max(b64Max(ATTACHMENT_LOCAL_MAX)),
+  preview: z9.object({ mime: ImageMimeSchema, data: z9.string().min(1).max(b64Max(PREVIEW_MAX)) }).optional()
+});
+var AttachmentErrorReasonSchema = z9.enum(["too_large", "not_image", "unreadable", "not_found", "offline"]);
+var requestId = z9.string().min(1).max(100);
+var AttachmentPutSchema = z9.object({ type: z9.literal("attachment.put"), requestId, id: z9.string().optional(), image: ImageUploadSchema });
+var AttachmentGetSchema = z9.object({ type: z9.literal("attachment.get"), requestId, attachment: AttachmentIdSchema, preview: z9.boolean().optional(), id: z9.string().optional(), machine: z9.string().optional() });
+var AttachmentStoredSchema = z9.object({ type: z9.literal("attachment.stored"), requestId, ref: AttachmentRefSchema });
+var AttachmentDataSchema = z9.object({ type: z9.literal("attachment.data"), requestId, attachment: AttachmentIdSchema, mime: ImageMimeSchema, data: z9.string() });
+var AttachmentErrorSchema = z9.object({ type: z9.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 = z10.object({
+  kind: z10.enum(["sessions", "pane", "reply", "git", "repo"]),
+  id: z10.string().optional(),
+  name: z10.string().optional(),
+  path: z10.string().optional()
+});
+var ChatProposalSchema = z10.object({
+  cwd: z10.string().min(1),
+  project: z10.string(),
+  prompt: z10.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: z10.string().optional(),
+  error: z10.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 = z10.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
+var ChatRelaySchema = z10.object({
+  id: z10.string().min(1),
+  name: z10.string(),
   tool: ToolSchema,
-  text: z13.string().min(1),
-  status: z13.enum(["queued", "sent"]).optional(),
-  sentAt: z13.string().datetime().optional(),
-  error: z13.string().optional(),
+  text: z10.string().min(1),
+  status: z10.enum(["queued", "sent"]).optional(),
+  sentAt: z10.string().datetime().optional(),
+  error: z10.string().optional(),
   /** Why it failed, as a code a front words itself (a RefusalCode, `ended`, or `failed` for the machinery); goes with `error`. */
-  code: z13.string().max(40).optional()
+  code: z10.string().max(40).optional()
 });
-var ChatCloseSchema = z13.object({
-  id: z13.string().min(1),
-  name: z13.string(),
+var ChatCloseSchema = z10.object({
+  id: z10.string().min(1),
+  name: z10.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(),
-  saveError: 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: z10.string().datetime().optional(),
+  how: z10.enum(["exit", "killed"]).optional(),
+  error: z10.string().optional()
+});
+var ChatClosesSchema = z10.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
+var ChatProjectProposalSchema = z10.object({
+  name: z10.string().min(1).max(80),
+  description: z10.string().max(500).optional(),
+  repos: z10.array(z10.object({ path: z10.string().min(1).max(4096), why: z10.string().min(1).max(200) })).min(1).max(50),
+  addTo: z10.string().min(1).max(80).optional()
+});
+var ChatTaskProposalSchema = z10.object({
+  to: z10.string().min(1),
+  toName: z10.string().optional(),
+  title: z10.string().min(1).max(200),
+  text: z10.string().max(2e4).optional(),
+  taskId: z10.string().optional(),
+  ownerName: z10.string().optional(),
+  state: z10.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  givenAt: z10.string().datetime().optional(),
+  error: z10.string().optional()
+});
+var ChatTasksSchema = z10.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
+var ActionVarsSchema = z10.record(z10.string().max(40), z10.string().max(300));
 var DETAIL_MAX = 4e3;
 var ACTION_ERROR_CODES = [
   "unknown",
@@ -1037,12 +918,6 @@ var ACTION_ERROR_CODES = [
   "no_request",
   "in_session",
   "no_note",
-  "member",
-  "not_member",
-  "unknown_role",
-  "not_resting",
-  "dissolved",
-  "no_seat",
   "closed",
   "holder",
   "changed",
@@ -1050,86 +925,84 @@ var ACTION_ERROR_CODES = [
   "not_decision",
   "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 = z10.enum(["running", "done", "denied", "failed", "refused"]);
+var ChatActionSchema = z10.object({
+  action: z10.string().min(1).max(40),
+  args: z10.record(z10.unknown()),
+  summary: z10.string().min(1).max(300),
   vars: ActionVarsSchema.optional(),
-  detail: z13.string().max(DETAIL_MAX).optional(),
-  detailCut: z13.literal(true).optional(),
+  detail: z10.string().max(DETAIL_MAX).optional(),
+  detailCut: z10.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z13.string().optional(),
-  team: z13.string().optional(),
+  session: z10.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: z10.string().datetime().optional(),
+  error: z10.string().optional(),
+  code: z10.string().max(40).optional()
+});
+var ChatActionsSchema = z10.array(ChatActionSchema).min(1).max(MAX_PROPOSALS);
+var ChatTurnSchema = z10.object({
+  machineId: z10.string().optional(),
+  machineName: z10.string().optional(),
+  choices: z10.array(z10.object({ id: z10.string(), label: z10.string() })).optional(),
+  qid: z10.string().min(1),
+  question: z10.string(),
+  askedAt: z10.string().datetime(),
+  steps: z10.array(ChatStepSchema),
+  answer: z10.string().optional(),
+  answeredAt: z10.string().datetime().optional(),
+  error: z10.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()
+  ignoredAt: z10.string().datetime().optional(),
+  attachments: z10.array(AttachmentRefSchema).optional()
 });
 var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
 
 // ../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",
@@ -1141,63 +1014,153 @@ 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(),
+  /** Kept in the list but never connected to: no peer, no retry, no session shown until it is enabled again. */
+  disabled: z16.boolean().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.disabled) ctx.addIssue({ code: "custom", message: "the local machine cannot be disabled", path: [0, "disabled"] });
+    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)
+});
+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(), 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 = 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 known = new Set(state.projects.map((p) => p.id));
+  const candidates = [
+    ...state.projects.flatMap((p) => p.repos.filter((r) => r.machine === machine).map((r) => ({ project: p.id, path: r.path, rule: false }))),
+    ...state.rules.filter((r) => r.machine === machine && known.has(r.project)).map((r) => ({ project: r.project, path: r.path, rule: true }))
+  ].filter((c) => under(cwd, c.path));
+  candidates.sort((x, y) => y.path.length - x.path.length || Number(y.rule) - Number(x.rule));
+  return candidates[0]?.project ?? null;
+}
+
 // ../protocol/src/thread.ts
 import { z as z19 } from "zod";
 var ToolStatusSchema = z19.enum(["running", "success", "failed", "unknown"]);
@@ -1225,10 +1188,8 @@ 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. */
+    /** An `other` notice from Ledge: `task`, the task a `<ledge-task>` is about. An older front, which does not know it, 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(),
@@ -1363,8 +1324,8 @@ 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()
+  /** Answers `openrig.status` and `openrig.act`: drives OpenRig on its machine. */
+  openrig: z21.boolean().optional()
 });
 var UpdateFailureSchema = z21.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
 var ServerMessageSchema = z21.discriminatedUnion("type", [
@@ -1378,6 +1339,11 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
   ReposInfoSchema,
   ReposFoundSchema,
   ModelsListingSchema,
+  OpenRigStateMessageSchema,
+  OpenRigDoneSchema,
+  OpenRigSpecListSchema,
+  OpenRigLaunchedSchema,
+  OpenRigReseatedSchema,
   /** `recents`: the folders of past sessions, most recent first. `launcher`: the command that runs `ledge` inside WSL
    *  (`[node, cli]`), so the overlay can attach a terminal to a session with `<launcher> attach <id>`. `daemon`: absent
    *  from daemons older than the auto-update. */
@@ -1419,7 +1385,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(), tasks: ChatTasksSchema.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),
@@ -1429,8 +1395,8 @@ 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. */
-  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() }),
+   *  again; `failed`: the handler turned it down; a free string, as an `error`'s). */
+  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() }),
   z21.object({ type: z21.literal("chat.error"), qid: z21.string(), message: z21.string() }),
   z21.object({ type: z21.literal("chat.history"), turns: z21.array(ChatTurnSchema) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
@@ -1454,15 +1420,6 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
   ContextPrefsMessageSchema,
   HandoverResultSchema,
   TaskUpdatedSchema,
-  RolesListingSchema,
-  TeamsMessageSchema,
-  TeamUpdatedSchema,
-  TeamLaunchedSchema,
-  TeamFailedSchema,
-  TeamSavedSchema,
-  DefinitionsListingSchema,
-  DefinitionResultSchema,
-  TeamChangedSchema,
   z21.object({
     type: z21.literal("error"),
     message: z21.string(),
@@ -1484,6 +1441,11 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
   ReposInspectSchema,
   ReposScanSchema,
   ModelsListSchema,
+  OpenRigStatusSchema,
+  OpenRigActSchema,
+  OpenRigSpecsSchema,
+  OpenRigLaunchSchema,
+  OpenRigSeatsSchema,
   /** The overlay starts a session: `cwd` is a WSL path (`~` allowed), `name` a preferred bot name (the daemon picks a
    *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation.
    *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields
@@ -1505,10 +1467,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()
   }),
@@ -1596,12 +1554,18 @@ 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) }),
-  /** A seat's hook told it its team as `key` names it (`seatKey`): at its start, or at a turn after the team changed. */
-  z21.object({ type: z21.literal("seat.seen"), id: z21.string(), key: z21.string().max(4e3) }),
   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 the agent runs in (`OPENRIG_SESSION_NAME`, `pod-member@rig`), when OpenRig launched it. */
+    rigSeat: RigSeatNameSchema.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() }),
@@ -1635,25 +1599,8 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
   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"] });
-});
+  HandoverShowSchema
+]);
 function parseClientMessage(raw) {
   return ClientMessageSchema.parse(raw);
 }
@@ -1742,6 +1689,7 @@ function pickName(taken, preferred) {
   if (first) return first;
   for (let i = 2; ; i++) if (free(`${NAMES[0]}-${i}`)) return `${NAMES[0]}-${i}`;
 }
+var namesInUse = (sessions) => [...sessions].filter((s) => s.state !== "exited" && !s.archivedAt).map((s) => s.name);
 
 // ../protocol/src/topic.ts
 var TOPIC_MAX = 80;
@@ -1824,7 +1772,7 @@ var MeResponseSchema = z23.object({
 });
 
 // ../protocol/src/phone.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 
 // ../protocol/src/push.ts
 import { z as z24 } from "zod";
@@ -1870,51 +1818,6 @@ var PushPayloadSchema = z24.object({
   tag: z24.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];
@@ -1933,38 +1836,38 @@ var THREAD_TEXT_MAX = 8192;
 var TOOL_TEXT_MAX = 2048;
 var CHECKLIST_TASKS_MAX = 50;
 var CHECKLIST_TEXT_MAX = 200;
-var ChecklistStatusSchema = z26.enum(["pending", "in_progress", "completed"]);
-var PhoneChecklistSchema = z26.object({
-  tasks: z26.array(z26.object({ text: z26.string().max(CHECKLIST_TEXT_MAX), status: ChecklistStatusSchema })).max(CHECKLIST_TASKS_MAX),
-  done: z26.number().int().nonnegative(),
-  total: z26.number().int().nonnegative(),
-  cut: z26.literal(true).optional()
-});
-var PhoneChecklistSummarySchema = z26.object({
-  done: z26.number().int().nonnegative(),
-  total: z26.number().int().nonnegative(),
-  current: z26.string().max(CHECKLIST_TEXT_MAX).optional(),
-  cut: z26.literal(true).optional()
+var ChecklistStatusSchema = z25.enum(["pending", "in_progress", "completed"]);
+var PhoneChecklistSchema = z25.object({
+  tasks: z25.array(z25.object({ text: z25.string().max(CHECKLIST_TEXT_MAX), status: ChecklistStatusSchema })).max(CHECKLIST_TASKS_MAX),
+  done: z25.number().int().nonnegative(),
+  total: z25.number().int().nonnegative(),
+  cut: z25.literal(true).optional()
+});
+var PhoneChecklistSummarySchema = z25.object({
+  done: z25.number().int().nonnegative(),
+  total: z25.number().int().nonnegative(),
+  current: z25.string().max(CHECKLIST_TEXT_MAX).optional(),
+  cut: z25.literal(true).optional()
 });
 var PENDING_BODY_MAX = 65536;
 var SNAPSHOT_BODY_MAX = 2048;
-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 CapabilitiesSchema = z26.object({
+var RiskSchema = z25.enum(["low", "high"]);
+var RiskReasonSchema = z25.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 = z25.string().uuid();
+var OperationStatusSchema = z25.enum(["received", "applied", "rejected", "failed"]);
+var OperationReasonSchema = z25.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired", "scheduled", ...ModelRefusalSchema.options]);
+var CapabilitiesSchema = z25.object({
   /** A question can be answered in free text. */
-  freeTextAnswer: z26.boolean(),
+  freeTextAnswer: z25.boolean(),
   /** The session's accept/deny can be typed; absent = true. */
-  decide: z26.boolean().optional(),
+  decide: z25.boolean().optional(),
   /** OMP's dialog questions can be answered from the phone; absent = false. */
-  questions: z26.boolean().optional()
+  questions: z25.boolean().optional()
 });
 var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
-var CapabilitiesByToolSchema = z26.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
-var PhonePendingSchema = PendingSchema.extend({ key: z26.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z26.literal(true).optional() });
-var SwitchableSessionSchema = SessionSchema.extend({ canSwitch: z26.literal(true).optional() });
+var CapabilitiesByToolSchema = z25.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
+var PhonePendingSchema = PendingSchema.extend({ key: z25.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z25.literal(true).optional() });
+var SwitchableSessionSchema = SessionSchema.extend({ canSwitch: z25.literal(true).optional() });
 var PhoneSessionSchema = SwitchableSessionSchema.pick({
   id: true,
   name: true,
@@ -1985,10 +1888,6 @@ 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,
@@ -1996,373 +1895,291 @@ var PhoneSessionSchema = SwitchableSessionSchema.pick({
   exitedAt: true
 }).extend({
   pending: PhonePendingSchema.optional(),
-  unread: z26.boolean(),
-  handover: z26.object({ state: HandoverStateSchema, toName: z26.string().max(80).optional() }).strict().optional(),
+  unread: z25.boolean(),
+  handover: z25.object({ state: HandoverStateSchema, toName: z25.string().max(80).optional() }).strict().optional(),
   /** Absent: the agent has no checklist. */
   checklist: PhoneChecklistSummarySchema.optional(),
   /** Started without Ledge (`hook_only`): the phone can neither close nor resume it. */
-  readOnly: z26.literal(true).optional()
+  readOnly: z25.literal(true).optional()
 });
-var B64U2 = z26.string().regex(/^[A-Za-z0-9_-]*$/);
-var CredentialSchema = z26.object({
+var B64U2 = z25.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z25.object({
   id: B64U2.max(1366),
   publicKey: B64U2.max(2048),
-  alg: z26.union([z26.literal(-7), z26.literal(-257)]),
+  alg: z25.union([z25.literal(-7), z25.literal(-257)]),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
-  transports: z26.array(z26.string().max(20)).max(8).optional()
+  transports: z25.array(z25.string().max(20)).max(8).optional()
 });
-var AssertionSchema = z26.object({
+var AssertionSchema = z25.object({
   id: B64U2.max(1366),
   clientDataJSON: B64U2.max(4096),
   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 = z25.enum(["register", "decide", "launch", "close", "act", "pc"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
-var PhoneChatProposalSchema = z26.object({
-  project: z26.string().max(80),
+var PhoneChatProposalSchema = z25.object({
+  project: z25.string().max(80),
   tool: ToolSchema,
-  prompt: z26.string().max(TOOL_TEXT_MAX).optional(),
-  launchedId: z26.string().optional(),
-  failed: z26.literal(true).optional()
+  prompt: z25.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z25.string().optional(),
+  failed: z25.literal(true).optional()
 }).strict();
-var PhoneChatRelaySchema = z26.object({
-  id: z26.string().min(1),
-  name: z26.string(),
+var PhoneChatRelaySchema = z25.object({
+  id: z25.string().min(1),
+  name: z25.string(),
   tool: ToolSchema,
-  text: z26.string().max(TOOL_TEXT_MAX),
-  status: z26.enum(["queued", "sent"]).optional(),
-  sentAt: z26.string().datetime().optional(),
-  failed: z26.literal(true).optional(),
+  text: z25.string().max(TOOL_TEXT_MAX),
+  status: z25.enum(["queued", "sent"]).optional(),
+  sentAt: z25.string().datetime().optional(),
+  failed: z25.literal(true).optional(),
   /** With `failed`: why, as the PC's code (never its text). */
-  code: z26.string().max(40).optional()
+  code: z25.string().max(40).optional()
 }).strict();
-var CloseHowSchema = z26.enum(["exit", "killed"]);
-var PhoneChatCloseSchema = z26.object({
-  id: z26.string().min(1),
-  name: z26.string(),
+var CloseHowSchema = z25.enum(["exit", "killed"]);
+var PhoneChatCloseSchema = z25.object({
+  id: z25.string().min(1),
+  name: z25.string(),
   tool: ToolSchema,
   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()
+  closedAt: z25.string().datetime().optional(),
+  failed: z25.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()
+var PhoneChatTaskSchema = z25.object({
+  to: z25.string().max(80),
+  toName: z25.string().max(80).optional(),
+  title: z25.string().max(200),
+  text: z25.string().max(TOOL_TEXT_MAX).optional(),
+  taskId: z25.string().max(40).optional(),
+  ownerName: z25.string().max(80).optional(),
+  state: z25.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  failed: z25.literal(true).optional()
 }).strict();
-var PhoneChatActionSchema = z26.object({
-  action: z26.string().min(1).max(40),
-  summary: z26.string().max(300),
+var PhoneChatActionSchema = z25.object({
+  action: z25.string().min(1).max(40),
+  summary: z25.string().max(300),
   vars: ActionVarsSchema.optional(),
-  detail: z26.string().max(TOOL_TEXT_MAX).optional(),
-  detailCut: z26.literal(true).optional(),
+  detail: z25.string().max(TOOL_TEXT_MAX).optional(),
+  detailCut: z25.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z26.string().max(100).optional(),
-  team: z26.string().max(40).optional(),
+  session: z25.string().max(100).optional(),
   state: ChatActionStateSchema.optional(),
-  doneAt: z26.string().datetime().optional(),
-  code: z26.string().max(40).optional()
+  doneAt: z25.string().datetime().optional(),
+  code: z25.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(),
+var PhoneTaskSchema = z25.object({
+  id: z25.string().max(40),
+  title: z25.string().max(200),
+  owner: z25.string().max(100),
+  ownerName: z25.string().max(80),
   /** Who gave it: `ledge` for Ledge's own; a session for a decision it put to the user (owner `ledge`), with its detail (the options). */
-  giver: z26.string().max(100).optional(),
-  giverName: z26.string().max(80).optional(),
-  text: z26.string().max(TOOL_TEXT_MAX).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()
+  giver: z25.string().max(100).optional(),
+  giverName: z25.string().max(80).optional(),
+  text: z25.string().max(TOOL_TEXT_MAX).optional(),
+  state: z25.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z25.string().max(TOOL_TEXT_MAX).optional(),
+  cut: z25.literal(true).optional(),
+  at: z25.string(),
+  updatedAt: z25.string(),
+  seen: z25.literal(true).optional()
 }).strict();
-var ChatErrorCodeSchema = z26.enum(["busy", "timeout", "cancelled", "failed"]);
-var PhoneChatTurnSchema = z26.object({
+var ChatErrorCodeSchema = z25.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z25.object({
   qid: OperationIdSchema,
-  question: z26.string().max(MESSAGE_MAX),
-  askedAt: z26.string().datetime(),
-  steps: z26.array(PhoneChatStepSchema).max(50),
-  answer: z26.string().max(THREAD_TEXT_MAX).optional(),
-  answeredAt: z26.string().datetime().optional(),
+  question: z25.string().max(MESSAGE_MAX),
+  askedAt: z25.string().datetime(),
+  steps: z25.array(PhoneChatStepSchema).max(50),
+  answer: z25.string().max(THREAD_TEXT_MAX).optional(),
+  answeredAt: z25.string().datetime().optional(),
   error: ChatErrorCodeSchema.optional(),
-  proposals: z26.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  proposals: z25.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
   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()
+  closes: z25.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
+  cut: z25.literal(true).optional(),
+  tasks: z25.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
+  actions: z25.array(PhoneChatActionSchema).min(1).max(MAX_PROPOSALS).optional(),
+  ignoredAt: z25.string().datetime().optional(),
+  attachments: z25.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
 }).strict();
 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 PcActionSchema = z26.enum(["update", "restart"]);
+var sessionId = z25.string().min(1).max(100);
+var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z25.string().min(1).max(64) });
+var CardRowsSchema = z25.array(z25.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 pcOp = { op: OperationIdSchema, assertion: AssertionSchema.optional() };
+var PcActionSchema = z25.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") }),
-  z26.object({ type: z26.literal("session.thread"), id: sessionId }),
+var PhoneClientMessageSchema = z25.discriminatedUnion("type", [
+  z25.object({ type: z25.literal("snapshot.request") }),
+  z25.object({ type: z25.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 }),
+  z25.object({ type: z25.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() }),
+  z25.object({ type: z25.literal("session.watch"), id: sessionId.nullable() }),
+  z25.object({ type: z25.literal("session.read"), id: sessionId, at: z25.string().datetime() }),
   /**
    * 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"),
+  z25.object({
+    type: z25.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: z25.string().regex(SEMVER).optional()
   }),
-  z26.object({ type: z26.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
-  z26.object({
-    type: z26.literal("session.decide"),
+  z25.object({ type: z25.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z25.object({
+    type: z25.literal("session.decide"),
     op: OperationIdSchema,
     id: sessionId,
     decision: DecisionSchema,
-    note: z26.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z25.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the phone showed: refused unless it is still the pending one. */
     expect: PhoneExpectSchema,
     /** The device check over the challenge of `confirm.prepare`; required by the daemon for a high-risk accept. */
     assertion: AssertionSchema.optional()
   }),
-  z26.object({
-    type: z26.literal("session.reply"),
+  z25.object({
+    type: z25.literal("session.reply"),
     op: OperationIdSchema,
     id: sessionId,
-    text: z26.string().max(MESSAGE_MAX),
-    attachments: z26.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+    text: z25.string().max(MESSAGE_MAX),
+    attachments: z25.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
     /** The request the reply answers, or null when the phone showed none: refused if the session's request is no longer that one. */
     expect: PhoneExpectSchema.nullable(),
     assertion: AssertionSchema.optional()
   }),
   /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order; `cancel` declines it. Bounds as the local `session.answer`. */
-  z26.object({
-    type: z26.literal("session.answer"),
+  z25.object({
+    type: z25.literal("session.answer"),
     op: OperationIdSchema,
     id: sessionId,
-    requestId: z26.string().min(1).max(200),
-    answers: z26.array(z26.object({ id: z26.string().max(200), selected: z26.array(z26.string().max(2e3)).max(100), text: z26.string().max(2e4).optional() })).max(50),
-    cancel: z26.literal(true).optional(),
+    requestId: z25.string().min(1).max(200),
+    answers: z25.array(z25.object({ id: z25.string().max(200), selected: z25.array(z25.string().max(2e3)).max(100), text: z25.string().max(2e4).optional() })).max(50),
+    cancel: z25.literal(true).optional(),
     expect: PhoneExpectSchema
   }),
-  z26.object({ type: z26.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  z25.object({ type: z25.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() }),
+  z25.object({ type: z25.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() }),
+  z25.object({ type: z25.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() }),
+  z25.object({ type: z25.literal("session.model"), op: OperationIdSchema, id: sessionId, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** The models an agent offers on the PC. */
-  z26.object({ type: z26.literal("models.list"), tool: ToolSchema }),
+  z25.object({ type: z25.literal("models.list"), tool: ToolSchema }),
   /** The phone drops its passkey from the daemon. */
-  z26.object({ type: z26.literal("device.forget"), op: OperationIdSchema }),
+  z25.object({ type: z25.literal("device.forget"), op: OperationIdSchema }),
   /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
-  z26.object({ type: z26.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
-  z26.object({ type: z26.literal("push.unsubscribe"), op: OperationIdSchema }),
+  z25.object({ type: z25.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z25.object({ type: z25.literal("push.unsubscribe"), op: OperationIdSchema }),
   /** The phone's own chat with Ledge. */
-  z26.object({ type: z26.literal("chat.ask"), qid: OperationIdSchema, text: z26.string().trim().max(MESSAGE_MAX), attachments: z26.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
-  z26.object({ type: z26.literal("chat.cancel"), qid: OperationIdSchema }),
-  z26.object({ type: z26.literal("chat.reset") }),
-  z26.object({ type: z26.literal("chat.history") }),
+  z25.object({ type: z25.literal("chat.ask"), qid: OperationIdSchema, text: z25.string().trim().max(MESSAGE_MAX), attachments: z25.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
+  z25.object({ type: z25.literal("chat.cancel"), qid: OperationIdSchema }),
+  z25.object({ type: z25.literal("chat.reset") }),
+  z25.object({ type: z25.literal("chat.history") }),
   /** An image to store, sent alone before the message that names it; no `id`, and at most `ATTACHMENT_MAX` bytes. */
-  AttachmentPutSchema.pick({ type: true, requestId: true }).extend({ image: ImageUploadSchema.extend({ data: z26.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
+  AttachmentPutSchema.pick({ type: true, requestId: true }).extend({ image: ImageUploadSchema.extend({ data: z25.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
   AttachmentGetSchema.pick({ type: true, requestId: true, attachment: true, preview: true }),
-  z26.object({ type: z26.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z25.object({ type: z25.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
   /** Takes the card's queued instruction back out of the queue, as the local `session.relay.cancel`. */
-  z26.object({ type: z26.literal("chat.relay.cancel"), 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() }),
+  z25.object({ type: z25.literal("chat.relay.cancel"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z25.object({ type: z25.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z25.object({ type: z25.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), 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) }),
+  z25.object({ type: z25.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z25.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({
-    type: z26.literal("chat.act"),
+  z25.object({
+    type: z25.literal("chat.act"),
     op: OperationIdSchema,
     qid: OperationIdSchema,
     rows: CardRowsSchema.optional(),
-    confirmed: z26.literal(true).optional(),
+    confirmed: z25.literal(true).optional(),
     assertion: AssertionSchema.optional(),
     /** « Refuser », as the local `chat.act`: no passkey, no confirmation. */
-    deny: z26.literal(true).optional()
+    deny: z25.literal(true).optional()
   }),
   /** « 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) }),
+  z25.object({ type: z25.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z25.literal(true).optional() }),
   /** 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) }),
+  z25.object({ type: z25.literal("task.seen"), op: OperationIdSchema, task: z25.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(),
+  z25.object({ type: z25.literal("presence"), visible: z25.boolean() }),
   /** 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(),
+  z25.object({ type: z25.literal("daemon.update"), ...pcOp, version: z25.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"] });
-});
-var PhoneModelChoiceSchema = z26.object({
+  z25.object({ type: z25.literal("daemon.restart"), ...pcOp }).strict()
+]);
+var PhoneModelChoiceSchema = z25.object({
   id: ModelChoiceSchema.shape.id.max(120),
-  label: z26.string().max(80),
-  description: z26.string().max(200).optional(),
-  efforts: z26.array(EffortSchema).max(8).optional(),
+  label: z25.string().max(80),
+  description: z25.string().max(200).optional(),
+  efforts: z25.array(EffortSchema).max(8).optional(),
   defaultEffort: EffortSchema.optional(),
-  isDefault: z26.boolean().optional()
+  isDefault: z25.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(),
+var PhoneServerMessageSchema = z25.discriminatedUnion("type", [
+  z25.object({ type: z25.literal("snapshot"), protocol: z25.literal(PHONE_PROTOCOL), sessions: z25.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z25.object({
+    version: z25.string(),
+    name: z25.string().max(40),
+    boot: z25.string().uuid().optional(),
     /** The daemon takes `session.model`. */
-    models: z26.literal(true).optional(),
+    models: z25.literal(true).optional(),
     /** The daemon sends `session.checklist` and a session's `checklist` summary. */
-    checklist: z26.literal(true).optional(),
+    checklist: z25.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(),
+    update: z25.literal(true).optional(),
+    restart: z25.literal(true).optional(),
     /** The daemon takes `session.close` and `session.resume`. */
-    sessionClose: 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() }),
-  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()
-  }),
-  z26.object({ type: z26.literal("session.updated"), session: PhoneSessionSchema }),
-  z26.object({ type: z26.literal("session.removed"), id: z26.string() }),
+    sessionClose: z25.literal(true).optional()
+  }), device: z25.object({ confirm: z25.boolean(), push: z25.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z25.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+  z25.object({ type: z25.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z25.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z25.number().int().positive() }),
+  z25.object({ type: z25.literal("session.updated"), session: PhoneSessionSchema }),
+  z25.object({ type: z25.literal("session.removed"), id: z25.string() }),
   /** A session's checklist, sent to the phone that watches it; `null`: it has none (any more). */
-  z26.object({ type: z26.literal("session.checklist"), id: z26.string(), checklist: PhoneChecklistSchema.nullable() }),
+  z25.object({ type: z25.literal("session.checklist"), id: z25.string(), checklist: PhoneChecklistSchema.nullable() }),
   /** `pending.cut` is set when even this body was shortened. */
-  z26.object({ type: z26.literal("session.pending"), id: z26.string(), pending: PhonePendingSchema }),
-  z26.object({ type: z26.literal("session.preview"), id: z26.string(), lines: z26.array(z26.string()) }),
+  z25.object({ type: z25.literal("session.pending"), id: z25.string(), pending: PhonePendingSchema }),
+  z25.object({ type: z25.literal("session.preview"), id: z25.string(), lines: z25.array(z25.string()) }),
   /** `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"),
+  z25.object({ type: z25.literal("session.thread"), id: z25.string(), items: z25.array(ThreadItemSchema), cut: z25.array(z25.string()), more: z25.boolean() }),
+  z25.object({ type: z25.literal("session.thread.item"), id: z25.string(), item: ThreadItemSchema, cut: z25.literal(true).optional() }),
+  z25.object({
+    type: z25.literal("operation.result"),
     op: OperationIdSchema,
     status: OperationStatusSchema,
     reason: OperationReasonSchema.optional(),
-    models: z26.array(PhoneSeatModelSchema).max(16).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() }),
+  z25.object({ type: z25.literal("models.listing"), tool: ToolSchema, models: z25.array(PhoneModelChoiceSchema).max(40), error: z25.literal(true).optional() }),
   /** A model change that was accepted and then failed (the agent could not restart). */
-  z26.object({ type: z26.literal("session.model.failed"), id: z26.string(), reason: ModelRefusalSchema }),
-  z26.object({ type: z26.literal("chat.history"), turns: z26.array(PhoneChatTurnSchema).max(50) }),
-  z26.object({ type: z26.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
+  z25.object({ type: z25.literal("session.model.failed"), id: z25.string(), reason: ModelRefusalSchema }),
+  z25.object({ type: z25.literal("chat.history"), turns: z25.array(PhoneChatTurnSchema).max(50) }),
+  z25.object({ type: z25.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
   /** The whole text so far, not an increment. */
-  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 }),
+  z25.object({ type: z25.literal("chat.delta"), qid: OperationIdSchema, text: z25.string().max(THREAD_TEXT_MAX) }),
+  z25.object({ type: z25.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
+  z25.object({ type: z25.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
   /** 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"]) }),
+  z25.object({ type: z25.literal("daemon.progress"), version: z25.string().max(40), step: z25.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) }),
+  z25.object({ type: z25.literal("daemon.failed"), version: z25.string().max(40), reason: UpdateFailureSchema }),
   /** 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 }),
+  z25.object({ type: z25.literal("tasks"), tasks: z25.array(PhoneTaskSchema).max(200) }),
+  z25.object({ type: z25.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() })
+  z25.object({ type: z25.literal("error"), code: z25.enum(["invalid", "unknown_session", "too_large"]), request: z25.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("");
-}
 
 // ../protocol/src/todos.ts
 var TODO_TOOLS = /* @__PURE__ */ new Set(["TodoWrite", "update_plan", "todo"]);
@@ -2555,8 +2372,6 @@ export {
   contextNear,
   BRIEF_MAX,
   ToolSchema,
-  autonomyArgs,
-  ompApprovalFor,
   SessionSchema,
   backendOf,
   isArchived,
@@ -2566,25 +2381,8 @@ export {
   extractProposal,
   parseRelayBlock,
   parseCloseBlock,
-  parseTeamBlock,
   parseTaskBlock,
   parseProjectBlock,
-  SshAliasSchema,
-  MachinesSchema,
-  PROJECT_COLORS,
-  ProjectsSchema,
-  DEFAULT_PROJECTS,
-  projectOf,
-  RoleIdSchema,
-  ROLE_LABEL_MAX,
-  ROLE_PROMPT_MAX,
-  RoleSchema,
-  TEAM_SEATS_MAX,
-  SeatsSchema,
-  TeamNameSchema,
-  TemplateIdSchema,
-  TeamSchema,
-  isTeamLive,
   NOTE_MAX,
   NOTE_NOT_TYPED,
   offers,
@@ -2608,7 +2406,20 @@ export {
   ChatTurnSchema,
   proposalRows,
   DOCUMENT_MAX_BYTES,
+  SshAliasSchema,
+  MachinesSchema,
   IslandPrefsSchema,
+  PROJECT_COLORS,
+  ProjectsSchema,
+  DEFAULT_PROJECTS,
+  projectOf,
+  RigSeatNameSchema,
+  KERNEL_RIG,
+  rigCommands,
+  showRigCommand,
+  RIG_POLICIES,
+  seatsByRole,
+  seatPlan,
   RouteResultSchema,
   DEFAULT_RELAY_URL,
   MobileConfigSchema,
@@ -2622,6 +2433,7 @@ export {
   parseServerMessage,
   NAMES,
   pickName,
+  namesInUse,
   TOPIC_MAX,
   cleanTopic,
   sessionTitle,
@@ -2634,11 +2446,6 @@ export {
   pushEndpointAllowed,
   PushSendResultSchema,
   PushPayloadSchema,
-  PhoneRoleSchema,
-  PhoneTemplateSchema,
-  TEAMS_OPERATION_TYPES,
-  isTeamsOperation,
-  canonicalJson,
   PHONE_PROTOCOL,
   padPlain,
   THREAD_ITEMS_MAX,
@@ -2655,8 +2462,6 @@ export {
   pcSubject,
   PhoneClientMessageSchema,
   PhoneModelChoiceSchema,
-  teamsPurpose,
-  teamsDigest,
   TODO_TOOLS,
   latestTodos,
   doneCount,