@runeya/runeya 2.0.70 → 2.0.72

package/{src-6WVQ2FQV.js → src-53OQNM27.js}

@@ -60,9 +60,11 @@ import {
   isVaultLocked,
   keyRoot,
   keyedFilePath,
+  killInstance,
   legacyMachineFilePath,
   legacyVaultRoot,
   listCloudVaults,
+  listInstances,
   listOrgVaults,
   loadFromEnv,
   localVaultRoot,
@@ -79,11 +81,14 @@ import {
   readOrgNames,
   refOfProjectAmong,
   refsOfProjectId,
+  registerInstance,
   registerProjectLoader,
   rememberFile,
   rememberOrgName,
+  restartInstance,
   rootOfProjectAmong,
   rootOfProjectRef,
+  scheduleSelfRestart,
   serviceStore,
   setEncryptionKey,
   setEncryptionKeyInMemory,
@@ -93,11 +98,12 @@ import {
   stableEncryptValue,
   stampOrgCloud,
   traefikManager,
+  unregisterInstance,
   vaultFor,
   vaultIdOfRoot,
   wasRead,
   writeEntity
-} from "./chunk-YSJ6OJGN.js";
+} from "./chunk-HPYBAUAH.js";
 
 // ../server/src/create-server.ts
 import express from "express";
@@ -4372,7 +4378,7 @@ var environmentRouter = router({
 
 // ../server/src/trpc/routers/settings.ts
 import { promises as dns } from "dns";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 import { TRPCError as TRPCError8 } from "@trpc/server";
 
 // ../server/src/services/settings-scope.ts
@@ -4384,6 +4390,122 @@ async function vaultOfProject(projectId) {
   return refs[0]?.orgId ?? void 0;
 }
 
+// ../server/src/services/lan-mode.ts
+import { networkInterfaces } from "os";
+import { readFile as readFile10, writeFile as writeFile10, rename as rename10, mkdir as mkdir10 } from "fs/promises";
+import { join as join11 } from "path";
+import { z as z10 } from "zod";
+var LOOPBACK = "127.0.0.1";
+var ANY = "0.0.0.0";
+var NETWORK_FILE = "network.json";
+var NetworkFileSchema = z10.object({
+  instances: z10.record(z10.string(), z10.object({ lanEnabled: z10.boolean().default(false) })).default({})
+});
+var httpServer = null;
+function instanceKey() {
+  return env.DATA_DIR;
+}
+function networkFilePath() {
+  return join11(machineRoot(), NETWORK_FILE);
+}
+async function readFileState() {
+  try {
+    return NetworkFileSchema.parse(JSON.parse(await readFile10(networkFilePath(), "utf-8")));
+  } catch {
+    return { instances: {} };
+  }
+}
+async function readPersisted() {
+  const state = await readFileState();
+  return state.instances[instanceKey()]?.lanEnabled ?? false;
+}
+async function writePersisted(lanEnabled) {
+  const root = machineRoot();
+  await mkdir10(root, { recursive: true });
+  const state = await readFileState();
+  state.instances[instanceKey()] = { lanEnabled };
+  const filePath = networkFilePath();
+  const tmpPath = filePath + ".tmp";
+  await writeFile10(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+  await rename10(tmpPath, filePath);
+}
+function registerHttpServer(server) {
+  httpServer = server;
+}
+function lanIps() {
+  const found = [];
+  for (const nets of Object.values(networkInterfaces())) {
+    for (const net of nets ?? []) {
+      if (net.family === "IPv4" && !net.internal) found.push(net.address);
+    }
+  }
+  return found;
+}
+function currentPort() {
+  const address = httpServer?.address();
+  return typeof address === "object" && address ? address.port : env.PORT;
+}
+function networkInfo() {
+  const port = currentPort();
+  return {
+    host: env.HOST,
+    port,
+    lanEnabled: env.RUNEYA_LAN_PROXY,
+    lanUrls: env.RUNEYA_LAN_PROXY ? lanIps().map((ip) => `http://${ip}:${port}`) : []
+  };
+}
+function setHost(host, enabled) {
+  env.HOST = host;
+  env.RUNEYA_HOST = host;
+  env.RUNEYA_LAN_PROXY = enabled;
+  process.env.RUNEYA_HOST = host;
+  process.env.RUNEYA_LAN_PROXY = enabled ? "true" : "false";
+}
+async function rebind(host, previousHost) {
+  const server = httpServer;
+  if (!server?.listening) return;
+  const port = currentPort();
+  const listenOn = (target) => new Promise((resolve7, reject) => {
+    const onError = (err) => {
+      server.removeListener("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      resolve7();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, target);
+  });
+  server.close(() => {
+  });
+  try {
+    await listenOn(host);
+  } catch (err) {
+    setHost(previousHost, previousHost === ANY);
+    await listenOn(previousHost).catch(() => {
+    });
+    throw err;
+  }
+}
+async function applyPersistedLanMode() {
+  if (env.RUNEYA_LAN_PROXY) return;
+  if (env.HOST !== LOOPBACK && env.HOST !== "localhost") return;
+  if (!await readPersisted()) return;
+  setHost(ANY, true);
+  console.log("[server] LAN mode: activ\xE9 par les r\xE9glages \u2014 \xE9coute sur 0.0.0.0");
+}
+async function setLanMode(enabled) {
+  await writePersisted(enabled);
+  const previousHost = env.HOST;
+  const host = enabled ? ANY : LOOPBACK;
+  setHost(host, enabled);
+  if (host !== previousHost) await rebind(host, previousHost);
+  console.log(`[server] LAN mode: ${enabled ? "activ\xE9" : "d\xE9sactiv\xE9"} \u2014 \xE9coute sur ${host}`);
+  return networkInfo();
+}
+
 // ../server/src/trpc/routers/settings.ts
 var NotificationPreferencesPatchSchema = NotificationPreferencesSchema.partial().strict();
 function maskApiKey2(plaintext) {
@@ -4391,8 +4513,8 @@ function maskApiKey2(plaintext) {
   return plaintext.slice(0, 4) + "****" + plaintext.slice(-4);
 }
 var ScopeShape = {
-  orgId: z10.string().max(128).nullable().optional(),
-  projectId: z10.string().max(128).optional()
+  orgId: z11.string().max(128).nullable().optional(),
+  projectId: z11.string().max(128).optional()
 };
 async function scopeOf(input) {
   return input?.orgId ?? await vaultOfProject(input?.projectId);
@@ -4419,6 +4541,27 @@ var settingsRouter = router({
     // whichever directory the server happened to be started in.
     machineDir: machineRoot()
   })),
+  /**
+   * Où le serveur écoute, et s'il est joignable depuis le réseau local.
+   */
+  getNetwork: protectedProcedure.query(() => networkInfo()),
+  /**
+   * Exposer — ou retirer — Runeya du réseau local, sans redémarrage.
+   *
+   * La socket d'écoute est rouverte sur place : les connexions en cours, dont
+   * celle de l'onglet qui bascule, ne sont pas coupées. Le choix est mémorisé
+   * dans les réglages, donc conservé au prochain démarrage.
+   */
+  setLanMode: protectedProcedure.input(z11.object({ enabled: z11.boolean() })).mutation(async ({ input }) => {
+    try {
+      return await setLanMode(input.enabled);
+    } catch (err) {
+      throw new TRPCError8({
+        code: "INTERNAL_SERVER_ERROR",
+        message: `Impossible de changer l'adresse d'\xE9coute : ${err.message}`
+      });
+    }
+  }),
   /**
    * Update settings (mode, cloudUrl)
    */
@@ -4434,7 +4577,7 @@ var settingsRouter = router({
   /**
    * Get notification preferences
    */
-  getNotificationPreferences: protectedProcedure.input(z10.object(ScopeShape).optional()).query(async ({ input }) => {
+  getNotificationPreferences: protectedProcedure.input(z11.object(ScopeShape).optional()).query(async ({ input }) => {
     const priv = await settingsManager.getPrivateSettings(await scopeOf(input));
     return NotificationPreferencesSchema.parse(priv.notifications ?? {});
   }),
@@ -4465,7 +4608,7 @@ var settingsRouter = router({
   /**
    * Get single parser by ID
    */
-  getParser: protectedProcedure.input(z10.object({ id: z10.string().max(128) })).query(async ({ input }) => {
+  getParser: protectedProcedure.input(z11.object({ id: z11.string().max(128) })).query(async ({ input }) => {
     const settings = await settingsManager.getSettings();
     const parser = (settings.logParsers || []).find((p) => p.id === input.id);
     if (!parser) {
@@ -4540,7 +4683,7 @@ var settingsRouter = router({
   /**
    * Delete parser by ID
    */
-  deleteParser: protectedProcedure.input(z10.object({ id: z10.string().max(128) })).mutation(async ({ input }) => {
+  deleteParser: protectedProcedure.input(z11.object({ id: z11.string().max(128) })).mutation(async ({ input }) => {
     const settings = await settingsManager.getSettings();
     const newParsers = (settings.logParsers || []).filter(
       (p) => p.id !== input.id
@@ -4563,7 +4706,7 @@ var settingsRouter = router({
   /**
    * List AI providers (API keys are masked)
    */
-  listAIProviders: protectedProcedure.input(z10.object(ScopeShape).optional()).query(async ({ input }) => {
+  listAIProviders: protectedProcedure.input(z11.object(ScopeShape).optional()).query(async ({ input }) => {
     const vault = await scopeOf(input);
     const priv = await settingsManager.getPrivateSettings(vault);
     return (priv.aiProviders ?? []).map((p) => {
@@ -4581,12 +4724,12 @@ var settingsRouter = router({
   /**
    * Create AI provider
    */
-  createAIProvider: protectedProcedure.input(z10.object({
-    name: z10.string().min(1).max(200),
+  createAIProvider: protectedProcedure.input(z11.object({
+    name: z11.string().min(1).max(200),
     provider: AIProviderSchema.shape.provider,
-    apiKey: z10.string().max(500).optional(),
+    apiKey: z11.string().max(500).optional(),
     // optional for providers like Ollama
-    model: z10.string().max(200).optional(),
+    model: z11.string().max(200).optional(),
     ...ScopeShape
   })).mutation(async ({ input }) => {
     if (input.provider !== "ollama" && !input.apiKey?.trim()) {
@@ -4619,12 +4762,12 @@ var settingsRouter = router({
   /**
    * Update AI provider (apiKey optional — omit to keep existing)
    */
-  updateAIProvider: protectedProcedure.input(z10.object({
-    id: z10.string().min(1).max(128),
-    name: z10.string().min(1).max(200).optional(),
+  updateAIProvider: protectedProcedure.input(z11.object({
+    id: z11.string().min(1).max(128),
+    name: z11.string().min(1).max(200).optional(),
     provider: AIProviderSchema.shape.provider.optional(),
-    apiKey: z10.string().min(1).max(500).optional(),
-    model: z10.string().max(200).optional(),
+    apiKey: z11.string().min(1).max(500).optional(),
+    model: z11.string().max(200).optional(),
     ...ScopeShape
   })).mutation(async ({ input }) => {
     const vault = await scopeOf(input);
@@ -4657,7 +4800,7 @@ var settingsRouter = router({
   /**
    * Delete AI provider
    */
-  deleteAIProvider: protectedProcedure.input(z10.object({ id: z10.string().min(1).max(128), ...ScopeShape })).mutation(async ({ input }) => {
+  deleteAIProvider: protectedProcedure.input(z11.object({ id: z11.string().min(1).max(128), ...ScopeShape })).mutation(async ({ input }) => {
     const vault = await scopeOf(input);
     const priv = await settingsManager.getPrivateSettings(vault);
     const providers = priv.aiProviders ?? [];
@@ -4671,7 +4814,7 @@ var settingsRouter = router({
   /**
    * Set one provider as active (clears active flag on all others)
    */
-  setActiveAIProvider: protectedProcedure.input(z10.object({ id: z10.string().min(1).max(128), ...ScopeShape })).mutation(async ({ input }) => {
+  setActiveAIProvider: protectedProcedure.input(z11.object({ id: z11.string().min(1).max(128), ...ScopeShape })).mutation(async ({ input }) => {
     const vault = await scopeOf(input);
     const priv = await settingsManager.getPrivateSettings(vault);
     const providers = priv.aiProviders ?? [];
@@ -4687,7 +4830,7 @@ var settingsRouter = router({
   /**
    * Get Traefik config for a specific agent (never returns credentials or cert key in plain text)
    */
-  getAgentTraefikConfig: protectedProcedure.input(z10.object({ agentId: z10.string().max(128) })).query(async ({ input }) => {
+  getAgentTraefikConfig: protectedProcedure.input(z11.object({ agentId: z11.string().max(128) })).query(async ({ input }) => {
     const raw = agentStore.getTraefikConfig(input.agentId);
     const parsed = raw ? TraefikConfigSchema.safeParse(raw) : null;
     const config = parsed?.success ? parsed.data : null;
@@ -4707,16 +4850,16 @@ var settingsRouter = router({
   /**
    * Update Traefik config for a specific agent (credentials are encrypted before saving)
    */
-  updateAgentTraefikConfig: protectedProcedure.input(z10.object({
-    agentId: z10.string().max(128),
-    enabled: z10.boolean().optional(),
-    acmeEmail: z10.string().email().max(256).optional(),
-    wildcardDomain: z10.string().max(253).optional(),
-    httpPort: z10.number().int().min(1).max(65535).optional(),
-    httpsPort: z10.number().int().min(1).max(65535).optional(),
-    dnsProvider: z10.string().max(64).optional(),
-    dnsCredentials: z10.record(z10.string().max(64), z10.string().max(2048)).optional(),
-    acmeStaging: z10.boolean().optional()
+  updateAgentTraefikConfig: protectedProcedure.input(z11.object({
+    agentId: z11.string().max(128),
+    enabled: z11.boolean().optional(),
+    acmeEmail: z11.string().email().max(256).optional(),
+    wildcardDomain: z11.string().max(253).optional(),
+    httpPort: z11.number().int().min(1).max(65535).optional(),
+    httpsPort: z11.number().int().min(1).max(65535).optional(),
+    dnsProvider: z11.string().max(64).optional(),
+    dnsCredentials: z11.record(z11.string().max(64), z11.string().max(2048)).optional(),
+    acmeStaging: z11.boolean().optional()
   })).mutation(async ({ input }) => {
     const { agentId, ...fields } = input;
     const raw = agentStore.getTraefikConfig(agentId);
@@ -4745,13 +4888,13 @@ var settingsRouter = router({
   /**
    * Get Traefik config files content for a specific agent
    */
-  getAgentTraefikConfigFiles: protectedProcedure.input(z10.object({ agentId: z10.string().max(128) })).query(async ({ input }) => {
+  getAgentTraefikConfigFiles: protectedProcedure.input(z11.object({ agentId: z11.string().max(128) })).query(async ({ input }) => {
     return agentManager.agentQuery(
       input.agentId,
       "config.getTraefikConfigFiles"
     );
   }),
-  getAgentTraefikFileTree: protectedProcedure.input(z10.object({ agentId: z10.string().max(128) })).query(async ({ input }) => {
+  getAgentTraefikFileTree: protectedProcedure.input(z11.object({ agentId: z11.string().max(128) })).query(async ({ input }) => {
     return agentManager.agentQuery(
       input.agentId,
       "config.getTraefikFileTree"
@@ -4760,7 +4903,7 @@ var settingsRouter = router({
   /**
    * Get Traefik container logs for a specific agent (snapshot)
    */
-  getAgentTraefikLogs: protectedProcedure.input(z10.object({ agentId: z10.string().max(128), lines: z10.number().int().min(1).max(500).default(100) })).query(async ({ input }) => {
+  getAgentTraefikLogs: protectedProcedure.input(z11.object({ agentId: z11.string().max(128), lines: z11.number().int().min(1).max(500).default(100) })).query(async ({ input }) => {
     const result = await agentManager.agentQuery(
       input.agentId,
       "config.getTraefikLogs",
@@ -4771,7 +4914,7 @@ var settingsRouter = router({
   /**
    * Stream Traefik logs in real-time (subscription, yields new lines every 500ms)
    */
-  streamAgentTraefikLogs: protectedProcedure.input(z10.object({ agentId: z10.string().max(128) })).subscription(async function* ({ input, signal }) {
+  streamAgentTraefikLogs: protectedProcedure.input(z11.object({ agentId: z11.string().max(128) })).subscription(async function* ({ input, signal }) {
     let seen = 0;
     while (!signal?.aborted) {
       try {
@@ -4794,7 +4937,7 @@ var settingsRouter = router({
   /**
    * Restart Traefik container on a specific agent (re-pushes config first to handle agent restarts)
    */
-  restartAgentTraefik: protectedProcedure.input(z10.object({ agentId: z10.string().max(128) })).mutation(async ({ input }) => {
+  restartAgentTraefik: protectedProcedure.input(z11.object({ agentId: z11.string().max(128) })).mutation(async ({ input }) => {
     const raw = agentStore.getTraefikConfig(input.agentId);
     const parsed = raw ? TraefikConfigSchema.safeParse(raw) : null;
     const config = parsed?.success ? parsed.data : null;
@@ -4807,7 +4950,7 @@ var settingsRouter = router({
   /**
    * Force certificate renewal for a specific agent (wipes acme.json + restarts container)
    */
-  renewAgentTraefikCert: protectedProcedure.input(z10.object({ agentId: z10.string().max(128) })).mutation(async ({ input }) => {
+  renewAgentTraefikCert: protectedProcedure.input(z11.object({ agentId: z11.string().max(128) })).mutation(async ({ input }) => {
     const raw = agentStore.getTraefikConfig(input.agentId);
     const parsed = raw ? TraefikConfigSchema.safeParse(raw) : null;
     const config = parsed?.success ? parsed.data : null;
@@ -4820,7 +4963,7 @@ var settingsRouter = router({
   /**
    * Validate Traefik configuration for a specific agent
    */
-  validateAgentTraefikConfig: protectedProcedure.input(z10.object({ agentId: z10.string().max(128) })).query(async ({ input }) => {
+  validateAgentTraefikConfig: protectedProcedure.input(z11.object({ agentId: z11.string().max(128) })).query(async ({ input }) => {
     const raw = agentStore.getTraefikConfig(input.agentId);
     const parsed = raw ? TraefikConfigSchema.safeParse(raw) : null;
     const config = parsed?.success ? parsed.data : null;
@@ -4852,20 +4995,20 @@ var settingsRouter = router({
     });
     if (config?.wildcardDomain?.trim()) {
       const sanitisedDomain = config.wildcardDomain.replace(/^\*\./, "").replace(/[^a-z0-9.-]/gi, "");
-      const probe2 = `probe.${sanitisedDomain}`;
+      const probe = `probe.${sanitisedDomain}`;
       try {
-        const addresses = await dns.resolve4(probe2);
+        const addresses = await dns.resolve4(probe);
         const pointsToLocalhost = addresses.some((a) => a === "127.0.0.1");
         checks.push({
           id: "dns_resolution",
           ok: pointsToLocalhost,
-          message: pointsToLocalhost ? `${probe2} \u2192 127.0.0.1 \u2713` : `${probe2} r\xE9sout vers ${addresses.join(", ")} (attendu : 127.0.0.1)`
+          message: pointsToLocalhost ? `${probe} \u2192 127.0.0.1 \u2713` : `${probe} r\xE9sout vers ${addresses.join(", ")} (attendu : 127.0.0.1)`
         });
       } catch {
         checks.push({
           id: "dns_resolution",
           ok: false,
-          message: `${probe2} ne r\xE9sout pas \u2014 v\xE9rifiez le DNS wildcard`
+          message: `${probe} ne r\xE9sout pas \u2014 v\xE9rifiez le DNS wildcard`
         });
       }
     }
@@ -4922,12 +5065,12 @@ var settingsRouter = router({
    * Test parser code: compile and run it against sample logs, return per-line results
    */
   testParser: protectedProcedure.input(
-    z10.object({
-      code: z10.string().max(5e4),
-      sampleLogs: z10.array(
-        z10.object({
-          raw: z10.string().max(16384),
-          stream: z10.enum(["stdout", "stderr"])
+    z11.object({
+      code: z11.string().max(5e4),
+      sampleLogs: z11.array(
+        z11.object({
+          raw: z11.string().max(16384),
+          stream: z11.enum(["stdout", "stderr"])
         })
       ).max(100).default([])
     })
@@ -4971,30 +5114,30 @@ var settingsRouter = router({
 });
 
 // ../server/src/trpc/routers/editor.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 import { TRPCError as TRPCError9 } from "@trpc/server";
 import { execFile as execFile3, spawn as spawn2 } from "child_process";
 import { stat as stat4 } from "fs/promises";
-import { resolve as resolve2, join as join12 } from "path";
+import { resolve as resolve2, join as join13 } from "path";
 import { homedir as homedir2 } from "os";
 
 // ../server/src/services/user-config-manager.ts
-import { readFile as readFile10, writeFile as writeFile10, rename as rename10, mkdir as mkdir10, chmod as chmod9 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile11, writeFile as writeFile11, rename as rename11, mkdir as mkdir11, chmod as chmod9 } from "fs/promises";
+import { join as join12 } from "path";
 import { homedir } from "os";
-import { z as z11 } from "zod";
-var CONFIG_DIR = join11(homedir(), ".runeya");
+import { z as z12 } from "zod";
+var CONFIG_DIR = join12(homedir(), ".runeya");
 var CONFIG_FILE = "runeya.conf";
-var EditorPreferencesSchema = z11.object({
-  default: z11.string().max(64).optional()
-}).catchall(z11.string().max(64)).refine((obj) => Object.keys(obj).length <= 500, "Too many editor preferences");
-var ProjectSettingsSchema = z11.object({
-  settings: z11.object({
+var EditorPreferencesSchema = z12.object({
+  default: z12.string().max(64).optional()
+}).catchall(z12.string().max(64)).refine((obj) => Object.keys(obj).length <= 500, "Too many editor preferences");
+var ProjectSettingsSchema = z12.object({
+  settings: z12.object({
     editors: EditorPreferencesSchema.optional()
   }).optional()
 });
-var UserConfigSchema = z11.record(
-  z11.string().max(128),
+var UserConfigSchema = z12.record(
+  z12.string().max(128),
   ProjectSettingsSchema
 ).refine((obj) => Object.keys(obj).length <= 100, "Too many projects in config");
 function configKey(ref) {
@@ -5003,20 +5146,20 @@ function configKey(ref) {
 var UserConfigManager = class {
   config = null;
   async ensureDir() {
-    await mkdir10(CONFIG_DIR, { recursive: true });
+    await mkdir11(CONFIG_DIR, { recursive: true });
   }
   async atomicWrite(data) {
     await this.ensureDir();
-    const filePath = join11(CONFIG_DIR, CONFIG_FILE);
+    const filePath = join12(CONFIG_DIR, CONFIG_FILE);
     const tmpPath = filePath + ".tmp";
-    await writeFile10(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-    await rename10(tmpPath, filePath);
+    await writeFile11(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    await rename11(tmpPath, filePath);
     await chmod9(filePath, 384);
   }
   async getConfig() {
     if (!this.config) {
       try {
-        const raw = await readFile10(join11(CONFIG_DIR, CONFIG_FILE), "utf-8");
+        const raw = await readFile11(join12(CONFIG_DIR, CONFIG_FILE), "utf-8");
         const parsed = UserConfigSchema.safeParse(JSON.parse(raw));
         this.config = parsed.success ? parsed.data : {};
       } catch {
@@ -5086,16 +5229,16 @@ var editorRouter = router({
     );
     return results;
   }),
-  getPreferences: protectedProcedure.input(z12.object({
-    projectId: z12.string().max(128),
-    orgId: z12.string().max(128).nullable().optional()
+  getPreferences: protectedProcedure.input(z13.object({
+    projectId: z13.string().max(128),
+    orgId: z13.string().max(128).nullable().optional()
   })).query(async ({ input }) => {
     return userConfigManager.getEditorPreferences({ id: input.projectId, orgId: input.orgId });
   }),
-  setDefault: protectedProcedure.input(z12.object({
-    projectId: z12.string().max(128),
-    orgId: z12.string().max(128).nullable().optional(),
-    editorKey: z12.string().max(64)
+  setDefault: protectedProcedure.input(z13.object({
+    projectId: z13.string().max(128),
+    orgId: z13.string().max(128).nullable().optional(),
+    editorKey: z13.string().max(64)
   })).mutation(async ({ input }) => {
     if (!EDITOR_BY_KEY.has(input.editorKey)) {
       throw new TRPCError9({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
@@ -5107,11 +5250,11 @@ var editorRouter = router({
     );
     return { success: true };
   }),
-  setServiceEditor: protectedProcedure.input(z12.object({
-    projectId: z12.string().max(128),
-    orgId: z12.string().max(128).nullable().optional(),
-    serviceId: z12.string().max(128),
-    editorKey: z12.string().max(64)
+  setServiceEditor: protectedProcedure.input(z13.object({
+    projectId: z13.string().max(128),
+    orgId: z13.string().max(128).nullable().optional(),
+    serviceId: z13.string().max(128),
+    editorKey: z13.string().max(64)
   })).mutation(async ({ input }) => {
     if (!EDITOR_BY_KEY.has(input.editorKey)) {
       throw new TRPCError9({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
@@ -5123,10 +5266,10 @@ var editorRouter = router({
     );
     return { success: true };
   }),
-  removeServiceEditor: protectedProcedure.input(z12.object({
-    projectId: z12.string().max(128),
-    orgId: z12.string().max(128).nullable().optional(),
-    serviceId: z12.string().max(128)
+  removeServiceEditor: protectedProcedure.input(z13.object({
+    projectId: z13.string().max(128),
+    orgId: z13.string().max(128).nullable().optional(),
+    serviceId: z13.string().max(128)
   })).mutation(async ({ input }) => {
     await userConfigManager.removeEditorPreference(
       { id: input.projectId, orgId: input.orgId },
@@ -5134,9 +5277,9 @@ var editorRouter = router({
     );
     return { success: true };
   }),
-  open: protectedProcedure.input(z12.object({
-    editorKey: z12.string().max(64),
-    path: z12.string().max(4096)
+  open: protectedProcedure.input(z13.object({
+    editorKey: z13.string().max(64),
+    path: z13.string().max(4096)
   })).mutation(async ({ input }) => {
     const editor = EDITOR_BY_KEY.get(input.editorKey);
     if (!editor) {
@@ -5159,17 +5302,17 @@ var editorRouter = router({
     child.unref();
     return { success: true };
   }),
-  openFile: protectedProcedure.input(z12.object({
-    editorKey: z12.string().max(64),
-    serviceId: z12.string().max(128),
-    relativePath: z12.string().max(4096)
+  openFile: protectedProcedure.input(z13.object({
+    editorKey: z13.string().max(64),
+    serviceId: z13.string().max(128),
+    relativePath: z13.string().max(4096)
   })).mutation(async ({ input }) => {
     const editor = EDITOR_BY_KEY.get(input.editorKey);
     if (!editor) {
       throw new TRPCError9({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
     }
     const cwd = await getServiceCwd(input.serviceId);
-    const filePath = join12(cwd, input.relativePath);
+    const filePath = join13(cwd, input.relativePath);
     if (!filePath.startsWith(cwd)) {
       throw new TRPCError9({ code: "BAD_REQUEST", message: "Path traversal not allowed" });
     }
@@ -5190,65 +5333,65 @@ var editorRouter = router({
 });
 
 // ../server/src/trpc/routers/api-keys.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 import { TRPCError as TRPCError10 } from "@trpc/server";
-import { mkdir as mkdir11, writeFile as writeFile11 } from "fs/promises";
-import { join as join13, dirname as dirname7 } from "path";
+import { mkdir as mkdir12, writeFile as writeFile12 } from "fs/promises";
+import { join as join14, dirname as dirname7 } from "path";
 var ALLOWED_SKILL_PATHS = /* @__PURE__ */ new Set([
   ".claude/skills/runeya/SKILL.md",
   ".cursor/rules/runeya.mdc",
   ".windsurf/rules/runeya.md"
 ]);
-var KeyInputSchema = z13.object({
-  name: z13.string().min(1).max(200),
+var KeyInputSchema = z14.object({
+  name: z14.string().min(1).max(200),
   scopes: ApiKeyScopeSchema,
-  isPublic: z13.boolean().default(false)
+  isPublic: z14.boolean().default(false)
 });
 var apiKeysRouter = router({
   list: protectedProcedure.query(() => apiKeyStore.list()),
-  create: protectedProcedure.input(KeyInputSchema.extend({ orgId: z13.string().min(1).max(128).nullable().optional() })).mutation(
+  create: protectedProcedure.input(KeyInputSchema.extend({ orgId: z14.string().min(1).max(128).nullable().optional() })).mutation(
     ({ input }) => apiKeyStore.create(input.name, input.scopes, input.isPublic, input.orgId ?? null)
   ),
   /**
    * Renvoie le secret d'une seule clé, sur demande explicite. `list` ne le
    * contient pas : une clé ne doit jamais être re-servie en masse.
    */
-  reveal: protectedProcedure.input(z13.object({ id: z13.string().max(128) })).query(async ({ input }) => {
+  reveal: protectedProcedure.input(z14.object({ id: z14.string().max(128) })).query(async ({ input }) => {
     const key = await apiKeyStore.reveal(input.id);
     if (!key) throw new TRPCError10({ code: "NOT_FOUND", message: "API key not found" });
     return { key };
   }),
-  update: protectedProcedure.input(KeyInputSchema.extend({ id: z13.string().max(128) })).mutation(async ({ input }) => {
+  update: protectedProcedure.input(KeyInputSchema.extend({ id: z14.string().max(128) })).mutation(async ({ input }) => {
     const updated = await apiKeyStore.update(input.id, input.name, input.scopes, input.isPublic);
     if (!updated) throw new TRPCError10({ code: "NOT_FOUND", message: "API key not found" });
     return maskApiKey(updated);
   }),
-  remove: protectedProcedure.input(z13.object({ id: z13.string().max(128) })).mutation(async ({ input }) => {
+  remove: protectedProcedure.input(z14.object({ id: z14.string().max(128) })).mutation(async ({ input }) => {
     const removed = await apiKeyStore.remove(input.id);
     if (!removed) throw new TRPCError10({ code: "NOT_FOUND", message: "API key not found" });
     return { success: true };
   }),
-  renewKey: protectedProcedure.input(z13.object({ id: z13.string().max(128) })).mutation(async ({ input }) => {
+  renewKey: protectedProcedure.input(z14.object({ id: z14.string().max(128) })).mutation(async ({ input }) => {
     const renewed = await apiKeyStore.renewKey(input.id);
     if (!renewed) throw new TRPCError10({ code: "NOT_FOUND", message: "API key not found" });
     return renewed;
   }),
-  writeSkillFile: protectedProcedure.input(z13.object({
-    relativePath: z13.string().max(256),
-    content: z13.string().max(32768)
+  writeSkillFile: protectedProcedure.input(z14.object({
+    relativePath: z14.string().max(256),
+    content: z14.string().max(32768)
   })).mutation(async ({ input }) => {
     if (!ALLOWED_SKILL_PATHS.has(input.relativePath)) {
       throw new TRPCError10({ code: "BAD_REQUEST", message: "Chemin non autoris\xE9" });
     }
-    const abs = join13(await resolveWorkspaceCwd({}), input.relativePath);
-    await mkdir11(dirname7(abs), { recursive: true });
-    await writeFile11(abs, input.content, { encoding: "utf-8", mode: 420 });
+    const abs = join14(await resolveWorkspaceCwd({}), input.relativePath);
+    await mkdir12(dirname7(abs), { recursive: true });
+    await writeFile12(abs, input.content, { encoding: "utf-8", mode: 420 });
     return { path: input.relativePath };
   })
 });
 
 // ../server/src/trpc/routers/chat.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 import Anthropic2 from "@anthropic-ai/sdk";
 import OpenAI2 from "openai";
 import { execFile as execFile4 } from "child_process";
@@ -5602,11 +5745,11 @@ function buildApiDocs(apiBaseUrl, apiToken) {
 }
 
 // ../server/src/services/claude-transcript-sync.ts
-import { readdir as readdir2, access, readFile as readFile11 } from "fs/promises";
+import { readdir as readdir2, access, readFile as readFile12 } from "fs/promises";
 import { watch } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join14 } from "path";
-var PROJECTS_DIR = join14(homedir3(), ".claude", "projects");
+import { join as join15 } from "path";
+var PROJECTS_DIR = join15(homedir3(), ".claude", "projects");
 var DEFAULT_TITLES = /* @__PURE__ */ new Set(["", "New conversation", "Nouvelle conversation"]);
 async function findClaudeSessionFile(sessionId) {
   let entries2;
@@ -5617,7 +5760,7 @@ async function findClaudeSessionFile(sessionId) {
   }
   const filename = `${sessionId}.jsonl`;
   for (const dir of entries2) {
-    const candidate = join14(PROJECTS_DIR, dir, filename);
+    const candidate = join15(PROJECTS_DIR, dir, filename);
     try {
       await access(candidate);
       return candidate;
@@ -5632,7 +5775,7 @@ async function claudeSessionExists(sessionId) {
 async function readClaudeTranscript(sessionId) {
   const path = await findClaudeSessionFile(sessionId);
   if (!path) return { found: false, path: null, entries: [] };
-  const raw = await readFile11(path, "utf-8");
+  const raw = await readFile12(path, "utf-8");
   const entries2 = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
@@ -5780,7 +5923,7 @@ async function startClaudeTranscriptWatcher() {
   }
   for (const dir of topLevel) {
     try {
-      const w = watch(join14(PROJECTS_DIR, dir), (_event, filename) => {
+      const w = watch(join15(PROJECTS_DIR, dir), (_event, filename) => {
         handleFsEvent(filename ? filename.toString() : null);
       });
       w.on("error", () => {
@@ -5806,8 +5949,8 @@ function stopClaudeTranscriptWatcher() {
 // ../server/src/services/codex-sessions.ts
 import { readdir as readdir3 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { join as join15 } from "path";
-var SESSIONS_DIR = join15(homedir4(), ".codex", "sessions");
+import { join as join16 } from "path";
+var SESSIONS_DIR = join16(homedir4(), ".codex", "sessions");
 async function findCodexSessionFile(sessionId) {
   const suffix = `-${sessionId}.jsonl`;
   async function walk(dir) {
@@ -5818,7 +5961,7 @@ async function findCodexSessionFile(sessionId) {
       return null;
     }
     for (const entry of entries2) {
-      const full = join15(dir, entry.name);
+      const full = join16(dir, entry.name);
       if (entry.isDirectory()) {
         const found = await walk(full);
         if (found) return found;
@@ -5838,12 +5981,12 @@ async function codexSessionExists(sessionId) {
 import { TRPCError as TRPCError12 } from "@trpc/server";
 
 // ../server/src/trpc/shared-schemas.ts
-import { z as z14 } from "zod";
-var Id128Schema = z14.string().max(128);
-var ConversationIdSchema = z14.string().max(128);
-var NameSchema = z14.string().min(1).max(200);
-var ShortString200Schema = z14.string().max(200);
-var DescriptionSchema = z14.string().max(2e3);
+import { z as z15 } from "zod";
+var Id128Schema = z15.string().max(128);
+var ConversationIdSchema = z15.string().max(128);
+var NameSchema = z15.string().min(1).max(200);
+var ShortString200Schema = z15.string().max(200);
+var DescriptionSchema = z15.string().max(2e3);
 var OptionalProviderIdSchema = Id128Schema.optional();
 
 // ../server/src/services/llms-txt-generator.ts
@@ -6778,11 +6921,11 @@ var ScenarioStore = class {
 var scenarioStore = new ScenarioStore();
 
 // ../server/src/services/scenario-run-store.ts
-import { mkdir as mkdir13, rm as rm2, readFile as readFile13 } from "fs/promises";
-import { join as join16 } from "path";
+import { mkdir as mkdir14, rm as rm2, readFile as readFile14 } from "fs/promises";
+import { join as join17 } from "path";
 
 // ../server/src/services/run-store-utils.ts
-import { chmod as chmod10, mkdir as mkdir12, rename as rename11, writeFile as writeFile12, readFile as readFile12 } from "fs/promises";
+import { chmod as chmod10, mkdir as mkdir13, rename as rename12, writeFile as writeFile13, readFile as readFile13 } from "fs/promises";
 import { dirname as dirname8, resolve as resolve3, sep } from "path";
 var SAFE_PATH_SEGMENT_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
 function resolveConversationRunDir(rootDirName, conversationId) {
@@ -6797,10 +6940,10 @@ function resolveConversationRunDir(rootDirName, conversationId) {
   return dir;
 }
 async function atomicWriteSecure(filePath, content) {
-  await mkdir12(dirname8(filePath), { recursive: true });
+  await mkdir13(dirname8(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp`;
-  await writeFile12(tmpPath, content, "utf-8");
-  await rename11(tmpPath, filePath);
+  await writeFile13(tmpPath, content, "utf-8");
+  await rename12(tmpPath, filePath);
   await chmod10(filePath, 384);
 }
 async function atomicWriteJsonSecure(filePath, data, pretty = false) {
@@ -6808,7 +6951,7 @@ async function atomicWriteJsonSecure(filePath, data, pretty = false) {
 }
 async function readJsonFileSafe(filePath) {
   try {
-    const raw = await readFile12(filePath, "utf-8");
+    const raw = await readFile13(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -6831,7 +6974,7 @@ var ScenarioRunStore = class _ScenarioRunStore {
   }
   async initializeConversationWorkspace(conversationId, scenario, userInput) {
     const dir = this.getRunDir(conversationId);
-    await mkdir13(dir, { recursive: true });
+    await mkdir14(dir, { recursive: true });
     await this.saveScenarioSnapshot(conversationId, scenario);
     const nodesById = new Map(scenario.nodes.map((p) => [p.id, p]));
     const teamMap = new Map(scenario.groups.map((t2) => [t2.id, t2.name]));
@@ -6856,8 +6999,8 @@ var ScenarioRunStore = class _ScenarioRunStore {
       "- Use read-only references from linked upstream files as context.",
       ""
     ].join("\n");
-    await atomicWriteSecure(join16(dir, "README.md"), overview);
-    await atomicWriteSecure(join16(dir, "USER_REQUEST.md"), `# User request
+    await atomicWriteSecure(join17(dir, "README.md"), overview);
+    await atomicWriteSecure(join17(dir, "USER_REQUEST.md"), `# User request
 
 ${userInput.trim() || "(empty)"}
 `);
@@ -6883,7 +7026,7 @@ ${userInput.trim() || "(empty)"}
         "- Waiting for assignment.",
         ""
       ].join("\n");
-      await atomicWriteSecure(join16(dir, fileName), content);
+      await atomicWriteSecure(join17(dir, fileName), content);
     }
   }
   async deleteRunDir(conversationId) {
@@ -6943,7 +7086,7 @@ ${userInput.trim() || "(empty)"}
     if (!runState) return;
     try {
       const dir = this.getRunDir(conversationId);
-      await mkdir13(dir, { recursive: true });
+      await mkdir14(dir, { recursive: true });
       const data = {
         nodeStates: { ...runState.nodeStates },
         nodeOutputs: { ...runState.nodeOutputs },
@@ -6951,18 +7094,18 @@ ${userInput.trim() || "(empty)"}
         ...Object.keys(runState.nodeAgentIds).length > 0 ? { nodeAgentIds: { ...runState.nodeAgentIds } } : {},
         ...Object.keys(runState.waitingInputs).length > 0 ? { waitingInputs: { ...runState.waitingInputs } } : {}
       };
-      await atomicWriteJsonSecure(join16(dir, "run-state.json"), data);
+      await atomicWriteJsonSecure(join17(dir, "run-state.json"), data);
     } catch {
     }
   }
   async loadPersistedRunState(conversationId) {
     const dir = this.getRunDir(conversationId);
-    return readJsonFileSafe(join16(dir, "run-state.json"));
+    return readJsonFileSafe(join17(dir, "run-state.json"));
   }
   async readUserRequest(conversationId) {
     try {
       const dir = this.getRunDir(conversationId);
-      const content = await readFile13(join16(dir, "USER_REQUEST.md"), "utf-8");
+      const content = await readFile14(join17(dir, "USER_REQUEST.md"), "utf-8");
       return content.replace(/^#\s*User request\s*\n+/, "").trim() || null;
     } catch {
       return null;
@@ -6971,23 +7114,23 @@ ${userInput.trim() || "(empty)"}
   async readReadme(conversationId) {
     try {
       const dir = this.getRunDir(conversationId);
-      return await readFile13(join16(dir, "README.md"), "utf-8");
+      return await readFile14(join17(dir, "README.md"), "utf-8");
     } catch {
       return null;
     }
   }
   async saveScenarioSnapshot(conversationId, scenario) {
     const dir = this.getRunDir(conversationId);
-    await mkdir13(dir, { recursive: true });
+    await mkdir14(dir, { recursive: true });
     await atomicWriteJsonSecure(
-      join16(dir, _ScenarioRunStore.SCENARIO_SNAPSHOT_FILE),
+      join17(dir, _ScenarioRunStore.SCENARIO_SNAPSHOT_FILE),
       scenario,
       true
     );
   }
   async loadScenarioSnapshot(conversationId) {
     const dir = this.getRunDir(conversationId);
-    return readJsonFileSafe(join16(dir, _ScenarioRunStore.SCENARIO_SNAPSHOT_FILE));
+    return readJsonFileSafe(join17(dir, _ScenarioRunStore.SCENARIO_SNAPSHOT_FILE));
   }
 };
 var scenarioRunStore = new ScenarioRunStore();
@@ -7033,9 +7176,9 @@ async function fetchProviderModels(provider, plaintextKey) {
 
 // ../server/src/services/image-storage.service.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { mkdir as mkdir14, writeFile as writeFile13, readFile as readFile14, unlink as unlink3, readdir as readdir4 } from "fs/promises";
+import { mkdir as mkdir15, writeFile as writeFile14, readFile as readFile15, unlink as unlink3, readdir as readdir4 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { join as join17, extname, resolve as resolve4, sep as sep2 } from "path";
+import { join as join18, extname, resolve as resolve4, sep as sep2 } from "path";
 var ALLOWED_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/png",
   "image/jpeg",
@@ -7052,7 +7195,7 @@ var ImageStorageService = class {
     this.dir = dir;
   }
   async ensureTmpDir() {
-    await mkdir14(this.dir, { recursive: true, mode: 448 });
+    await mkdir15(this.dir, { recursive: true, mode: 448 });
   }
   async saveImage(buffer, originalName, mimeType, contextId) {
     if (!ALLOWED_MIME_TYPES.has(mimeType)) {
@@ -7072,15 +7215,15 @@ var ImageStorageService = class {
     const imageId = randomUUID4();
     const safeExt = ext.replace(/[^a-z.]/g, "");
     const fileName = `${imageId}${safeExt}`;
-    const filePath = join17(this.dir, fileName);
+    const filePath = join18(this.dir, fileName);
     const resolvedPath = resolve4(filePath);
     const resolvedDir = resolve4(this.dir);
     if (resolvedPath !== resolvedDir && !resolvedPath.startsWith(resolvedDir + sep2)) {
       throw new Error("Invalid file path");
     }
-    await writeFile13(filePath, buffer, { mode: 384 });
+    await writeFile14(filePath, buffer, { mode: 384 });
     const meta = { imageId, filePath, mimeType, originalName, createdAt: Date.now(), contextId };
-    await writeFile13(`${filePath}.meta.json`, JSON.stringify(meta), { encoding: "utf-8", mode: 384 });
+    await writeFile14(`${filePath}.meta.json`, JSON.stringify(meta), { encoding: "utf-8", mode: 384 });
     return meta;
   }
   /**
@@ -7098,7 +7241,7 @@ var ImageStorageService = class {
       const files = await readdir4(this.dir);
       const metaFile = files.find((f) => f.startsWith(imageId) && f.endsWith(".meta.json"));
       if (!metaFile) return null;
-      const raw = JSON.parse(await readFile14(join17(this.dir, metaFile), "utf-8"));
+      const raw = JSON.parse(await readFile15(join18(this.dir, metaFile), "utf-8"));
       if (expectedContextId !== void 0 && raw.contextId !== expectedContextId) return null;
       if (!existsSync2(raw.filePath)) return null;
       return { filePath: raw.filePath, mimeType: raw.mimeType, contextId: raw.contextId };
@@ -7124,7 +7267,7 @@ var ImageStorageService = class {
     await Promise.all(
       files.filter((f) => f.endsWith(".meta.json")).map(async (file) => {
         try {
-          const raw = JSON.parse(await readFile14(join17(this.dir, file), "utf-8"));
+          const raw = JSON.parse(await readFile15(join18(this.dir, file), "utf-8"));
           if (raw.contextId === contextId) {
             await unlink3(raw.filePath).catch(() => {
             });
@@ -7139,7 +7282,7 @@ var ImageStorageService = class {
   async readImageAsBase64(imageId, expectedContextId) {
     const result = await this.getImagePath(imageId, expectedContextId);
     if (!result) return null;
-    const buffer = await readFile14(result.filePath);
+    const buffer = await readFile15(result.filePath);
     return { base64: buffer.toString("base64"), mimeType: result.mimeType };
   }
   async listExpiredImages(ttlMs = IMAGE_TTL_MS) {
@@ -7154,7 +7297,7 @@ var ImageStorageService = class {
     for (const file of files) {
       if (!file.endsWith(".meta.json")) continue;
       try {
-        const raw = JSON.parse(await readFile14(join17(this.dir, file), "utf-8"));
+        const raw = JSON.parse(await readFile15(join18(this.dir, file), "utf-8"));
         if (now - raw.createdAt > ttlMs) expired.push(raw);
       } catch {
       }
@@ -7216,11 +7359,8 @@ async function resolveImagesToBase64(images, contextId) {
   return results.filter((r) => r !== null);
 }
 
-// ../server/src/services/kanban-commands.ts
-import { randomUUID as randomUUID5 } from "crypto";
-
 // ../server/src/trpc/routers/cloud-auth.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 import { hostname } from "os";
 import { basename } from "path";
 import { TRPCError as TRPCError11 } from "@trpc/server";
@@ -7255,7 +7395,7 @@ function isAllowedProxyPath(path) {
 }
 var cloudAuthRouter = router({
   /** Build the cloud authorization URL to open in the browser. */
-  startLogin: protectedProcedure.input(z15.object({ returnTo: z15.string().url().max(2048) })).mutation(async ({ input }) => {
+  startLogin: protectedProcedure.input(z16.object({ returnTo: z16.string().url().max(2048) })).mutation(async ({ input }) => {
     if (!isLocalOrigin(input.returnTo)) {
       throw new TRPCError11({ code: "BAD_REQUEST", message: "returnTo must be a local origin." });
     }
@@ -7300,7 +7440,7 @@ var cloudAuthRouter = router({
    * drops the session, and the local token is dropped here too, so nothing is
    * left holding a dead credential.
    */
-  revokeDevice: protectedProcedure.input(z15.object({ id: z15.string().min(1).max(128) })).mutation(async ({ input }) => {
+  revokeDevice: protectedProcedure.input(z16.object({ id: z16.string().min(1).max(128) })).mutation(async ({ input }) => {
     const res = await cloudFetch2("/api/auth/device/revoke", { method: "POST", body: { id: input.id } });
     if (!res.ok) {
       if (res.status === 401) await cloudSessionStore.clear();
@@ -7317,11 +7457,11 @@ var cloudAuthRouter = router({
    * the cloud: the web UI asks its own server, which holds the credential.
    */
   proxy: protectedProcedure.input(
-    z15.object({
-      path: z15.string().min(1).max(512),
-      method: z15.enum(["GET", "POST"]).default("GET"),
-      query: z15.record(z15.string().max(128), z15.string().max(2048)).optional(),
-      body: z15.unknown().optional()
+    z16.object({
+      path: z16.string().min(1).max(512),
+      method: z16.enum(["GET", "POST"]).default("GET"),
+      query: z16.record(z16.string().max(128), z16.string().max(2048)).optional(),
+      body: z16.unknown().optional()
     })
   ).mutation(async ({ input }) => {
     if (!isAllowedProxyPath(input.path)) {
@@ -7466,6 +7606,20 @@ var KanbanStore = class {
     });
     return res.ok;
   }
+  /**
+   * Ajouter une carte, sans réécrire le tableau.
+   *
+   * La colonne se nomme par son titre : c'est ce que connaît une IA qui lit un
+   * tableau, et le cloud le résout. Deux ajouts qui se croisent se rangent tous
+   * les deux, ce qu'une sauvegarde de tableau entier ne garantissait pas.
+   */
+  async addCard(boardId, input) {
+    const res = await callCloud("/kanban/card/add", {
+      method: "POST",
+      body: { boardId, ...input }
+    });
+    return res.data?.card ?? null;
+  }
   /** Déplacer une carte, sans réécrire le tableau. */
   async moveCard(boardId, cardId, toColumnId) {
     const res = await callCloud("/kanban/card/move", {
@@ -7558,7 +7712,6 @@ async function executeKanbanCommands(boardId, cardId, commands, conversationId)
       return;
     }
   }
-  let pendingBoardWrite = false;
   for (const cmd of commands) {
     if (cmd.type === "move_card" && cmd.columnTitle) {
       const target = board.columns.find(
@@ -7574,11 +7727,14 @@ async function executeKanbanCommands(boardId, cardId, commands, conversationId)
       const ok = await kanbanStore.addComment(board.id, cardId, cmd.comment, conversationId);
       if (!ok) console.warn(`[kanban-commands] add_comment failed: card=${cardId}`);
     } else if (cmd.type === "add_card" && cmd.columnTitle && cmd.cardTitle) {
-      addCardToColumn(board, cmd.columnTitle, cmd.cardTitle, cmd.cardContent);
-      pendingBoardWrite = true;
+      const card = await kanbanStore.addCard(board.id, {
+        column: cmd.columnTitle,
+        title: cmd.cardTitle,
+        markdown: cmd.cardContent
+      });
+      if (!card) console.warn(`[kanban-commands] add_card failed: column="${cmd.columnTitle}"`);
     }
   }
-  if (pendingBoardWrite) await kanbanStore.update({ id: board.id, columns: board.columns });
 }
 async function executeKanbanBoardCommands(boardId, commands) {
   if (commands.length === 0) return;
@@ -7586,30 +7742,14 @@ async function executeKanbanBoardCommands(boardId, commands) {
   if (!board) return;
   for (const cmd of commands) {
     if (cmd.type === "add_card" && cmd.columnTitle && cmd.cardTitle) {
-      addCardToColumn(board, cmd.columnTitle, cmd.cardTitle, cmd.cardContent);
-    }
-  }
-  await kanbanStore.update({ id: board.id, columns: board.columns });
-}
-function addCardToColumn(board, columnTitle, cardTitle, cardContent) {
-  const col = board.columns.find((c) => c.title.toLowerCase() === columnTitle.toLowerCase());
-  if (!col) return;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const card = {
-    id: randomUUID5(),
-    title: cardTitle,
-    markdown: cardContent ?? "",
-    images: [],
-    // `.default([])` on the schema makes these optional on the wire but required
-    // on the inferred type — a card built by hand has to supply them.
-    attachments: [],
-    assignees: [],
-    order: col.cards.length,
-    history: [{ type: "created", timestamp: now, detail: `AI \u2014 In column "${col.title}"` }],
-    createdAt: now,
-    updatedAt: now
-  };
-  col.cards.push(card);
+      const card = await kanbanStore.addCard(board.id, {
+        column: cmd.columnTitle,
+        title: cmd.cardTitle,
+        markdown: cmd.cardContent
+      });
+      if (!card) console.warn(`[kanban-commands] add_card failed: column="${cmd.columnTitle}"`);
+    }
+  }
 }
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} o`;
@@ -7835,7 +7975,7 @@ Ne jamais omettre ce tag. Il doit \xEAtre la toute derni\xE8re ligne de ta r\xE9
 `.trim();
 
 // ../server/src/services/ai-runners/claude-pty-runner.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // ../server/src/services/ai-runners/claude-pty-tail.ts
 import { open } from "fs/promises";
@@ -7959,7 +8099,7 @@ function tailTranscript(opts) {
 
 // ../server/src/services/ai-runners/claude-pty-runner.ts
 async function getAgentManager() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-74WZPMVQ.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-YDLSYZE3.js");
   return agentManager2;
 }
 function buildPtyArgs(params, sessionId, opts) {
@@ -8029,7 +8169,7 @@ function dispatchEntry(entry, state, cbs) {
 async function runClaudeViaPty(params) {
   const { agentId, signal, skipTokenInstructions } = params;
   if (!agentId) throw new Error("runClaudeViaPty requires an agentId");
-  const sessionId = params.sessionId && params.sessionId.length > 0 ? params.sessionId : randomUUID6();
+  const sessionId = params.sessionId && params.sessionId.length > 0 ? params.sessionId : randomUUID5();
   const args = buildPtyArgs(params, sessionId, { excludeMcp: true });
   const agentMgr = await getAgentManager();
   const displayArgs = args.map((a) => {
@@ -8700,7 +8840,7 @@ async function shutdownCodexAppServer() {
   }
 }
 async function getAgentManager2() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-74WZPMVQ.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-YDLSYZE3.js");
   return agentManager2;
 }
 function parseRuneyaCurlCommand(command) {
@@ -9141,18 +9281,18 @@ ${prompt}`;
 
 // ../server/src/trpc/routers/chat.ts
 var execFileAsync3 = promisify3(execFile4);
-var MessageSchema = z16.object({
-  role: z16.enum(["user", "assistant"]),
-  content: z16.string().max(1e5)
+var MessageSchema = z17.object({
+  role: z17.enum(["user", "assistant"]),
+  content: z17.string().max(1e5)
 });
-var ImagePartSchema = z16.object({
-  type: z16.literal("image"),
-  imageId: z16.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
-  url: z16.string().max(500),
-  mimeType: z16.string().max(100),
-  altText: z16.string().max(500).optional()
+var ImagePartSchema = z17.object({
+  type: z17.literal("image"),
+  imageId: z17.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  url: z17.string().max(500),
+  mimeType: z17.string().max(100),
+  altText: z17.string().max(500).optional()
 });
-var ImagePartsSchema = z16.array(ImagePartSchema).max(5).optional();
+var ImagePartsSchema = z17.array(ImagePartSchema).max(5).optional();
 var LANGUAGE_INSTRUCTION = "Always respond in the same language the user writes in.";
 async function buildSystemPrompt(apiKey) {
   const allServices = await serviceStore.list();
@@ -9539,24 +9679,24 @@ async function startCodexSession(convId, prompt, opts = {}) {
   });
   return { session, done };
 }
-var MessagePartSchema = z16.discriminatedUnion("type", [
-  z16.object({ type: z16.literal("thinking"), text: z16.string().max(1e5) }),
-  z16.object({ type: z16.literal("text"), text: z16.string().max(1e5) }),
-  z16.object({
-    type: z16.literal("tool"),
+var MessagePartSchema = z17.discriminatedUnion("type", [
+  z17.object({ type: z17.literal("thinking"), text: z17.string().max(1e5) }),
+  z17.object({ type: z17.literal("text"), text: z17.string().max(1e5) }),
+  z17.object({
+    type: z17.literal("tool"),
     id: Id128Schema,
     name: Id128Schema,
-    input: z16.record(z16.string(), z16.unknown()).optional(),
-    rawInput: z16.string().max(1e4).optional(),
-    result: z16.unknown().optional(),
-    isError: z16.boolean().optional(),
-    pending: z16.boolean()
+    input: z17.record(z17.string(), z17.unknown()).optional(),
+    rawInput: z17.string().max(1e4).optional(),
+    result: z17.unknown().optional(),
+    isError: z17.boolean().optional(),
+    pending: z17.boolean()
   })
 ]);
-var StoredMessageSchema = z16.object({
-  role: z16.enum(["user", "assistant"]),
-  content: z16.string().max(1e5),
-  parts: z16.array(MessagePartSchema).max(200).optional()
+var StoredMessageSchema = z17.object({
+  role: z17.enum(["user", "assistant"]),
+  content: z17.string().max(1e5),
+  parts: z17.array(MessagePartSchema).max(200).optional()
 });
 async function conversationCwd(conv) {
   return resolveConversationCwd(conv.id);
@@ -9570,7 +9710,7 @@ var chatRouter = router({
      * et sans le même filtre il y reversait toutes les conversations de la
      * machine, une seconde après un chargement pourtant filtré.
      */
-    onChanged: protectedProcedure.input(z16.object({
+    onChanged: protectedProcedure.input(z17.object({
       projectId: Id128Schema.optional(),
       orgId: Id128Schema.nullable().optional()
     }).optional()).subscription(async function* ({ input }) {
@@ -9618,7 +9758,7 @@ var chatRouter = router({
      * reachable where they were written, without leaking into every other
      * organization's projects.
      */
-    list: protectedProcedure.input(z16.object({
+    list: protectedProcedure.input(z17.object({
       projectId: Id128Schema.optional(),
       orgId: Id128Schema.nullable().optional()
     }).optional()).query(async ({ input }) => {
@@ -9626,24 +9766,24 @@ var chatRouter = router({
       if (!projectId) return conversationStore.list();
       return conversationStore.listForProject({ id: projectId, orgId: input?.orgId });
     }),
-    get: protectedProcedure.input(z16.object({ id: Id128Schema })).query(async ({ input }) => {
+    get: protectedProcedure.input(z17.object({ id: Id128Schema })).query(async ({ input }) => {
       const conv = await conversationStore.get(input.id);
       if (!conv) throw new TRPCError12({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
     }),
-    create: protectedProcedure.input(z16.object({
+    create: protectedProcedure.input(z17.object({
       title: ShortString200Schema.optional(),
-      isCli: z16.boolean().optional(),
-      runner: z16.enum(["claude-code", "codex"]).optional(),
+      isCli: z17.boolean().optional(),
+      runner: z17.enum(["claude-code", "codex"]).optional(),
       providerId: Id128Schema.optional(),
       scenarioId: Id128Schema.optional(),
-      scenarioInput: z16.string().max(1e5).optional(),
+      scenarioInput: z17.string().max(1e5).optional(),
       kanbanBoardId: Id128Schema.optional(),
       kanbanCardId: Id128Schema.optional(),
       // The project the conversation is about: only the caller knows which
       // one it is looking at.
       projectId: Id128Schema.optional(),
-      orgId: z16.string().max(128).nullable().optional()
+      orgId: z17.string().max(128).nullable().optional()
     })).mutation(async ({ input }) => {
       let scenario = null;
       if (input.scenarioId) {
@@ -9674,20 +9814,20 @@ var chatRouter = router({
       }
       return conv;
     }),
-    update: protectedProcedure.input(z16.object({
+    update: protectedProcedure.input(z17.object({
       id: Id128Schema,
       title: ShortString200Schema.optional(),
-      messages: z16.array(StoredMessageSchema).max(500).optional(),
-      contextUsage: z16.object({
-        inputTokens: z16.number().int().nonnegative(),
-        contextWindow: z16.number().int().positive()
+      messages: z17.array(StoredMessageSchema).max(500).optional(),
+      contextUsage: z17.object({
+        inputTokens: z17.number().int().nonnegative(),
+        contextWindow: z17.number().int().positive()
       }).optional()
     })).mutation(async ({ input }) => {
       const conv = await conversationStore.update(input.id, { title: input.title, messages: input.messages, contextUsage: input.contextUsage });
       if (!conv) throw new TRPCError12({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
     }),
-    delete: protectedProcedure.input(z16.object({ id: Id128Schema })).mutation(async ({ input }) => {
+    delete: protectedProcedure.input(z17.object({ id: Id128Schema })).mutation(async ({ input }) => {
       const existing = await conversationStore.get(input.id);
       if (!existing) throw new TRPCError12({ code: "NOT_FOUND", message: "Conversation not found" });
       for (const agent of agentManager.listAgents()) {
@@ -9709,18 +9849,18 @@ var chatRouter = router({
         (err) => console.error("[chat.delete] Image cleanup error:", err)
       );
     }),
-    archive: protectedProcedure.input(z16.object({ id: Id128Schema, archived: z16.boolean() })).mutation(async ({ input }) => {
+    archive: protectedProcedure.input(z17.object({ id: Id128Schema, archived: z17.boolean() })).mutation(async ({ input }) => {
       const conv = await conversationStore.update(input.id, { archived: input.archived });
       if (!conv) throw new TRPCError12({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
     })
   }),
-  listModels: protectedProcedure.input(z16.object({
+  listModels: protectedProcedure.input(z17.object({
     providerId: Id128Schema.optional(),
     // Le projet dit de quelle organisation lire les fournisseurs ; absent,
     // ce sont ceux du poste.
     projectId: Id128Schema.optional(),
-    orgId: z16.string().max(128).nullable().optional()
+    orgId: z17.string().max(128).nullable().optional()
   }).optional()).query(async ({ input }) => {
     const active = await getActiveProvider(
       input?.providerId,
@@ -9733,7 +9873,7 @@ var chatRouter = router({
       return [];
     }
   }),
-  checkCliAvailability: protectedProcedure.input(z16.object({ agentId: Id128Schema.optional() }).optional()).query(async ({ input }) => {
+  checkCliAvailability: protectedProcedure.input(z17.object({ agentId: Id128Schema.optional() }).optional()).query(async ({ input }) => {
     if (input?.agentId) {
       try {
         const res = await agentManager.agentQuery(
@@ -9751,12 +9891,12 @@ var chatRouter = router({
     ]);
     return { available: claudeOk, codexAvailable: codexOk };
   }),
-  enhanceScenarioPrompt: protectedProcedure.input(z16.object({
-    text: z16.string().max(1e4),
+  enhanceScenarioPrompt: protectedProcedure.input(z17.object({
+    text: z17.string().max(1e4),
     providerId: Id128Schema.optional(),
-    model: z16.string().max(200).optional(),
+    model: z17.string().max(200).optional(),
     projectId: Id128Schema.optional(),
-    orgId: z16.string().max(128).nullable().optional()
+    orgId: z17.string().max(128).nullable().optional()
   })).mutation(async ({ input }) => {
     const active = await getActiveProvider(
       input.providerId,
@@ -9813,22 +9953,22 @@ Return ONLY the improved text, no explanation, no preamble.`;
     }
   }),
   getStreamingStatus: protectedProcedure.query(() => activeSessionRegistry.listActive()),
-  stopSession: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
+  stopSession: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
     if (process.env.RUNEYA_DEBUG) console.log("[chat]: stopSession");
     const killed = activeSessionRegistry.kill(input.conversationId);
     if (!killed) throw new TRPCError12({ code: "NOT_FOUND", message: "No active session for this conversation" });
     return { ok: true };
   }),
-  streamViaClaudeCode: protectedProcedure.input(z16.object({
+  streamViaClaudeCode: protectedProcedure.input(z17.object({
     conversationId: ConversationIdSchema,
-    prompt: z16.string().max(1e5),
-    contextNote: z16.string().max(2e5).optional(),
+    prompt: z17.string().max(1e5),
+    contextNote: z17.string().max(2e5).optional(),
     model: ShortString200Schema.optional(),
-    effort: z16.enum(["low", "medium", "high"]).optional(),
-    reconnect: z16.boolean().optional(),
+    effort: z17.enum(["low", "medium", "high"]).optional(),
+    reconnect: z17.boolean().optional(),
     agentId: Id128Schema.optional(),
-    environmentId: z16.string().max(128).optional(),
-    imageIds: z16.array(z16.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
+    environmentId: z17.string().max(128).optional(),
+    imageIds: z17.array(z17.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
     imageParts: ImagePartsSchema
   })).subscription(async function* ({ input, ctx, signal }) {
     if (process.env.RUNEYA_DEBUG) console.log("[chat]: Reconnect");
@@ -9939,15 +10079,15 @@ ${imagePaths.map((p) => `Image: ${p}`).join("\n")}` : cliPrompt;
     if (process.env.RUNEYA_DEBUG) console.log("[chat]: drainSession...");
     yield* drainSession(session, signal, false);
   }),
-  streamViaCodex: protectedProcedure.input(z16.object({
+  streamViaCodex: protectedProcedure.input(z17.object({
     conversationId: ConversationIdSchema,
-    prompt: z16.string().max(1e5),
-    contextNote: z16.string().max(2e5).optional(),
+    prompt: z17.string().max(1e5),
+    contextNote: z17.string().max(2e5).optional(),
     model: ShortString200Schema.optional(),
-    reconnect: z16.boolean().optional(),
+    reconnect: z17.boolean().optional(),
     agentId: Id128Schema.optional(),
-    environmentId: z16.string().max(128).optional(),
-    imageIds: z16.array(z16.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
+    environmentId: z17.string().max(128).optional(),
+    imageIds: z17.array(z17.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
     imageParts: ImagePartsSchema
   })).subscription(async function* ({ input, ctx, signal }) {
     const existingSession = activeSessionRegistry.get(input.conversationId);
@@ -10025,13 +10165,13 @@ ${input.prompt}` : input.prompt;
     });
     yield* drainSession(session, signal, false);
   }),
-  send: protectedProcedure.input(z16.object({
+  send: protectedProcedure.input(z17.object({
     conversationId: ConversationIdSchema,
-    messages: z16.array(MessageSchema).min(0).max(100),
+    messages: z17.array(MessageSchema).min(0).max(100),
     model: ShortString200Schema.optional(),
-    contextNote: z16.string().max(2e5).optional(),
-    reconnect: z16.boolean().optional(),
-    imageIds: z16.array(z16.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
+    contextNote: z17.string().max(2e5).optional(),
+    reconnect: z17.boolean().optional(),
+    imageIds: z17.array(z17.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
     imageParts: ImagePartsSchema
   })).subscription(async function* ({ input, ctx, signal }) {
     const existingSession = activeSessionRegistry.get(input.conversationId);
@@ -10149,25 +10289,25 @@ ${input.prompt}` : input.prompt;
   // ── PTY passthrough (interactive Claude Code session) ────────────────────
   pty: router({
     /** Start a PTY session running `claude --resume <sessionId>` (or fresh). */
-    start: protectedProcedure.input(z16.object({
-      agentId: z16.string().max(128).optional(),
-      sessionId: z16.string().max(128).optional(),
-      runner: z16.enum(["claude-code", "codex"]).default("claude-code"),
-      resume: z16.boolean().default(false),
-      model: z16.string().max(128).optional(),
-      cwd: z16.string().max(4096).optional(),
+    start: protectedProcedure.input(z17.object({
+      agentId: z17.string().max(128).optional(),
+      sessionId: z17.string().max(128).optional(),
+      runner: z17.enum(["claude-code", "codex"]).default("claude-code"),
+      resume: z17.boolean().default(false),
+      model: z17.string().max(128).optional(),
+      cwd: z17.string().max(4096).optional(),
       /** Anchors the session when no explicit cwd is given. */
-      serviceId: z16.string().max(128).optional(),
+      serviceId: z17.string().max(128).optional(),
       projectId: Id128Schema.optional(),
-      orgId: z16.string().max(128).nullable().optional(),
-      cols: z16.number().int().min(1).max(1e3).default(120),
-      rows: z16.number().int().min(1).max(1e3).default(30),
-      enableMcp: z16.boolean().default(false),
-      apiBaseUrl: z16.string().max(512).optional(),
-      environmentId: z16.string().max(128).optional(),
-      attachedContexts: z16.array(z16.object({
-        label: z16.string().max(200),
-        text: z16.string().max(1e6)
+      orgId: z17.string().max(128).nullable().optional(),
+      cols: z17.number().int().min(1).max(1e3).default(120),
+      rows: z17.number().int().min(1).max(1e3).default(30),
+      enableMcp: z17.boolean().default(false),
+      apiBaseUrl: z17.string().max(512).optional(),
+      environmentId: z17.string().max(128).optional(),
+      attachedContexts: z17.array(z17.object({
+        label: z17.string().max(200),
+        text: z17.string().max(1e6)
       })).max(20).optional()
     })).mutation(async ({ input, ctx }) => {
       const t0 = Date.now();
@@ -10326,10 +10466,10 @@ Context:
       return { spawnId: res.spawnId, agentId, reattached: false };
     }),
     /** Subscribe to PTY output stream (raw text with ANSI). */
-    stream: protectedProcedure.input(z16.object({
-      agentId: z16.string().max(128).optional(),
-      spawnId: z16.string().max(128),
-      fromOffset: z16.number().int().min(0).default(0)
+    stream: protectedProcedure.input(z17.object({
+      agentId: z17.string().max(128).optional(),
+      spawnId: z17.string().max(128),
+      fromOffset: z17.number().int().min(0).default(0)
     })).subscription(async function* ({ input, signal }) {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError12({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -10381,10 +10521,10 @@ Context:
       }
     }),
     /** Write input to a PTY session (keystrokes from xterm). */
-    write: protectedProcedure.input(z16.object({
-      agentId: z16.string().max(128).optional(),
-      spawnId: z16.string().max(128),
-      data: z16.string().max(1e6)
+    write: protectedProcedure.input(z17.object({
+      agentId: z17.string().max(128).optional(),
+      spawnId: z17.string().max(128),
+      data: z17.string().max(1e6)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError12({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -10394,11 +10534,11 @@ Context:
       });
     }),
     /** Resize a PTY session. */
-    resize: protectedProcedure.input(z16.object({
-      agentId: z16.string().max(128).optional(),
-      spawnId: z16.string().max(128),
-      cols: z16.number().int().min(1).max(1e3),
-      rows: z16.number().int().min(1).max(1e3)
+    resize: protectedProcedure.input(z17.object({
+      agentId: z17.string().max(128).optional(),
+      spawnId: z17.string().max(128),
+      cols: z17.number().int().min(1).max(1e3),
+      rows: z17.number().int().min(1).max(1e3)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError12({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -10414,11 +10554,11 @@ Context:
      * picks it up. Returns the tmp path and which clipboard method succeeded
      * (null if none — caller should inject `@<path>` instead of Ctrl+V).
      */
-    pasteImage: protectedProcedure.input(z16.object({
-      agentId: z16.string().max(128).optional(),
-      sessionId: z16.string().max(128).optional(),
-      mimeType: z16.string().max(64),
-      base64: z16.string().max(15e6)
+    pasteImage: protectedProcedure.input(z17.object({
+      agentId: z17.string().max(128).optional(),
+      sessionId: z17.string().max(128).optional(),
+      mimeType: z17.string().max(64),
+      base64: z17.string().max(15e6)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError12({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -10436,7 +10576,7 @@ Context:
      * Read the transcript Claude Code stores on disk for a given session.
      * Returns parsed JSONL entries (user / assistant messages, tool uses, etc.).
      */
-    transcript: protectedProcedure.input(z16.object({ sessionId: z16.string().max(128) })).query(async ({ input }) => {
+    transcript: protectedProcedure.input(z17.object({ sessionId: z17.string().max(128) })).query(async ({ input }) => {
       return readClaudeTranscript(input.sessionId);
     }),
     /**
@@ -10444,9 +10584,9 @@ Context:
      * when was the transcript JSONL last touched? Used by the non-PTY view
      * to show a "Claude is thinking…" indicator while output streams.
      */
-    activity: protectedProcedure.input(z16.object({
-      agentId: z16.string().max(128).optional(),
-      sessionId: z16.string().max(128)
+    activity: protectedProcedure.input(z17.object({
+      agentId: z17.string().max(128).optional(),
+      sessionId: z17.string().max(128)
     })).query(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       let running = false;
@@ -10472,7 +10612,7 @@ Context:
      * them on the conversation, so the non-PTY chat view stays in sync.
      * Uses the conversation id as session id (PTY sessions are spawned that way).
      */
-    syncTranscript: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).mutation(async ({ input }) => {
+    syncTranscript: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).mutation(async ({ input }) => {
       const conv = await conversationStore.get(input.conversationId);
       if (!conv) {
         throw new TRPCError12({ code: "NOT_FOUND", message: `Conversation ${input.conversationId} not found` });
@@ -10486,14 +10626,14 @@ Context:
      * with the given sessionId. Used to benchmark the PTY → tRPC → xterm.js
      * pipeline. Open the conversation in PTY mode to attach to it.
      */
-    debugStress: protectedProcedure.input(z16.object({
-      sessionId: z16.string().max(128),
-      agentId: z16.string().max(128).optional(),
-      bytesPerSec: z16.number().int().min(100).max(1e7).default(5e4),
-      chunkSize: z16.number().int().min(1).max(65536).default(256),
-      durationMs: z16.number().int().min(0).max(36e5).default(0),
-      cols: z16.number().int().min(1).max(1e3).default(120),
-      rows: z16.number().int().min(1).max(1e3).default(30)
+    debugStress: protectedProcedure.input(z17.object({
+      sessionId: z17.string().max(128),
+      agentId: z17.string().max(128).optional(),
+      bytesPerSec: z17.number().int().min(100).max(1e7).default(5e4),
+      chunkSize: z17.number().int().min(1).max(65536).default(256),
+      durationMs: z17.number().int().min(0).max(36e5).default(0),
+      cols: z17.number().int().min(1).max(1e3).default(120),
+      rows: z17.number().int().min(1).max(1e3).default(30)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError12({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -10540,9 +10680,9 @@ Context:
       return { spawnId: res.spawnId, agentId, stressSessionId };
     }),
     /** Kill a PTY session. */
-    kill: protectedProcedure.input(z16.object({
-      agentId: z16.string().max(128).optional(),
-      spawnId: z16.string().max(128)
+    kill: protectedProcedure.input(z17.object({
+      agentId: z17.string().max(128).optional(),
+      spawnId: z17.string().max(128)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError12({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -10554,16 +10694,16 @@ Context:
 });
 
 // ../server/src/trpc/routers/git.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 import { TRPCError as TRPCError13 } from "@trpc/server";
 import Anthropic3 from "@anthropic-ai/sdk";
 import OpenAI3 from "openai";
-var SERVICE_ID_SCHEMA = z17.string().max(128);
-var SAFE_PATH_SCHEMA = z17.string().min(1).max(4096).refine((p) => !p.startsWith("/") && !p.includes("../"), {
+var SERVICE_ID_SCHEMA = z18.string().max(128);
+var SAFE_PATH_SCHEMA = z18.string().min(1).max(4096).refine((p) => !p.startsWith("/") && !p.includes("../"), {
   message: "Path must be relative and not traverse up"
 });
-var REMOTE_SCHEMA = z17.string().min(1).max(128).regex(/^[a-zA-Z0-9_\-.]+$/);
-var BRANCH_SCHEMA = z17.string().min(1).max(256).regex(/^[a-zA-Z0-9._\-/]+$/);
+var REMOTE_SCHEMA = z18.string().min(1).max(128).regex(/^[a-zA-Z0-9_\-.]+$/);
+var BRANCH_SCHEMA = z18.string().min(1).max(256).regex(/^[a-zA-Z0-9._\-/]+$/);
 async function resolveServiceContext(serviceId) {
   const service = await serviceStore.get(serviceId);
   if (!service) {
@@ -10577,11 +10717,11 @@ async function resolveServiceContext(serviceId) {
 }
 var gitTargetShape = {
   serviceId: SERVICE_ID_SCHEMA.optional(),
-  agentId: z17.string().max(128).optional(),
+  agentId: z18.string().max(128).optional(),
   /** Anchors on a project when no service is targeted (e.g. from the AI chat). */
-  projectId: z17.string().max(128).optional(),
+  projectId: z18.string().max(128).optional(),
   /** Son organisation : un id de projet seul peut en nommer un par organisation. */
-  orgId: z17.string().max(128).nullable().optional()
+  orgId: z18.string().max(128).nullable().optional()
 };
 async function resolveGitContext(input) {
   if (input.serviceId) return resolveServiceContext(input.serviceId);
@@ -10594,82 +10734,82 @@ async function resolveGitContext(input) {
 }
 var gitRouter = router({
   /** Get full git status */
-  status: protectedProcedure.input(z17.object({ ...gitTargetShape })).query(async ({ input }) => {
+  status: protectedProcedure.input(z18.object({ ...gitTargetShape })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.status", { cwd });
   }),
   /** Get commit log */
-  log: protectedProcedure.input(z17.object({ ...gitTargetShape, limit: z17.number().int().min(1).max(200).default(50) })).query(async ({ input }) => {
+  log: protectedProcedure.input(z18.object({ ...gitTargetShape, limit: z18.number().int().min(1).max(200).default(50) })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.log", { cwd, limit: input.limit });
   }),
   /** List local and remote branches */
-  branches: protectedProcedure.input(z17.object({ ...gitTargetShape })).query(async ({ input }) => {
+  branches: protectedProcedure.input(z18.object({ ...gitTargetShape })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.branches", { cwd });
   }),
   /** Checkout a branch */
-  checkout: protectedProcedure.input(z17.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, create: z17.boolean().default(false) })).mutation(async ({ input }) => {
+  checkout: protectedProcedure.input(z18.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, create: z18.boolean().default(false) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.checkout", { cwd, branch: input.branch, create: input.create });
   }),
   /** Stage files */
-  stage: protectedProcedure.input(z17.object({ ...gitTargetShape, paths: z17.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  stage: protectedProcedure.input(z18.object({ ...gitTargetShape, paths: z18.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stage", { cwd, paths: input.paths });
   }),
   /** Stage all files */
-  stageAll: protectedProcedure.input(z17.object({ ...gitTargetShape })).mutation(async ({ input }) => {
+  stageAll: protectedProcedure.input(z18.object({ ...gitTargetShape })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stageAll", { cwd });
   }),
   /** Unstage files */
-  unstage: protectedProcedure.input(z17.object({ ...gitTargetShape, paths: z17.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  unstage: protectedProcedure.input(z18.object({ ...gitTargetShape, paths: z18.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.unstage", { cwd, paths: input.paths });
   }),
   /** Unstage all files */
-  unstageAll: protectedProcedure.input(z17.object({ ...gitTargetShape })).mutation(async ({ input }) => {
+  unstageAll: protectedProcedure.input(z18.object({ ...gitTargetShape })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.unstageAll", { cwd });
   }),
   /** Commit staged changes */
-  commit: protectedProcedure.input(z17.object({ ...gitTargetShape, message: z17.string().min(1).max(4096) })).mutation(async ({ input }) => {
+  commit: protectedProcedure.input(z18.object({ ...gitTargetShape, message: z18.string().min(1).max(4096) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.commit", { cwd, message: input.message });
   }),
   /** Push to remote */
-  push: protectedProcedure.input(z17.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z17.boolean().default(false) })).mutation(async ({ input }) => {
+  push: protectedProcedure.input(z18.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z18.boolean().default(false) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.push", { cwd, remote: input.remote, setUpstream: input.setUpstream });
   }),
   /** Pull from remote */
-  pull: protectedProcedure.input(z17.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+  pull: protectedProcedure.input(z18.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.pull", { cwd, remote: input.remote });
   }),
   /** Fetch from remote */
-  fetch: protectedProcedure.input(z17.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+  fetch: protectedProcedure.input(z18.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.fetch", { cwd, remote: input.remote });
   }),
   /** Get diff for a file or the whole index */
-  diff: protectedProcedure.input(z17.object({
+  diff: protectedProcedure.input(z18.object({
     ...gitTargetShape,
-    path: z17.string().max(4096).optional(),
-    staged: z17.boolean().default(false),
-    untracked: z17.boolean().default(false)
+    path: z18.string().max(4096).optional(),
+    staged: z18.boolean().default(false),
+    untracked: z18.boolean().default(false)
   })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.diff", { cwd, path: input.path, staged: input.staged, untracked: input.untracked });
   }),
   /** Discard changes to working tree files */
-  discard: protectedProcedure.input(z17.object({ ...gitTargetShape, paths: z17.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  discard: protectedProcedure.input(z18.object({ ...gitTargetShape, paths: z18.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.discard", { cwd, paths: input.paths });
   }),
   /** Generate a commit message from staged diffs using AI (diff fetched from agent, AI runs on server) */
-  generateCommitMessage: protectedProcedure.input(z17.object({ ...gitTargetShape, providerId: OptionalProviderIdSchema, model: z17.string().max(200).optional() })).mutation(async ({ input }) => {
+  generateCommitMessage: protectedProcedure.input(z18.object({ ...gitTargetShape, providerId: OptionalProviderIdSchema, model: z18.string().max(200).optional() })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     const { diff } = await agentManager.agentQuery(agentId, "git.stagedDiff", { cwd });
     if (!diff.trim()) {
@@ -10716,42 +10856,42 @@ Rules:
     throw new TRPCError13({ code: "BAD_REQUEST", message: "Unsupported AI provider" });
   }),
   /** Merge a branch into the current branch */
-  merge: protectedProcedure.input(z17.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, noFf: z17.boolean().default(false) })).mutation(async ({ input }) => {
+  merge: protectedProcedure.input(z18.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, noFf: z18.boolean().default(false) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.merge", { cwd, branch: input.branch, noFf: input.noFf });
   }),
   /** Rebase current branch onto another branch */
-  rebase: protectedProcedure.input(z17.object({ ...gitTargetShape, branch: BRANCH_SCHEMA })).mutation(async ({ input }) => {
+  rebase: protectedProcedure.input(z18.object({ ...gitTargetShape, branch: BRANCH_SCHEMA })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.rebase", { cwd, branch: input.branch });
   }),
   /** List stash entries */
-  stashList: protectedProcedure.input(z17.object({ ...gitTargetShape })).query(async ({ input }) => {
+  stashList: protectedProcedure.input(z18.object({ ...gitTargetShape })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.stashList", { cwd });
   }),
   /** Stash current changes */
-  stashPush: protectedProcedure.input(z17.object({ ...gitTargetShape, message: z17.string().max(4096).optional(), includeUntracked: z17.boolean().default(true) })).mutation(async ({ input }) => {
+  stashPush: protectedProcedure.input(z18.object({ ...gitTargetShape, message: z18.string().max(4096).optional(), includeUntracked: z18.boolean().default(true) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stashPush", { cwd, message: input.message, includeUntracked: input.includeUntracked });
   }),
   /** Pop a stash entry */
-  stashPop: protectedProcedure.input(z17.object({ ...gitTargetShape, index: z17.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashPop: protectedProcedure.input(z18.object({ ...gitTargetShape, index: z18.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stashPop", { cwd, index: input.index });
   }),
   /** Apply a stash entry without dropping it */
-  stashApply: protectedProcedure.input(z17.object({ ...gitTargetShape, index: z17.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashApply: protectedProcedure.input(z18.object({ ...gitTargetShape, index: z18.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stashApply", { cwd, index: input.index });
   }),
   /** Drop a stash entry */
-  stashDrop: protectedProcedure.input(z17.object({ ...gitTargetShape, index: z17.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashDrop: protectedProcedure.input(z18.object({ ...gitTargetShape, index: z18.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stashDrop", { cwd, index: input.index });
   }),
   /** Watch .git/ for changes and stream updated status */
-  onStatusChange: protectedProcedure.input(z17.object({ ...gitTargetShape })).subscription(async function* ({ input }) {
+  onStatusChange: protectedProcedure.input(z18.object({ ...gitTargetShape })).subscription(async function* ({ input }) {
     const { agentId, cwd } = await resolveGitContext(input);
     const queue = [];
     let resolve7 = null;
@@ -10798,16 +10938,16 @@ Rules:
     }
   }),
   /** List remotes */
-  remotes: protectedProcedure.input(z17.object({ ...gitTargetShape })).query(async ({ input }) => {
+  remotes: protectedProcedure.input(z18.object({ ...gitTargetShape })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.remotes", { cwd });
   })
 });
 
 // ../server/src/trpc/routers/scenario.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { TRPCError as TRPCError16 } from "@trpc/server";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // ../server/src/trpc/crud-procedure-utils.ts
 import { TRPCError as TRPCError14 } from "@trpc/server";
@@ -10921,9 +11061,9 @@ async function* streamWithActiveProvider(opts) {
 }
 
 // ../server/src/services/scenario-runner.ts
-import { mkdir as mkdir15 } from "fs/promises";
-import { randomUUID as randomUUID7 } from "crypto";
-import { join as join18 } from "path";
+import { mkdir as mkdir16 } from "fs/promises";
+import { randomUUID as randomUUID6 } from "crypto";
+import { join as join19 } from "path";
 
 // ../server/src/services/scenario-presets.ts
 var BUILT_IN_PRESETS = [
@@ -11264,7 +11404,7 @@ function applyHireDirectivesFromOutput(manager, scenario, output) {
   }
   const hired = [];
   for (const payload of hireDirectives) {
-    const id = `hire-${randomUUID7().slice(0, 8)}`;
+    const id = `hire-${randomUUID6().slice(0, 8)}`;
     const position = computeHirePosition(manager, scenario.nodes);
     ensureGroupCanContainNode(scenario, manager.groupId ?? null, position);
     const node = {
@@ -11703,7 +11843,7 @@ async function appendNodeOutput(conversationId, node, output) {
   if (!dir) return;
   const slug = node.label.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 60) || "member";
   const safeId = node.id.replace(/[^a-z0-9_-]/gi, "-").slice(0, 80);
-  const filePath = join18(dir, `${slug}_${safeId}.md`);
+  const filePath = join19(dir, `${slug}_${safeId}.md`);
   const content = `## Output
 
 ${output}
@@ -11716,9 +11856,9 @@ async function appendToReadme(conversationId, bus, text) {
   const line = `${text}
 `;
   try {
-    await mkdir15(dir, { recursive: true });
+    await mkdir16(dir, { recursive: true });
     const { appendFile: appendFile2 } = await import("fs/promises");
-    await appendFile2(join18(dir, "README.md"), line, "utf-8");
+    await appendFile2(join19(dir, "README.md"), line, "utf-8");
   } catch {
   }
   publishToBus(bus, { type: "readme_append", text: line });
@@ -11738,7 +11878,7 @@ async function writeFinalMd(conversationId, bus, userRequest, content) {
 
 ${content}
 `;
-  const filePath = join18(dir, "FINAL.md");
+  const filePath = join19(dir, "FINAL.md");
   await atomicWriteSecure(filePath, fullContent);
   await appendToReadme(
     conversationId,
@@ -12406,33 +12546,33 @@ Modify the scenario. Keep existing ids when possible.`;
   return `Generate an scenario org-chart based on: ${userPrompt}`;
 }
 var ScopeShape2 = {
-  orgId: z18.string().max(128).nullable().optional(),
+  orgId: z19.string().max(128).nullable().optional(),
   projectId: Id128Schema.optional()
 };
 async function scopeOf2(input) {
   return input?.orgId ?? await vaultOfProject(input?.projectId);
 }
 var scenarioRouter = router({
-  list: protectedProcedure.input(z18.object(ScopeShape2).optional()).query(async ({ input }) => scenarioStore.list(await scopeOf2(input))),
-  get: protectedProcedure.input(z18.object({ id: Id128Schema, ...ScopeShape2 })).query(async ({ input }) => getOrNotFound(
+  list: protectedProcedure.input(z19.object(ScopeShape2).optional()).query(async ({ input }) => scenarioStore.list(await scopeOf2(input))),
+  get: protectedProcedure.input(z19.object({ id: Id128Schema, ...ScopeShape2 })).query(async ({ input }) => getOrNotFound(
     async () => scenarioStore.get(input.id, await scopeOf2(input)),
     "Scenario not found"
   )),
-  create: protectedProcedure.input(z18.object({
+  create: protectedProcedure.input(z19.object({
     name: NameSchema,
-    icon: z18.string().max(64).optional(),
+    icon: z19.string().max(64).optional(),
     description: DescriptionSchema.optional(),
     leaderId: Id128Schema,
-    groups: z18.array(ScenarioGroupSchema).max(100).optional(),
-    nodes: z18.array(ScenarioNodeSchema).min(1).max(500),
-    traversalMode: z18.enum(["hierarchical", "topological"]).optional(),
-    presetId: z18.string().max(128).optional(),
-    isPublished: z18.boolean().optional(),
+    groups: z19.array(ScenarioGroupSchema).max(100).optional(),
+    nodes: z19.array(ScenarioNodeSchema).min(1).max(500),
+    traversalMode: z19.enum(["hierarchical", "topological"]).optional(),
+    presetId: z19.string().max(128).optional(),
+    isPublished: z19.boolean().optional(),
     ...ScopeShape2
   })).mutation(({ input }) => {
     const now = Date.now();
     return createOrBadRequest(async () => scenarioStore.create({
-      id: randomUUID8(),
+      id: randomUUID7(),
       name: input.name,
       icon: input.icon,
       description: input.description,
@@ -12446,17 +12586,17 @@ var scenarioRouter = router({
       updatedAt: now
     }));
   }),
-  update: protectedProcedure.input(z18.object({
+  update: protectedProcedure.input(z19.object({
     id: Id128Schema,
     name: NameSchema.optional(),
-    icon: z18.string().max(64).optional(),
+    icon: z19.string().max(64).optional(),
     description: DescriptionSchema.optional(),
     leaderId: Id128Schema.optional(),
-    groups: z18.array(ScenarioGroupSchema).max(100).optional(),
-    nodes: z18.array(ScenarioNodeSchema).min(1).max(500).optional(),
-    traversalMode: z18.enum(["hierarchical", "topological"]).optional(),
-    presetId: z18.string().max(128).optional(),
-    isPublished: z18.boolean().optional(),
+    groups: z19.array(ScenarioGroupSchema).max(100).optional(),
+    nodes: z19.array(ScenarioNodeSchema).min(1).max(500).optional(),
+    traversalMode: z19.enum(["hierarchical", "topological"]).optional(),
+    presetId: z19.string().max(128).optional(),
+    isPublished: z19.boolean().optional(),
     ...ScopeShape2
   })).mutation(({ input }) => updateOrThrow(
     async () => scenarioStore.update(input.id, {
@@ -12473,22 +12613,22 @@ var scenarioRouter = router({
     }, await scopeOf2(input)),
     "Scenario not found"
   )),
-  delete: protectedProcedure.input(z18.object({ id: Id128Schema, ...ScopeShape2 })).mutation(({ input }) => deleteOrNotFound(
+  delete: protectedProcedure.input(z19.object({ id: Id128Schema, ...ScopeShape2 })).mutation(({ input }) => deleteOrNotFound(
     async () => scenarioStore.delete(input.id, await scopeOf2(input)),
     "Scenario not found"
   )),
-  run: protectedProcedure.input(z18.object({
+  run: protectedProcedure.input(z19.object({
     conversationId: ConversationIdSchema,
     scenarioId: Id128Schema,
-    userRequest: z18.string().max(1e5),
-    runnerOverride: z18.enum(["claude-code", "codex"]).optional(),
+    userRequest: z19.string().max(1e5),
+    runnerOverride: z19.enum(["claude-code", "codex"]).optional(),
     modelOverride: Id128Schema.optional(),
     agentId: Id128Schema.optional(),
     /** Anchors the run's working directory on the project it belongs to. */
     projectId: Id128Schema.optional(),
     /** Son organisation : sans elle, un id partagé désignerait un projet au hasard. */
-    orgId: z18.string().max(128).nullable().optional(),
-    resume: z18.boolean().optional()
+    orgId: z19.string().max(128).nullable().optional(),
+    resume: z19.boolean().optional()
   })).subscription(async function* ({ input, signal }) {
     const scenario = await scenarioStore.get(input.scenarioId, await scopeOf2(input));
     if (!scenario) throw new TRPCError16({ code: "NOT_FOUND", message: "Scenario not found" });
@@ -12508,41 +12648,41 @@ var scenarioRouter = router({
     }
     yield* tapBus(input.conversationId, signal ?? new AbortController().signal);
   }),
-  stop: protectedProcedure.input(z18.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
+  stop: protectedProcedure.input(z19.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
     abortScenario(input.conversationId);
     return { ok: true };
   }),
-  sendNodeInput: protectedProcedure.input(z18.object({
+  sendNodeInput: protectedProcedure.input(z19.object({
     conversationId: ConversationIdSchema,
     nodeId: Id128Schema,
-    text: z18.string().min(1).max(1e5)
+    text: z19.string().min(1).max(1e5)
   })).mutation(({ input }) => {
     const resolved = resolveNodeInput(input.conversationId, input.nodeId, input.text);
     if (!resolved) throw new TRPCError16({ code: "NOT_FOUND", message: "No pending input request for this node" });
     return { ok: true };
   }),
-  isRunning: protectedProcedure.input(z18.object({ conversationId: ConversationIdSchema })).query(({ input }) => ({ running: isScenarioRunning(input.conversationId) })),
-  runState: protectedProcedure.input(z18.object({ conversationId: ConversationIdSchema })).query(({ input }) => {
+  isRunning: protectedProcedure.input(z19.object({ conversationId: ConversationIdSchema })).query(({ input }) => ({ running: isScenarioRunning(input.conversationId) })),
+  runState: protectedProcedure.input(z19.object({ conversationId: ConversationIdSchema })).query(({ input }) => {
     const runState = scenarioRunStore.getRunState(input.conversationId);
     return runState ?? { nodeStates: {}, nodeOutputs: {}, activeNodeId: void 0 };
   }),
-  getPersistedRunState: protectedProcedure.input(z18.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
+  getPersistedRunState: protectedProcedure.input(z19.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
     return await scenarioRunStore.loadPersistedRunState(input.conversationId);
   }),
-  getReadme: protectedProcedure.input(z18.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
+  getReadme: protectedProcedure.input(z19.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
     return await scenarioRunStore.readReadme(input.conversationId);
   }),
-  getSnapshot: protectedProcedure.input(z18.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
+  getSnapshot: protectedProcedure.input(z19.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
     return await scenarioRunStore.loadScenarioSnapshot(input.conversationId);
   }),
-  streamGenerateWithAI: protectedProcedure.input(z18.object({
-    prompt: z18.string().min(1).max(1e4),
+  streamGenerateWithAI: protectedProcedure.input(z19.object({
+    prompt: z19.string().min(1).max(1e4),
     providerId: OptionalProviderIdSchema,
-    model: z18.string().max(200).optional(),
-    current: z18.object({
+    model: z19.string().max(200).optional(),
+    current: z19.object({
       leaderId: Id128Schema,
-      groups: z18.array(ScenarioGroupSchema).max(100),
-      nodes: z18.array(ScenarioNodeSchema).max(500)
+      groups: z19.array(ScenarioGroupSchema).max(100),
+      nodes: z19.array(ScenarioNodeSchema).max(500)
     }).optional()
   })).subscription(async function* ({ input, signal }) {
     const userMessage = buildScenarioUserMessage(input.prompt, input.current);
@@ -12555,7 +12695,7 @@ var scenarioRouter = router({
       signal: signal ?? void 0
     });
   }),
-  streamRunEvents: protectedProcedure.input(z18.object({ conversationId: ConversationIdSchema })).subscription(async function* ({ input }) {
+  streamRunEvents: protectedProcedure.input(z19.object({ conversationId: ConversationIdSchema })).subscription(async function* ({ input }) {
     const convId = input.conversationId;
     const runState = scenarioRunStore.getRunState(convId);
     if (runState) {
@@ -12569,14 +12709,14 @@ var scenarioRouter = router({
    * open a debug PTY with `claude --resume <sessionId>` on the right agent.
    * Falls back to the persisted run-state for past nodes.
    */
-  getNodeSession: protectedProcedure.input(z18.object({
+  getNodeSession: protectedProcedure.input(z19.object({
     conversationId: ConversationIdSchema,
     nodeId: Id128Schema
   })).query(async ({ input }) => {
     return await scenarioRunStore.getNodeSessionPersistent(input.conversationId, input.nodeId);
   }),
   listPresets: protectedProcedure.query(() => listPresets()),
-  getPreset: protectedProcedure.input(z18.object({ id: Id128Schema })).query(({ input }) => {
+  getPreset: protectedProcedure.input(z19.object({ id: Id128Schema })).query(({ input }) => {
     const preset = getPreset(input.id);
     if (!preset) throw new TRPCError16({ code: "NOT_FOUND", message: "Preset not found" });
     return preset;
@@ -12584,9 +12724,9 @@ var scenarioRouter = router({
 });
 
 // ../server/src/trpc/routers/debug.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { TRPCError as TRPCError17 } from "@trpc/server";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var MAX_BUFFER3 = 300;
 var jobs = /* @__PURE__ */ new Map();
 function publish(job, event) {
@@ -12643,11 +12783,11 @@ async function* tapJob(job, signal) {
   }
 }
 var debugRouter = router({
-  startRandomJob: protectedProcedure.input(z19.object({
-    intervalMs: z19.number().int().min(100).max(5e3).optional(),
-    maxTicks: z19.number().int().min(1).max(1e4).optional()
+  startRandomJob: protectedProcedure.input(z20.object({
+    intervalMs: z20.number().int().min(100).max(5e3).optional(),
+    maxTicks: z20.number().int().min(1).max(1e4).optional()
   }).optional()).mutation(({ input }) => {
-    const jobId = randomUUID9();
+    const jobId = randomUUID8();
     const intervalMs = input?.intervalMs ?? 400;
     const maxTicks = input?.maxTicks ?? 500;
     const job = {
@@ -12679,15 +12819,15 @@ var debugRouter = router({
     jobs.set(jobId, job);
     return { jobId, intervalMs, maxTicks, startedAt: job.startedAt };
   }),
-  streamRandomJob: protectedProcedure.input(z19.object({ jobId: z19.string().max(128) })).subscription(async function* ({ input, signal }) {
+  streamRandomJob: protectedProcedure.input(z20.object({ jobId: z20.string().max(128) })).subscription(async function* ({ input, signal }) {
     const job = jobs.get(input.jobId);
     if (!job) {
       throw new TRPCError17({ code: "NOT_FOUND", message: "Random job not found" });
     }
     yield* tapJob(job, signal ?? new AbortController().signal);
   }),
-  stopRandomJob: protectedProcedure.input(z19.object({ jobId: z19.string().max(128) })).mutation(({ input }) => ({ ok: stopJob(input.jobId, "stopped") })),
-  randomJobStatus: protectedProcedure.input(z19.object({ jobId: z19.string().max(128) })).query(({ input }) => {
+  stopRandomJob: protectedProcedure.input(z20.object({ jobId: z20.string().max(128) })).mutation(({ input }) => ({ ok: stopJob(input.jobId, "stopped") })),
+  randomJobStatus: protectedProcedure.input(z20.object({ jobId: z20.string().max(128) })).query(({ input }) => {
     const job = jobs.get(input.jobId);
     return {
       running: !!job && !job.done,
@@ -12698,6 +12838,7 @@ var debugRouter = router({
 
 // ../server/src/trpc/routers/diagnostics.ts
 import { z as z21 } from "zod";
+import { TRPCError as TRPCError18 } from "@trpc/server";
 
 // ../server/src/services/log-buffer.ts
 import { EventEmitter as EventEmitter4 } from "events";
@@ -12765,128 +12906,6 @@ function onEntry(listener) {
   return () => emitter.off("entry", listener);
 }
 
-// ../server/src/services/instance-registry.ts
-import { mkdir as mkdir16, readdir as readdir5, readFile as readFile15, writeFile as writeFile14, rm as rm3 } from "fs/promises";
-import { join as join19 } from "path";
-import { z as z20 } from "zod";
-var InstanceFileSchema = z20.object({
-  pid: z20.number().int().positive(),
-  port: z20.number().int().min(1).max(65535),
-  agentPort: z20.number().int().min(1).max(65535),
-  cwd: z20.string().max(4096),
-  dataDir: z20.string().max(4096),
-  version: z20.string().max(64),
-  fromDesktop: z20.boolean(),
-  startedAt: z20.number().int().nonnegative()
-});
-function registryDir() {
-  return join19(machineRoot(), "instances");
-}
-function fileFor(pid) {
-  return join19(registryDir(), `${pid}.json`);
-}
-function selfRecord() {
-  return {
-    pid: process.pid,
-    port: env.PORT,
-    agentPort: env.RUNEYA_AGENT_PORT,
-    cwd: process.cwd(),
-    dataDir: env.DATA_DIR,
-    version: process.env["RUNEYA_VERSION"] ?? "unknown",
-    fromDesktop: env.FROM_DESKTOP,
-    startedAt: Date.now()
-  };
-}
-async function registerInstance() {
-  try {
-    await mkdir16(registryDir(), { recursive: true });
-    await writeFile14(fileFor(process.pid), JSON.stringify(selfRecord(), null, 2));
-  } catch (err) {
-    console.log("[instances] Could not register this instance:", err.message);
-  }
-}
-async function unregisterInstance() {
-  await rm3(fileFor(process.pid), { force: true }).catch(() => {
-  });
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
-async function probe(port) {
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/api/trpc/health.check`, {
-      signal: AbortSignal.timeout(1500)
-    });
-    if (!res.ok) return { ok: false, uptimeMs: null, version: null };
-    const body = await res.json();
-    const data = body.result?.data;
-    return { ok: true, uptimeMs: data?.uptime ?? null, version: data?.version ?? null };
-  } catch {
-    return { ok: false, uptimeMs: null, version: null };
-  }
-}
-async function listInstances() {
-  let files;
-  try {
-    files = await readdir5(registryDir());
-  } catch {
-    return [];
-  }
-  const found = await Promise.all(
-    files.filter((f) => f.endsWith(".json")).map(async (name) => {
-      const path = join19(registryDir(), name);
-      let record;
-      try {
-        const parsed = InstanceFileSchema.safeParse(JSON.parse(await readFile15(path, "utf8")));
-        if (!parsed.success) {
-          await rm3(path, { force: true }).catch(() => {
-          });
-          return null;
-        }
-        record = parsed.data;
-      } catch {
-        return null;
-      }
-      if (!isProcessAlive(record.pid)) {
-        await rm3(path, { force: true }).catch(() => {
-        });
-        return null;
-      }
-      const { ok, uptimeMs, version } = await probe(record.port);
-      if (!ok) {
-        await rm3(path, { force: true }).catch(() => {
-        });
-        return null;
-      }
-      return {
-        ...record,
-        // Trust the live answer over the file: the file was written at boot
-        // and an upgraded instance would keep claiming its old version.
-        version: version ?? record.version,
-        reachable: true,
-        current: record.pid === process.pid,
-        uptimeMs
-      };
-    })
-  );
-  return dedupeByPort(found.filter((i) => i !== null)).sort((a, b) => Number(b.current) - Number(a.current) || a.port - b.port);
-}
-function dedupeByPort(instances) {
-  const byPort = /* @__PURE__ */ new Map();
-  for (const instance of instances) {
-    const kept = byPort.get(instance.port);
-    if (!kept || instance.current || !kept.current && instance.startedAt > kept.startedAt) {
-      byPort.set(instance.port, instance);
-    }
-  }
-  return [...byPort.values()];
-}
-
 // ../server/src/trpc/routers/diagnostics.ts
 var diagnosticsRouter = router({
   /** Backlog for a client that just opened the panel. */
@@ -12924,14 +12943,71 @@ var diagnosticsRouter = router({
     }
   }),
   /** Every Runeya answering on this machine, this one included. */
-  instances: protectedProcedure.query(() => listInstances())
+  instances: protectedProcedure.query(() => listInstances()),
+  /**
+   * Stop another Runeya on this machine — its agent first, then its server.
+   *
+   * The pid is a *selector*, not an instruction: it is looked up in the list
+   * `listInstances()` has just vouched for, and anything absent from it is
+   * refused. That is what keeps this from being a way to signal arbitrary
+   * processes with the server's privileges.
+   */
+  killInstance: protectedProcedure.input(z21.object({ pid: z21.number().int().positive() })).mutation(async ({ input }) => {
+    try {
+      return await killInstance(input.pid);
+    } catch (err) {
+      const reason = err.message;
+      if (reason === "instance-not-found") {
+        throw new TRPCError18({ code: "NOT_FOUND", message: "No live Runeya instance with this pid." });
+      }
+      if (reason === "instance-is-current") {
+        throw new TRPCError18({ code: "BAD_REQUEST", message: "This instance cannot stop itself." });
+      }
+      throw new TRPCError18({ code: "INTERNAL_SERVER_ERROR", message: reason });
+    }
+  }),
+  /**
+   * Redémarrer une Runeya de cette machine : même exécutable, mêmes arguments,
+   * même répertoire, mêmes `RUNEYA_*`.
+   *
+   * Deux chemins pour une même promesse. Une autre instance est arrêtée puis
+   * relancée d'ici, et la réponse dit ce qui s'est passé. Celle-ci ne peut pas :
+   * elle répond d'abord, pose un relanceur détaché, et part — d'où un résultat
+   * qui annonce un redémarrage à venir plutôt qu'un redémarrage fait.
+   *
+   * Mêmes garde-fous que `killInstance` — le pid est un sélecteur cherché dans
+   * la liste validée — plus un refus propre quand le lancement n'est pas
+   * reproductible : instance trop ancienne pour avoir publié sa ligne de
+   * commande, ou lancée avec un secret que le registre ne conserve pas.
+   */
+  restartInstance: protectedProcedure.input(z21.object({ pid: z21.number().int().positive() })).mutation(async ({ input }) => {
+    try {
+      if (input.pid === process.pid) {
+        const { relauncherPid, port } = await scheduleSelfRestart();
+        return { self: true, relauncherPid, port };
+      }
+      return { self: false, ...await restartInstance(input.pid) };
+    } catch (err) {
+      const reason = err.message;
+      if (reason === "instance-not-found") {
+        throw new TRPCError18({ code: "NOT_FOUND", message: "No live Runeya instance with this pid." });
+      }
+      if (reason.startsWith("instance-not-restartable:")) {
+        throw new TRPCError18({
+          code: "BAD_REQUEST",
+          message: `This instance cannot be restarted (${reason.split(":")[1]}).`
+        });
+      }
+      throw new TRPCError18({ code: "INTERNAL_SERVER_ERROR", message: reason });
+    }
+  })
 });
 
 // ../server/src/trpc/routers/kanban-queue.ts
 import { z as z22 } from "zod";
 
 // ../server/src/services/kanban-queue.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { EventEmitter as EventEmitter5 } from "events";
 var KanbanQueueService = class extends EventEmitter5 {
   items = [];
@@ -12959,7 +13035,7 @@ var KanbanQueueService = class extends EventEmitter5 {
       return { id: alreadyRunning.id, addedAt: alreadyRunning.startedAt, ...item };
     }
     const queueItem = {
-      id: randomUUID10(),
+      id: randomUUID9(),
       ...item,
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -13179,12 +13255,12 @@ var kanbanQueueRouter = router({
 });
 
 // ../server/src/trpc/routers/kanban.ts
-import { mkdir as mkdir17, readdir as readdir6, rm as rm4, stat as stat5, writeFile as writeFile15 } from "fs/promises";
+import { mkdir as mkdir17, readdir as readdir5, rm as rm3, stat as stat5, writeFile as writeFile15 } from "fs/promises";
 import { createHash } from "crypto";
 import { tmpdir } from "os";
 import { join as join20 } from "path";
 import { z as z23 } from "zod";
-import { TRPCError as TRPCError18 } from "@trpc/server";
+import { TRPCError as TRPCError19 } from "@trpc/server";
 function summarizeCard(card, boardId, columnTitle) {
   return {
     boardId,
@@ -13239,10 +13315,10 @@ var ATTACHMENT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 async function purgeStaleAttachments(dir, ttlMs = ATTACHMENT_CACHE_TTL_MS) {
   try {
     const cutoff = Date.now() - ttlMs;
-    for (const name of await readdir6(dir)) {
+    for (const name of await readdir5(dir)) {
       const path = join20(dir, name);
       const info = await stat5(path).catch(() => null);
-      if (info && info.mtimeMs < cutoff) await rm4(path, { force: true });
+      if (info && info.mtimeMs < cutoff) await rm3(path, { force: true });
     }
   } catch {
   }
@@ -13263,7 +13339,7 @@ async function storeAttachment(id, name, body, dirs = attachmentCacheDirs()) {
       refusals.push(`${dir} (${err instanceof Error ? err.message : String(err)})`);
     }
   }
-  throw new TRPCError18({
+  throw new TRPCError19({
     code: "INTERNAL_SERVER_ERROR",
     message: `Impossible d'\xE9crire la pi\xE8ce jointe sur cette machine. Emplacements essay\xE9s : ${refusals.join(" ; ")}. V\xE9rifiez les droits d'\xE9criture, ou l'espace disque.`
   });
@@ -13420,7 +13496,7 @@ var kanbanRouter = router({
       input.parentCardId ? { boardId: input.parentBoardId ?? input.boardId, cardId: input.parentCardId } : null
     );
     if (!ok) {
-      throw new TRPCError18({ code: "BAD_REQUEST", message: "The cloud refused the link (unknown card, or a cycle)." });
+      throw new TRPCError19({ code: "BAD_REQUEST", message: "The cloud refused the link (unknown card, or a cycle)." });
     }
     return { ok: true };
   }),
@@ -13463,25 +13539,25 @@ var kanbanRouter = router({
   downloadAttachment: protectedProcedure.input(z23.object({ attachmentId: z23.string().max(128) })).mutation(async ({ input }) => {
     const id = input.attachmentId;
     if (!ATTACHMENT_ID_REGEX.test(id)) {
-      throw new TRPCError18({ code: "BAD_REQUEST", message: "Invalid attachment id" });
+      throw new TRPCError19({ code: "BAD_REQUEST", message: "Invalid attachment id" });
     }
     const res = await cloudFetch2(`/api/kanban/file/${id}`, { timeoutMs: 12e4 });
     if (res.status === 404) {
-      throw new TRPCError18({ code: "NOT_FOUND", message: `Attachment ${id} not found` });
+      throw new TRPCError19({ code: "NOT_FOUND", message: `Attachment ${id} not found` });
     }
     if (!res.ok) {
-      throw new TRPCError18({
+      throw new TRPCError19({
         code: res.status === 403 ? "FORBIDDEN" : "INTERNAL_SERVER_ERROR",
         message: `Cloud refused the attachment (HTTP ${res.status})`
       });
     }
     const declared = Number(res.headers.get("content-length") ?? 0);
     if (declared > MAX_ATTACHMENT_BYTES) {
-      throw new TRPCError18({ code: "PAYLOAD_TOO_LARGE", message: "Attachment too large to download" });
+      throw new TRPCError19({ code: "PAYLOAD_TOO_LARGE", message: "Attachment too large to download" });
     }
     const body = Buffer.from(await res.arrayBuffer());
     if (body.length > MAX_ATTACHMENT_BYTES) {
-      throw new TRPCError18({ code: "PAYLOAD_TOO_LARGE", message: "Attachment too large to download" });
+      throw new TRPCError19({ code: "PAYLOAD_TOO_LARGE", message: "Attachment too large to download" });
     }
     const contentType = res.headers.get("content-type") ?? "application/octet-stream";
     const disposition = res.headers.get("content-disposition") ?? "";
@@ -13494,7 +13570,7 @@ var kanbanRouter = router({
 
 // ../server/src/trpc/routers/terminal.ts
 import { z as z24 } from "zod";
-import { TRPCError as TRPCError19 } from "@trpc/server";
+import { TRPCError as TRPCError20 } from "@trpc/server";
 var terminalRouter = router({
   /** Create a PTY shell session on the target agent */
   create: protectedProcedure.input(z24.object({
@@ -13506,7 +13582,8 @@ var terminalRouter = router({
     /** L'organisation du projet : un id seul peut en nommer un par organisation. */
     orgId: z24.string().max(128).nullable().optional(),
     cols: z24.number().int().min(1).max(512).optional(),
-    rows: z24.number().int().min(1).max(256).optional()
+    rows: z24.number().int().min(1).max(256).optional(),
+    title: z24.string().max(128).optional()
   })).mutation(async ({ input }) => {
     const result = await agentManager.agentMutation(
       input.agentId,
@@ -13520,11 +13597,32 @@ var terminalRouter = router({
           orgId: input.orgId
         }),
         cols: input.cols,
-        rows: input.rows
+        rows: input.rows,
+        title: input.title
       }
     );
     return result;
   }),
+  /** Les sessions PTY encore vivantes sur l'agent (onglets à retrouver) */
+  list: protectedProcedure.input(z24.object({ agentId: z24.string().max(128) })).query(async ({ input }) => {
+    return agentManager.agentQuery(
+      input.agentId,
+      "terminal.list"
+    );
+  }),
+  /** Renommer un onglet */
+  rename: protectedProcedure.input(z24.object({
+    agentId: z24.string().max(128),
+    sessionId: z24.string().max(128),
+    title: z24.string().max(128)
+  })).mutation(async ({ input }) => {
+    await agentManager.agentMutation(
+      input.agentId,
+      "terminal.rename",
+      { sessionId: input.sessionId, title: input.title }
+    );
+    return { ok: true };
+  }),
   /** Send keystrokes / data to a PTY session */
   write: protectedProcedure.input(z24.object({
     agentId: z24.string().max(128),
@@ -13567,7 +13665,9 @@ var terminalRouter = router({
   /** Stream PTY output — proxied via AgentWSBridge dynamic subscription */
   onData: protectedProcedure.input(z24.object({
     agentId: z24.string().max(128),
-    sessionId: z24.string().max(128)
+    sessionId: z24.string().max(128),
+    /** Rejouer l'historique de la session avant le flux temps réel. */
+    replay: z24.boolean().optional()
   })).subscription(async function* ({ input }) {
     const queue = [];
     let resolve7 = null;
@@ -13577,7 +13677,7 @@ var terminalRouter = router({
       unsubscribe = agentManager.agentSubscribe(
         input.agentId,
         "terminal.onData",
-        { sessionId: input.sessionId },
+        { sessionId: input.sessionId, replay: input.replay },
         (data) => {
           if (typeof data === "string") queue.push(data);
           if (resolve7) {
@@ -13594,7 +13694,7 @@ var terminalRouter = router({
         }
       );
     } catch (err) {
-      throw new TRPCError19({
+      throw new TRPCError20({
         code: "BAD_REQUEST",
         message: `Cannot subscribe to terminal: ${err.message}`
       });
@@ -13629,8 +13729,8 @@ var utilityRouter = router({
 
 // ../server/src/trpc/routers/wiki.ts
 import { z as z26 } from "zod";
-import { TRPCError as TRPCError20 } from "@trpc/server";
-import { readFile as readFile16, readdir as readdir7, stat as stat6, realpath, writeFile as writeFile16, mkdir as mkdir18, rename as rename12, rm as rm5 } from "fs/promises";
+import { TRPCError as TRPCError21 } from "@trpc/server";
+import { readFile as readFile16, readdir as readdir6, stat as stat6, realpath, writeFile as writeFile16, mkdir as mkdir18, rename as rename13, rm as rm4 } from "fs/promises";
 import { resolve as resolvePath, join as join21, relative, sep as sep3, dirname as dirname9 } from "path";
 var SCOPE_SCHEMA = z26.union([
   z26.literal("global"),
@@ -13665,27 +13765,27 @@ async function resolveScope(scope) {
     const settings = await settingsManager.getSettings();
     const sub = (settings.globalDocsPath?.trim() || "wiki").replace(/^[\\/]+|[\\/]+$/g, "");
     if (sub.includes("..") || sub.includes("\0")) {
-      throw new TRPCError20({ code: "BAD_REQUEST", message: "Sous-chemin invalide" });
+      throw new TRPCError21({ code: "BAD_REQUEST", message: "Sous-chemin invalide" });
     }
     const dataDirAbs = resolvePath(env.DATA_DIR);
     await mkdir18(dataDirAbs, { recursive: true });
     const base = dirname9(await realpath(dataDirAbs));
     const target = resolvePath(base, sub);
     if (target !== base && !(target + sep3).startsWith(base + sep3)) {
-      throw new TRPCError20({ code: "FORBIDDEN", message: "Hors du dossier de donn\xE9es du serveur" });
+      throw new TRPCError21({ code: "FORBIDDEN", message: "Hors du dossier de donn\xE9es du serveur" });
     }
     await mkdir18(target, { recursive: true });
     const root = await realpath(target);
     if (root !== base && !(root + sep3).startsWith(base + sep3)) {
-      throw new TRPCError20({ code: "FORBIDDEN", message: "Le dossier wiki r\xE9sout hors du dossier de donn\xE9es" });
+      throw new TRPCError21({ code: "FORBIDDEN", message: "Le dossier wiki r\xE9sout hors du dossier de donn\xE9es" });
     }
     return { mode: "local", root };
   }
   const serviceId = scope.slice("service:".length);
   const service = await serviceStore.get(serviceId);
-  if (!service) throw new TRPCError20({ code: "NOT_FOUND", message: "Service introuvable" });
+  if (!service) throw new TRPCError21({ code: "NOT_FOUND", message: "Service introuvable" });
   const agentId = await resolveEffectiveAgentId(service);
-  if (!agentId) throw new TRPCError20({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9 pour ce service" });
+  if (!agentId) throw new TRPCError21({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9 pour ce service" });
   const cwd = await resolveWorkspaceCwd({ serviceId, override: service.docsPath?.trim() || void 0 });
   return { mode: "agent", agentId, cwd };
 }
@@ -13693,7 +13793,7 @@ async function walkLocal(root, dir, depth, counter) {
   if (depth > MAX_DEPTH || counter.n >= MAX_FILES) return [];
   let entries2;
   try {
-    entries2 = await readdir7(dir, { withFileTypes: true });
+    entries2 = await readdir6(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -13720,7 +13820,7 @@ async function walkLocal(root, dir, depth, counter) {
 }
 async function resolveSafeLocal(root, relPath, requireExist) {
   if (relPath.includes("..") || relPath.startsWith("/")) {
-    throw new TRPCError20({ code: "BAD_REQUEST", message: "Chemin invalide" });
+    throw new TRPCError21({ code: "BAD_REQUEST", message: "Chemin invalide" });
   }
   const target = resolvePath(root, relPath);
   if (requireExist) {
@@ -13728,10 +13828,10 @@ async function resolveSafeLocal(root, relPath, requireExist) {
     try {
       real = await realpath(target);
     } catch {
-      throw new TRPCError20({ code: "NOT_FOUND", message: "Chemin introuvable" });
+      throw new TRPCError21({ code: "NOT_FOUND", message: "Chemin introuvable" });
     }
     if (real !== root && !(real + sep3).startsWith(root + sep3)) {
-      throw new TRPCError20({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
+      throw new TRPCError21({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
     }
     return real;
   }
@@ -13743,7 +13843,7 @@ async function resolveSafeLocal(root, relPath, requireExist) {
     realParent = parent;
   }
   if (realParent !== root && !(realParent + sep3).startsWith(root + sep3)) {
-    throw new TRPCError20({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
+    throw new TRPCError21({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
   }
   return resolvePath(realParent, target.slice(parent.length).replace(/^[\\/]+/, ""));
 }
@@ -13759,7 +13859,7 @@ var wikiRouter = router({
   }),
   read: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).output(z26.object({ path: z26.string(), content: z26.string() })).query(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
-      throw new TRPCError20({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
+      throw new TRPCError21({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
@@ -13767,14 +13867,14 @@ var wikiRouter = router({
     }
     const file = await resolveSafeLocal(target.root, input.path, true);
     const s = await stat6(file);
-    if (!s.isFile()) throw new TRPCError20({ code: "BAD_REQUEST", message: "Pas un fichier" });
-    if (s.size > MAX_FILE_BYTES) throw new TRPCError20({ code: "PAYLOAD_TOO_LARGE", message: "Fichier trop volumineux" });
+    if (!s.isFile()) throw new TRPCError21({ code: "BAD_REQUEST", message: "Pas un fichier" });
+    if (s.size > MAX_FILE_BYTES) throw new TRPCError21({ code: "PAYLOAD_TOO_LARGE", message: "Fichier trop volumineux" });
     const content = await readFile16(file, "utf-8");
     return { path: input.path, content };
   }),
   write: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA, content: z26.string().max(5e6) })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
-      throw new TRPCError20({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
+      throw new TRPCError21({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
@@ -13787,7 +13887,7 @@ var wikiRouter = router({
   }),
   createFile: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
-      throw new TRPCError20({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
+      throw new TRPCError21({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
@@ -13796,9 +13896,9 @@ var wikiRouter = router({
     const file = await resolveSafeLocal(target.root, input.path, false);
     try {
       await stat6(file);
-      throw new TRPCError20({ code: "CONFLICT", message: "Fichier d\xE9j\xE0 existant" });
+      throw new TRPCError21({ code: "CONFLICT", message: "Fichier d\xE9j\xE0 existant" });
     } catch (err) {
-      if (err instanceof TRPCError20) throw err;
+      if (err instanceof TRPCError21) throw err;
     }
     await mkdir18(dirname9(file), { recursive: true });
     await writeFile16(file, "", "utf-8");
@@ -13822,12 +13922,12 @@ var wikiRouter = router({
     const to = await resolveSafeLocal(target.root, input.toPath, false);
     try {
       await stat6(to);
-      throw new TRPCError20({ code: "CONFLICT", message: "La cible existe d\xE9j\xE0" });
+      throw new TRPCError21({ code: "CONFLICT", message: "La cible existe d\xE9j\xE0" });
     } catch (err) {
-      if (err instanceof TRPCError20) throw err;
+      if (err instanceof TRPCError21) throw err;
     }
     await mkdir18(dirname9(to), { recursive: true });
-    await rename12(from, to);
+    await rename13(from, to);
     return { fromPath: input.fromPath, toPath: input.toPath, ok: true };
   }),
   ensureRoot: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA })).mutation(async ({ input }) => {
@@ -13837,9 +13937,9 @@ var wikiRouter = router({
     }
     const serviceId = input.scope.slice("service:".length);
     const service = await serviceStore.get(serviceId);
-    if (!service) throw new TRPCError20({ code: "NOT_FOUND", message: "Service introuvable" });
+    if (!service) throw new TRPCError21({ code: "NOT_FOUND", message: "Service introuvable" });
     const agentId = await resolveEffectiveAgentId(service);
-    if (!agentId) throw new TRPCError20({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9" });
+    if (!agentId) throw new TRPCError21({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9" });
     const cwd = await resolveWorkspaceCwd({ serviceId, override: service.docsPath?.trim() || void 0 });
     return agentManager.agentMutation(agentId, "wiki.ensureRoot", { cwd });
   }),
@@ -13849,8 +13949,8 @@ var wikiRouter = router({
       return agentManager.agentMutation(target.agentId, "wiki.deletePath", { cwd: target.cwd, path: input.path });
     }
     const fp = await resolveSafeLocal(target.root, input.path, true);
-    if (fp === target.root) throw new TRPCError20({ code: "FORBIDDEN", message: "Impossible de supprimer la racine" });
-    await rm5(fp, { recursive: true, force: true });
+    if (fp === target.root) throw new TRPCError21({ code: "FORBIDDEN", message: "Impossible de supprimer la racine" });
+    await rm4(fp, { recursive: true, force: true });
     return { path: input.path, ok: true };
   })
 });
@@ -13870,7 +13970,7 @@ var configRouter = router({
 
 // ../server/src/trpc/routers/cloud-sync.ts
 import { z as z27 } from "zod";
-import { TRPCError as TRPCError21 } from "@trpc/server";
+import { TRPCError as TRPCError22 } from "@trpc/server";
 
 // ../server/src/services/org-sync-scope.ts
 import { access as access2 } from "fs/promises";
@@ -13937,8 +14037,8 @@ async function reconcileOrgCanary(orgId) {
 }
 
 // ../server/src/services/cloud-sync-bridge.ts
-import { randomUUID as randomUUID11 } from "crypto";
-import { mkdir as mkdir20, rm as rm6 } from "fs/promises";
+import { randomUUID as randomUUID10 } from "crypto";
+import { mkdir as mkdir20, rm as rm5 } from "fs/promises";
 import * as Y from "yjs";
 
 // ../server/src/services/org-lock.ts
@@ -14051,7 +14151,7 @@ var OrgSyncConnection = class {
   projects = getCollection(this.doc, "projects");
   services = getCollection(this.doc, "services");
   environments = getCollection(this.doc, "environments");
-  conn = randomUUID11();
+  conn = randomUUID10();
   link;
   stopped = false;
   initializing = true;
@@ -14395,7 +14495,7 @@ var OrgSyncConnection = class {
   async unfollowProject(projectId) {
     this.tracked.delete(projectId);
     await projectStore.forgetLocally({ id: projectId, orgId: this.link.orgId });
-    await rm6(projectVaultRoot(this.link.orgId, projectId), { recursive: true, force: true }).catch(() => {
+    await rm5(projectVaultRoot(this.link.orgId, projectId), { recursive: true, force: true }).catch(() => {
     });
   }
   /**
@@ -14755,7 +14855,7 @@ var CloudSyncBridge = class {
 var cloudSyncBridge = new CloudSyncBridge();
 
 // ../server/src/services/key-adoption.ts
-import { readdir as readdir8, readFile as readFile18, writeFile as writeFile17, mkdir as mkdir21, copyFile, rename as rename13, stat as stat7 } from "fs/promises";
+import { readdir as readdir7, readFile as readFile18, writeFile as writeFile17, mkdir as mkdir21, copyFile, rename as rename14, stat as stat7 } from "fs/promises";
 import { join as join24 } from "path";
 import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes5 } from "crypto";
 var ALGORITHM = "aes-256-gcm";
@@ -14813,7 +14913,7 @@ async function rootsOfOrg(orgId) {
 }
 async function jsonFilesIn(root) {
   try {
-    const entries2 = await readdir8(root, { withFileTypes: true });
+    const entries2 = await readdir7(root, { withFileTypes: true });
     return entries2.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => e.name);
   } catch {
     return [];
@@ -14868,7 +14968,7 @@ async function adoptOrgKey(orgId, newKey, masterPassword, now) {
   for (const item of pending) {
     const tmp = item.path + ".tmp";
     await writeFile17(tmp, item.content, "utf-8");
-    await rename13(tmp, item.path);
+    await rename14(tmp, item.path);
   }
   await installOrgKey(orgId, newKey, masterPassword);
   clearVaultLock(orgId);
@@ -14899,7 +14999,7 @@ async function assertOrgReadable(orgId) {
     await assertOrgVaultReadable(orgId);
   } catch (err) {
     if (err instanceof OrgVaultUnreadableError) {
-      throw new TRPCError21({ code: "FORBIDDEN", message: err.message });
+      throw new TRPCError22({ code: "FORBIDDEN", message: err.message });
     }
     throw err;
   }
@@ -14909,10 +15009,10 @@ async function assertOrgKey(orgId) {
     await reconcileOrgCanary(orgId);
   } catch (err) {
     if (err instanceof OrgKeyMismatchError) {
-      throw new TRPCError21({ code: "FORBIDDEN", message: err.message });
+      throw new TRPCError22({ code: "FORBIDDEN", message: err.message });
     }
     if (err instanceof CanaryUnavailableError) {
-      throw new TRPCError21({ code: "PRECONDITION_FAILED", message: err.message });
+      throw new TRPCError22({ code: "PRECONDITION_FAILED", message: err.message });
     }
     throw err;
   }
@@ -14947,7 +15047,7 @@ var cloudSyncRouter = router({
       return { pulled, state: syncState(input.orgId) };
     } catch (err) {
       if (err instanceof ProjectHeldElsewhereError) {
-        throw new TRPCError21({ code: "CONFLICT", message: err.code, cause: err });
+        throw new TRPCError22({ code: "CONFLICT", message: err.code, cause: err });
       }
       throw err;
     }
@@ -14974,10 +15074,10 @@ var cloudSyncRouter = router({
   ).mutation(async ({ input }) => {
     const local = await projectStore.get({ id: input.projectId, orgId: null });
     if (!local) {
-      throw new TRPCError21({ code: "NOT_FOUND", message: "PROJECT_NOT_LOCAL" });
+      throw new TRPCError22({ code: "NOT_FOUND", message: "PROJECT_NOT_LOCAL" });
     }
     if (await projectStore.get({ id: input.projectId, orgId: input.orgId })) {
-      throw new TRPCError21({ code: "CONFLICT", message: "PROJECT_ALREADY_IN_ORG" });
+      throw new TRPCError22({ code: "CONFLICT", message: "PROJECT_ALREADY_IN_ORG" });
     }
     await assertOrgReadable(input.orgId);
     const connected = cloudSyncBridge.states().some((s) => s.orgId === input.orgId);
@@ -14996,7 +15096,7 @@ var cloudSyncRouter = router({
       await cloudSyncBridge.followProject(input.orgId, input.projectId);
     } catch (err) {
       if (err instanceof ProjectHeldElsewhereError) {
-        throw new TRPCError21({ code: "CONFLICT", message: err.code, cause: err });
+        throw new TRPCError22({ code: "CONFLICT", message: err.code, cause: err });
       }
       throw err;
     }
@@ -15019,7 +15119,7 @@ var cloudSyncRouter = router({
       { method: "GET" }
     );
     if (!res.ok) {
-      throw new TRPCError21({ code: "BAD_GATEWAY", message: await cloudMessage(res) || `CANARY_READ_FAILED (${res.status})` });
+      throw new TRPCError22({ code: "BAD_GATEWAY", message: await cloudMessage(res) || `CANARY_READ_FAILED (${res.status})` });
     }
     const { canary } = await res.json();
     if (typeof canary !== "string") return { matches: false, published: false };
@@ -15065,7 +15165,7 @@ var cloudSyncRouter = router({
   resetOrgKey: protectedProcedure.input(z27.object({ orgId: z27.string().min(1).max(128) })).mutation(async ({ input }) => {
     const canary = await readVerifyFile(await keyRoot());
     if (!canary) {
-      throw new TRPCError21({
+      throw new TRPCError22({
         code: "PRECONDITION_FAILED",
         message: "Cette machine n'a pas encore de cl\xE9 de chiffrement."
       });
@@ -15076,7 +15176,7 @@ var cloudSyncRouter = router({
     });
     if (!res.ok) {
       const detail = await cloudMessage(res);
-      throw new TRPCError21({
+      throw new TRPCError22({
         code: res.status === 403 ? "FORBIDDEN" : "BAD_GATEWAY",
         message: detail || `ORG_KEY_RESET_FAILED (${res.status})`
       });
@@ -15122,8 +15222,8 @@ var cloudSyncRouter = router({
         body: { organizationId: input.orgId, projectId: input.projectId }
       });
     } catch (err) {
-      if (err instanceof TRPCError21 && err.code === "PRECONDITION_FAILED") {
-        throw new TRPCError21({ code: "PRECONDITION_FAILED", message: "CLOUD_NOT_LINKED" });
+      if (err instanceof TRPCError22 && err.code === "PRECONDITION_FAILED") {
+        throw new TRPCError22({ code: "PRECONDITION_FAILED", message: "CLOUD_NOT_LINKED" });
       }
       throw err;
     }
@@ -15131,12 +15231,12 @@ var cloudSyncRouter = router({
     const detail = await cloudMessage(res);
     if (res.status === 403) {
       const code = /not a member/i.test(detail) ? "PROJECT_NOT_MEMBER" : "PROJECT_DELETE_FORBIDDEN";
-      throw new TRPCError21({ code: "FORBIDDEN", message: code, cause: new Error(detail) });
+      throw new TRPCError22({ code: "FORBIDDEN", message: code, cause: new Error(detail) });
     }
     if (res.status === 404) {
-      throw new TRPCError21({ code: "NOT_FOUND", message: "PROJECT_NOT_IN_ORG", cause: new Error(detail) });
+      throw new TRPCError22({ code: "NOT_FOUND", message: "PROJECT_NOT_IN_ORG", cause: new Error(detail) });
     }
-    throw new TRPCError21({
+    throw new TRPCError22({
       code: "BAD_GATEWAY",
       message: detail || `PROJECT_DELETE_FAILED (${res.status})`
     });
@@ -15193,7 +15293,7 @@ var cloudSyncRouter = router({
 });
 
 // ../server/src/trpc/routers/filesystem.ts
-import { readdir as readdir9, stat as stat8 } from "fs/promises";
+import { readdir as readdir8, stat as stat8 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { isAbsolute as isAbsolute4, join as join25, resolve as resolve5, dirname as dirname10, basename as basename2 } from "path";
 import { z as z28 } from "zod";
@@ -15230,7 +15330,7 @@ var filesystemRouter = router({
     }
     let names;
     try {
-      names = (await readdir9(dir, { withFileTypes: true })).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort((a, b) => a.localeCompare(b));
+      names = (await readdir8(dir, { withFileTypes: true })).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort((a, b) => a.localeCompare(b));
     } catch {
       throw new Error(`R\xE9pertoire illisible : ${dir}`);
     }
@@ -15369,7 +15469,7 @@ async function ensureFilePermissions() {
 }
 
 // ../server/src/services/vault-migration.ts
-import { readdir as readdir10, readFile as readFile19, writeFile as writeFile18, mkdir as mkdir22, copyFile as copyFile2, unlink as unlink5, rename as rename14, stat as stat10 } from "fs/promises";
+import { readdir as readdir9, readFile as readFile19, writeFile as writeFile18, mkdir as mkdir22, copyFile as copyFile2, unlink as unlink5, rename as rename15, stat as stat10 } from "fs/promises";
 import { join as join26 } from "path";
 var KEY_FILES = [".encryption.key.enc", ".runeya-verify"];
 var MACHINE_FILES = [
@@ -15382,7 +15482,7 @@ var MACHINE_FILES = [
 ];
 var rekeyValue = rekeyJsonValue;
 async function vaultJsonFiles(root) {
-  const entries2 = await readdir10(root, { withFileTypes: true });
+  const entries2 = await readdir9(root, { withFileTypes: true });
   return entries2.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => e.name);
 }
 async function exists2(path) {
@@ -15422,7 +15522,7 @@ async function migrateLegacyVault(legacyRoot, machineRootDir, legacyKey, machine
     if (counter.n === 0) continue;
     const tmp = join26(legacyRoot, `${name}.tmp`);
     await writeFile18(tmp, JSON.stringify(converted, null, 2), "utf-8");
-    await rename14(tmp, join26(legacyRoot, name));
+    await rename15(tmp, join26(legacyRoot, name));
     rekeyed.push({ file: name, values: counter.n });
   }
   for (const { file, values } of rekeyed) {
@@ -15458,7 +15558,7 @@ async function migrateLegacyVault(legacyRoot, machineRootDir, legacyKey, machine
 }
 
 // ../server/src/services/settings-migration.ts
-import { readFile as readFile20, writeFile as writeFile19, rename as rename15, unlink as unlink6, mkdir as mkdir23, chmod as chmod12, stat as stat11 } from "fs/promises";
+import { readFile as readFile20, writeFile as writeFile19, rename as rename16, unlink as unlink6, mkdir as mkdir23, chmod as chmod12, stat as stat11 } from "fs/promises";
 import { join as join27 } from "path";
 var SETTINGS_FILE2 = "settings.json";
 var SETTINGS_PRIVATE_FILE2 = "settings.private.json";
@@ -15477,7 +15577,7 @@ async function moveInto(root, filename, from) {
   const contents = await readFile20(from, "utf-8");
   const tmp = to + ".tmp";
   await writeFile19(tmp, contents, "utf-8");
-  await rename15(tmp, to);
+  await rename16(tmp, to);
   await chmod12(to, 384);
   await unlink6(from);
 }
@@ -15512,14 +15612,14 @@ async function migrateSettingsIntoVaults() {
 // ../server/src/migrations/migrate-from-legacy.ts
 import { createRequire as createRequire2 } from "module";
 import { randomBytes as randomBytes6, createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3 } from "crypto";
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import {
   readFile as readFile21,
   writeFile as writeFile20,
-  rename as rename16,
+  rename as rename17,
   mkdir as mkdir24,
   access as access3,
-  readdir as readdir11
+  readdir as readdir10
 } from "fs/promises";
 import { join as join28, dirname as dirname11 } from "path";
 var _require = createRequire2(import.meta.url);
@@ -15651,7 +15751,7 @@ async function decryptLegacyFile(filePath, key, sodium) {
 async function atomicWrite(path, data) {
   const tmp = path + ".tmp";
   await writeFile20(tmp, JSON.stringify(data, null, 2), "utf-8");
-  await rename16(tmp, path);
+  await rename17(tmp, path);
 }
 async function runLegacyMigration(dataDir) {
   const legacyRoot = env.DATA_DIR;
@@ -15664,10 +15764,10 @@ async function runLegacyMigration(dataDir) {
   console.log("[legacy-migration] Legacy Runeya data detected, starting migration\u2026");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
   const legacyTmp = join28(abCwd, ".runeya-tmp");
-  await rename16(legacyRoot, legacyTmp);
+  await rename17(legacyRoot, legacyTmp);
   await mkdir24(dataDir, { recursive: true });
   const legacyOld = join28(dataDir, `backup-${timestamp}`);
-  await rename16(legacyTmp, legacyOld);
+  await rename17(legacyTmp, legacyOld);
   console.log(`[legacy-migration] Legacy data backed up to ${legacyOld}`);
   const keyJson = JSON.parse(await readFile21(join28(legacyOld, "dbs", "encryption-key.json"), "utf-8"));
   const sodium = await getSodium();
@@ -15686,14 +15786,14 @@ async function runLegacyMigration(dataDir) {
     }
   }
   const envsDir = join28(dbsDir, "envs");
-  const envFiles = (await readdir11(envsDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
+  const envFiles = (await readdir10(envsDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyEnvs = {};
   for (const file of envFiles) {
     const name = file.replace(".encrypted.json", "");
     legacyEnvs[name] = await readEncrypted(join28(envsDir, file));
   }
   const servicesDir = join28(dbsDir, "services");
-  const serviceFiles = (await readdir11(servicesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
+  const serviceFiles = (await readdir10(servicesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyServices = {};
   for (const file of serviceFiles) {
     const name = file.replace(".encrypted.json", "");
@@ -15702,7 +15802,7 @@ async function runLegacyMigration(dataDir) {
     if (data?.label) legacyServices[name] = data;
   }
   const overridesDir = join28(dbsDir, "overrides");
-  const overrideFiles = (await readdir11(overridesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
+  const overrideFiles = (await readdir10(overridesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyServiceOverrides = {};
   const legacyEnvOverrides = {};
   for (const file of overrideFiles) {
@@ -15716,17 +15816,17 @@ async function runLegacyMigration(dataDir) {
     }
   }
   const parsersDir = join28(dbsDir, "parsers");
-  const parserFiles = (await readdir11(parsersDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
+  const parserFiles = (await readdir10(parsersDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyParsers = [];
   for (const file of parserFiles) {
     const data = await readEncrypted(join28(parsersDir, file));
     if (data?.id) legacyParsers.push(data);
   }
-  const projectMonoId = randomUUID12();
+  const projectMonoId = randomUUID11();
   const envIdMap = {};
   const labelToKey = {};
   for (const [name, legacyEnv] of Object.entries(legacyEnvs)) {
-    envIdMap[name] = randomUUID12();
+    envIdMap[name] = randomUUID11();
     if (legacyEnv?.label) labelToKey[legacyEnv.label] = name;
   }
   const runeEnvs = [];
@@ -15751,7 +15851,7 @@ async function runLegacyMigration(dataDir) {
         if (hasInvalidInterpolation(value)) continue;
         const cleaned = cleanVarKey(key);
         if (inheritedVars[cleaned] === value) continue;
-        const varId = randomUUID12();
+        const varId = randomUUID11();
         variables[varId] = makeVariable(cleaned, value);
         varIdLookup.set(`${envIdMap[name]}:${cleaned}`, varId);
       }
@@ -15772,7 +15872,7 @@ async function runLegacyMigration(dataDir) {
   const serviceIdMap = {};
   const runeServices = [];
   for (const [name, legacy] of Object.entries(legacyServices)) {
-    const id = randomUUID12();
+    const id = randomUUID11();
     serviceIdMap[name] = id;
     const rootPath = legacy.rootPath || "";
     const rootPathCwd = rootPath && rootPath !== "." ? rootPath : "";
@@ -15781,7 +15881,7 @@ async function runLegacyMigration(dataDir) {
       const parts = [cmd.spawnCmd, ...cmd.spawnArgs || []].filter(Boolean);
       if (!parts.length) continue;
       commands.push({
-        id: cmd.id || randomUUID12(),
+        id: cmd.id || randomUUID11(),
         label: "Launch",
         command: parts.join(" "),
         cwd: cmd.spawnOptions?.cwd || "",
@@ -15842,7 +15942,7 @@ async function runLegacyMigration(dataDir) {
       const legacyBootstrapCmds = container.bootstrap?.commands || [];
       if (legacyBootstrapCmds.length > 0) {
         dockerConfig.bootstrapCommands = legacyBootstrapCmds.filter((bs) => bs.cmd || bs.entrypoint).map((bs, idx) => ({
-          id: bs.id || randomUUID12(),
+          id: bs.id || randomUUID11(),
           label: bs.label || `Bootstrap ${idx + 1}`,
           command: bs.cmd || "",
           ...bs.entrypoint ? { entrypoint: bs.entrypoint } : {},
@@ -15890,7 +15990,7 @@ async function runLegacyMigration(dataDir) {
       cwd: serviceCwd,
       runner: dockerConfig ? "docker" : "native",
       shortcuts: (legacy.shortcuts || []).filter((s) => s.spawnCmd || s.label).map((s) => ({
-        id: s.id || randomUUID12(),
+        id: s.id || randomUUID11(),
         label: s.label || s.spawnCmd || "",
         command: [s.spawnCmd, ...s.spawnArgs || []].filter(Boolean).join(" "),
         ...s.spawnOptions?.cwd ? { cwd: s.spawnOptions.cwd } : {}
@@ -15930,7 +16030,7 @@ async function runLegacyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID12(),
+          id: randomUUID11(),
           projectId: projectMonoId,
           name: `${service?.name || name} (${globalEnv.name})`,
           scope: "service",
@@ -15954,7 +16054,7 @@ async function runLegacyMigration(dataDir) {
         const varPost = typeof varData === "object" ? String(varData.suffix ?? "") : "";
         if (!varKey || existingKeys.has(cleanVarKey(varKey))) continue;
         const cleaned = cleanVarKey(varKey);
-        const varId = randomUUID12();
+        const varId = randomUUID11();
         svcScopedEnv.variables[varId] = makeVariable(cleaned, varValue, varPre, varPost);
         existingKeys.add(cleaned);
       }
@@ -15974,7 +16074,7 @@ async function runLegacyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID12(),
+          id: randomUUID11(),
           projectId: projectMonoId,
           name: `${service?.name || serviceName} (${globalEnv.name})`,
           scope: "service",
@@ -15995,7 +16095,7 @@ async function runLegacyMigration(dataDir) {
         const baseEntry = Object.entries(svcScopedEnv.variables).find(([, v]) => v.key === cleaned);
         let varId = baseEntry?.[0];
         if (!varId) {
-          varId = randomUUID12();
+          varId = randomUUID11();
           svcScopedEnv.variables[varId] = {
             key: cleaned,
             value: { value: "", pre: "", post: "", isSecret: false, injectIntoAi: false }
@@ -16025,13 +16125,13 @@ async function runLegacyMigration(dataDir) {
             flatOverrides[varId] = makeVariable(cleaned, value);
           }
         } else {
-          flatOverrides[randomUUID12()] = makeVariable(cleaned, value);
+          flatOverrides[randomUUID11()] = makeVariable(cleaned, value);
         }
       } else {
         const cleaned = cleanVarKey(key);
         const existingVarId = Object.entries(env2.variables).find(([, v]) => v.key === cleaned)?.[0];
         if (!existingVarId) {
-          const varId = randomUUID12();
+          const varId = randomUUID11();
           env2.variables[varId] = makeVariable(cleaned, value);
           varIdLookup.set(`${envId}:${cleaned}`, varId);
         }
@@ -16096,7 +16196,7 @@ ${p.transform ?? ""}`,
 }
 async function findLegacyKeyInBackup(dataDir) {
   try {
-    const entries2 = await readdir11(dataDir);
+    const entries2 = await readdir10(dataDir);
     const backupDirs = entries2.filter((e) => e.startsWith("backup-")).sort((a, b) => a < b ? -1 : a > b ? 1 : 0).reverse();
     for (const dir of backupDirs) {
       const keyJsonPath = join28(dataDir, dir, "dbs", "encryption-key.json");
@@ -16129,7 +16229,7 @@ async function runOverrideOnlyMigration(dataDir) {
   let overrideFiles = [];
   for (const dir of candidateDirs) {
     try {
-      const files = (await readdir11(dir)).filter((f) => f.endsWith(".encrypted.json"));
+      const files = (await readdir10(dir)).filter((f) => f.endsWith(".encrypted.json"));
       if (files.length > 0) {
         overridesDir = dir;
         overrideFiles = files;
@@ -16215,7 +16315,7 @@ async function runOverrideOnlyMigration(dataDir) {
         if (isSameAsBase(value, baseVar)) continue;
         flatOverrides[varId] = makeVariable(cleaned, value);
       } else {
-        flatOverrides[randomUUID12()] = makeVariable(cleaned, value);
+        flatOverrides[randomUUID11()] = makeVariable(cleaned, value);
       }
     }
   }
@@ -16252,7 +16352,7 @@ async function runOverrideOnlyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID12(),
+          id: randomUUID11(),
           projectId: globalEnv["projectId"],
           name: `${service?.["name"] || serviceName} (${globalEnv["name"]})`,
           scope: "service",
@@ -16274,7 +16374,7 @@ async function runOverrideOnlyMigration(dataDir) {
         const baseEntry = Object.entries(svcScopedEnv["variables"]).find(([, v]) => v.key === cleaned);
         let varId = baseEntry?.[0];
         if (!varId) {
-          varId = randomUUID12();
+          varId = randomUUID11();
           svcScopedEnv["variables"][varId] = {
             key: cleaned,
             value: { value: "", pre: "", post: "", isSecret: false, injectIntoAi: false }
@@ -16294,7 +16394,7 @@ async function runOverrideOnlyMigration(dataDir) {
   }
   const migratedDir = overridesDir.replace(/overrides$/, "overrides-migrated");
   try {
-    await rename16(overridesDir, migratedDir);
+    await rename17(overridesDir, migratedDir);
     console.log(`[override-migration] Moved overrides/ \u2192 overrides-migrated/`);
   } catch (err) {
     console.warn(`[override-migration] Could not rename overrides dir: ${err.message}`);
@@ -16742,6 +16842,7 @@ async function createLocalServer() {
     await ensureDataGitignore(env.DATA_DIR);
   }
   await settingsManager.getSettings();
+  await applyPersistedLanMode();
   await migrationEngine.run();
   await ensureFilePermissions();
   auditService.cleanup().catch((err) => console.error("[server] Audit cleanup failed:", err));
@@ -17338,6 +17439,7 @@ async function createLocalServer() {
   }));
   app.use(errorHandler);
   const server = createServer(app);
+  registerHttpServer(server);
   const wss = new WebSocketServer({ noServer: true });
   applyWSSHandler({
     wss,
@@ -17589,4 +17691,4 @@ export {
   pullEnv,
   registerInstance
 };
-//# sourceMappingURL=src-6WVQ2FQV.js.map
+//# sourceMappingURL=src-53OQNM27.js.map