@runeya/runeya 2.0.124 → 2.0.126

package/mcp-server/index.js

@@ -3,9 +3,1214 @@
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z24 } from "zod";
+
+// ../ai-capabilities/dist/index.js
+import { z as z22 } from "zod";
+
+// ../shared/dist/index.js
 import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import { z as z7 } from "zod";
+import { z as z5 } from "zod";
+import { z as z4 } from "zod";
+import { z as z6 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
+import { z as z10 } from "zod";
+import { z as z11 } from "zod";
+import { z as z12 } from "zod";
+import { z as z13 } from "zod";
+import { z as z14 } from "zod";
+import { z as z15 } from "zod";
+import { z as z16 } from "zod";
+import { z as z17 } from "zod";
+import { z as z18 } from "zod";
+import { z as z19 } from "zod";
+import { z as z20 } from "zod";
+import { z as z21 } from "zod";
+import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
+import vm from "vm";
+import * as Y from "yjs";
+var UserSchema = z.object({
+  id: z.string().max(128),
+  email: z.string().email().max(320),
+  name: z.string().min(1).max(500),
+  avatar: z.string().url().max(2048).nullable().optional()
+});
+var OrgSchema = z2.object({
+  id: z2.string().max(128),
+  name: z2.string().min(1).max(100),
+  slug: z2.string().min(1).max(100).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/),
+  ownerId: z2.string().max(128)
+});
+var OrgMemberSchema = z2.object({
+  id: z2.string().max(128),
+  orgId: z2.string().max(128),
+  userId: z2.string().max(128),
+  globalRole: z2.enum(["owner", "admin", "member"]),
+  invitedAt: z2.coerce.date(),
+  joinedAt: z2.coerce.date().nullable().optional()
+});
+var ProjectSchema = z3.object({
+  id: z3.string().max(128),
+  orgId: z3.string().max(128).nullable().optional(),
+  name: z3.string().min(1).max(200),
+  description: z3.string().max(1e4).optional().default(""),
+  serviceIds: z3.array(z3.string().max(128)).max(1e4).default([]),
+  // Environment support
+  // NOTE: activeEnvironmentId is runtime-only (not persisted to JSON)
+  // It's initialized to 'local' by default at load time
+  activeEnvironmentId: z3.string().max(128).optional(),
+  environmentIds: z3.array(z3.string().max(128)).max(100).default([]),
+  // Ordre d'affichage des groupes de services dans la sidebar (noms de groupes).
+  // Les groupes absents de cette liste sont affichés après, par ordre alphabétique.
+  groupOrder: z3.array(z3.string().max(200)).max(100).default([])
+});
+var CreateProjectSchema = ProjectSchema.omit({ id: true }).partial().required({ name: true });
+var UpdateProjectSchema = ProjectSchema.partial().required({ id: true });
+var PositionSchema = z4.object({
+  x: z4.number(),
+  y: z4.number()
+});
+var ScenarioGroupSchema = z4.object({
+  id: z4.string().min(1).max(128),
+  name: z4.string().min(1).max(200),
+  description: z4.string().max(1e3).optional(),
+  color: z4.string().max(32).optional(),
+  position: PositionSchema.default({ x: 0, y: 0 }),
+  width: z4.number().default(300),
+  height: z4.number().default(200)
+});
+var ScenarioPresetRoleSchema = z4.object({
+  id: z4.string().min(1).max(64),
+  name: z4.string().min(1).max(200),
+  systemPrompt: z4.string().max(1e4).default(""),
+  prompt: z4.string().max(1e4).default("")
+});
+var ScenarioPresetInitialDataSchema = z4.object({
+  leaderId: z4.string().min(1).max(128),
+  groups: z4.array(z4.object({
+    id: z4.string().min(1).max(128),
+    name: z4.string().min(1).max(200),
+    description: z4.string().max(1e3).optional(),
+    color: z4.string().max(32).optional(),
+    position: z4.object({ x: z4.number(), y: z4.number() }).default({ x: 0, y: 0 }),
+    width: z4.number().default(300),
+    height: z4.number().default(200)
+  })).max(100).default([]),
+  nodes: z4.array(z4.object({
+    id: z4.string().min(1).max(128),
+    type: z4.enum(["ai", "ask"]).default("ai"),
+    parentIds: z4.array(z4.string().max(128)).default([]),
+    groupId: z4.string().max(128).nullable().default(null),
+    label: z4.string().max(240).default(""),
+    role: z4.string().max(64).default("other"),
+    prompt: z4.string().max(5e4).default(""),
+    question: z4.string().max(2e3).default(""),
+    autoGenerated: z4.boolean().default(true),
+    canAddNode: z4.boolean().default(false),
+    aiCli: z4.enum(["claude-code", "codex"]).default("claude-code"),
+    model: z4.string().max(128).default("sonnet"),
+    position: z4.object({ x: z4.number(), y: z4.number() }).default({ x: 0, y: 0 })
+  })).min(1).max(500)
+});
+var LocalizedStringSchema = z4.record(z4.string(), z4.string().max(100));
+var ScenarioPresetLabelsSchema = z4.object({
+  group: LocalizedStringSchema.optional(),
+  node: LocalizedStringSchema.optional(),
+  role: LocalizedStringSchema.optional(),
+  leader: LocalizedStringSchema.optional()
+});
+var ScenarioPresetSchema = z4.object({
+  id: z4.string().min(1).max(128),
+  name: z4.string().min(1).max(200),
+  icon: z4.string().max(64).optional(),
+  defaultTraversalMode: z4.enum(["hierarchical", "topological"]).optional(),
+  canChangeTraversalMode: z4.boolean().default(true),
+  roles: z4.array(ScenarioPresetRoleSchema).min(1).max(100),
+  initialData: ScenarioPresetInitialDataSchema.optional(),
+  labels: ScenarioPresetLabelsSchema.optional()
+});
+var ScenarioNodeSchema = z4.object({
+  id: z4.string().min(1).max(128),
+  type: z4.enum(["ai", "ask"]).default("ai"),
+  parentIds: z4.array(z4.string().max(128)).default([]),
+  groupId: z4.string().max(128).nullable().default(null),
+  label: z4.string().max(240).default(""),
+  role: z4.string().max(64).default("other"),
+  prompt: z4.string().max(5e4).default(""),
+  question: z4.string().max(2e3).default(""),
+  autoGenerated: z4.boolean().default(true),
+  canAddNode: z4.boolean().default(false),
+  aiCli: z4.enum(["claude-code", "codex"]).default("claude-code"),
+  model: z4.string().max(128).default("sonnet"),
+  position: PositionSchema.default({ x: 0, y: 0 }),
+  injectParentOutputs: z4.boolean().default(false),
+  injectedAncestorIds: z4.array(z4.string().max(128)).default([])
+});
+var ScenarioSchema = z4.object({
+  id: z4.string().min(1).max(128),
+  name: z4.string().min(1).max(200),
+  icon: z4.string().max(64).optional(),
+  description: z4.string().max(2e3).optional(),
+  leaderId: z4.string().min(1).max(128),
+  groups: z4.array(ScenarioGroupSchema).max(100).default([]),
+  nodes: z4.array(ScenarioNodeSchema).min(1).max(500),
+  traversalMode: z4.enum(["hierarchical", "topological"]).default("hierarchical"),
+  presetId: z4.string().max(128).optional(),
+  isPublished: z4.boolean().default(false),
+  createdAt: z4.number(),
+  updatedAt: z4.number()
+});
+var AI_PROVIDERS = ["anthropic", "openai", "mistral", "groq", "ollama"];
+var AIProviderSchema = z5.object({
+  id: z5.string().min(1).max(128),
+  name: z5.string().min(1).max(200),
+  provider: z5.enum(AI_PROVIDERS),
+  encryptedApiKey: z5.string().max(2e3).default(""),
+  model: z5.string().max(200).optional(),
+  active: z5.boolean().default(false),
+  createdAt: z5.coerce.date(),
+  updatedAt: z5.coerce.date()
+});
+var JSLogParserSchema = z5.object({
+  id: z5.string().min(1).max(128),
+  name: z5.string().min(1).max(200),
+  description: z5.string().max(2e3).optional(),
+  code: z5.string().min(1).max(5e4).refine(
+    (s) => !s.includes("require(") && !s.includes("import ") && !s.includes("eval("),
+    { message: "Code must not contain require, import, or eval patterns" }
+  ),
+  enabled: z5.boolean().default(true),
+  builtin: z5.boolean().optional(),
+  createdAt: z5.coerce.date(),
+  updatedAt: z5.coerce.date()
+});
+var NotificationPreferencesSchema = z5.object({
+  scenario_waiting_input: z5.boolean().default(true),
+  ai_conversation_complete: z5.boolean().default(true),
+  ai_conversation_error: z5.boolean().default(true),
+  service_error_log: z5.boolean().default(true),
+  service_status_changed: z5.boolean().default(true),
+  service_health_changed: z5.boolean().default(true),
+  /** Service IDs excluded from error-log notifications */
+  service_error_log_excluded: z5.array(z5.string().max(100)).max(500).default([]),
+  /** Service IDs excluded from status-change notifications */
+  service_status_changed_excluded: z5.array(z5.string().max(100)).max(500).default([]),
+  /** Service IDs excluded from health-change notifications */
+  service_health_changed_excluded: z5.array(z5.string().max(100)).max(500).default([])
+});
+var CompanionSettingsSchema = z5.object({
+  /** Activer le compagnon d'office sur les conversations créées ensuite. */
+  enabledByDefault: z5.boolean().default(false),
+  /**
+   * Spécificités ajoutées aux consignes Runeya.
+   *
+   * Vide — l'absence — signifie « aucune spécificité ». On ne recopie pas le
+   * texte par défaut dans le réglage : les consignes Runeya restent dans le
+   * code, pour profiter de leurs corrections.
+   *
+   * Rejeté au-delà de la borne plutôt que tronqué (§1) : un prompt coupé en
+   * plein milieu produirait des relectures incohérentes sans rien signaler.
+   */
+  prompt: z5.string().max(2e4).optional()
+});
+var SettingsSchema = z5.object({
+  mode: z5.enum(["local-simple", "cloud"]),
+  cloudUrl: z5.string().url().max(2048).nullable().optional(),
+  logParsers: z5.array(JSLogParserSchema).max(100).default([]),
+  scenarios: z5.array(ScenarioSchema).max(100).default([]),
+  /** Absolute path to the folder where the global wiki/docs markdown files live. Optional. */
+  globalDocsPath: z5.string().max(4096).optional(),
+  /**
+   * Optionnel plutôt que défauté : un réglage absent est un réglage jamais
+   * touché, et le rendre obligatoire dans le type forcerait chaque appelant qui
+   * construit un objet de réglages à inventer une valeur.
+   */
+  companion: CompanionSettingsSchema.optional()
+});
+var TraefikConfigSchema = z5.object({
+  enabled: z5.boolean().default(false),
+  acmeEmail: z5.string().email().max(256).optional(),
+  wildcardDomain: z5.string().max(253).optional(),
+  httpPort: z5.number().int().min(1).max(65535).default(80),
+  httpsPort: z5.number().int().min(1).max(65535).default(443),
+  dnsProvider: z5.string().max(64).optional(),
+  dnsCredentials: z5.record(z5.string().max(64), z5.string().max(2048)).default({}),
+  acmeStaging: z5.boolean().default(false),
+  encryptedCert: z5.string().max(65536).optional(),
+  encryptedCertKey: z5.string().max(65536).optional()
+});
+var SettingsPrivateSchema = z5.object({
+  aiProviders: z5.array(AIProviderSchema).max(50).default([]),
+  scenarios: z5.array(ScenarioSchema).max(100).default([]),
+  notifications: NotificationPreferencesSchema.default(() => ({
+    scenario_waiting_input: true,
+    ai_conversation_complete: true,
+    ai_conversation_error: true,
+    service_error_log: true,
+    service_status_changed: true,
+    service_health_changed: true,
+    service_error_log_excluded: [],
+    service_status_changed_excluded: [],
+    service_health_changed_excluded: []
+  })),
+  traefikConfig: TraefikConfigSchema.optional()
+});
+var SchemaVersionSchema = z5.object({
+  version: z5.number().int().positive(),
+  migratedAt: z5.coerce.date()
+});
+var safePath = z6.string().min(1).max(4096).refine(
+  (p) => !p.includes("\0"),
+  { message: "path must not contain null bytes" }
+).refine(
+  (p) => !/(^|[/\\])\.\.([/\\]|$)/.test(p),
+  { message: "path must not contain path-traversal sequences (..)" }
+);
+var ConsoleLogSourceSchema = z6.object({
+  type: z6.literal("console")
+});
+var FileLogSourceSchema = z6.object({
+  type: z6.literal("file"),
+  path: safePath,
+  encoding: z6.string().max(32).default("utf-8"),
+  startFromEnd: z6.boolean().default(true),
+  createIfNotExists: z6.boolean().default(false)
+});
+var MongoLogSourceSchema = z6.object({
+  type: z6.literal("mongo"),
+  /** @sensitive — stored encrypted (AES-256-GCM) on disk */
+  connectionString: z6.string().min(1).max(2048),
+  database: z6.string().min(1).max(256),
+  collection: z6.string().min(1).max(256),
+  filter: z6.record(z6.string(), z6.unknown()).optional(),
+  timestampField: z6.string().max(128).default("timestamp"),
+  messageField: z6.string().max(128).default("message"),
+  levelField: z6.string().max(128).optional()
+});
+var MySQLLogSourceSchema = z6.object({
+  type: z6.literal("mysql"),
+  host: z6.string().min(1).max(253),
+  port: z6.number().int().min(1).max(65535).default(3306),
+  user: z6.string().min(1).max(256),
+  /** @sensitive — stored encrypted (AES-256-GCM) on disk */
+  password: z6.string().max(2048),
+  database: z6.string().min(1).max(256),
+  table: z6.string().min(1).max(256),
+  query: z6.string().max(8192).optional(),
+  timestampColumn: z6.string().max(128).default("created_at"),
+  messageColumn: z6.string().max(128).default("message"),
+  levelColumn: z6.string().max(128).optional(),
+  pollIntervalMs: z6.number().int().min(500).max(6e4).default(2e3)
+});
+var LogSourceConfigSchema = z6.discriminatedUnion("type", [
+  ConsoleLogSourceSchema,
+  FileLogSourceSchema,
+  MongoLogSourceSchema,
+  MySQLLogSourceSchema
+]);
+var HealthCheckSchema = z7.object({
+  type: z7.enum(["http", "command"]).default("http"),
+  // HTTP-specific (required when type=http)
+  path: z7.string().min(1).max(500).startsWith("/").optional(),
+  method: z7.enum(["GET", "HEAD", "POST", "PUT"]).optional().default("GET"),
+  expectedStatus: z7.number().int().min(100).max(599).optional().default(200),
+  // Command-specific (required when type=command)
+  command: z7.string().min(1).max(4096).optional(),
+  // Shared
+  interval: z7.number().int().positive().default(1e3),
+  timeout: z7.number().int().positive().default(1e3),
+  retries: z7.number().int().nonnegative().default(3),
+  initialDelay: z7.number().int().nonnegative().optional().default(0)
+}).refine(
+  (data) => data.type === "http" ? !!data.path : !!data.command,
+  { message: "HTTP type requires path; command type requires command" }
+);
+var BootstrapCommandSchema = z7.object({
+  id: z7.string().min(1).max(64),
+  label: z7.string().max(200).default(""),
+  entrypoint: z7.string().max(4096).optional(),
+  command: z7.string().max(4096).default(""),
+  user: z7.string().max(256).optional()
+});
+var DockerConfigSchema = z7.object({
+  // Image mode (pull from registry) — mutually exclusive with build mode in UI
+  image: z7.string().min(1).max(1024).optional(),
+  // Build mode — Dockerfile stored inline in services.json
+  dockerfile: z7.string().max(65536).optional(),
+  buildContext: z7.string().max(4096).optional(),
+  buildArgs: z7.record(z7.string().max(256), z7.string().max(4096)).default({}).refine(
+    (obj) => Object.keys(obj).length <= 50,
+    { message: "Max 50 build args" }
+  ),
+  targetStage: z7.string().max(256).optional(),
+  // Runtime config
+  networkMode: z7.enum(["host", "bridge"]).default("host"),
+  ports: z7.array(z7.string().max(64)).max(100).default([]),
+  volumes: z7.array(z7.string().max(1024)).max(100).default([]),
+  mountRootpath: z7.boolean().default(false),
+  entrypoint: z7.string().max(4096).optional(),
+  command: z7.string().max(4096).optional(),
+  user: z7.string().max(256).optional(),
+  useNativeCommand: z7.boolean().default(false),
+  nativeCommandMode: z7.enum(["shared", "isolated"]).default("isolated"),
+  nativeShell: z7.string().max(256).default("sh"),
+  bootstrapCommands: z7.array(BootstrapCommandSchema).max(20).default([])
+});
+var RestartStrategySchema = z7.enum(["none", "on-failure", "always", "unless-stopped"]).default("none");
+var ServiceShortcutSchema = z7.object({
+  id: z7.string().min(1).max(64),
+  label: z7.string().max(200).default(""),
+  command: z7.string().max(4096).default(""),
+  cwd: z7.string().max(4096).optional()
+});
+var ServiceCommandSchema = z7.object({
+  id: z7.string().min(1).max(64),
+  label: z7.string().max(200).default(""),
+  command: z7.string().max(4096).default(""),
+  cwd: z7.string().max(4096).optional(),
+  shell: z7.boolean().optional().default(true)
+});
+var VariableSlotSchema = z7.object({
+  value: z7.string().max(8192).default(""),
+  pre: z7.string().max(8192).default(""),
+  post: z7.string().max(8192).default(""),
+  isSecret: z7.boolean().default(false),
+  // Deux décisions distinctes, et il ne faut pas les confondre :
+  //
+  // - `shareWithAi` est une permission de **lecture** : une IA (le chat de
+  //   Runeya, un agent par le serveur MCP) peut voir la valeur de ce secret.
+  //   Une variable publique est lisible de toute façon, le drapeau ne la
+  //   concerne pas.
+  // - `injectIntoAi` est une **exécution** : la variable est posée dans
+  //   l'environnement du process des agents (Claude Code, Codex, …) lancés
+  //   depuis Runeya pendant que cet environnement est actif.
+  //
+  // Les deux sont opt-in : sans rien cocher, aucun secret ne part vers une IA.
+  // Injecter implique lire (ce que le process reçoit, l'agent le voit), donc
+  // la lecture accepte l'un OU l'autre : voir `isSharedWithAi`, qui est le seul
+  // endroit où cette règle s'écrit.
+  shareWithAi: z7.boolean().default(false),
+  injectIntoAi: z7.boolean().default(false),
+  // Une variable obligatoire doit avoir une valeur finale non vide avant qu'un
+  // service de cet environnement puisse démarrer. Le démarrage est refusé
+  // sinon, avec la liste des manquantes — l'assistant est le moyen de remplir.
+  required: z7.boolean().default(false),
+  // Une variable « seulement surchargeable » n'a jamais de valeur partagée :
+  // `value` reste vide dans le document synchronisé, et chaque poste DOIT
+  // fournir sa propre surcharge machine-locale (chemin local, jeton personnel).
+  // `pre` et `post` restent partagés — ils décrivent la forme, pas le secret.
+  overrideOnly: z7.boolean().default(false),
+  // À quoi sert cette variable, pour quelqu'un qui doit la remplir. Affichée
+  // par l'assistant de complétion et dans l'éditeur.
+  //
+  // Du **markdown**, pas du texte brut : une description gagne à pouvoir
+  // pointer vers la console qui délivre le jeton. Écrite et relue par le même
+  // éditeur Tiptap (`packages/editor-ui`), jamais injectée en HTML — Tiptap
+  // analyse le markdown dans son propre schéma, si bien qu'une description
+  // arrivée d'un autre poste par la synchronisation ne peut rien exécuter.
+  description: z7.string().max(2e3).default("")
+}).refine(
+  (slot) => !slot.overrideOnly || slot.value === "",
+  { message: "An override-only variable cannot carry a shared value", path: ["value"] }
+);
+var MissingVariableReasonSchema = z7.enum(["required", "overrideOnly"]);
+var MissingVariableSchema = z7.object({
+  variableId: z7.string().max(128),
+  key: z7.string().max(256),
+  description: z7.string().max(2e3),
+  reason: MissingVariableReasonSchema,
+  isSecret: z7.boolean(),
+  environmentId: z7.string().max(128),
+  environmentName: z7.string().max(200)
+});
+var VariableSchema = z7.object({
+  key: z7.string().min(1).max(256),
+  value: VariableSlotSchema
+});
+var VariablesRecordSchema = z7.record(
+  z7.string().max(128),
+  VariableSchema
+).refine(
+  (obj) => Object.keys(obj).length <= 200,
+  { message: "Max 200 variables" }
+);
+var VariableSlotsRecordSchema = z7.record(
+  z7.string().max(256),
+  VariableSlotSchema
+).refine(
+  (obj) => Object.keys(obj).length <= 200,
+  { message: "Max 200 variable slots" }
+);
+var ServiceConfigSchema = z7.object({
+  id: z7.string().max(128),
+  orgId: z7.string().max(128).nullable().optional(),
+  agentId: z7.string().max(128).optional(),
+  // Optional: if absent, inherited from active environment's agentId
+  name: z7.string().min(1).max(200),
+  commands: z7.array(ServiceCommandSchema).max(50).optional().default([]),
+  cwd: z7.string().max(4096).optional(),
+  ports: z7.array(z7.number().int().positive().max(65535)).max(20).optional().default([]),
+  // Metadata fields (migration from old Runeya)
+  groups: z7.array(z7.string().max(200)).max(20).optional().default([]),
+  description: z7.string().max(2e3).optional(),
+  /** Path (relative to service.cwd or absolute) where the service's docs/wiki markdown files live. Optional — defaults to service.cwd. */
+  docsPath: z7.string().max(4096).optional(),
+  url: z7.string().max(2048).optional(),
+  localUrls: z7.array(z7.object({
+    url: z7.string().max(253).regex(/^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/),
+    port: z7.number().int().min(1).max(65535)
+  })).max(20).optional().default([]),
+  openapiUrl: z7.string().max(2048).optional(),
+  git: z7.object({
+    remote: z7.string().max(2048).optional(),
+    home: z7.string().max(2048).optional()
+  }).optional(),
+  meta: z7.record(z7.string().max(256), z7.string().max(2e3)).optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
+  // Transient env dict (resolved by server before deployment, used directly by agent runner — NOT persisted)
+  env: z7.record(z7.string().max(256), z7.string().max(8192)).default({}).refine(
+    (obj) => Object.keys(obj).length <= 200,
+    { message: "Too many env vars (max 200)" }
+  ),
+  envSecrets: z7.array(z7.string().max(256)).max(200).default([]),
+  // Transient: resolved JS log parsers (from parserIds, resolved by server before deployment — NOT persisted)
+  resolvedLogParsers: z7.array(JSLogParserSchema).default([]).optional(),
+  // Transient: resolved working directory (cwd with env vars expanded — NOT persisted)
+  resolvedCwd: z7.string().optional(),
+  runner: z7.enum(["native", "docker"]).optional().default("native"),
+  dockerConfig: DockerConfigSchema.optional(),
+  healthCheck: HealthCheckSchema.optional(),
+  parserIds: z7.array(z7.string().max(128)).max(50).default([]),
+  shortcuts: z7.array(ServiceShortcutSchema).max(50).optional().default([]),
+  autoRestart: z7.boolean().optional().default(false),
+  clearLogsOnStart: z7.boolean().optional().default(false),
+  restartStrategy: RestartStrategySchema.optional(),
+  maxRestarts: z7.number().int().nonnegative().optional(),
+  restartBackoffMs: z7.number().int().positive().optional().default(1e3),
+  // Log sources additionnelles (au-delà du stdout/stderr console par défaut)
+  logSources: z7.array(LogSourceConfigSchema).max(20).optional().default([])
+});
+var CreateServiceSchema = ServiceConfigSchema.omit({ id: true }).partial().required({ name: true });
+var UpdateServiceSchema = ServiceConfigSchema.partial().required({ id: true }).extend({
+  agentId: z7.string().max(128).nullable().optional(),
+  // null = clear (inherit from env), undefined = no change
+  cwd: z7.string().max(4096).nullable().optional(),
+  git: z7.object({ remote: z7.string().max(2048).optional(), home: z7.string().max(2048).optional() }).nullable().optional(),
+  meta: z7.record(z7.string().max(256), z7.string().max(2e3)).nullable().optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
+  healthCheck: HealthCheckSchema.nullable().optional()
+});
+var ProcessStateSchema = z8.enum(["starting", "running", "stopped", "errored"]);
+var HealthStatusSchema = z8.enum(["healthy", "unhealthy", "unknown"]);
+var ProcessStatusSchema = z8.object({
+  id: z8.string().max(128),
+  serviceId: z8.string().max(128),
+  agentId: z8.string().max(128),
+  state: ProcessStateSchema,
+  pid: z8.number().int().nullable().optional(),
+  pids: z8.array(z8.number().int()).optional().default([]),
+  exitCode: z8.number().int().nullable().optional(),
+  startedAt: z8.coerce.date().nullable().optional(),
+  restartCount: z8.number().int().nonnegative().default(0),
+  uptime: z8.number().nonnegative().default(0),
+  healthStatus: HealthStatusSchema.default("unknown"),
+  /**
+   * Le répertoire où le processus s'exécute VRAIMENT, absolutisé par l'agent.
+   *
+   * Rapporté par l'agent plutôt que déduit de la config : entre le `cwd` de la
+   * commande, celui du service, l'ancrage sur le projet et les variables que
+   * l'agent étend lui-même, la valeur affichée n'aurait rien prouvé. Ce qui
+   * intéresse quand un service tourne contre le mauvais dépôt, c'est le chemin
+   * final — y compris quand il retombe sur le répertoire de l'agent.
+   */
+  cwd: z8.string().max(4096).nullable().optional()
+});
+var LogLevelSchema = z9.enum(["debug", "info", "warn", "error", "fatal"]);
+var LogLineSchema = z9.object({
+  /** Raw log line as received from the process (immutable context) */
+  raw: z9.string(),
+  /** Source stream (immutable context) */
+  stream: z9.enum(["stdout", "stderr"]),
+  /** Severity level */
+  level: LogLevelSchema,
+  /** Parsed/enriched message to display */
+  message: z9.string(),
+  /** When true, the line is hidden from the log view */
+  hidden: z9.boolean(),
+  /** Arbitrary key/value pairs shown in the detail panel */
+  metadata: z9.record(z9.string().max(256), z9.unknown()).refine(
+    (obj) => Object.keys(obj).length <= 100,
+    { message: "Too many metadata keys (max 100)" }
+  ),
+  /** Full parsed JSON object when the line is JSON */
+  json: z9.record(z9.string(), z9.unknown()).optional(),
+  /** Custom header for the JSON log card (supports HTML, sanitized before display) */
+  jsonHeader: z9.string().max(256).optional()
+});
+var LogCardDirectiveSchema = z9.object({
+  id: z9.string().max(128),
+  type: z9.string().max(64),
+  header: z9.string().max(256),
+  collapsable: z9.boolean().optional(),
+  collapsed: z9.boolean().optional(),
+  state: z9.enum(["open", "append", "close", "self"])
+});
+var ParsedLogSchema = z9.object({
+  id: z9.string().max(128),
+  processId: z9.string().max(128),
+  pid: z9.number().int().nullable().optional(),
+  timestamp: z9.coerce.date(),
+  level: LogLevelSchema.default("info"),
+  message: z9.string().max(16384),
+  raw: z9.string().max(16384),
+  stream: z9.enum(["stdout", "stderr"]).default("stdout"),
+  hidden: z9.boolean().optional().default(false),
+  metadata: z9.record(z9.string().max(256), z9.unknown()).optional().refine(
+    (obj) => !obj || Object.keys(obj).length <= 100,
+    { message: "Too many metadata keys (max 100)" }
+  ),
+  json: z9.record(z9.string(), z9.unknown()).optional(),
+  logCard: LogCardDirectiveSchema.optional(),
+  sourceType: z9.enum(["console", "file", "mongo", "mysql"]).optional(),
+  sourcePath: z9.string().max(4096).optional()
+});
+var ENV_VAR_NAME_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var AgentConfigSchema = z10.object({
+  id: z10.string().max(128),
+  name: z10.string().min(1).max(100),
+  url: z10.string().url().max(2048),
+  passphrase: z10.string().min(1).max(1024),
+  passthroughEnv: z10.array(
+    z10.string().regex(ENV_VAR_NAME_REGEX).max(256)
+  ).max(100).default([])
+});
+var AgentStatusSchema = z10.object({
+  connected: z10.boolean(),
+  lastSeen: z10.string().nullable().optional(),
+  uptime: z10.number().nonnegative().default(0),
+  runnersAvailable: z10.array(z10.enum(["native", "docker"])).default(["native"]),
+  lanIp: z10.string().optional(),
+  /**
+   * Ce que la machine de l'agent vaut pour les builtins de portée `agent`.
+   * Sert à PRÉVISUALISER — la valeur injectée reste calculée au lancement, par
+   * l'agent lui-même : une IP change, un agent se déconnecte, et un statut
+   * n'est qu'un cliché.
+   */
+  os: z10.string().max(64).optional(),
+  home: z10.string().max(4096).optional(),
+  cwd: z10.string().max(4096).optional()
+});
+var GlobalRoleSchema = z11.enum(["owner", "admin", "member"]);
+var ProjectRoleSchema = z11.enum(["admin", "editor", "viewer"]);
+var ProjectMemberRoleSchema = z11.object({
+  id: z11.string().max(128),
+  projectId: z11.string().max(128),
+  userId: z11.string().max(128),
+  role: ProjectRoleSchema
+});
+var ConfigVersionSchema = z12.object({
+  id: z12.string().max(128),
+  entityType: z12.enum(["project", "service"]),
+  entityId: z12.string().max(128),
+  version: z12.string().max(128),
+  parentVersion: z12.string().max(128),
+  data: z12.record(z12.string(), z12.unknown()).refine(
+    (obj) => Object.keys(obj).length <= 1e3,
+    "Too many data keys (max 1000)"
+  ),
+  patch: z12.array(z12.record(z12.string(), z12.unknown())).max(1e3),
+  userId: z12.string().max(128),
+  timestamp: z12.coerce.date(),
+  resolved: z12.boolean().default(false)
+});
+var ConfigChangeSchema = z12.object({
+  entityType: z12.enum(["project", "service"]),
+  entityId: z12.string().max(128),
+  version: z12.string().max(128),
+  parentVersion: z12.string().max(128),
+  data: z12.record(z12.string(), z12.unknown()).refine(
+    (obj) => Object.keys(obj).length <= 1e3,
+    "Too many data keys (max 1000)"
+  ),
+  patch: z12.array(z12.record(z12.string(), z12.unknown())).max(1e3)
+});
+var SyncStatusSchema = z12.object({
+  connected: z12.boolean(),
+  lastSync: z12.coerce.date().nullable().optional(),
+  pendingChanges: z12.number().int().nonnegative().default(0),
+  conflicts: z12.number().int().nonnegative().default(0)
+});
+var AuditActionSchema = z13.enum([
+  "create",
+  "update",
+  "delete",
+  "invite",
+  "remove",
+  "deploy",
+  "start",
+  "stop",
+  "roleChange"
+]);
+var AuditEntityTypeSchema = z13.enum([
+  "org",
+  "project",
+  "service",
+  "member",
+  "permission"
+]);
+var AuditLogSchema = z13.object({
+  id: z13.string().max(128),
+  orgId: z13.string().max(128),
+  userId: z13.string().max(128),
+  action: AuditActionSchema,
+  entityType: AuditEntityTypeSchema,
+  entityId: z13.string().max(128),
+  metadata: z13.record(z13.string().max(256), z13.unknown()).default({}).refine(
+    (obj) => Object.keys(obj).length <= 100,
+    { message: "Too many metadata keys (max 100)" }
+  ),
+  timestamp: z13.coerce.date()
+});
+var ProcessMetricsSchema = z14.object({
+  processId: z14.string().max(128),
+  cpu: z14.number().nonnegative(),
+  memory: z14.number().int().nonnegative(),
+  timestamp: z14.string()
+});
+var EnvironmentVariablesSchema = z15.record(
+  z15.string().max(256),
+  VariableSchema
+).refine(
+  (obj) => Object.keys(obj).length <= 200,
+  { message: "Max 200 variables" }
+);
+var EnvironmentSchema = z15.object({
+  id: z15.string().max(128),
+  projectId: z15.string().max(128),
+  name: z15.string().min(1).max(200),
+  description: z15.string().max(2e3).optional().default(""),
+  parentIds: z15.array(z15.string().max(128)).max(10).default([]),
+  variables: EnvironmentVariablesSchema.default({}),
+  // Scope: 'global' = project-level env, 'service' = per-service env
+  scope: z15.enum(["global", "service"]).default("global"),
+  // When scope='service': the serviceId this env belongs to
+  reference: z15.string().max(128).optional(),
+  // When scope='service': the globalEnvId this env activates on
+  activateOn: z15.string().max(128).optional(),
+  immutable: z15.boolean().default(false),
+  default: z15.boolean().optional().default(false),
+  color: z15.string().max(20).optional(),
+  bgColor: z15.string().max(20).optional(),
+  // When scope='global': the default agent used by services that don't have an explicit agentId
+  agentId: z15.string().max(128).optional()
+});
+var ResolvedEnvironmentSchema = z15.object({
+  variables: z15.record(z15.string().max(256), VariableSchema).refine((obj) => Object.keys(obj).length <= 500, { message: "Max 500 resolved variables" }),
+  env: z15.record(z15.string().max(256), z15.string().max(8192)).refine((obj) => Object.keys(obj).length <= 500, { message: "Max 500 resolved env vars" }),
+  envSecrets: z15.array(z15.string().max(256)).max(500),
+  sources: z15.record(z15.string().max(256), z15.object({
+    environmentId: z15.string().max(128),
+    environmentName: z15.string().max(200),
+    overridden: z15.boolean(),
+    resolvedFrom: z15.object({
+      environmentId: z15.string().max(128),
+      environmentName: z15.string().max(200)
+    }).optional(),
+    // Set when a machine-local override was applied to this variable, pointing
+    // at the environment that carries the winning override. Distinct from
+    // `overridden`, which also covers "shadows an inherited variable".
+    overriddenBy: z15.object({
+      environmentId: z15.string().max(128),
+      environmentName: z15.string().max(200)
+    }).optional()
+  })).refine((obj) => Object.keys(obj).length <= 500, { message: "Max 500 source entries" })
+});
+var CreateEnvironmentSchema = EnvironmentSchema.omit({ id: true }).extend({
+  description: z15.string().max(2e3).optional().default(""),
+  parentIds: z15.array(z15.string().max(128)).max(10).optional().default([]),
+  variables: EnvironmentVariablesSchema.optional().default({}),
+  scope: z15.enum(["global", "service"]).optional().default("global"),
+  reference: z15.string().max(128).optional(),
+  activateOn: z15.string().max(128).optional(),
+  immutable: z15.boolean().optional().default(false)
+});
+var UpdateEnvironmentSchema = EnvironmentSchema.partial().required({ id: true }).extend({
+  description: z15.string().max(2e3).optional(),
+  parentIds: z15.array(z15.string().max(128)).max(10).optional(),
+  variables: EnvironmentVariablesSchema.optional(),
+  scope: z15.enum(["global", "service"]).optional(),
+  immutable: z15.boolean().optional(),
+  default: z15.boolean().optional(),
+  agentId: z15.string().max(128).nullable().optional()
+  // null = clear (no default agent)
+});
+var VariableOverrideSchema = z16.object({
+  value: VariableSlotSchema
+});
+var EnvironmentOverridesSchema = z16.record(
+  z16.string().max(128),
+  VariableOverrideSchema
+).refine(
+  (obj) => Object.keys(obj).length <= 5e3,
+  { message: "Max 5000 overrides" }
+);
+var ApiServiceActionSchema = z17.enum([
+  "service:read",
+  "service:start",
+  "service:stop",
+  "service:restart",
+  "service:healthcheck",
+  "service:status",
+  "logs:read"
+]);
+var ApiEnvActionSchema = z17.enum(["env:read", "env:write"]);
+var ApiEnvPermSchema = z17.object({
+  environmentId: z17.string().max(128),
+  actions: z17.array(ApiEnvActionSchema).max(10).default(["env:read"]),
+  includeSecrets: z17.boolean().default(false)
+});
+var ApiServicePermSchema = z17.object({
+  serviceId: z17.string().max(128),
+  actions: z17.array(ApiServiceActionSchema).max(10).default(["service:read"]),
+  environments: z17.array(ApiEnvPermSchema).max(100).default([])
+});
+var ApiKeyScopeSchema = z17.object({
+  services: z17.array(ApiServicePermSchema).max(500).default([])
+});
+var ApiKeySchema = z17.object({
+  id: z17.string().max(128),
+  name: z17.string().min(1).max(200),
+  key: z17.string().regex(/^[0-9a-f]{64}$/i),
+  scopes: ApiKeyScopeSchema,
+  createdAt: z17.string().max(64),
+  isPublic: z17.boolean().default(false)
+});
+var PersistedApiKeySchema = ApiKeySchema.extend({
+  key: z17.string().min(1).max(4096)
+});
+var ApiKeysFileSchema = z17.object({
+  keys: z17.array(PersistedApiKeySchema).max(100)
+});
+var MaskedApiKeySchema = ApiKeySchema.omit({ key: true }).extend({
+  /** Last 4 characters of the secret, for recognising a key in a list. */
+  keyPreview: z17.string().max(8)
+});
+var ALLOWED_IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
+var ImagePartSchema = z18.object({
+  type: z18.literal("image"),
+  imageId: z18.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "Must be a valid UUID"),
+  url: z18.string().min(1),
+  mimeType: z18.enum(ALLOWED_IMAGE_MIME_TYPES),
+  altText: z18.string().max(500).optional()
+});
+var ImageUploadResponseSchema = z18.object({
+  imageId: z18.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "Must be a valid UUID"),
+  url: z18.string().min(1),
+  mimeType: z18.enum(ALLOWED_IMAGE_MIME_TYPES),
+  originalName: z18.string()
+});
+var ImageMetaSchema = z18.object({
+  imageId: z18.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "Must be a valid UUID"),
+  filePath: z18.string().min(1),
+  mimeType: z18.enum(ALLOWED_IMAGE_MIME_TYPES),
+  originalName: z18.string().min(1),
+  createdAt: z18.number().positive(),
+  size: z18.number().positive().optional()
+});
+var KanbanAttachmentSchema = z19.object({
+  /** Server-issued id, also the storage key. */
+  id: z19.string().max(128),
+  name: z19.string().max(255),
+  size: z19.number().int().nonnegative(),
+  contentType: z19.string().max(128)
+});
+var KanbanCardEventSchema = z19.object({
+  type: z19.enum(["created", "edited", "moved", "image_added", "image_removed", "title_changed", "conversation_started", "scenario_started", "comment", "archived", "unarchived"]),
+  timestamp: z19.string(),
+  /** Extra context: old/new column name, old/new title, comment text, etc. */
+  /**
+   * Le texte de l'entrée : le corps d'un commentaire, ou le contexte du geste.
+   *
+   * Borné comme le corps d'une carte (100 000), et non plus à 5 000 : un
+   * commentaire est de la prose comme une description, et rien de technique ne
+   * justifiait un écart de vingt fois. La borne étroite s'est vue à l'import
+   * d'un Kanbanize, où des commentaires de 12 000 caractères passaient par
+   * l'API publique — bornée, elle, à 20 000 — pour écrire en base une donnée que
+   * ce schéma déclarait invalide, et qu'aucune reprise depuis l'interface
+   * n'aurait ensuite pu enregistrer.
+   */
+  detail: z19.string().max(1e5).optional(),
+  /**
+   * Stable identity of the event, used to tell an edit from an insertion when a
+   * whole history is written back. Absent on events recorded before the field
+   * existed; those fall back to (type, timestamp).
+   */
+  id: z19.string().max(128).optional(),
+  /** Who authored this event — 'ai' or 'user'. Only set for comment events. */
+  author: z19.enum(["ai", "user"]).optional(),
+  /**
+   * Qui est derrière l'événement, estampillé par le serveur — jamais pris du
+   * client, sans quoi n'importe qui pourrait signer au nom d'un autre.
+   *
+   * Posé sur les commentaires (c'est ce qui rend « mon propre commentaire »
+   * répondable ; `author` ne sépare que l'IA de l'humain) et sur les
+   * déplacements. Absent des événements écrits avant qu'on l'estampille : un
+   * lecteur doit donc afficher « on ne sait pas », pas un nom vide.
+   *
+   * Pour une clé d'API, c'est le nom de la clé et non son porteur : la clé
+   * emprunte les droits de son créateur, pas son identité — personne ne doit
+   * croire qu'un humain a déplacé ce qu'un robot de CI a déplacé.
+   */
+  authorUser: z19.object({ id: z19.string().max(128), name: z19.string().max(200) }).optional(),
+  /** Set when the author amended their comment, so the UI can say so. */
+  editedAt: z19.string().optional(),
+  /** Files attached to a comment — same storage as a card's own attachments. */
+  attachments: z19.array(KanbanAttachmentSchema).max(20).optional(),
+  /** Conversation that produced this event (comments only). Used to navigate back to the conversation. */
+  conversationId: z19.string().optional()
+});
+var KanbanCardSchema = z19.object({
+  id: z19.string(),
+  title: z19.string().min(1).max(500),
+  markdown: z19.string().max(1e5).default(""),
+  /**
+   * Legacy inline images, kept so boards written before object storage still
+   * render. New uploads go to `attachments` instead.
+   */
+  images: z19.array(z19.string()).default([]),
+  /** Files attached to the card — stored out of band, referenced here. */
+  attachments: z19.array(KanbanAttachmentSchema).max(50).default([]),
+  order: z19.number().int(),
+  /**
+   * La priorité de la carte, de 1 à 10 — 10 étant le plus urgent.
+   *
+   * Facultative, et absente veut dire « pas de priorité », pas « la plus
+   * basse » : une carte qu'on n'a pas encore arbitrée ne doit pas se ranger
+   * d'office au fond de la pile.
+   */
+  priority: z19.number().int().min(1).max(10).optional(),
+  /**
+   * Les groupes de la carte — des étiquettes libres, posées par l'équipe.
+   *
+   * Rien ne les déclare ailleurs : un groupe existe parce qu'une carte le
+   * porte, et disparaît avec la dernière qui le portait. C'est ce qui permet
+   * d'en créer un en le tapant, sans passer par un écran d'administration.
+   */
+  groups: z19.array(z19.string().min(1).max(60)).max(30).optional(),
+  /**
+   * L'échéance de la carte : le jour où elle est attendue, `AAAA-MM-JJ`.
+   *
+   * Un jour, pas un instant, et c'est une décision : une équipe se dit « pour
+   * vendredi », jamais « pour vendredi 23:59:59 UTC ». Stocker un instant
+   * ferait afficher une échéance au 4 mars comme le 3 mars à qui travaille à
+   * l'ouest de Greenwich — la carte serait en retard d'un jour pour la moitié
+   * de l'équipe, et personne ne saurait pourquoi.
+   *
+   * Facultative, et absente veut dire « pas d'échéance », pas « en retard » :
+   * une carte qu'on n'a pas datée ne doit pas s'annoncer comme urgente.
+   */
+  deadline: z19.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  /**
+   * La couleur de la carte, en hexadécimal (`#RRGGBB`) — un liseré en haut de
+   * la carte, et rien d'autre : ce qu'elle veut dire appartient à l'équipe.
+   *
+   * Bornée à une notation stricte plutôt qu'à une chaîne libre : cette valeur
+   * finit dans un attribut `style`, et une couleur ne doit pouvoir contenir
+   * qu'une couleur. Absente sur les cartes sans couleur.
+   */
+  color: z19.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+  /**
+   * Le journal de la carte — commentaires compris.
+   *
+   * Optionnel, et c'est tout l'intérêt : c'est la partie qui grossit sans fin
+   * (une IA bavarde y écrit des pages), alors les lectures de tableau ne le
+   * transportent plus. `undefined` veut dire « pas chargé », et une écriture
+   * qui l'omet laisse au serveur celui qu'il a en base — à ne pas confondre
+   * avec `[]`, qui demanderait bel et bien de le vider.
+   */
+  history: z19.array(KanbanCardEventSchema).optional(),
+  /**
+   * Ce que le journal absent laisse quand même dire : combien de commentaires,
+   * et quand fut le dernier. Posés par le serveur en lecture, ignorés en
+   * écriture — la carte ne les stocke pas, ils se déduisent de `history`.
+   */
+  commentCount: z19.number().int().nonnegative().optional(),
+  lastCommentAt: z19.string().optional(),
+  /**
+   * Les entrées de journal qui ouvrent une conversation IA. Elles restent dans
+   * la lecture allégée — il y en a une poignée par carte, et l'hôte s'en sert
+   * pour dire, sans ouvrir la carte, qu'une IA y travaille.
+   */
+  conversationEvents: z19.array(KanbanCardEventSchema).optional(),
+  createdAt: z19.string(),
+  updatedAt: z19.string(),
+  /**
+   * Quand la carte a été archivée — absente tant qu'elle est au tableau.
+   *
+   * Une carte archivée reste dans sa colonne en base : c'est la lecture qui la
+   * retire du tableau, jamais une écriture qui la déplace. Rien à recoller donc
+   * au désarchivage, et aucun cimetière où une carte pourrait se perdre.
+   */
+  archivedAt: z19.string().optional(),
+  /**
+   * La colonne d'où la carte a été archivée, telle qu'elle s'appelait alors.
+   *
+   * L'identifiant sert à l'y remettre, le titre à le dire dans l'archive même
+   * quand la colonne a disparu depuis — auquel cas le désarchivage repose la
+   * carte dans la première colonne, sans se taire sur son origine.
+   */
+  archivedFrom: z19.object({ columnId: z19.string().max(128), columnTitle: z19.string().max(200) }).optional(),
+  /**
+   * Quand la carte a été supprimée. Rien n'est effacé : la carte reste en base,
+   * et toutes les lectures l'écartent.
+   *
+   * Une suppression est le seul geste que rien ne rattrape — sauf à ne pas
+   * l'exécuter vraiment. La colonne et le tableau portent le même champ, pour
+   * que supprimer l'un n'emporte jamais les cartes de l'autre.
+   */
+  deletedAt: z19.string().optional(),
+  /**
+   * People assigned to the card. Names are denormalized for display; the server
+   * keeps only members of the owning organization, and notifies newcomers.
+   */
+  assignees: z19.array(z19.object({ id: z19.string().max(128), name: z19.string().max(200) })).max(20).default([]),
+  /**
+   * Who first created the card. Stamped by the server the first time a card id
+   * appears in a board write, never taken from the client — a member could
+   * otherwise claim any authorship. Absent on cards created before this field
+   * existed, so readers must treat it as unknown rather than assume.
+   */
+  createdBy: z19.object({ id: z19.string().max(128), name: z19.string().max(200) }).optional()
+});
+var KanbanColumnSchema = z19.object({
+  id: z19.string(),
+  title: z19.string().min(1).max(200),
+  order: z19.number().int(),
+  cards: z19.array(KanbanCardSchema).default([]),
+  /**
+   * Le regroupement auquel la colonne appartient, s'il y en a un.
+   *
+   * Un pointeur vers le parent, et rien dans l'autre sens : le groupe ne tient
+   * pas la liste de ses membres. Deux listes qui prétendent dire qui contient
+   * quoi finissent par se contredire, et un déplacement devient alors deux
+   * écritures au lieu d'une.
+   */
+  groupId: z19.string().optional(),
+  /** Supprimée, mais conservée — voir `deletedAt` sur la carte. */
+  deletedAt: z19.string().optional()
+});
+var KanbanColumnGroupSchema = z19.object({
+  id: z19.string(),
+  title: z19.string().min(1).max(200),
+  /** La couleur du bandeau, en hexadécimal — l'interface décide du défaut. */
+  color: z19.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+  /** Le groupe parent, pour les regroupements imbriqués. */
+  parentId: z19.string().optional(),
+  /** Supprimé, mais conservé — comme une colonne. */
+  deletedAt: z19.string().optional()
+});
+var KanbanBoardSchema = z19.object({
+  id: z19.string(),
+  name: z19.string().min(1).max(200),
+  description: z19.string().max(1e4).default(""),
+  /**
+   * Le mode d'emploi du tableau, en texte libre : ce que veulent dire ses
+   * colonnes, quand une carte a le droit d'avancer, les conventions de
+   * l'équipe. Écrit par les humains, lu surtout par l'IA — il est injecté dans
+   * le prompt des agents pour qu'ils travaillent selon les règles du tableau
+   * plutôt que selon les leurs.
+   */
+  instructions: z19.string().max(2e4).default(""),
+  columns: z19.array(KanbanColumnSchema).default([]),
+  /** Les regroupements de colonnes — vide sur un tableau qui n'en a jamais eu. */
+  columnGroups: z19.array(KanbanColumnGroupSchema).default([]),
+  /**
+   * Les projets auxquels le tableau est rattaché, par leur identifiant.
+   *
+   * Un rattachement, pas une possession : il ne sert qu'à filtrer la liste des
+   * tableaux, et un tableau sans projet (`[]`, le cas par défaut) reste visible
+   * partout. Plusieurs projets sont permis parce qu'une équipe partage souvent
+   * un même tableau entre deux projets — obliger à choisir l'un des deux
+   * ferait disparaître le tableau de la liste de l'autre.
+   *
+   * Les identifiants sont ceux des projets de l'organisation ; le serveur
+   * refuse ceux qu'il ne connaît pas plutôt que de garder un lien mort.
+   */
+  projectIds: z19.array(z19.string().min(1).max(128)).max(20).default([]),
+  archived: z19.boolean().default(false),
+  /** Supprimé, mais conservé avec ses cartes — voir `deletedAt` sur la carte. */
+  deletedAt: z19.string().optional(),
+  createdAt: z19.string(),
+  updatedAt: z19.string()
+});
+var CreateKanbanBoardInput = z19.object({
+  name: z19.string().min(1).max(200),
+  description: z19.string().max(1e4).optional(),
+  instructions: z19.string().max(2e4).optional(),
+  projectIds: z19.array(z19.string().min(1).max(128)).max(20).optional()
+});
+var UpdateKanbanBoardInput = z19.object({
+  id: z19.string(),
+  name: z19.string().min(1).max(200).optional(),
+  description: z19.string().max(1e4).optional(),
+  instructions: z19.string().max(2e4).optional(),
+  columns: z19.array(KanbanColumnSchema).optional(),
+  archived: z19.boolean().optional(),
+  projectIds: z19.array(z19.string().min(1).max(128)).max(20).optional()
+});
+var KanbanCardLinkSchema = z19.object({
+  id: z19.string().max(128),
+  /** Le tableau et la carte qui *dépendent* de l'autre. */
+  childBoardId: z19.string().max(64),
+  childCardId: z19.string().max(128),
+  /** Le tableau et la carte *dont* on dépend. */
+  parentBoardId: z19.string().max(64),
+  parentCardId: z19.string().max(128),
+  createdAt: z19.string(),
+  createdBy: z19.object({ id: z19.string().max(128), name: z19.string().max(200) }).optional()
+});
+var KanbanCardRefSchema = z19.object({
+  cardId: z19.string().max(128),
+  boardId: z19.string().max(64),
+  boardName: z19.string().max(200),
+  columnId: z19.string().max(128),
+  columnTitle: z19.string().max(200),
+  title: z19.string().max(500),
+  /** Les mêmes informations qu'une ligne de tableau montre d'une carte d'ici. */
+  assignees: z19.array(z19.object({ id: z19.string().max(128), name: z19.string().max(200) })).default([]),
+  commentCount: z19.number().int().nonnegative().default(0)
+});
+var CloudApiScopeSchema = z20.enum([
+  "kanban:read",
+  "kanban:write",
+  "kanban:comment",
+  "kanban:delete"
+]);
+var CloudApiKeySecretSchema = z20.string().regex(/^rk_[0-9a-f]{64}$/);
+var CloudApiKeySchema = z20.object({
+  id: z20.string().max(128),
+  organizationId: z20.string().max(128),
+  name: z20.string().min(1).max(200),
+  scopes: z20.array(CloudApiScopeSchema).min(1).max(10),
+  /**
+   * Les tableaux que la clé peut atteindre, ou `null` pour « tous ceux de
+   * l'organisation ».
+   *
+   * `null` et `[]` ne sont pas la même chose : la liste vide n'ouvre rien, et
+   * c'est délibéré — un tableau supprimé ne doit pas élargir une clé qui ne le
+   * nommait plus que lui.
+   */
+  boards: z20.array(z20.string().max(64)).max(200).nullable(),
+  createdAt: z20.string().max(64),
+  /** Dernier usage constaté, pour reconnaître une clé oubliée. */
+  lastUsedAt: z20.string().max(64).nullable(),
+  /** Qui l'a émise — une clé sans visage ne se révoque jamais sereinement. */
+  createdBy: z20.object({ id: z20.string().max(128), name: z20.string().max(200) }),
+  /** Les 4 derniers caractères du secret, pour reconnaître une clé dans une liste. */
+  keyPreview: z20.string().max(8)
+});
+var CreatedCloudApiKeySchema = z20.object({
+  key: CloudApiKeySchema,
+  secret: CloudApiKeySecretSchema
+});
+var CreateCloudApiKeyInput = z20.object({
+  organizationId: z20.string().min(1).max(128),
+  name: z20.string().min(1).max(200),
+  scopes: z20.array(CloudApiScopeSchema).min(1).max(10),
+  boards: z20.array(z20.string().max(64)).max(200).nullable().default(null)
+});
+var UpdateCloudApiKeyInput = z20.object({
+  id: z20.string().min(1).max(128),
+  name: z20.string().min(1).max(200).optional(),
+  scopes: z20.array(CloudApiScopeSchema).min(1).max(10).optional(),
+  boards: z20.array(z20.string().max(64)).max(200).nullable().optional()
+});
+var ChangelogSurfaceSchema = z21.enum(["app", "cloud"]);
+var ChangelogChangeKindSchema = z21.enum(["feature", "improvement", "fix", "breaking"]);
+var ChangelogTextSchema = z21.object({
+  fr: z21.string().min(1).max(500),
+  en: z21.string().min(1).max(500)
+});
+var ChangelogChangeSchema = z21.object({
+  kind: ChangelogChangeKindSchema,
+  text: ChangelogTextSchema
+});
+var ChangelogDraftSchema = ChangelogChangeSchema.extend({
+  date: z21.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  title: ChangelogTextSchema.optional()
+});
+var ChangelogReleaseSchema = z21.object({
+  surface: ChangelogSurfaceSchema,
+  /** `1.4.2` pour l'app (version npm publiée), `2026-09-03` — ou `2026-09-03.2` — pour le cloud. */
+  version: z21.string().min(1).max(32).regex(/^[0-9][0-9.-]*$/),
+  /** Date de publication, `YYYY-MM-DD`. */
+  date: z21.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  /** Facultatif : une version peut s'annoncer par son seul numéro. */
+  title: ChangelogTextSchema.optional(),
+  /** Une version sans changement n'a rien à annoncer : elle n'a pas sa place ici. */
+  changes: z21.array(ChangelogChangeSchema).min(1).max(50)
+});
+var ChangelogIndexItemSchema = ChangelogReleaseSchema.omit({ changes: true }).extend({
+  changeCount: z21.number().int().nonnegative()
+});
+var MASKED_VALUE = "***";
+function maskLogSourceSecrets(sources) {
+  return sources.map((src) => {
+    if (src.type === "mongo") return { ...src, connectionString: MASKED_VALUE };
+    if (src.type === "mysql" && src.password) return { ...src, password: MASKED_VALUE };
+    return src;
+  });
+}
+var BUILTIN_VARIABLES = [
+  // ── Le service ───────────────────────────────────────────────────────────
+  { name: "service.NAME", scope: "server", descriptionKey: "serviceName" },
+  { name: "service.ID", scope: "server", descriptionKey: "serviceId" },
+  { name: "service.PORT", scope: "server", descriptionKey: "servicePort" },
+  { name: "service.URL", scope: "server", descriptionKey: "serviceUrl" },
+  { name: "service.BASE_URL", scope: "server", descriptionKey: "serviceBaseUrl" },
+  { name: "service.CWD", scope: "agent", descriptionKey: "serviceCwd" },
+  // ── Le projet et l'environnement actif ───────────────────────────────────
+  { name: "project.NAME", scope: "server", descriptionKey: "projectName" },
+  { name: "runeya.ENV_NAME", scope: "server", descriptionKey: "envName" },
+  // ── Le serveur Runeya ────────────────────────────────────────────────────
+  // `service.HOST` a toujours désigné l'adresse d'écoute du SERVEUR, pas une
+  // propriété du service : le nom trompait, il devient un alias.
+  { name: "runeya.HOST", scope: "server", descriptionKey: "runeyaHost", deprecatedAlias: "service.HOST" },
+  // ── La machine qui exécute ───────────────────────────────────────────────
+  { name: "agent.HOST_LAN", scope: "agent", descriptionKey: "agentHostLan", deprecatedAlias: "service.HOST_LAN" },
+  // Le NOM de l'agent est une étiquette de la configuration du serveur, pas
+  // une propriété de la machine : c'est le serveur qui le connaît et le résout.
+  { name: "agent.NAME", scope: "server", descriptionKey: "agentName" },
+  { name: "agent.OS", scope: "agent", descriptionKey: "agentOs" },
+  { name: "agent.HOME", scope: "agent", descriptionKey: "agentHome" }
+];
+var GRACE_PERIOD = 1e4;
+var AGENT_STOP_FETCH_TIMEOUT = GRACE_PERIOD + 15e3;
+var SUPPORTED_EDITORS = [
+  { key: "vscode", name: "Visual Studio Code", command: "code" },
+  { key: "cursor", name: "Cursor", command: "cursor" },
+  { key: "windsurf", name: "Windsurf", command: "windsurf" },
+  { key: "sublime", name: "Sublime Text", command: "subl" },
+  { key: "atom", name: "Atom", command: "atom" },
+  { key: "antigravity", name: "Antigravity", command: "antigravity" },
+  { key: "intellij", name: "IntelliJ IDEA", command: "idea" },
+  { key: "android-studio", name: "Android Studio", command: "studio" },
+  { key: "webstorm", name: "WebStorm", command: "webstorm" },
+  { key: "zed", name: "Zed", command: "zed" },
+  { key: "neovim", name: "Neovim", command: "nvim" },
+  { key: "vim", name: "Vim", command: "vim" },
+  { key: "emacs", name: "Emacs", command: "emacs" },
+  { key: "fleet", name: "Fleet", command: "fleet" }
+];
+var EDITOR_BY_KEY = new Map(
+  SUPPORTED_EDITORS.map((e) => [e.key, e])
+);
 
 // ../ai-capabilities/dist/index.js
+import { z as z23 } from "zod";
+import { z as z32 } from "zod";
 function toList(raw) {
   if (!raw) return [];
   const text = raw.trim();
@@ -32,9 +1237,107 @@ function gitTarget(p) {
     ...p.orgId ? { orgId: p.orgId } : {}
   };
 }
+var toBool = (raw) => raw.trim().toLowerCase() === "true";
+var newId = () => globalThis.crypto.randomUUID();
+function listItem(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseTyped(name, schema, raw) {
+  if (raw === void 0) return void 0;
+  let result = raw.trim() === "null" ? schema.safeParse(null) : schema.safeParse(raw);
+  if (!result.success && raw.trim() === "null") result = schema.safeParse(raw);
+  if (!result.success) {
+    const text = raw.trim();
+    const json = listItem(text);
+    if (json !== text) result = schema.safeParse(json);
+    if (!result.success && !/^[[{]/.test(text)) {
+      const list = schema.safeParse(toList(text).map(listItem));
+      if (list.success) result = list;
+    }
+  }
+  if (!result.success) throw new Error(`${name}: ${z22.prettifyError(result.error)}`);
+  return result.data;
+}
+function withIds(items) {
+  return items.map((item) => ({ ...item, id: item.id || newId() }));
+}
+var optionalId = (schema) => schema.extend({ id: z22.string().min(1).max(64).optional() });
+var DockerConfigInput = DockerConfigSchema.extend({
+  bootstrapCommands: z22.array(optionalId(BootstrapCommandSchema)).max(20).default([])
+}).refine((c) => !!c.image !== !!c.dockerfile, {
+  message: 'dockerConfig needs exactly one of "image" (an image to pull) or "dockerfile" (a Dockerfile to build)'
+});
+var SERVICE_FIELDS = [
+  { name: "description", description: "What the service is, in a sentence" },
+  { name: "agentId", description: "The agent that runs it, from list_agents. Omit to inherit from the environment.", clearable: true },
+  { name: "cwd", description: `Working directory, RELATIVE to the project root (e.g. "apps/web", or omit for the root). The project is synced between machines and lives in a different folder on each: Runeya resolves a relative cwd against each machine's own project folder, while an absolute path (/home/you/\u2026) breaks on every other machine. Use an absolute path only for something outside the project, written with ~ or an environment variable ($NAME) rather than a literal home directory.`, clearable: true },
+  { name: "command", description: 'Shortcut for a single command line (e.g. "npm run dev"). Replaces every existing command. Use commands for several.' },
+  { name: "commands", description: 'The processes of the service. They all start AT THE SAME TIME, in parallel, and the service runs while they run \u2014 not one after another. Use several for processes that live side by side (a web server and a worker). Steps that must follow each other (build, then install, then launch) go in ONE command chained with &&. A one-off action the user triggers by hand (build, deploy, read logs) is a shortcut, not a command. Each command runs in the service cwd, or its own "cwd", relative to the project root. No absolute paths of this machine: the service is synced to other machines. Replaces every existing command. "id" is generated when omitted; "shell" runs the line through a shell (default true).', schema: z22.array(optionalId(ServiceCommandSchema)).max(50) },
+  { name: "ports", description: "Ports the service listens on. Declare them: they become {{service.PORT}}, {{service.URL}} and {{services.<slug>.URL}} for the other services, which environment variables should reference instead of repeating the numbers.", schema: ServiceConfigSchema.shape.ports.unwrap().unwrap() },
+  { name: "groups", description: "Groups the service belongs to. Replaces the current ones.", schema: ServiceConfigSchema.shape.groups.unwrap().unwrap() },
+  { name: "url", description: "URL where the service is reached" },
+  { name: "localUrls", description: 'Local domain names routed to a port of the service (e.g. {"url":"api.localhost.dev","port":3000})', schema: ServiceConfigSchema.shape.localUrls.unwrap().unwrap() },
+  { name: "openapiUrl", description: "URL of its OpenAPI document" },
+  { name: "docsPath", description: "Where its markdown docs live, relative to cwd or absolute. Defaults to cwd." },
+  { name: "git", description: 'Its git repository: "remote" URL and "home" page', schema: ServiceConfigSchema.shape.git.unwrap(), clearable: true },
+  { name: "meta", description: "Free key/value metadata (strings)", schema: ServiceConfigSchema.shape.meta.unwrap(), clearable: true },
+  { name: "runner", description: '"native" runs the commands on the machine; "docker" runs the service in a container and then needs dockerConfig', schema: ServiceConfigSchema.shape.runner.unwrap().unwrap() },
+  { name: "dockerConfig", description: 'With runner "docker": the container. Exactly one of "image" (pull) or "dockerfile" (inline Dockerfile, built with "buildContext", "buildArgs", "targetStage"). Ports and volumes use Docker syntax ("8080:80", "./data:/data"); host paths in volumes relative to the service directory, never an absolute path of this machine. "useNativeCommand" runs the service commands inside the container instead of its CMD ("nativeCommandMode": one shared container or one per command). "bootstrapCommands" run once when the container starts. Replaces the whole Docker configuration: read it first with get_service to keep what you do not change.', schema: DockerConfigInput },
+  { name: "healthCheck", description: 'How to tell the service is ready: an HTTP "path" to call, or a "command" that must succeed', schema: HealthCheckSchema, clearable: true },
+  { name: "autoRestart", description: "Restart the service when it crashes", schema: z22.boolean() },
+  { name: "restartStrategy", description: "When to restart it", schema: RestartStrategySchema.unwrap() },
+  { name: "maxRestarts", description: "Give up after this many restarts", schema: ServiceConfigSchema.shape.maxRestarts.unwrap() },
+  { name: "restartBackoffMs", description: "Delay before a restart, in milliseconds", schema: ServiceConfigSchema.shape.restartBackoffMs.unwrap().unwrap() },
+  { name: "clearLogsOnStart", description: "Clear the logs each time the service starts", schema: z22.boolean() },
+  { name: "shortcuts", description: 'One-click actions shown on the service, run on demand and independently of the running commands (build, deploy, migrate, read logs). Same path rules as commands: relative to the project root, never an absolute path of this machine. Replaces the current ones. "id" is generated when omitted.', schema: z22.array(optionalId(ServiceShortcutSchema)).max(50) },
+  { name: "parserIds", description: "Log parsers applied to its output, by id", schema: ServiceConfigSchema.shape.parserIds.unwrap() },
+  { name: "logSources", description: 'Extra log sources beyond the console output (files, databases\u2026). Replaces the current ones. Credentials (mongo connectionString, mysql password) read as "***": send "***" back to keep the stored value, or the real value to change it.', schema: ServiceConfigSchema.shape.logSources.unwrap().unwrap() }
+];
+function serviceParams(clearable2) {
+  return SERVICE_FIELDS.map((f) => {
+    const nullable = clearable2 && f.clearable;
+    const base = f.schema ?? (nullable ? z22.string() : void 0);
+    return {
+      name: f.name,
+      description: nullable ? `${f.description} null clears it.` : f.description,
+      required: false,
+      ...base ? { schema: nullable ? base.nullable() : base } : {}
+    };
+  });
+}
+function serviceFields(p, params) {
+  const out = {};
+  for (const param of params) {
+    if (p[param.name] === void 0 || param.name === "command") continue;
+    out[param.name] = param.schema ? parseTyped(param.name, param.schema, p[param.name]) : p[param.name];
+  }
+  if (p.command !== void 0 && p.commands === void 0) out["commands"] = [{ label: "", command: p.command, shell: true }];
+  if (Array.isArray(out["commands"])) out["commands"] = withIds(out["commands"]);
+  if (Array.isArray(out["shortcuts"])) out["shortcuts"] = withIds(out["shortcuts"]);
+  const docker = out["dockerConfig"];
+  if (docker?.bootstrapCommands) out["dockerConfig"] = { ...docker, bootstrapCommands: withIds(docker.bootstrapCommands) };
+  return out;
+}
+function maskServices(result) {
+  if (Array.isArray(result)) return result.map(maskServices);
+  if (result && typeof result === "object" && Array.isArray(result.logSources)) {
+    const service = result;
+    return { ...service, logSources: maskLogSourceSecrets(service.logSources) };
+  }
+  return result;
+}
+var refs = (scope) => BUILTIN_VARIABLES.filter((b) => b.scope === scope).map((b) => `{{${b.name}}}`).join(", ");
+var BUILTINS_HELP = `Built-in references Runeya fills itself \u2014 filled when the service is deployed, from the service that receives the variable: ${refs("server")}, the numbered {{service.PORT_2}} / {{service.URL_2}}\u2026 for its other ports, and {{services.<slug>.PORT}}, .URL, .BASE_URL, .NAME, .ID for a sibling service of the project (slug = its name in lowercase-dashes). Filled on the machine when the service starts: ${refs("agent")}.`;
+var CREATE_SERVICE_PARAMS = serviceParams(false);
+var UPDATE_SERVICE_PARAMS = serviceParams(true);
 var RUNEYA_CAPABILITIES = [
   {
     name: "list_services",
+    transformOutput: maskServices,
     description: "List services, with the serviceId and agentId to use in other calls. Pass the projectId your context names to stay on the project the user is looking at, or another one from list_projects to look elsewhere. Called with no project, this can answer for every project of every organization on the machine \u2014 far more than the interface shows.",
     route: "service.list",
     method: "GET",
@@ -320,8 +1623,8 @@ var RUNEYA_CAPABILITIES = [
   },
   // ─── Lecture seule ───────────────────────────────────────────────────────
   //
-  // Tout ce qui se consulte sans rien changer. La création, la mise à jour et
-  // la suppression restent hors MCP : elles s'ajouteront au cas par cas.
+  // Tout ce qui se consulte sans rien changer. Les écritures s'ajoutent au cas
+  // par cas : aujourd'hui les services et leurs variables, plus bas.
   //
   // Volontairement absentes, et à ne pas ajouter sans y regarder à deux fois,
   // parce qu'elles rendent un secret : `environment.list` / `get` / `resolve` /
@@ -348,6 +1651,7 @@ var RUNEYA_CAPABILITIES = [
   },
   {
     name: "get_service",
+    transformOutput: maskServices,
     description: "Read the full configuration of one service: its commands, ports, groups, runner, log sources and restart policy. list_services gives the ids.",
     route: "service.get",
     method: "GET",
@@ -358,13 +1662,145 @@ var RUNEYA_CAPABILITIES = [
   },
   {
     name: "get_service_env",
-    description: 'Read the environment variables a service runs with, and the project\'s variable inventory. `env` lists every key the service receives; a value reads "***" when it is a secret whose author did not share it with AI (sharing = ticking "AI read", or injecting it into the agents\' environment, which grants reading too). `envSecrets` says which keys are secret, `hiddenKeys` which ones are masked. A masked key is set on the service: never treat it as missing, never suggest adding it, and never pass "***" as a value \u2014 ask the user for it. `variables` describes every variable of the project \u2014 which environment defines it and its scope, its description, its flags, whether this machine overrides it, and `inService: false` for the ones this service does not receive. Use it to say where a variable must be changed instead of guessing. On an overridden variable, `sharedValue` is what the machine-local override replaces (the team\'s value, masked as "***" when unreadable); no other value appears there.',
+    description: 'Read the environment variables a service runs with, and the project\'s variable inventory. `env` lists every key the service receives; a value reads "***" when it is a secret whose author did not share it with AI (sharing = ticking "AI read", or injecting it into the agents\' environment, which grants reading too). `envSecrets` says which keys are secret, `hiddenKeys` which ones are masked. A masked key is set on the service: never treat it as missing, never suggest adding it, and never pass "***" as a value \u2014 ask the user for it. `variables` describes every variable of the project \u2014 which environment defines it and its scope, its description, its flags, whether this machine overrides it, and `inService: false` for the ones this service does not receive. Use it to say where a variable must be changed instead of guessing. On an overridden variable, `sharedValue` is what the machine-local override replaces (the team\'s value, masked as "***" when unreadable); no other value appears there. This is the resolver: the values are what the service would receive \u2014 inheritance, {{environment.KEY}} references, this machine\'s overrides and server built-ins applied; agent built-ins stay as written until the service starts. Use it to check a variable you just composed. `unresolvedReferences` lists references nothing will fill (a typo, a variable that does not exist): fix them.',
     route: "service.getEnv",
     method: "GET",
     params: [
-      { name: "serviceId", description: "The service ID", required: true }
+      { name: "serviceId", description: "The service ID", required: true },
+      { name: "environmentId", description: "A global environment of the project to resolve in instead of the active one, without activating it (from list_environments). Omit for the active one.", required: false }
     ],
-    buildInput: (p) => ({ id: p.serviceId })
+    buildInput: (p) => ({ id: p.serviceId, ...p.environmentId ? { environmentId: p.environmentId } : {} })
+  },
+  // ─── Écrire un service et ses variables ────────────────────────────────────
+  //
+  // Les variables s'écrivent à l'aveugle (`environment.setVariableBlind`) : une
+  // IA remplace la valeur d'un secret sans la lire, et ne peut ni le rendre
+  // public, ni le partager avec les IA. La règle tient côté serveur, dans la
+  // route ; ces outils ne passent jamais par une route qui renvoie des valeurs
+  // (`upsertVariable`, `removeVariable`, `update` rendent l'environnement entier).
+  {
+    name: "create_service",
+    transformOutput: maskServices,
+    description: "Create a service, native or Docker, in a project: it joins the project and gets its environments in the same call. Pass the projectId your context names. Projects are synced between machines, so write paths relative to the project root and put machine-specific values (a device serial, a local token) in environment variables, referenced as $NAME in commands \u2014 see the cwd, commands and shortcuts parameters. Then set its variables with set_environment_variable.",
+    route: "service.create",
+    method: "POST",
+    params: [
+      { name: "name", description: "The service name", required: true },
+      { name: "projectId", description: "The project it joins: the one your context names, or another from list_projects. Without it, the service belongs to no project.", required: false },
+      { name: "orgId", description: "Its organization. Needed only when the same project id exists in several.", required: false },
+      ...CREATE_SERVICE_PARAMS
+    ],
+    buildInput: (p) => {
+      const fields = serviceFields(p, CREATE_SERVICE_PARAMS);
+      if (fields["runner"] === "docker" && !fields["dockerConfig"]) {
+        throw new Error('dockerConfig: required with runner "docker" \u2014 give an "image" or a "dockerfile"');
+      }
+      return {
+        name: p.name,
+        ...fields,
+        ...p.projectId ? { projectId: p.projectId } : {},
+        ...p.orgId ? { orgId: p.orgId } : {}
+      };
+    }
+  },
+  {
+    name: "add_service_to_project",
+    description: "Add an existing service to a project, and create its environments \u2014 one for each of the project's environments, where its own variables go. Not needed after create_service, which already does it; calling it again changes nothing.",
+    route: "project.addService",
+    method: "POST",
+    params: [
+      { name: "projectId", description: "The project ID, from list_projects", required: true },
+      { name: "serviceId", description: "The service ID", required: true },
+      { name: "orgId", description: "Its organization. Needed only when the same project id exists in several.", required: false }
+    ],
+    buildInput: (p) => ({ projectId: p.projectId, serviceId: p.serviceId, ...p.orgId ? { orgId: p.orgId } : {} })
+  },
+  {
+    name: "update_service",
+    transformOutput: maskServices,
+    description: "Change any part of a service configuration \u2014 commands, ports, health check, restart policy, shortcuts, log sources, whether it runs natively or in Docker (runner, dockerConfig)\u2026 Only the fields you pass change; a list or an object you pass replaces the current one whole. Read the service first with get_service.",
+    route: "service.update",
+    method: "POST",
+    params: [
+      { name: "serviceId", description: "The service ID", required: true },
+      { name: "name", description: "New name", required: false },
+      { name: "orgId", description: "Move the service to this organization vault. Leave unset unless asked.", required: false, schema: z22.string().max(128).nullable() },
+      ...UPDATE_SERVICE_PARAMS
+    ],
+    buildInput: (p) => ({
+      id: p.serviceId,
+      ...p.name ? { name: p.name } : {},
+      ...p.orgId !== void 0 ? { orgId: parseTyped("orgId", z22.string().max(128).nullable(), p.orgId) } : {},
+      ...serviceFields(p, UPDATE_SERVICE_PARAMS)
+    })
+  },
+  {
+    name: "list_environments",
+    description: "List the environments of a project, with no value: each one's id, name and scope (global = shared by the whole project, service = one service's own variables), which global environment is active, which service a service environment belongs to and which global environment activates it, its parents (it inherits their variables), `isolated` when a service environment does not inherit from its global one, and the variables it defines with their flags. Empty environments are listed too \u2014 a service you just created has one per global environment, where its own variables go. Use it to find the environmentId before set_environment_variable.",
+    route: "environment.listForAi",
+    method: "GET",
+    params: [
+      { name: "projectId", description: "The project ID: the one your context names, or another from list_projects", required: true },
+      { name: "orgId", description: "Its organization. Needed only when the same project id exists in several.", required: false }
+    ],
+    buildInput: (p) => ({ projectId: p.projectId, ...p.orgId ? { orgId: p.orgId } : {} })
+  },
+  {
+    name: "resolve_environment",
+    description: "Resolve one environment alone \u2014 its variables with those inherited from its parents and this machine's overrides \u2014 as an AI may read it: secrets not shared with AI read \"***\". Built-in references ({{service.*}}, {{services.*}}, {{agent.*}}\u2026) are NOT filled, since they depend on the service that receives the variable; use get_service_env for a service's final values. `unresolvedReferences` lists references nothing will fill: a misspelled {{environment.KEY}}, or a name that is no built-in.",
+    route: "environment.resolveForAi",
+    method: "GET",
+    params: [
+      { name: "environmentId", description: "The environment, from list_environments", required: true }
+    ],
+    buildInput: (p) => ({ environmentId: p.environmentId })
+  },
+  {
+    name: "set_environment_variable",
+    description: `Create or change an environment variable, by name, in one environment \u2014 global or service, same rules for both. Find the environmentId with list_environments. Where it belongs: a value shared by several services (a database host, an API base URL) goes ONCE in the active global environment; services inherit it. A value only one service needs goes in that service's environment (scope service, activated by the active global one), where it also overrides a global variable of the same name. Never hardcode what Runeya already knows: a service's own port is {{service.PORT}}, its own URL {{service.URL}}, another service's address {{services.<slug>.URL}} \u2014 a copied "3210" or "http://localhost:3211" breaks as soon as a port changes or the project runs on another machine. If the port a variable needs is not declared on its service, declare it there (update_service, ports) instead of writing the number. When a written value contains a port or URL of a project service, the response lists \`suggestions\`: rewrite the value with those references. Compose instead of copying: a value can reference another variable of the resolved environment as {{environment.KEY}} (e.g. "postgres://{{environment.DB_USER}}@{{environment.DB_HOST}}:5432"). ${BUILTINS_HELP} After writing, check the result with get_service_env (a service, optionally in another global environment) or resolve_environment (an environment alone). References are substituted in one pass: a reference to a variable whose own value is only a reference may stay unexpanded, so point at the variable that holds the actual value. $NAME is not a reference here: it only expands inside a shell command. pre and post are concatenated around the value, each resolved separately. You can replace a secret's value without reading it, and create a variable as secret. You cannot make a secret public nor make it readable by AI: that stays the user's decision. Never pass "***" as a value. The response never contains the value.`,
+    route: "environment.setVariableBlind",
+    method: "POST",
+    params: [
+      { name: "environmentId", description: "The environment that holds the variable, from list_environments", required: true },
+      { name: "key", description: "The variable name, e.g. DATABASE_URL", required: true },
+      { name: "value", description: "The new value, possibly with {{environment.KEY}} references. Omit to leave it unchanged.", required: false },
+      { name: "pre", description: 'Text put before the value (e.g. "https://"). Omit to leave it unchanged.', required: false },
+      { name: "post", description: 'Text put after the value (e.g. "/api"). Omit to leave it unchanged.', required: false },
+      { name: "isSecret", description: '"true" to store it as a secret. On an existing public variable, makes it secret.', required: false },
+      { name: "description", description: "What the variable is for, in markdown", required: false }
+    ],
+    buildInput: (p) => ({
+      environmentId: p.environmentId,
+      key: p.key,
+      ...p.value !== void 0 ? { value: p.value } : {},
+      ...p.pre !== void 0 ? { pre: p.pre } : {},
+      ...p.post !== void 0 ? { post: p.post } : {},
+      ...p.isSecret !== void 0 ? { isSecret: toBool(p.isSecret) } : {},
+      ...p.description !== void 0 ? { description: p.description } : {}
+    })
+  },
+  {
+    name: "set_environment_inheritance",
+    description: "Switch whether a service environment inherits the variables of the global environment that activates it (the default), or is isolated from it and receives only its own variables. list_environments shows this as `isolated`. Isolating a service is unusual: it loses every shared variable of the project. Do it only when the user asks, and never to work around a variable \u2014 override it in the service environment instead.",
+    route: "environment.setInheritanceBlind",
+    method: "POST",
+    params: [
+      { name: "environmentId", description: "A service environment (scope service), from list_environments", required: true },
+      { name: "inherit", description: '"true" to inherit from the global environment, "false" to isolate', required: true, schema: z22.boolean() }
+    ],
+    buildInput: (p) => ({ environmentId: p.environmentId, inherit: toBool(p.inherit ?? "true") })
+  },
+  {
+    name: "remove_environment_variable",
+    description: "Delete an environment variable, by name, from one environment. Its value is lost.",
+    route: "environment.removeVariableBlind",
+    method: "POST",
+    params: [
+      { name: "environmentId", description: "The environment that holds the variable", required: true },
+      { name: "key", description: "The variable name", required: true }
+    ],
+    buildInput: (p) => ({ environmentId: p.environmentId, key: p.key }),
+    destructive: true
   },
   {
     name: "get_service_metrics",
@@ -590,13 +2026,29 @@ var RUNEYA_CAPABILITIES = [
     buildInput: () => void 0
   }
 ];
-async function callTrpc(baseUrl, route, method, input, authToken) {
+function buildMcpShape(cap) {
+  const shape = {};
+  for (const param of cap.params) {
+    const base = (param.schema ?? z32.string()).describe(param.description);
+    shape[param.name] = param.required ? base : base.optional();
+  }
+  shape["authToken"] = z32.string().describe("Bearer token for authentication").optional();
+  return shape;
+}
+function toRawParams(input, cap) {
+  const typed = new Set(cap?.params.filter((p) => p.schema).map((p) => p.name));
+  return Object.fromEntries(Object.entries(input).map(([k, v]) => [
+    k,
+    v === null && typed.has(k) ? "null" : v == null ? void 0 : typeof v === "object" ? JSON.stringify(v) : String(v)
+  ]));
+}
+async function callTrpc(baseUrl, route, method, input, authToken, fetchImpl = fetch) {
   const headers = {
     "Content-Type": "application/json",
     "Authorization": `Bearer ${authToken}`
   };
   const url = method === "GET" && input ? `${baseUrl}/api/trpc/${route}?input=${encodeURIComponent(JSON.stringify(input))}` : `${baseUrl}/api/trpc/${route}`;
-  const res = await fetch(url, {
+  const res = await fetchImpl(url, {
     method,
     headers,
     ...method === "POST" ? { body: JSON.stringify(input ?? {}) } : {},
@@ -607,8 +2059,10 @@ async function callTrpc(baseUrl, route, method, input, authToken) {
   const result = json["result"];
   return result?.["data"] ?? result ?? json;
 }
-
-// src/project-default.ts
+async function runCapability(cap, baseUrl, params, authToken, fetchImpl = fetch) {
+  const result = await callTrpc(baseUrl, cap.route, cap.method, cap.buildInput(params), authToken, fetchImpl);
+  return cap.transformOutput ? cap.transformOutput(result) : result;
+}
 function applyProjectAnchor(cap, params, anchor) {
   if (!anchor.projectId) return params;
   const accepts = (name) => cap.params.some((p) => p.name === name);
@@ -633,19 +2087,14 @@ var PROJECT_ANCHOR = {
 };
 var server = new McpServer({ name: "runeya", version: "1.0.0" });
 for (const cap of RUNEYA_CAPABILITIES) {
-  const zodShape = {};
-  for (const param of cap.params) {
-    const base = z.string().describe(param.description);
-    zodShape[param.name] = param.required ? base : base.optional();
-  }
-  zodShape["authToken"] = z.string().describe("Bearer token for authentication").optional();
-  server.tool(cap.name, cap.description, zodShape, async (input) => {
+  server.tool(cap.name, cap.description, buildMcpShape(cap), async (input) => {
     try {
-      const raw = input.authToken;
+      const rawParams = toRawParams(input, cap);
+      const raw = rawParams["authToken"];
       const authToken = raw && !raw.startsWith("$") ? raw : ENV_TOKEN || INTERNAL_TOKEN || void 0;
       if (!authToken) throw new Error("No auth token available");
-      const params = applyProjectAnchor(cap, input, PROJECT_ANCHOR);
-      const result = await callTrpc(BASE_URL, cap.route, cap.method, cap.buildInput(params), authToken);
+      const params = applyProjectAnchor(cap, rawParams, PROJECT_ANCHOR);
+      const result = await runCapability(cap, BASE_URL, params, authToken);
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     } catch (err) {
       return {
@@ -659,7 +2108,7 @@ if (CONVERSATION_ID && INTERNAL_TOKEN) {
   server.tool(
     "ask_user",
     "Ask the user a question and wait for their reply. Use this when you need clarification or input from the user to proceed.",
-    { question: z.string().describe("The question to ask the user") },
+    { question: z24.string().describe("The question to ask the user") },
     async ({ question }) => {
       try {
         const res = await fetch(`${BASE_URL}/api/trpc/scenario.requestInput`, {