@paradow/ledge 0.25.1 → 0.27.0

package/dist/cli/{chunk-ARB4BKZJ.js → chunk-37G5F75H.js}

@@ -176,7 +176,7 @@ function isArchived(s) {
 }
 
 // ../protocol/src/teams.ts
-import { z as z4 } from "zod";
+import { z as z7 } from "zod";
 
 // ../protocol/src/models.ts
 import { z as z3 } from "zod";
@@ -204,118 +204,257 @@ var ModelsListingSchema = z3.object({
   error: z3.string().optional()
 });
 
+// ../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 = z4.string().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/);
+var RoleIdSchema = z7.string().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/);
 var ROLE_LABEL_MAX = 40;
 var ROLE_PROMPT_MAX = 8e3;
-var RoleSchema = z4.object({
+var DefinitionHashSchema = z7.string().regex(/^[0-9a-f]{16}$/);
+var RoleSchema = z7.object({
   id: RoleIdSchema,
-  label: z4.string().min(1).max(ROLE_LABEL_MAX),
-  prompt: z4.string().max(ROLE_PROMPT_MAX),
+  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: z4.enum(["repo", "home"]),
-  path: z4.string(),
-  shadows: z4.string().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 = z4.object({ path: z4.string(), reason: z4.string() });
+var DefinitionProblemSchema = z7.object({ path: z7.string(), reason: z7.string() });
 var TEAM_SEATS_MAX = 8;
-var SeatSchema = z4.object({
+var SeatSchema = z7.object({
   role: RoleIdSchema,
   tool: ToolSchema.optional(),
   model: ModelIdSchema.optional(),
   effort: EffortSchema.optional(),
-  name: z4.string().min(1).max(40).optional()
+  name: z7.string().min(1).max(40).optional()
 });
 var uniqueRoles = (seats) => new Set(seats.map((s) => s.role)).size === seats.length;
-var SeatsSchema = z4.array(SeatSchema).min(1).max(TEAM_SEATS_MAX).refine(uniqueRoles, "a role twice in one team");
-var TeamNameSchema = z4.string().trim().min(1).max(60);
-var TeamTemplateSchema = z4.object({ id: z4.string().min(1).max(64), name: TeamNameSchema, seats: SeatsSchema, source: z4.enum(["repo", "home"]), path: z4.string() });
-var TeamIdSchema = z4.string().regex(/^team-[0-9a-f]{4,8}$/);
-var TeamStateSchema = z4.enum(["active", "resting", "dissolved"]);
-var TeamSchema = z4.object({
+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: z4.string().optional(),
-  project: z4.string().nullable(),
-  machine: z4.string(),
-  cwd: z4.string(),
+  template: z7.string().optional(),
+  project: z7.string().nullable(),
+  machine: z7.string(),
+  cwd: z7.string(),
   state: TeamStateSchema,
-  seats: z4.array(z4.object({ role: RoleIdSchema, sessionId: z4.string().nullable() })).max(TEAM_SEATS_MAX * 2),
-  createdAt: z4.string(),
-  updatedAt: z4.string(),
-  restingAt: z4.string().optional(),
-  dissolvedAt: z4.string().optional()
+  /** A live seat: `tool`, `model` and `effort` are what it was composed with over the role's defaults; `leaving` marks a seat removed
+   *  from the composition that finishes its turn and then is closed. */
+  seats: z7.array(z7.object({
+    role: RoleIdSchema,
+    sessionId: z7.string().nullable(),
+    tool: ToolSchema.optional(),
+    model: ModelIdSchema.optional(),
+    effort: EffortSchema.optional(),
+    leaving: z7.literal(true).optional()
+  })).max(TEAM_SEATS_MAX * 2),
+  createdAt: z7.string(),
+  updatedAt: z7.string(),
+  restingAt: z7.string().optional(),
+  dissolvedAt: z7.string().optional()
 });
-var RolesListSchema = z4.object({ type: z4.literal("roles.list"), cwd: z4.string().min(1).optional(), requestId: z4.string().max(100).optional(), machineId: z4.string().optional() });
-var RolesListingSchema = z4.object({
-  type: z4.literal("roles.listing"),
-  requestId: z4.string().optional(),
-  roles: z4.array(RoleSchema),
-  templates: z4.array(TeamTemplateSchema).default([]),
-  problems: z4.array(DefinitionProblemSchema),
+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: z4.string().optional()
+  error: z7.string().optional()
 });
-var TeamLaunchSchema = z4.object({
-  type: z4.literal("team.launch"),
-  rid: z4.string().min(1).max(100),
-  cwd: z4.string().min(1).optional(),
-  template: z4.string().min(1).max(64).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: z4.string().min(1).optional(),
-  machineId: z4.string().optional()
+  qid: z7.string().min(1).optional(),
+  machineId: z7.string().optional(),
+  /** The project's name, for a client that holds no path (the phone): the daemon resolves its folder. */
+  project: ProjectIdSchema.optional()
+});
+var TeamJoinSchema = z7.object({ type: z7.literal("team.join"), team: TeamIdSchema, session: z7.string().min(1), role: RoleIdSchema });
+var TeamLeaveSchema = z7.object({ type: z7.literal("team.leave"), team: TeamIdSchema, session: z7.string().min(1) });
+var TeamResumeSchema = z7.object({ type: z7.literal("team.resume"), team: TeamIdSchema });
+var TeamDissolveSchema = z7.object({ type: z7.literal("team.dissolve"), team: TeamIdSchema });
+var TeamSaveSchema = z7.object({ type: z7.literal("team.save"), rid: z7.string().min(1).max(100), name: TeamNameSchema, seats: SeatsSchema, qid: z7.string().min(1).optional() });
+var DefinitionScopeSchema = z7.enum(["home", "repo"]);
+var RoleDraftSchema = RoleSchema.pick({ id: true, label: true, prompt: true, tool: true, model: true, effort: true, autonomy: true });
+var DefinitionCodeSchema = z7.enum(["changed", "exists", "missing", "unknown_project", "invalid"]);
+var scopeFields = { rid: z7.string().min(1).max(100), scope: DefinitionScopeSchema, project: ProjectIdSchema.optional() };
+var scopeIssue = (m) => m.scope === void 0 || m.scope === "repo" === (m.project !== void 0) ? null : "a repo scope names a project, a home scope none";
+var DefinitionBaseSchema = DefinitionHashSchema;
+var DefinitionsListSchema = z7.object({ type: z7.literal("definitions.list"), requestId: z7.string().max(100).optional() });
+var RoleWriteSchema = z7.object({ type: z7.literal("role.write"), ...scopeFields, role: RoleDraftSchema, base: DefinitionBaseSchema.nullable() });
+var RoleDeleteSchema = z7.object({ type: z7.literal("role.delete"), ...scopeFields, id: RoleIdSchema, base: DefinitionBaseSchema });
+var TemplateWriteSchema = z7.object({
+  type: z7.literal("template.write"),
+  ...scopeFields,
+  id: TemplateIdSchema.optional(),
+  name: TeamNameSchema,
+  seats: SeatsSchema,
+  base: DefinitionBaseSchema.nullable()
+});
+var TemplateDeleteSchema = z7.object({ type: z7.literal("template.delete"), ...scopeFields, id: TemplateIdSchema, base: DefinitionBaseSchema });
+var TeamComposeSchema = z7.object({ type: z7.literal("team.compose"), rid: z7.string().min(1).max(100), team: TeamIdSchema, seats: SeatsSchema });
+var TeamSeatSchema = z7.object({ type: z7.literal("team.seat"), rid: z7.string().min(1).max(100), team: TeamIdSchema, role: RoleIdSchema, action: z7.enum(["start", "restart"]) });
+var DefinitionsListingSchema = z7.object({
+  type: z7.literal("definitions.listing"),
+  requestId: z7.string().optional(),
+  scopes: z7.array(z7.object({
+    scope: DefinitionScopeSchema,
+    project: z7.string().nullable(),
+    roles: z7.array(RoleSchema),
+    templates: z7.array(TeamTemplateSchema),
+    problems: z7.array(DefinitionProblemSchema)
+  }))
 });
-var TeamJoinSchema = z4.object({ type: z4.literal("team.join"), team: TeamIdSchema, session: z4.string().min(1), role: RoleIdSchema });
-var TeamLeaveSchema = z4.object({ type: z4.literal("team.leave"), team: TeamIdSchema, session: z4.string().min(1) });
-var TeamResumeSchema = z4.object({ type: z4.literal("team.resume"), team: TeamIdSchema });
-var TeamDissolveSchema = z4.object({ type: z4.literal("team.dissolve"), team: TeamIdSchema });
-var TeamSaveSchema = z4.object({ type: z4.literal("team.save"), rid: z4.string().min(1).max(100), name: TeamNameSchema, seats: SeatsSchema, qid: z4.string().min(1).optional() });
-var TeamsMessageSchema = z4.object({ type: z4.literal("teams"), teams: z4.array(TeamSchema) });
-var TeamUpdatedSchema = z4.object({ type: z4.literal("team.updated"), team: TeamSchema });
-var TeamLaunchedSchema = z4.object({ type: z4.literal("team.launched"), rid: z4.string(), team: TeamSchema });
-var TeamFailedSchema = z4.object({ type: z4.literal("team.failed"), rid: z4.string(), reason: z4.string(), team: TeamSchema.optional() });
-var TeamSavedSchema = z4.object({ type: z4.literal("team.saved"), rid: z4.string(), path: z4.string().optional(), reason: z4.string().optional() });
+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 TeamChangedSchema = z7.object({ type: z7.literal("team.changed"), rid: z7.string(), team: TeamSchema.optional(), reason: z7.string().optional() });
+var TeamsMessageSchema = z7.object({ type: z7.literal("teams"), teams: z7.array(TeamSchema) });
+var TeamUpdatedSchema = z7.object({ type: z7.literal("team.updated"), team: TeamSchema });
+var TeamLaunchedSchema = z7.object({ type: z7.literal("team.launched"), rid: z7.string(), team: TeamSchema });
+var TeamFailedSchema = z7.object({ type: z7.literal("team.failed"), rid: z7.string(), reason: z7.string(), team: TeamSchema.optional() });
+var TeamSavedSchema = z7.object({ type: z7.literal("team.saved"), rid: z7.string(), path: z7.string().optional(), reason: z7.string().optional() });
 var isTeamLive = (t) => t.state !== "dissolved";
 
 // ../protocol/src/tasks.ts
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 var TASK_TITLE_MAX = 200;
 var TASK_TEXT_MAX = 2e4;
 var LEDGE_GIVER = "ledge";
 var TASK_OPS = ["give", "take", "pass", "done", "refuse", "cancel", "drop"];
 var TRANSMISSION_OPS = ["give", "pass", "done", "refuse", "cancel"];
-var TaskLogEntrySchema = z5.object({
-  at: z5.string(),
-  by: z5.string(),
-  what: z5.string(),
-  op: z5.enum(TASK_OPS).optional(),
-  from: z5.string().optional(),
-  to: z5.string().optional(),
-  fromName: z5.string().optional(),
-  toName: z5.string().optional(),
-  note: z5.string().optional()
+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 = z5.object({
-  id: z5.string(),
-  title: z5.string(),
-  text: z5.string().optional(),
-  giver: z5.string(),
-  giverName: z5.string(),
-  owner: z5.string(),
-  ownerName: z5.string(),
-  state: z5.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z5.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: z5.string().optional(),
+  team: z8.string().optional(),
   /** A task Ledge gave and the user put away from « À toi » once closed. */
-  seen: z5.boolean().optional(),
-  at: z5.string(),
-  updatedAt: z5.string(),
-  log: z5.array(TaskLogEntrySchema)
+  seen: z8.boolean().optional(),
+  at: z8.string(),
+  updatedAt: z8.string(),
+  log: z8.array(TaskLogEntrySchema)
 });
 var handOver = (op) => TRANSMISSION_OPS.includes(op ?? "");
 function transmissions(t) {
@@ -323,54 +462,54 @@ function transmissions(t) {
 }
 var givenByLedge = (t) => t.giver === LEDGE_GIVER;
 var taskClosed = (t) => t.state === "done" || t.state === "refused" || t.state === "dropped";
-var TaskCmdSchema = z5.object({
-  type: z5.literal("task.cmd"),
-  rid: z5.string().min(1),
-  by: z5.string().min(1),
-  op: z5.enum(["give", "take", "done", "refuse", "pass", "show", "list", "seen", "cancel"]),
-  task: z5.string().min(1).max(40).optional(),
-  to: z5.string().min(1).optional(),
-  title: z5.string().min(1).max(TASK_TITLE_MAX).optional(),
-  text: z5.string().max(TASK_TEXT_MAX).optional(),
-  all: z5.boolean().optional(),
-  team: z5.string().min(1).max(40).optional(),
-  qid: z5.string().min(1).optional(),
-  row: z5.number().int().min(0).max(7).optional()
+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 = z5.object({ type: z5.literal("task.updated"), task: TaskSchema });
-var TaskResultSchema = z5.object({
-  type: z5.literal("task.result"),
-  rid: z5.string(),
+var TaskUpdatedSchema = z8.object({ type: z8.literal("task.updated"), task: TaskSchema });
+var TaskResultSchema = z8.object({
+  type: z8.literal("task.result"),
+  rid: z8.string(),
   task: TaskSchema.optional(),
-  tasks: z5.array(TaskSchema).optional(),
-  reason: z5.string().optional()
+  tasks: z8.array(TaskSchema).optional(),
+  reason: z8.string().optional()
 });
 
 // ../protocol/src/actions.ts
-import { z as z8 } from "zod";
+import { z as z11 } from "zod";
 
 // ../protocol/src/proposal.ts
-import { z as z6 } from "zod";
-var ProposalBlockSchema = z6.object({ cwd: z6.string().trim().min(1), prompt: z6.string().optional() });
-var RelayBlockSchema = z6.object({ session: z6.string().trim().min(1), text: z6.string().trim().min(1) });
-var ProjectBlockSchema = z6.object({
-  name: z6.string().trim().min(1).max(80),
-  description: z6.string().max(500).optional(),
-  repos: z6.array(z6.object({ path: z6.string().min(1).max(4096), why: z6.string().trim().min(1).max(200) })).min(1).max(50),
-  addTo: z6.string().trim().max(80).optional()
+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 = z6.object({ session: z6.string().trim().min(1) });
-var TeamBlockSchema = z6.object({
-  cwd: z6.string().trim().min(1),
-  template: z6.string().trim().min(1).max(64).optional(),
-  name: z6.string().trim().min(1).max(60).optional(),
-  seats: z6.array(z6.object({ role: z6.string().trim().min(1).max(40), tool: z6.enum(["claude", "codex", "cursor", "omp"]).optional(), model: z6.string().max(200).optional(), effort: z6.string().max(20).optional(), name: z6.string().max(40).optional() })).min(1).max(8).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 = z6.object({
-  to: z6.string().trim().min(1).max(80),
-  team: z6.string().trim().max(40).optional(),
-  title: z6.string().trim().min(1).max(200),
-  text: z6.string().max(2e4).optional()
+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;
 function extractProposal(answer) {
@@ -424,8 +563,8 @@ function parseProjectBlock(raw) {
 }
 
 // ../protocol/src/decisions.ts
-import { z as z7 } from "zod";
-var DecisionSchema = z7.enum(["accept", "deny", "always"]);
+import { z as z10 } from "zod";
+var DecisionSchema = z10.enum(["accept", "deny", "always"]);
 var NOTE_MAX = 4e3;
 var NOTE_NOT_TYPED = "note_not_typed";
 var DECISION_OFFERS = {
@@ -455,7 +594,7 @@ function pendingKey(p) {
 }
 
 // ../protocol/src/actions.ts
-var ActionRiskSchema = z8.enum(["read", "reversible", "destructive"]);
+var ActionRiskSchema = z11.enum(["read", "reversible", "destructive"]);
 var ACTION_IDS = [
   "session.launch",
   "session.relay",
@@ -477,11 +616,11 @@ var ACTION_IDS = [
   "task.cancel",
   "task.pass"
 ];
-var ActionIdSchema = z8.enum(ACTION_IDS);
+var ActionIdSchema = z11.enum(ACTION_IDS);
 var def = (d) => d;
-var SessionRef = z8.string().trim().min(1).max(80);
-var TeamRef = z8.string().trim().min(1).max(60);
-var TaskRef = z8.string().trim().min(1).max(40);
+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 LaunchArgs = ProposalBlockSchema.extend({ model: ModelIdSchema.optional(), effort: EffortSchema.optional() });
 var ACTIONS = [
   def({
@@ -559,14 +698,14 @@ var ACTIONS = [
     phone: null,
     risk: "reversible",
     max: 8,
-    args: z8.object({ session: SessionRef, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+    args: z11.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: z8.object({ session: SessionRef }),
+    args: z11.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -577,7 +716,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.archive",
-    args: z8.object({ session: SessionRef }),
+    args: z11.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -588,7 +727,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.restore",
-    args: z8.object({ session: SessionRef }),
+    args: z11.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -599,7 +738,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.resume",
-    args: z8.object({ session: SessionRef }),
+    args: z11.object({ session: SessionRef }),
     card: "generic",
     phone: "act",
     risk: "reversible",
@@ -613,7 +752,7 @@ var ACTIONS = [
     card: "generic",
     phone: "act",
     max: 1,
-    args: z8.object({ session: SessionRef, decision: z8.enum(["accept", "deny"]), note: z8.string().trim().min(1).max(NOTE_MAX).optional() }),
+    args: z11.object({ session: SessionRef, decision: z11.enum(["accept", "deny"]), note: z11.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",
@@ -621,7 +760,7 @@ var ACTIONS = [
   }),
   def({
     id: "team.join",
-    args: z8.object({ team: TeamRef, session: SessionRef, role: RoleIdSchema }),
+    args: z11.object({ team: TeamRef, session: SessionRef, role: RoleIdSchema }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -632,7 +771,7 @@ var ACTIONS = [
   }),
   def({
     id: "team.leave",
-    args: z8.object({ team: TeamRef, session: SessionRef }),
+    args: z11.object({ team: TeamRef, session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -643,7 +782,7 @@ var ACTIONS = [
   }),
   def({
     id: "team.resume",
-    args: z8.object({ team: TeamRef }),
+    args: z11.object({ team: TeamRef }),
     card: "generic",
     phone: "act",
     risk: "reversible",
@@ -654,7 +793,7 @@ var ACTIONS = [
   }),
   def({
     id: "team.dissolve",
-    args: z8.object({ team: TeamRef }),
+    args: z11.object({ team: TeamRef }),
     card: "generic",
     phone: "act",
     risk: "destructive",
@@ -666,7 +805,7 @@ var ACTIONS = [
   }),
   def({
     id: "team.save",
-    args: z8.object({ team: TeamRef, name: TeamNameSchema }),
+    args: z11.object({ team: TeamRef, name: TeamNameSchema }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -677,7 +816,7 @@ var ACTIONS = [
   }),
   def({
     id: "task.cancel",
-    args: z8.object({ task: TaskRef, reason: z8.string().trim().min(1).max(500).optional() }),
+    args: z11.object({ task: TaskRef, reason: z11.string().trim().min(1).max(500).optional() }),
     card: "generic",
     phone: "act",
     risk: "destructive",
@@ -688,7 +827,7 @@ var ACTIONS = [
   }),
   def({
     id: "task.pass",
-    args: z8.object({ task: TaskRef, to: SessionRef, note: z8.string().trim().min(1).max(TASK_TEXT_MAX).optional() }),
+    args: z11.object({ task: TaskRef, to: SessionRef, note: z11.string().trim().min(1).max(TASK_TEXT_MAX).optional() }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -701,7 +840,7 @@ 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 = z8.object({ action: z8.string().trim().min(1).max(40), args: z8.record(z8.unknown()).default({}) });
+var ActionBlockSchema = z11.object({ action: z11.string().trim().min(1).max(40), args: z11.record(z11.unknown()).default({}) });
 var LEGACY_FENCE_ACTION = {
   session: "session.launch",
   relay: "session.relay",
@@ -747,119 +886,119 @@ var NEVER_PROPOSED = [
 import { z as z21 } from "zod";
 
 // ../protocol/src/chat.ts
-import { z as z10 } from "zod";
+import { z as z13 } from "zod";
 
 // ../protocol/src/attachments.ts
-import { z as z9 } from "zod";
+import { z as z12 } from "zod";
 var ATTACHMENT_ID = /^[0-9a-f]{64}$/;
-var AttachmentIdSchema = z9.string().regex(ATTACHMENT_ID);
+var AttachmentIdSchema = z12.string().regex(ATTACHMENT_ID);
 var IMAGE_MIMES = ["image/webp", "image/jpeg", "image/png", "image/gif"];
-var ImageMimeSchema = z9.enum(IMAGE_MIMES);
+var ImageMimeSchema = z12.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 = z9.object({
+var AttachmentRefSchema = z12.object({
   id: AttachmentIdSchema,
   mime: ImageMimeSchema,
-  width: z9.number().int().positive(),
-  height: z9.number().int().positive(),
-  bytes: z9.number().int().positive(),
-  preview: z9.boolean()
+  width: z12.number().int().positive(),
+  height: z12.number().int().positive(),
+  bytes: z12.number().int().positive(),
+  preview: z12.boolean()
 });
-var ImageUploadSchema = z9.object({
+var ImageUploadSchema = z12.object({
   mime: ImageMimeSchema,
-  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()
+  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 = 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 });
+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 });
 
 // ../protocol/src/chat.ts
-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 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 = z10.object({
-  cwd: z10.string().min(1),
-  project: z10.string(),
-  prompt: z10.string().optional(),
+var ChatProposalSchema = z13.object({
+  cwd: z13.string().min(1),
+  project: z13.string(),
+  prompt: z13.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: z10.string().optional(),
-  error: z10.string().optional()
+  launchedId: z13.string().optional(),
+  error: z13.string().optional()
 });
 var MAX_PROPOSALS = 8;
-var ChatProposalsSchema = z10.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
-var ChatRelaySchema = z10.object({
-  id: z10.string().min(1),
-  name: z10.string(),
+var ChatProposalsSchema = z13.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
+var ChatRelaySchema = z13.object({
+  id: z13.string().min(1),
+  name: z13.string(),
   tool: ToolSchema,
-  text: z10.string().min(1),
-  status: z10.enum(["queued", "sent"]).optional(),
-  sentAt: z10.string().datetime().optional(),
-  error: z10.string().optional()
+  text: z13.string().min(1),
+  status: z13.enum(["queued", "sent"]).optional(),
+  sentAt: z13.string().datetime().optional(),
+  error: z13.string().optional()
 });
-var ChatCloseSchema = z10.object({
-  id: z10.string().min(1),
-  name: z10.string(),
+var ChatCloseSchema = z13.object({
+  id: z13.string().min(1),
+  name: z13.string(),
   tool: ToolSchema,
-  closedAt: z10.string().datetime().optional(),
-  how: z10.enum(["exit", "killed"]).optional(),
-  error: z10.string().optional()
+  closedAt: z13.string().datetime().optional(),
+  how: z13.enum(["exit", "killed"]).optional(),
+  error: z13.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 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 = z10.object({
-  role: z10.string().min(1),
-  label: z10.string(),
+var ChatTeamSeatSchema = z13.object({
+  role: z13.string().min(1),
+  label: z13.string(),
   tool: ToolSchema,
-  model: z10.string().optional(),
-  effort: z10.string().optional(),
+  model: z13.string().optional(),
+  effort: z13.string().optional(),
   autonomy: AutonomySchema.optional(),
-  name: z10.string().optional()
+  name: z13.string().optional()
 });
-var ChatTeamProposalSchema = z10.object({
-  cwd: z10.string().min(1),
-  project: z10.string(),
-  projectName: z10.string().optional(),
-  name: z10.string().min(1),
-  template: z10.string().optional(),
-  seats: z10.array(ChatTeamSeatSchema).min(1).max(8),
-  teamId: z10.string().optional(),
-  launchedAt: z10.string().datetime().optional(),
-  error: z10.string().optional(),
-  savedPath: z10.string().optional()
+var ChatTeamProposalSchema = z13.object({
+  cwd: z13.string().min(1),
+  project: z13.string(),
+  projectName: z13.string().optional(),
+  name: z13.string().min(1),
+  template: z13.string().optional(),
+  seats: z13.array(ChatTeamSeatSchema).min(1).max(8),
+  teamId: z13.string().optional(),
+  launchedAt: z13.string().datetime().optional(),
+  error: z13.string().optional(),
+  savedPath: z13.string().optional()
 });
-var ChatTaskProposalSchema = z10.object({
-  to: z10.string().min(1),
-  toName: z10.string().optional(),
-  team: 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 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 = z10.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
-var ActionVarsSchema = z10.record(z10.string().max(40), z10.string().max(300));
+var ChatTasksSchema = z13.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
+var ActionVarsSchema = z13.record(z13.string().max(40), z13.string().max(300));
 var DETAIL_MAX = 4e3;
 var ACTION_ERROR_CODES = [
   "unknown",
@@ -886,34 +1025,34 @@ var ACTION_ERROR_CODES = [
   "cut",
   "failed"
 ];
-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),
+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),
   vars: ActionVarsSchema.optional(),
-  detail: z10.string().max(DETAIL_MAX).optional(),
-  detailCut: z10.literal(true).optional(),
+  detail: z13.string().max(DETAIL_MAX).optional(),
+  detailCut: z13.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z10.string().optional(),
-  team: z10.string().optional(),
+  session: z13.string().optional(),
+  team: z13.string().optional(),
   state: ChatActionStateSchema.optional(),
-  doneAt: z10.string().datetime().optional(),
-  error: z10.string().optional(),
-  code: z10.string().max(40).optional()
+  doneAt: z13.string().datetime().optional(),
+  error: z13.string().optional(),
+  code: z13.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(),
+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(),
   proposal: ChatProposalSchema.optional(),
   proposals: ChatProposalsSchema.optional(),
   relay: ChatRelaySchema.optional(),
@@ -922,50 +1061,50 @@ var ChatTurnSchema = z10.object({
   team: ChatTeamProposalSchema.optional(),
   tasks: ChatTasksSchema.optional(),
   actions: ChatActionsSchema.optional(),
-  ignoredAt: z10.string().datetime().optional(),
-  attachments: z10.array(AttachmentRefSchema).optional()
+  ignoredAt: z13.string().datetime().optional(),
+  attachments: z13.array(AttachmentRefSchema).optional()
 });
 var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
 
 // ../protocol/src/repos.ts
-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()
+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 = 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) });
+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) });
 
 // ../protocol/src/scan.ts
-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() });
+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() });
 
 // ../protocol/src/documents.ts
-import { z as z13 } from "zod";
+import { z as z16 } from "zod";
 var DOCUMENT_MAX_BYTES = 1048576;
-var path = z13.string().min(1).max(4096);
-var requestId2 = z13.string().min(1);
-var DocumentReadSchema = z13.object({
-  type: z13.literal("document.read"),
+var path = z16.string().min(1).max(4096);
+var requestId2 = z16.string().min(1);
+var DocumentReadSchema = z16.object({
+  type: z16.literal("document.read"),
   requestId: requestId2,
   path,
-  machineId: z13.string().optional(),
-  sessionId: z13.string().min(1).optional(),
+  machineId: z16.string().optional(),
+  sessionId: z16.string().min(1).optional(),
   basePath: path.optional()
 });
-var DocumentContentSchema = z13.object({
-  type: z13.literal("document.content"),
+var DocumentContentSchema = z16.object({
+  type: z16.literal("document.content"),
   requestId: requestId2,
   path,
-  text: z13.string(),
-  bytes: z13.number().int().nonnegative(),
-  modifiedAt: z13.string().datetime()
+  text: z16.string(),
+  bytes: z16.number().int().nonnegative(),
+  modifiedAt: z16.string().datetime()
 });
-var DocumentErrorCodeSchema = z13.enum([
+var DocumentErrorCodeSchema = z16.enum([
   "not_found",
   "not_file",
   "unsupported_path",
@@ -977,150 +1116,63 @@ var DocumentErrorCodeSchema = z13.enum([
   "session_missing",
   "read_failed"
 ]);
-var DocumentErrorSchema = z13.object({
-  type: z13.literal("document.error"),
+var DocumentErrorSchema = z16.object({
+  type: z16.literal("document.error"),
   requestId: requestId2,
   path,
   code: DocumentErrorCodeSchema
 });
 
 // ../protocol/src/routing.ts
-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)
+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 = 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 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 = z14.object({
+var RouteResultSchema = z17.object({
   /** Null means an answer or a clarification, never an implicit local destination. */
-  machineId: z14.string().nullable(),
-  text: z14.string().min(1).max(2e4),
-  choices: z14.array(z14.string()).max(20).optional()
-});
-
-// ../protocol/src/ssh.ts
-import { z as z15 } from "zod";
-var SshAliasSchema = z15.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
-
-// ../protocol/src/machines.ts
-import { z as z16 } from "zod";
-var MachineIdSchema = z16.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
-var MachineSchema = z16.object({
-  id: MachineIdSchema,
-  label: z16.string().trim().min(1).max(80),
-  ssh: SshAliasSchema.optional()
-});
-var MachinesSchema = z16.array(MachineSchema).min(1).max(20).superRefine((list, ctx) => {
-  if (list[0]?.id !== "local" || list[0].ssh !== void 0) ctx.addIssue({ code: "custom", message: "the first machine is local, without ssh", path: [0] });
-  const ids = /* @__PURE__ */ new Set(), aliases = /* @__PURE__ */ new Set();
-  list.forEach((m, i) => {
-    if (i > 0 && !m.ssh) ctx.addIssue({ code: "custom", message: "a remote machine needs an ssh alias", path: [i, "ssh"] });
-    if (ids.has(m.id)) ctx.addIssue({ code: "custom", message: `duplicate id ${m.id}`, path: [i, "id"] });
-    ids.add(m.id);
-    if (m.ssh) {
-      if (aliases.has(m.ssh)) ctx.addIssue({ code: "custom", message: `duplicate ssh alias ${m.ssh}`, path: [i, "ssh"] });
-      aliases.add(m.ssh);
-    }
-  });
+  machineId: z17.string().nullable(),
+  text: z17.string().min(1).max(2e4),
+  choices: z17.array(z17.string()).max(20).optional()
 });
 
 // ../protocol/src/island.ts
-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({
+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({
   /** Shown at the top of the screen; hidden, Desktop still notifies. */
-  visible: z17.boolean(),
+  visible: z18.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: z17.string().trim().min(1).max(200),
-  position: z17.enum(["center", "left", "right"]),
+  screen: z18.string().trim().min(1).max(200),
+  position: z18.enum(["center", "left", "right"]),
   /** A strip under a maximised window. */
-  discreet: z17.boolean(),
+  discreet: z18.boolean(),
   islandScale: IslandScaleSchema,
   panelScale: IslandScaleSchema,
   /** What the island shows besides asks and questions, which it always shows. */
-  shows: z17.object({
+  shows: z18.object({
     /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
-    quick: z17.boolean(),
+    quick: z18.boolean(),
     /** The 6 s bubble when an agent finishes. */
-    finished: z17.boolean(),
+    finished: z18.boolean(),
     /** An agent's sentence in a bubble. */
-    say: z17.boolean(),
+    say: z18.boolean(),
     /** The sub-agents next to their main agent. */
-    helpers: z17.boolean()
+    helpers: z18.boolean()
   }),
   /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
-  shortcut: z17.string().trim().min(1).max(40)
+  shortcut: z18.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"]);
@@ -1382,6 +1434,9 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
   TeamLaunchedSchema,
   TeamFailedSchema,
   TeamSavedSchema,
+  DefinitionsListingSchema,
+  DefinitionResultSchema,
+  TeamChangedSchema,
   z21.object({
     type: z21.literal("error"),
     message: z21.string(),
@@ -1559,8 +1614,18 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
   TeamLeaveSchema,
   TeamResumeSchema,
   TeamDissolveSchema,
-  TeamSaveSchema
-]);
+  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"] });
+});
 function parseClientMessage(raw) {
   return ClientMessageSchema.parse(raw);
 }
@@ -1731,7 +1796,7 @@ var MeResponseSchema = z23.object({
 });
 
 // ../protocol/src/phone.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // ../protocol/src/push.ts
 import { z as z24 } from "zod";
@@ -1777,6 +1842,51 @@ 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];
@@ -1795,22 +1905,22 @@ var THREAD_TEXT_MAX = 8192;
 var TOOL_TEXT_MAX = 2048;
 var PENDING_BODY_MAX = 65536;
 var SNAPSHOT_BODY_MAX = 2048;
-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"]);
-var CapabilitiesSchema = z25.object({
+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"]);
+var CapabilitiesSchema = z26.object({
   /** A question can be answered in free text. */
-  freeTextAnswer: z25.boolean(),
+  freeTextAnswer: z26.boolean(),
   /** The session's accept/deny can be typed; absent = true. */
-  decide: z25.boolean().optional(),
+  decide: z26.boolean().optional(),
   /** OMP's dialog questions can be answered from the phone; absent = false. */
-  questions: z25.boolean().optional()
+  questions: z26.boolean().optional()
 });
 var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
-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 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 PhoneSessionSchema = SessionSchema.pick({
   id: true,
   name: true,
@@ -1833,240 +1943,318 @@ var PhoneSessionSchema = SessionSchema.pick({
   /** 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
-}).extend({ pending: PhonePendingSchema.optional(), unread: z25.boolean(), handover: z25.object({ state: HandoverStateSchema, toName: z25.string().max(80).optional() }).strict().optional() });
-var B64U2 = z25.string().regex(/^[A-Za-z0-9_-]*$/);
-var CredentialSchema = z25.object({
+}).extend({ pending: PhonePendingSchema.optional(), unread: z26.boolean(), handover: z26.object({ state: HandoverStateSchema, toName: z26.string().max(80).optional() }).strict().optional() });
+var B64U2 = z26.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z26.object({
   id: B64U2.max(1366),
   publicKey: B64U2.max(2048),
-  alg: z25.union([z25.literal(-7), z25.literal(-257)]),
+  alg: z26.union([z26.literal(-7), z26.literal(-257)]),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
-  transports: z25.array(z25.string().max(20)).max(8).optional()
+  transports: z26.array(z26.string().max(20)).max(8).optional()
 });
-var AssertionSchema = z25.object({
+var AssertionSchema = z26.object({
   id: B64U2.max(1366),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
   signature: B64U2.max(1024)
 });
-var ConfirmPurposeSchema = z25.enum(["register", "decide", "launch", "close", "act"]);
+var TeamsDigestSchema = z26.string().regex(/^[0-9a-f]{64}$/);
+var ConfirmPurposeSchema = z26.enum(["register", "decide", "launch", "close", "act", "define", "team", "pc"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
-var PhoneChatProposalSchema = z25.object({
-  project: z25.string().max(80),
+var PhoneChatProposalSchema = z26.object({
+  project: z26.string().max(80),
   tool: ToolSchema,
-  prompt: z25.string().max(TOOL_TEXT_MAX).optional(),
-  launchedId: z25.string().optional(),
-  failed: z25.literal(true).optional()
+  prompt: z26.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z26.string().optional(),
+  failed: z26.literal(true).optional()
 }).strict();
-var PhoneChatRelaySchema = z25.object({
-  id: z25.string().min(1),
-  name: z25.string(),
+var PhoneChatRelaySchema = z26.object({
+  id: z26.string().min(1),
+  name: z26.string(),
   tool: ToolSchema,
-  text: z25.string().max(TOOL_TEXT_MAX),
-  status: z25.enum(["queued", "sent"]).optional(),
-  sentAt: z25.string().datetime().optional(),
-  failed: z25.literal(true).optional()
+  text: z26.string().max(TOOL_TEXT_MAX),
+  status: z26.enum(["queued", "sent"]).optional(),
+  sentAt: z26.string().datetime().optional(),
+  failed: z26.literal(true).optional()
 }).strict();
-var PhoneChatCloseSchema = z25.object({
-  id: z25.string().min(1),
-  name: z25.string(),
+var PhoneChatCloseSchema = z26.object({
+  id: z26.string().min(1),
+  name: z26.string(),
   tool: ToolSchema,
-  how: z25.enum(["exit", "killed"]).optional(),
-  closedAt: z25.string().datetime().optional(),
-  failed: z25.literal(true).optional()
+  how: z26.enum(["exit", "killed"]).optional(),
+  closedAt: z26.string().datetime().optional(),
+  failed: z26.literal(true).optional()
 }).strict();
-var PhoneChatTeamSchema = z25.object({
-  project: z25.string().max(80),
-  name: z25.string().max(60),
-  template: z25.string().max(64).optional(),
-  seats: z25.array(z25.object({ role: z25.string().max(40), label: z25.string().max(40), tool: ToolSchema, model: z25.string().max(200).optional(), effort: z25.string().max(20).optional(), autonomy: AutonomySchema.optional() }).strict()).min(1).max(8),
-  teamId: z25.string().max(40).optional(),
-  launchedAt: z25.string().datetime().optional(),
-  failed: z25.literal(true).optional()
+var PhoneChatTeamSchema = z26.object({
+  project: z26.string().max(80),
+  name: z26.string().max(60),
+  template: z26.string().max(64).optional(),
+  seats: z26.array(z26.object({ role: z26.string().max(40), label: z26.string().max(40), tool: ToolSchema, model: z26.string().max(200).optional(), effort: z26.string().max(20).optional(), autonomy: AutonomySchema.optional() }).strict()).min(1).max(8),
+  teamId: z26.string().max(40).optional(),
+  launchedAt: z26.string().datetime().optional(),
+  failed: z26.literal(true).optional()
 }).strict();
-var PhoneChatTaskSchema = 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()
+var PhoneChatTaskSchema = z26.object({
+  to: z26.string().max(80),
+  toName: z26.string().max(80).optional(),
+  title: z26.string().max(200),
+  text: z26.string().max(TOOL_TEXT_MAX).optional(),
+  taskId: z26.string().max(40).optional(),
+  ownerName: z26.string().max(80).optional(),
+  state: z26.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  failed: z26.literal(true).optional()
 }).strict();
-var PhoneChatActionSchema = z25.object({
-  action: z25.string().min(1).max(40),
-  summary: z25.string().max(300),
+var PhoneChatActionSchema = z26.object({
+  action: z26.string().min(1).max(40),
+  summary: z26.string().max(300),
   vars: ActionVarsSchema.optional(),
-  detail: z25.string().max(TOOL_TEXT_MAX).optional(),
-  detailCut: z25.literal(true).optional(),
+  detail: z26.string().max(TOOL_TEXT_MAX).optional(),
+  detailCut: z26.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z25.string().max(100).optional(),
-  team: z25.string().max(40).optional(),
+  session: z26.string().max(100).optional(),
+  team: z26.string().max(40).optional(),
   state: ChatActionStateSchema.optional(),
-  doneAt: z25.string().datetime().optional(),
-  code: z25.string().max(40).optional()
+  doneAt: z26.string().datetime().optional(),
+  code: z26.string().max(40).optional()
 }).strict();
-var PhoneTeamSchema = z25.object({
-  id: z25.string().max(40),
-  name: z25.string().max(60),
-  project: z25.string().max(80).nullable(),
-  state: z25.enum(["active", "resting"]),
-  seats: z25.array(z25.object({ role: z25.string().max(40), sessionId: z25.string().max(100).nullable() }).strict()).max(16),
-  done: z25.number().int().min(0),
-  given: z25.number().int().min(0)
+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 = z25.object({
-  id: z25.string().max(40),
-  title: z25.string().max(200),
-  owner: z25.string().max(100),
-  ownerName: z25.string().max(80),
-  ownerRole: z25.string().max(40).optional(),
-  team: z25.string().max(40).optional(),
-  teamName: z25.string().max(60).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()
+var PhoneTaskSchema = z26.object({
+  id: z26.string().max(40),
+  title: z26.string().max(200),
+  owner: z26.string().max(100),
+  ownerName: z26.string().max(80),
+  ownerRole: z26.string().max(40).optional(),
+  team: z26.string().max(40).optional(),
+  teamName: z26.string().max(60).optional(),
+  state: z26.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z26.string().max(TOOL_TEXT_MAX).optional(),
+  cut: z26.literal(true).optional(),
+  at: z26.string(),
+  updatedAt: z26.string(),
+  seen: z26.literal(true).optional()
 }).strict();
-var ChatErrorCodeSchema = z25.enum(["busy", "timeout", "cancelled", "failed"]);
-var PhoneChatTurnSchema = z25.object({
+var ChatErrorCodeSchema = z26.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z26.object({
   qid: OperationIdSchema,
-  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(),
+  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(),
   error: ChatErrorCodeSchema.optional(),
-  proposals: z25.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  proposals: z26.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
   relay: PhoneChatRelaySchema.optional(),
-  closes: z25.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
-  cut: z25.literal(true).optional(),
+  closes: z26.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
+  cut: z26.literal(true).optional(),
   team: PhoneChatTeamSchema.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()
+  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()
 }).strict();
 var CHAT_HISTORY_BUDGET = 393216;
-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 PhoneClientMessageSchema = z25.discriminatedUnion("type", [
-  z25.object({ type: z25.literal("snapshot.request") }),
-  z25.object({ type: z25.literal("session.thread"), id: sessionId }),
+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 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 }),
   /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
-  z25.object({ type: z25.literal("session.pending"), id: sessionId }),
+  z26.object({ type: z26.literal("session.pending"), id: sessionId }),
   /** The session whose terminal the phone shows; null when it shows none. */
-  z25.object({ type: z25.literal("session.watch"), id: sessionId.nullable() }),
-  z25.object({ type: z25.literal("session.read"), id: sessionId, at: z25.string().datetime() }),
+  z26.object({ type: z26.literal("session.watch"), id: sessionId.nullable() }),
+  z26.object({ type: z26.literal("session.read"), id: sessionId, at: z26.string().datetime() }),
   /** Asks for a challenge. One object for both purposes: the gateway refuses a `decide` without `id` and `expect`. */
-  z25.object({ type: z25.literal("confirm.prepare"), purpose: ConfirmPurposeSchema, id: sessionId.optional(), expect: PhoneExpectSchema.optional(), qid: OperationIdSchema.optional() }),
-  z25.object({ type: z25.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
-  z25.object({
-    type: z25.literal("session.decide"),
+  z26.object({
+    type: z26.literal("confirm.prepare"),
+    purpose: ConfirmPurposeSchema,
+    id: sessionId.optional(),
+    expect: PhoneExpectSchema.optional(),
+    qid: OperationIdSchema.optional(),
+    /** sha256 of the `define` or `team` operation the challenge is for (`teamsDigest`). */
+    digest: TeamsDigestSchema.optional(),
+    /** A `pc` challenge: what it is for, and for an update the version it covers. */
+    action: PcActionSchema.optional(),
+    version: z26.string().regex(SEMVER).optional()
+  }),
+  z26.object({ type: z26.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z26.object({
+    type: z26.literal("session.decide"),
     op: OperationIdSchema,
     id: sessionId,
     decision: DecisionSchema,
-    note: z25.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z26.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()
   }),
-  z25.object({
-    type: z25.literal("session.reply"),
+  z26.object({
+    type: z26.literal("session.reply"),
     op: OperationIdSchema,
     id: sessionId,
-    text: z25.string().max(MESSAGE_MAX),
-    attachments: z25.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+    text: z26.string().max(MESSAGE_MAX),
+    attachments: z26.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`. */
-  z25.object({
-    type: z25.literal("session.answer"),
+  z26.object({
+    type: z26.literal("session.answer"),
     op: OperationIdSchema,
     id: sessionId,
-    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(),
+    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(),
     expect: PhoneExpectSchema
   }),
-  z25.object({ type: z25.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  z26.object({ type: z26.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
   /** The phone drops its passkey from the daemon. */
-  z25.object({ type: z25.literal("device.forget"), op: OperationIdSchema }),
+  z26.object({ type: z26.literal("device.forget"), op: OperationIdSchema }),
   /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
-  z25.object({ type: z25.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
-  z25.object({ type: z25.literal("push.unsubscribe"), op: OperationIdSchema }),
+  z26.object({ type: z26.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z26.object({ type: z26.literal("push.unsubscribe"), op: OperationIdSchema }),
   /** The phone's own chat with Ledge. */
-  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") }),
+  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") }),
   /** 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: z25.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
+  AttachmentPutSchema.pick({ type: true, requestId: true }).extend({ image: ImageUploadSchema.extend({ data: z26.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
   AttachmentGetSchema.pick({ type: true, requestId: true, attachment: true, preview: true }),
-  z25.object({ type: z25.literal("chat.relay"), 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() }),
+  z26.object({ type: z26.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z26.object({ type: z26.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z26.object({ type: z26.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
   /** The turn's team card (roles spec §3.8): launched like a session card, with the device check (purpose `launch`, the turn). */
-  z25.object({ type: z25.literal("chat.team"), op: OperationIdSchema, qid: OperationIdSchema, assertion: AssertionSchema.optional() }),
+  z26.object({ type: z26.literal("chat.team"), op: OperationIdSchema, qid: OperationIdSchema, assertion: AssertionSchema.optional() }),
   /** A row of the turn's task card: given by Ledge. */
-  z25.object({ type: z25.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z25.number().int().min(0).max(MAX_PROPOSALS - 1) }),
+  z26.object({ type: z26.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z26.number().int().min(0).max(MAX_PROPOSALS - 1) }),
   /** Rows of the turn's generic card (action registry spec §5): `confirmed` as the local `chat.act`; a row whose action asks
    *  for a device check (`phone`) needs one assertion, purpose `act`, over the turn. */
-  z25.object({
-    type: z25.literal("chat.act"),
+  z26.object({
+    type: z26.literal("chat.act"),
     op: OperationIdSchema,
     qid: OperationIdSchema,
     rows: CardRowsSchema.optional(),
-    confirmed: z25.literal(true).optional(),
+    confirmed: z26.literal(true).optional(),
     assertion: AssertionSchema.optional(),
     /** « Refuser », as the local `chat.act`: no passkey, no confirmation. */
-    deny: z25.literal(true).optional()
+    deny: z26.literal(true).optional()
   }),
   /** « Ignorer » the turn's cards, or `undo` (« Revoir »), as the local `chat.ignore`. */
-  z25.object({ type: z25.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z25.literal(true).optional() }),
+  z26.object({ type: z26.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z26.literal(true).optional() }),
   /** « Reprendre » a resting team. */
-  z25.object({ type: z25.literal("team.resume"), op: OperationIdSchema, team: z25.string().min(1).max(40) }),
+  z26.object({ type: z26.literal("team.resume"), op: OperationIdSchema, team: z26.string().min(1).max(40) }),
   /** Puts a closed task Ledge gave away from « À traiter ». */
-  z25.object({ type: z25.literal("task.seen"), op: OperationIdSchema, task: z25.string().min(1).max(40) }),
+  z26.object({ type: z26.literal("task.seen"), op: OperationIdSchema, task: z26.string().min(1).max(40) }),
   /** Whether the phone's app is in front: a device that is visible gets no push. */
-  z25.object({ type: z25.literal("presence"), visible: z25.boolean() })
-]);
-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() }), 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() }),
+  z26.object({ type: z26.literal("presence"), visible: z26.boolean() }),
+  /** The roles, templates and problems of every scope the phone may name; then one role whole, when the catalog cut its prompt. */
+  z26.object({ type: z26.literal("teams.catalog") }),
+  z26.object({ type: z26.literal("teams.role"), ...teamsScope, id: RoleIdSchema }).strict(),
+  /** `base` is the hash the phone was shown, null to create. */
+  z26.object({ type: z26.literal("role.write"), ...teamsOp, ...teamsScope, role: PhoneRoleDraftSchema, base: DefinitionHashSchema.nullable() }).strict(),
+  z26.object({ type: z26.literal("role.delete"), ...teamsOp, ...teamsScope, id: RoleIdSchema, base: DefinitionHashSchema }).strict(),
+  /** No `id`: create, the id comes from the name. */
+  z26.object({ type: z26.literal("template.write"), ...teamsOp, ...teamsScope, id: TemplateIdSchema.optional(), name: TeamNameSchema, seats: PhoneSeatsSchema, base: DefinitionHashSchema.nullable() }).strict(),
+  z26.object({ type: z26.literal("template.delete"), ...teamsOp, ...teamsScope, id: TemplateIdSchema, base: DefinitionHashSchema }).strict(),
+  z26.object({ type: z26.literal("team.launch"), ...teamsOp, project: z26.string().min(1).max(80), name: TeamNameSchema, seats: PhoneSeatsSchema, template: z26.string().min(1).max(64).optional() }).strict(),
+  z26.object({ type: z26.literal("team.compose"), ...teamsOp, team: TeamIdSchema, seats: PhoneSeatsSchema }).strict(),
+  z26.object({ type: z26.literal("team.seat"), ...teamsOp, team: TeamIdSchema, role: RoleIdSchema, action: z26.enum(["start", "restart"]) }).strict(),
+  z26.object({ type: z26.literal("team.dissolve"), ...teamsOp, team: TeamIdSchema }).strict(),
+  /** Installs `version` on the PC, then restarts its daemon; the phone asks for its own build's version. Passkey, purpose `pc`. */
+  z26.object({ type: z26.literal("daemon.update"), ...teamsOp, version: z26.string().regex(SEMVER) }).strict(),
+  /** 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 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(),
+    /** `update`: the daemon can install a version and restart (npm, systemd); `restart`: it can restart (systemd). */
+    update: z26.literal(true).optional(),
+    restart: z26.literal(true).optional()
+  }), device: z26.object({ confirm: z26.boolean(), push: z26.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z26.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+  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() }),
   /** `pending.cut` is set when even this body was shortened. */
-  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()) }),
+  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()) }),
   /** `cut`: the ids of the items shortened; `more`: older items were left out. */
-  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() }),
-  z25.object({ type: z25.literal("chat.history"), turns: z25.array(PhoneChatTurnSchema).max(50) }),
-  z25.object({ type: z25.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
+  z26.object({ type: z26.literal("session.thread"), id: z26.string(), items: z26.array(ThreadItemSchema), cut: z26.array(z26.string()), more: z26.boolean() }),
+  z26.object({ type: z26.literal("session.thread.item"), id: z26.string(), item: ThreadItemSchema, cut: z26.literal(true).optional() }),
+  z26.object({ type: z26.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
+  z26.object({ type: z26.literal("chat.history"), turns: z26.array(PhoneChatTurnSchema).max(50) }),
+  z26.object({ type: z26.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
   /** The whole text so far, not an increment. */
-  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 }),
+  z26.object({ type: z26.literal("chat.delta"), qid: OperationIdSchema, text: z26.string().max(THREAD_TEXT_MAX) }),
+  z26.object({ type: z26.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
+  z26.object({ type: z26.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
+  z26.object({ type: z26.literal("teams.catalog"), catalog: PhoneCatalogSchema }),
+  /** The daemon updating or restarting itself, whoever asked: npm runs, then the service restarts (the link drops right after). */
+  z26.object({ type: z26.literal("daemon.progress"), version: z26.string().max(40), step: z26.enum(["installing", "restarting"]) }),
+  /** Nothing was changed. Never npm's output nor a command: both hold the PC's paths. */
+  z26.object({ type: z26.literal("daemon.failed"), version: z26.string().max(40), reason: UpdateFailureSchema }),
+  z26.object({ type: z26.literal("teams.role"), role: PhoneRoleSchema }),
   /** The live teams, after each snapshot and on every change. */
-  z25.object({ type: z25.literal("teams"), teams: z25.array(PhoneTeamSchema).max(50) }),
+  z26.object({ type: z26.literal("teams"), teams: z26.array(PhoneTeamSchema).max(50) }),
   /** The tasks Ledge gave, open or closed lately, after each snapshot; then each change. */
-  z25.object({ type: z25.literal("tasks"), tasks: z25.array(PhoneTaskSchema).max(200) }),
-  z25.object({ type: z25.literal("task.updated"), task: PhoneTaskSchema }),
+  z26.object({ type: z26.literal("tasks"), tasks: z26.array(PhoneTaskSchema).max(200) }),
+  z26.object({ type: z26.literal("task.updated"), task: PhoneTaskSchema }),
   AttachmentStoredSchema,
   AttachmentDataSchema,
   AttachmentErrorSchema,
   /** Never carries free text. */
-  z25.object({ type: z25.literal("error"), code: z25.enum(["invalid", "unknown_session", "too_large"]), request: z25.string().max(40).optional() })
+  z26.object({ type: z26.literal("error"), code: z26.enum(["invalid", "unknown_session", "too_large"]), request: z26.string().max(40).optional() })
 ]);
+var teamsPurpose = (type) => type.startsWith("team.") ? "team" : "define";
+var DIGEST_OP = "00000000-0000-4000-8000-000000000000";
+async function teamsDigest(m) {
+  const { op: _op, assertion: _assertion, ...raw } = m;
+  const { op: _parsedOp, assertion: _parsedAssertion, ...rest } = PhoneClientMessageSchema.parse({ ...raw, op: DIGEST_OP });
+  const bytes = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonicalJson(rest))));
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
 
 // src/auth.ts
 import { createHash, createHmac, randomBytes, timingSafeEqual } from "crypto";
@@ -2218,12 +2406,19 @@ export {
   parseTeamBlock,
   parseTaskBlock,
   parseProjectBlock,
+  SshAliasSchema,
+  MachinesSchema,
+  PROJECT_COLORS,
+  ProjectsSchema,
+  DEFAULT_PROJECTS,
+  projectOf,
   RoleIdSchema,
   ROLE_LABEL_MAX,
   ROLE_PROMPT_MAX,
   RoleSchema,
   SeatsSchema,
   TeamNameSchema,
+  TemplateIdSchema,
   TeamSchema,
   isTeamLive,
   NOTE_MAX,
@@ -2248,19 +2443,14 @@ export {
   ChatTurnSchema,
   proposalRows,
   DOCUMENT_MAX_BYTES,
-  SshAliasSchema,
-  MachinesSchema,
   IslandPrefsSchema,
-  PROJECT_COLORS,
-  ProjectsSchema,
-  DEFAULT_PROJECTS,
-  projectOf,
   RouteResultSchema,
   DEFAULT_RELAY_URL,
   MobileConfigSchema,
   PROTOCOL_PORT,
   RefusalCodeSchema,
   RecentSchema,
+  SEMVER,
   MESSAGE_MAX,
   SUMMARY_MAX,
   parseClientMessage,
@@ -2279,6 +2469,11 @@ export {
   pushEndpointAllowed,
   PushSendResultSchema,
   PushPayloadSchema,
+  PhoneRoleSchema,
+  PhoneTemplateSchema,
+  TEAMS_OPERATION_TYPES,
+  isTeamsOperation,
+  canonicalJson,
   PHONE_PROTOCOL,
   padPlain,
   THREAD_ITEMS_MAX,
@@ -2290,7 +2485,10 @@ export {
   OperationIdSchema,
   UNTYPABLE,
   CHAT_HISTORY_BUDGET,
+  pcSubject,
   PhoneClientMessageSchema,
+  teamsPurpose,
+  teamsDigest,
   tokenEquals,
   hostAllowed,
   requestAuthorized,