@runeya/runeya 2.0.71 → 2.0.73

package/{src-Q3PSCMS7.js → src-MY5W5AYS.js}

@@ -85,8 +85,10 @@ import {
   registerProjectLoader,
   rememberFile,
   rememberOrgName,
+  restartInstance,
   rootOfProjectAmong,
   rootOfProjectRef,
+  scheduleSelfRestart,
   serviceStore,
   setEncryptionKey,
   setEncryptionKeyInMemory,
@@ -101,7 +103,7 @@ import {
   vaultIdOfRoot,
   wasRead,
   writeEntity
-} from "./chunk-Z3KAXI7V.js";
+} from "./chunk-OTJQEK4D.js";
 
 // ../server/src/create-server.ts
 import express from "express";
@@ -4376,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
@@ -4388,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) {
@@ -4395,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);
@@ -4423,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)
    */
@@ -4438,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 ?? {});
   }),
@@ -4469,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) {
@@ -4544,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
@@ -4567,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) => {
@@ -4585,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()) {
@@ -4623,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);
@@ -4661,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 ?? [];
@@ -4675,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 ?? [];
@@ -4691,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;
@@ -4711,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);
@@ -4749,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"
@@ -4764,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",
@@ -4775,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 {
@@ -4798,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;
@@ -4811,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;
@@ -4824,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;
@@ -4926,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([])
     })
@@ -4975,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) {
@@ -5007,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 {
@@ -5090,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}` });
@@ -5111,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}` });
@@ -5127,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 },
@@ -5138,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) {
@@ -5163,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" });
     }
@@ -5194,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";
@@ -5606,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;
@@ -5621,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;
@@ -5636,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;
@@ -5784,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", () => {
@@ -5810,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) {
@@ -5822,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;
@@ -5842,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
@@ -6782,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) {
@@ -6801,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) {
@@ -6812,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;
@@ -6835,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]));
@@ -6860,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)"}
 `);
@@ -6887,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) {
@@ -6947,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 },
@@ -6955,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;
@@ -6975,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();
@@ -7037,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",
@@ -7056,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)) {
@@ -7076,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;
   }
   /**
@@ -7102,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 };
@@ -7128,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(() => {
             });
@@ -7143,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) {
@@ -7158,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 {
       }
@@ -7224,7 +7363,7 @@ async function resolveImagesToBase64(images, contextId) {
 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";
@@ -7259,7 +7398,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." });
     }
@@ -7304,7 +7443,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();
@@ -7321,11 +7460,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)) {
@@ -7386,12 +7525,12 @@ async function callCloud(path, init = {}) {
     const res = await cloudFetch2(`/api/auth${path}`, init);
     if (!res.ok) {
       console.error("[kanban-store] cloud call failed: %s %s", res.status, path);
-      return { ok: false, data: null, reason: planGateMessage(res.status, path) };
+      return { ok: false, data: null, reason: planGateMessage(res.status, path), status: res.status };
     }
-    return { ok: true, data: await res.json(), reason: null };
+    return { ok: true, data: await res.json(), reason: null, status: res.status };
   } catch (err) {
     console.error("[kanban-store] cloud call errored:", err);
-    return { ok: false, data: null, reason: `Appel au cloud impossible : ${err.message}` };
+    return { ok: false, data: null, reason: `Appel au cloud impossible : ${err.message}`, status: null };
   }
 }
 function must(res) {
@@ -7470,6 +7609,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 { card: res.data?.card ?? null, unsupported: res.status === 404 };
+  }
   /** Déplacer une carte, sans réécrire le tableau. */
   async moveCard(boardId, cardId, toColumnId) {
     const res = await callCloud("/kanban/card/move", {
@@ -7562,7 +7715,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(
@@ -7578,11 +7730,9 @@ 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;
+      await addCardOrFallback(board, cmd.columnTitle, cmd.cardTitle, cmd.cardContent);
     }
   }
-  if (pendingBoardWrite) await kanbanStore.update({ id: board.id, columns: board.columns });
 }
 async function executeKanbanBoardCommands(boardId, commands) {
   if (commands.length === 0) return;
@@ -7590,30 +7740,38 @@ 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 addCardOrFallback(board, cmd.columnTitle, cmd.cardTitle, cmd.cardContent);
     }
   }
-  await kanbanStore.update({ id: board.id, columns: board.columns });
 }
-function addCardToColumn(board, columnTitle, cardTitle, cardContent) {
+async function addCardOrFallback(board, columnTitle, cardTitle, cardContent) {
+  const { card, unsupported } = await kanbanStore.addCard(board.id, {
+    column: columnTitle,
+    title: cardTitle,
+    markdown: cardContent
+  });
+  if (card) return;
+  if (!unsupported) {
+    console.warn(`[kanban-commands] add_card failed: column="${columnTitle}"`);
+    return;
+  }
+  console.warn("[kanban-commands] cloud sans /kanban/card/add \u2014 repli sur la sauvegarde du tableau");
   const col = board.columns.find((c) => c.title.toLowerCase() === columnTitle.toLowerCase());
   if (!col) return;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const card = {
+  col.cards.push({
     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,
+    order: col.cards.reduce((max, c) => Math.max(max, c.order + 1), 0),
     history: [{ type: "created", timestamp: now, detail: `AI \u2014 In column "${col.title}"` }],
     createdAt: now,
     updatedAt: now
-  };
-  col.cards.push(card);
+  });
+  await kanbanStore.update({ id: board.id, columns: board.columns });
 }
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} o`;
@@ -7963,7 +8121,7 @@ function tailTranscript(opts) {
 
 // ../server/src/services/ai-runners/claude-pty-runner.ts
 async function getAgentManager() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-UUSQK6S2.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-LBV3CVHB.js");
   return agentManager2;
 }
 function buildPtyArgs(params, sessionId, opts) {
@@ -8704,7 +8862,7 @@ async function shutdownCodexAppServer() {
   }
 }
 async function getAgentManager2() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-UUSQK6S2.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-LBV3CVHB.js");
   return agentManager2;
 }
 function parseRuneyaCurlCommand(command) {
@@ -9145,18 +9303,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();
@@ -9543,24 +9701,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);
@@ -9574,7 +9732,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 }) {
@@ -9622,7 +9780,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 }) => {
@@ -9630,24 +9788,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) {
@@ -9678,20 +9836,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()) {
@@ -9713,18 +9871,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,
@@ -9737,7 +9895,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(
@@ -9755,12 +9913,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,
@@ -9817,22 +9975,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");
@@ -9943,15 +10101,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);
@@ -10029,13 +10187,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);
@@ -10153,25 +10311,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();
@@ -10330,10 +10488,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" });
@@ -10385,10 +10543,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" });
@@ -10398,11 +10556,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" });
@@ -10418,11 +10576,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" });
@@ -10440,7 +10598,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);
     }),
     /**
@@ -10448,9 +10606,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;
@@ -10476,7 +10634,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` });
@@ -10490,14 +10648,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" });
@@ -10544,9 +10702,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" });
@@ -10558,16 +10716,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) {
@@ -10581,11 +10739,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);
@@ -10598,82 +10756,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()) {
@@ -10720,42 +10878,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;
@@ -10802,7 +10960,7 @@ 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 });
   })
@@ -10811,7 +10969,7 @@ Rules:
 // ../server/src/trpc/routers/scenario.ts
 import { randomUUID as randomUUID8 } 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";
@@ -10925,9 +11083,9 @@ async function* streamWithActiveProvider(opts) {
 }
 
 // ../server/src/services/scenario-runner.ts
-import { mkdir as mkdir15 } from "fs/promises";
+import { mkdir as mkdir16 } from "fs/promises";
 import { randomUUID as randomUUID7 } from "crypto";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // ../server/src/services/scenario-presets.ts
 var BUILT_IN_PRESETS = [
@@ -11707,7 +11865,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}
@@ -11720,9 +11878,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 });
@@ -11742,7 +11900,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,
@@ -12410,28 +12568,28 @@ 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();
@@ -12450,17 +12608,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, {
@@ -12477,22 +12635,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" });
@@ -12512,41 +12670,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);
@@ -12559,7 +12717,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) {
@@ -12573,14 +12731,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;
@@ -12590,7 +12748,7 @@ var scenarioRouter = router({
 // ../server/src/trpc/routers/debug.ts
 import { randomUUID as randomUUID9 } 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) {
@@ -12647,9 +12805,9 @@ 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 intervalMs = input?.intervalMs ?? 400;
@@ -12683,15 +12841,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,
@@ -12701,7 +12859,7 @@ var debugRouter = router({
 });
 
 // ../server/src/trpc/routers/diagnostics.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 import { TRPCError as TRPCError18 } from "@trpc/server";
 
 // ../server/src/services/log-buffer.ts
@@ -12773,7 +12931,7 @@ function onEntry(listener) {
 // ../server/src/trpc/routers/diagnostics.ts
 var diagnosticsRouter = router({
   /** Backlog for a client that just opened the panel. */
-  recentLogs: protectedProcedure.input(z20.object({ limit: z20.number().int().min(1).max(2e3).default(500) }).optional()).query(({ input }) => recentEntries(input?.limit ?? 500)),
+  recentLogs: protectedProcedure.input(z21.object({ limit: z21.number().int().min(1).max(2e3).default(500) }).optional()).query(({ input }) => recentEntries(input?.limit ?? 500)),
   /**
    * Live log stream.
    *
@@ -12782,7 +12940,7 @@ var diagnosticsRouter = router({
    * silently loses lines, which is precisely what someone watching a boot
    * failure cannot afford.
    */
-  streamLogs: protectedProcedure.input(z20.object({ afterSeq: z20.number().int().nonnegative().default(0) }).optional()).subscription(async function* ({ input, signal }) {
+  streamLogs: protectedProcedure.input(z21.object({ afterSeq: z21.number().int().nonnegative().default(0) }).optional()).subscription(async function* ({ input, signal }) {
     for (const entry of entriesSince(input?.afterSeq ?? 0)) yield entry;
     const queue = [];
     let wake = null;
@@ -12816,7 +12974,7 @@ var diagnosticsRouter = router({
    * refused. That is what keeps this from being a way to signal arbitrary
    * processes with the server's privileges.
    */
-  killInstance: protectedProcedure.input(z20.object({ pid: z20.number().int().positive() })).mutation(async ({ input }) => {
+  killInstance: protectedProcedure.input(z21.object({ pid: z21.number().int().positive() })).mutation(async ({ input }) => {
     try {
       return await killInstance(input.pid);
     } catch (err) {
@@ -12829,11 +12987,46 @@ var diagnosticsRouter = router({
       }
       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 z21 } from "zod";
+import { z as z22 } from "zod";
 
 // ../server/src/services/kanban-queue.ts
 import { randomUUID as randomUUID10 } from "crypto";
@@ -13021,36 +13214,36 @@ var kanbanQueue = new KanbanQueueService();
 // ../server/src/trpc/routers/kanban-queue.ts
 var kanbanQueueRouter = router({
   getState: protectedProcedure.query(() => kanbanQueue.getState()),
-  add: protectedProcedure.input(z21.object({
-    boardId: z21.string().max(128),
-    cardId: z21.string().max(128),
-    runner: z21.enum(["claude-code", "codex"]).optional(),
-    model: z21.string().max(128).optional(),
-    scenarioId: z21.string().max(128).optional(),
+  add: protectedProcedure.input(z22.object({
+    boardId: z22.string().max(128),
+    cardId: z22.string().max(128),
+    runner: z22.enum(["claude-code", "codex"]).optional(),
+    model: z22.string().max(128).optional(),
+    scenarioId: z22.string().max(128).optional(),
     // Le projet ouvert quand la carte a été mise en file : la conversation
     // qui en naîtra lui appartient, plutôt que de rester orpheline et de
     // s'afficher dans tous les projets.
-    projectId: z21.string().max(128).optional(),
-    orgId: z21.string().max(128).nullable().optional()
+    projectId: z22.string().max(128).optional(),
+    orgId: z22.string().max(128).nullable().optional()
   })).mutation(({ input }) => kanbanQueue.add(input)),
-  addColumn: protectedProcedure.input(z21.object({
-    boardId: z21.string().max(128),
-    columnId: z21.string().max(128),
-    runner: z21.enum(["claude-code", "codex"]).optional(),
-    model: z21.string().max(128).optional(),
-    scenarioId: z21.string().max(128).optional(),
-    projectId: z21.string().max(128).optional(),
-    orgId: z21.string().max(128).nullable().optional()
+  addColumn: protectedProcedure.input(z22.object({
+    boardId: z22.string().max(128),
+    columnId: z22.string().max(128),
+    runner: z22.enum(["claude-code", "codex"]).optional(),
+    model: z22.string().max(128).optional(),
+    scenarioId: z22.string().max(128).optional(),
+    projectId: z22.string().max(128).optional(),
+    orgId: z22.string().max(128).nullable().optional()
   })).mutation(async ({ input }) => {
     const { boardId, columnId, ...options } = input;
     return kanbanQueue.addColumn(boardId, columnId, options);
   }),
-  remove: protectedProcedure.input(z21.object({ itemId: z21.string().max(128) })).mutation(({ input }) => ({ removed: kanbanQueue.remove(input.itemId) })),
+  remove: protectedProcedure.input(z22.object({ itemId: z22.string().max(128) })).mutation(({ input }) => ({ removed: kanbanQueue.remove(input.itemId) })),
   stopAll: protectedProcedure.mutation(() => {
     kanbanQueue.stopAll();
     return { ok: true };
   }),
-  setMaxConcurrent: protectedProcedure.input(z21.object({ max: z21.number().int().min(1).max(20) })).mutation(({ input }) => {
+  setMaxConcurrent: protectedProcedure.input(z22.object({ max: z22.number().int().min(1).max(20) })).mutation(({ input }) => {
     kanbanQueue.setMaxConcurrent(input.max);
     return kanbanQueue.getState();
   }),
@@ -13084,11 +13277,11 @@ var kanbanQueueRouter = router({
 });
 
 // ../server/src/trpc/routers/kanban.ts
-import { mkdir as mkdir16, readdir as readdir5, rm as rm3, stat as stat5, writeFile as writeFile14 } 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 join19 } from "path";
-import { z as z22 } from "zod";
+import { join as join20 } from "path";
+import { z as z23 } from "zod";
 import { TRPCError as TRPCError19 } from "@trpc/server";
 function summarizeCard(card, boardId, columnTitle) {
   return {
@@ -13138,14 +13331,14 @@ function safeDecode(value) {
 }
 var MAX_ATTACHMENT_BYTES = 55 * 1024 * 1024;
 function attachmentCacheDir() {
-  return join19(tmpdir(), "runeya-kanban-attachments");
+  return join20(tmpdir(), "runeya-kanban-attachments");
 }
 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 readdir5(dir)) {
-      const path = join19(dir, name);
+      const path = join20(dir, name);
       const info = await stat5(path).catch(() => null);
       if (info && info.mtimeMs < cutoff) await rm3(path, { force: true });
     }
@@ -13153,15 +13346,15 @@ async function purgeStaleAttachments(dir, ttlMs = ATTACHMENT_CACHE_TTL_MS) {
   }
 }
 function attachmentCacheDirs() {
-  return [attachmentCacheDir(), join19(machineRoot(), "kanban-attachments")];
+  return [attachmentCacheDir(), join20(machineRoot(), "kanban-attachments")];
 }
 async function storeAttachment(id, name, body, dirs = attachmentCacheDirs()) {
   const refusals = [];
   for (const dir of dirs) {
     try {
-      await mkdir16(dir, { recursive: true });
-      const path = join19(dir, safeLocalName(id, name));
-      await writeFile14(path, body);
+      await mkdir17(dir, { recursive: true });
+      const path = join20(dir, safeLocalName(id, name));
+      await writeFile15(path, body);
       void purgeStaleAttachments(dir);
       return path;
     } catch (err) {
@@ -13184,9 +13377,9 @@ var kanbanRouter = router({
    * card graph, so listing them in full would be megabytes to answer "which
    * boards exist?". Use `getBoard` for the cards of one.
    */
-  listBoards: protectedProcedure.input(z22.object({
-    includeArchived: z22.boolean().optional(),
-    organizationId: z22.string().max(128).optional()
+  listBoards: protectedProcedure.input(z23.object({
+    includeArchived: z23.boolean().optional(),
+    organizationId: z23.string().max(128).optional()
   }).optional()).query(async ({ input }) => {
     const { organizationId, boards } = await kanbanStore.list(
       input?.includeArchived ?? false,
@@ -13212,7 +13405,7 @@ var kanbanRouter = router({
     };
   }),
   /** One board: its columns, and the cards in each. */
-  getBoard: protectedProcedure.input(z22.object({ boardId: z22.string().max(128) })).query(async ({ input }) => {
+  getBoard: protectedProcedure.input(z23.object({ boardId: z23.string().max(128) })).query(async ({ input }) => {
     const board = await kanbanStore.get(input.boardId);
     if (!board) return { board: null };
     const { links } = await kanbanStore.cardLinks(input.boardId);
@@ -13251,11 +13444,11 @@ var kanbanRouter = router({
    * organization — or one board when `boardId` is given. Archived boards are
    * left out: they are what the team decided to stop looking at.
    */
-  searchCards: protectedProcedure.input(z22.object({
-    query: z22.string().min(1).max(256),
-    boardId: z22.string().max(128).optional(),
-    limit: z22.number().int().min(1).max(100).optional(),
-    organizationId: z22.string().max(128).optional()
+  searchCards: protectedProcedure.input(z23.object({
+    query: z23.string().min(1).max(256),
+    boardId: z23.string().max(128).optional(),
+    limit: z23.number().int().min(1).max(100).optional(),
+    organizationId: z23.string().max(128).optional()
   })).query(async ({ input }) => {
     const needle = normalize(input.query);
     const ids = input.boardId ? [input.boardId] : (await kanbanStore.list(false, input.organizationId)).boards.map((b) => b.id);
@@ -13274,10 +13467,10 @@ var kanbanRouter = router({
    * qu'un `commentCount`, et rien n'en donnait le texte. Cette route est la
    * relecture, pour une seule carte : c'est le journal qui pèse, pas le reste.
    */
-  getCardComments: protectedProcedure.input(z22.object({
-    boardId: z22.string().max(128),
-    cardId: z22.string().max(128),
-    limit: z22.number().int().min(1).max(200).optional()
+  getCardComments: protectedProcedure.input(z23.object({
+    boardId: z23.string().max(128),
+    cardId: z23.string().max(128),
+    limit: z23.number().int().min(1).max(200).optional()
   })).query(async ({ input }) => {
     const history = await kanbanStore.cardHistory(input.boardId, input.cardId);
     const comments = history.filter((e) => e.type === "comment");
@@ -13306,18 +13499,18 @@ var kanbanRouter = router({
    * `getBoard` en donne déjà l'essentiel carte par carte ; cette route sert
    * quand c'est l'arbre lui-même qu'on veut, dates et auteurs compris.
    */
-  getCardLinks: protectedProcedure.input(z22.object({ boardId: z22.string().max(128) })).query(async ({ input }) => kanbanStore.cardLinks(input.boardId)),
+  getCardLinks: protectedProcedure.input(z23.object({ boardId: z23.string().max(128) })).query(async ({ input }) => kanbanStore.cardLinks(input.boardId)),
   /**
    * Rattacher une carte à une carte parente, ou l'en détacher.
    *
    * Sans `parentCardId`, le lien est retiré. Le parent peut vivre sur un autre
    * tableau : `parentBoardId` le désigne alors, sinon c'est celui de la carte.
    */
-  setCardParent: protectedProcedure.input(z22.object({
-    boardId: z22.string().max(128),
-    cardId: z22.string().max(128),
-    parentCardId: z22.string().max(128).optional(),
-    parentBoardId: z22.string().max(128).optional()
+  setCardParent: protectedProcedure.input(z23.object({
+    boardId: z23.string().max(128),
+    cardId: z23.string().max(128),
+    parentCardId: z23.string().max(128).optional(),
+    parentBoardId: z23.string().max(128).optional()
   })).mutation(async ({ input }) => {
     const ok = await kanbanStore.setCardParent(
       input.boardId,
@@ -13329,31 +13522,31 @@ var kanbanRouter = router({
     }
     return { ok: true };
   }),
-  moveCard: protectedProcedure.input(z22.object({
-    boardId: z22.string().max(128),
-    cardId: z22.string().max(128),
-    targetColumn: z22.string().max(256)
+  moveCard: protectedProcedure.input(z23.object({
+    boardId: z23.string().max(128),
+    cardId: z23.string().max(128),
+    targetColumn: z23.string().max(256)
   })).mutation(async ({ input }) => {
     await executeKanbanCommands(input.boardId, input.cardId, [
       { type: "move_card", columnTitle: input.targetColumn }
     ]);
     return { ok: true };
   }),
-  addComment: protectedProcedure.input(z22.object({
-    boardId: z22.string().max(128),
-    cardId: z22.string().max(128),
-    comment: z22.string().max(2e4)
+  addComment: protectedProcedure.input(z23.object({
+    boardId: z23.string().max(128),
+    cardId: z23.string().max(128),
+    comment: z23.string().max(2e4)
   })).mutation(async ({ input }) => {
     await executeKanbanCommands(input.boardId, input.cardId, [
       { type: "add_comment", comment: input.comment }
     ]);
     return { ok: true };
   }),
-  addCard: protectedProcedure.input(z22.object({
-    boardId: z22.string().max(128),
-    column: z22.string().max(256),
-    title: z22.string().max(512),
-    content: z22.string().max(2e4).optional()
+  addCard: protectedProcedure.input(z23.object({
+    boardId: z23.string().max(128),
+    column: z23.string().max(256),
+    title: z23.string().max(512),
+    content: z23.string().max(2e4).optional()
   })).mutation(async ({ input }) => {
     await executeKanbanBoardCommands(input.boardId, [
       { type: "add_card", columnTitle: input.column, cardTitle: input.title, cardContent: input.content }
@@ -13365,7 +13558,7 @@ var kanbanRouter = router({
    * agent can open it with its own file tools. The bytes never go through the
    * prompt: the card context lists the attachments, this returns a path.
    */
-  downloadAttachment: protectedProcedure.input(z22.object({ attachmentId: z22.string().max(128) })).mutation(async ({ input }) => {
+  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 TRPCError19({ code: "BAD_REQUEST", message: "Invalid attachment id" });
@@ -13398,21 +13591,21 @@ var kanbanRouter = router({
 });
 
 // ../server/src/trpc/routers/terminal.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 import { TRPCError as TRPCError20 } from "@trpc/server";
 var terminalRouter = router({
   /** Create a PTY shell session on the target agent */
-  create: protectedProcedure.input(z23.object({
-    agentId: z23.string().max(128),
-    cwd: z23.string().max(512).optional(),
+  create: protectedProcedure.input(z24.object({
+    agentId: z24.string().max(128),
+    cwd: z24.string().max(512).optional(),
     /** Anchors the terminal when no explicit cwd is given. */
-    serviceId: z23.string().max(128).optional(),
-    projectId: z23.string().max(128).optional(),
+    serviceId: z24.string().max(128).optional(),
+    projectId: z24.string().max(128).optional(),
     /** L'organisation du projet : un id seul peut en nommer un par organisation. */
-    orgId: z23.string().max(128).nullable().optional(),
-    cols: z23.number().int().min(1).max(512).optional(),
-    rows: z23.number().int().min(1).max(256).optional(),
-    title: z23.string().max(128).optional()
+    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(),
+    title: z24.string().max(128).optional()
   })).mutation(async ({ input }) => {
     const result = await agentManager.agentMutation(
       input.agentId,
@@ -13433,17 +13626,17 @@ var terminalRouter = router({
     return result;
   }),
   /** Les sessions PTY encore vivantes sur l'agent (onglets à retrouver) */
-  list: protectedProcedure.input(z23.object({ agentId: z23.string().max(128) })).query(async ({ input }) => {
+  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(z23.object({
-    agentId: z23.string().max(128),
-    sessionId: z23.string().max(128),
-    title: z23.string().max(128)
+  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,
@@ -13453,10 +13646,10 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Send keystrokes / data to a PTY session */
-  write: protectedProcedure.input(z23.object({
-    agentId: z23.string().max(128),
-    sessionId: z23.string().max(128),
-    data: z23.string().max(65536)
+  write: protectedProcedure.input(z24.object({
+    agentId: z24.string().max(128),
+    sessionId: z24.string().max(128),
+    data: z24.string().max(65536)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -13466,11 +13659,11 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Resize the PTY */
-  resize: protectedProcedure.input(z23.object({
-    agentId: z23.string().max(128),
-    sessionId: z23.string().max(128),
-    cols: z23.number().int().min(1).max(512),
-    rows: z23.number().int().min(1).max(256)
+  resize: protectedProcedure.input(z24.object({
+    agentId: z24.string().max(128),
+    sessionId: z24.string().max(128),
+    cols: z24.number().int().min(1).max(512),
+    rows: z24.number().int().min(1).max(256)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -13480,9 +13673,9 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Destroy a PTY session */
-  destroy: protectedProcedure.input(z23.object({
-    agentId: z23.string().max(128),
-    sessionId: z23.string().max(128)
+  destroy: protectedProcedure.input(z24.object({
+    agentId: z24.string().max(128),
+    sessionId: z24.string().max(128)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -13492,11 +13685,11 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Stream PTY output — proxied via AgentWSBridge dynamic subscription */
-  onData: protectedProcedure.input(z23.object({
-    agentId: z23.string().max(128),
-    sessionId: z23.string().max(128),
+  onData: protectedProcedure.input(z24.object({
+    agentId: z24.string().max(128),
+    sessionId: z24.string().max(128),
     /** Rejouer l'historique de la session avant le flux temps réel. */
-    replay: z23.boolean().optional()
+    replay: z24.boolean().optional()
   })).subscription(async function* ({ input }) {
     const queue = [];
     let resolve7 = null;
@@ -13545,11 +13738,11 @@ var terminalRouter = router({
 });
 
 // ../server/src/trpc/routers/utility.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var MAX_WAIT_MS = 5 * 60 * 1e3;
 var utilityRouter = router({
-  wait: protectedProcedure.input(z24.object({
-    ms: z24.number().int().min(0).max(MAX_WAIT_MS)
+  wait: protectedProcedure.input(z25.object({
+    ms: z25.number().int().min(0).max(MAX_WAIT_MS)
   })).mutation(async ({ input }) => {
     await new Promise((resolve7) => setTimeout(resolve7, input.ms));
     return { waited: input.ms };
@@ -13557,15 +13750,15 @@ var utilityRouter = router({
 });
 
 // ../server/src/trpc/routers/wiki.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 import { TRPCError as TRPCError21 } from "@trpc/server";
-import { readFile as readFile15, readdir as readdir6, stat as stat6, realpath, writeFile as writeFile15, mkdir as mkdir17, rename as rename12, rm as rm4 } from "fs/promises";
-import { resolve as resolvePath, join as join20, relative, sep as sep3, dirname as dirname9 } from "path";
-var SCOPE_SCHEMA = z25.union([
-  z25.literal("global"),
-  z25.string().regex(/^service:[A-Za-z0-9_-]{1,128}$/, "Invalid service scope")
+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"),
+  z26.string().regex(/^service:[A-Za-z0-9_-]{1,128}$/, "Invalid service scope")
 ]);
-var REL_PATH_SCHEMA = z25.string().min(1).max(512).regex(/^[A-Za-z0-9_./-]+$/).refine((p) => !p.includes("..") && !p.startsWith("/"), {
+var REL_PATH_SCHEMA = z26.string().min(1).max(512).regex(/^[A-Za-z0-9_./-]+$/).refine((p) => !p.includes("..") && !p.startsWith("/"), {
   message: "Path must be a relative path without traversal"
 });
 var MAX_FILES = 500;
@@ -13585,9 +13778,9 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "target",
   "out"
 ]);
-var DocsEntrySchema = z25.lazy(() => z25.union([
-  z25.object({ type: z25.literal("file"), name: z25.string(), path: z25.string() }),
-  z25.object({ type: z25.literal("dir"), name: z25.string(), path: z25.string(), children: z25.array(DocsEntrySchema) })
+var DocsEntrySchema = z26.lazy(() => z26.union([
+  z26.object({ type: z26.literal("file"), name: z26.string(), path: z26.string() }),
+  z26.object({ type: z26.literal("dir"), name: z26.string(), path: z26.string(), children: z26.array(DocsEntrySchema) })
 ]));
 async function resolveScope(scope) {
   if (scope === "global") {
@@ -13597,13 +13790,13 @@ async function resolveScope(scope) {
       throw new TRPCError21({ code: "BAD_REQUEST", message: "Sous-chemin invalide" });
     }
     const dataDirAbs = resolvePath(env.DATA_DIR);
-    await mkdir17(dataDirAbs, { recursive: true });
+    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 TRPCError21({ code: "FORBIDDEN", message: "Hors du dossier de donn\xE9es du serveur" });
     }
-    await mkdir17(target, { recursive: true });
+    await mkdir18(target, { recursive: true });
     const root = await realpath(target);
     if (root !== base && !(root + sep3).startsWith(base + sep3)) {
       throw new TRPCError21({ code: "FORBIDDEN", message: "Le dossier wiki r\xE9sout hors du dossier de donn\xE9es" });
@@ -13630,7 +13823,7 @@ async function walkLocal(root, dir, depth, counter) {
   for (const e of entries2) {
     if (counter.n >= MAX_FILES) break;
     if (e.name.startsWith(".") && e.name !== ".") continue;
-    const abs = join20(dir, e.name);
+    const abs = join21(dir, e.name);
     const rel = relative(root, abs).split(sep3).join("/");
     if (e.isDirectory()) {
       if (IGNORED_DIRS.has(e.name)) continue;
@@ -13677,7 +13870,7 @@ async function resolveSafeLocal(root, relPath, requireExist) {
   return resolvePath(realParent, target.slice(parent.length).replace(/^[\\/]+/, ""));
 }
 var wikiRouter = router({
-  list: protectedProcedure.input(z25.object({ scope: SCOPE_SCHEMA })).output(z25.object({ root: z25.string(), entries: z25.array(DocsEntrySchema), truncated: z25.boolean() })).query(async ({ input }) => {
+  list: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA })).output(z26.object({ root: z26.string(), entries: z26.array(DocsEntrySchema), truncated: z26.boolean() })).query(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentQuery(target.agentId, "wiki.listRepoMarkdown", { cwd: target.cwd });
@@ -13686,7 +13879,7 @@ var wikiRouter = router({
     const entries2 = await walkLocal(target.root, target.root, 0, counter);
     return { root: target.root, entries: entries2, truncated: counter.n >= MAX_FILES };
   }),
-  read: protectedProcedure.input(z25.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).output(z25.object({ path: z25.string(), content: z25.string() })).query(async ({ input }) => {
+  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 TRPCError21({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -13698,10 +13891,10 @@ var wikiRouter = router({
     const s = await stat6(file);
     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 readFile15(file, "utf-8");
+    const content = await readFile16(file, "utf-8");
     return { path: input.path, content };
   }),
-  write: protectedProcedure.input(z25.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA, content: z25.string().max(5e6) })).mutation(async ({ input }) => {
+  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 TRPCError21({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -13710,11 +13903,11 @@ var wikiRouter = router({
       return agentManager.agentMutation(target.agentId, "wiki.writeMarkdown", { cwd: target.cwd, path: input.path, content: input.content });
     }
     const file = await resolveSafeLocal(target.root, input.path, false);
-    await mkdir17(dirname9(file), { recursive: true });
-    await writeFile15(file, input.content, "utf-8");
+    await mkdir18(dirname9(file), { recursive: true });
+    await writeFile16(file, input.content, "utf-8");
     return { path: input.path, ok: true };
   }),
-  createFile: protectedProcedure.input(z25.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createFile: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError21({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -13729,20 +13922,20 @@ var wikiRouter = router({
     } catch (err) {
       if (err instanceof TRPCError21) throw err;
     }
-    await mkdir17(dirname9(file), { recursive: true });
-    await writeFile15(file, "", "utf-8");
+    await mkdir18(dirname9(file), { recursive: true });
+    await writeFile16(file, "", "utf-8");
     return { path: input.path, ok: true };
   }),
-  createDir: protectedProcedure.input(z25.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createDir: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentMutation(target.agentId, "wiki.createDir", { cwd: target.cwd, path: input.path });
     }
     const dir = await resolveSafeLocal(target.root, input.path, false);
-    await mkdir17(dir, { recursive: true });
+    await mkdir18(dir, { recursive: true });
     return { path: input.path, ok: true };
   }),
-  rename: protectedProcedure.input(z25.object({ scope: SCOPE_SCHEMA, fromPath: REL_PATH_SCHEMA, toPath: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  rename: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA, fromPath: REL_PATH_SCHEMA, toPath: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentMutation(target.agentId, "wiki.renamePath", { cwd: target.cwd, fromPath: input.fromPath, toPath: input.toPath });
@@ -13755,11 +13948,11 @@ var wikiRouter = router({
     } catch (err) {
       if (err instanceof TRPCError21) throw err;
     }
-    await mkdir17(dirname9(to), { recursive: true });
-    await rename12(from, to);
+    await mkdir18(dirname9(to), { recursive: true });
+    await rename13(from, to);
     return { fromPath: input.fromPath, toPath: input.toPath, ok: true };
   }),
-  ensureRoot: protectedProcedure.input(z25.object({ scope: SCOPE_SCHEMA })).mutation(async ({ input }) => {
+  ensureRoot: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA })).mutation(async ({ input }) => {
     if (input.scope === "global") {
       await resolveScope("global");
       return { ok: true };
@@ -13772,7 +13965,7 @@ var wikiRouter = router({
     const cwd = await resolveWorkspaceCwd({ serviceId, override: service.docsPath?.trim() || void 0 });
     return agentManager.agentMutation(agentId, "wiki.ensureRoot", { cwd });
   }),
-  delete: protectedProcedure.input(z25.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  delete: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentMutation(target.agentId, "wiki.deletePath", { cwd: target.cwd, path: input.path });
@@ -13798,14 +13991,14 @@ var configRouter = router({
 });
 
 // ../server/src/trpc/routers/cloud-sync.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 import { TRPCError as TRPCError22 } from "@trpc/server";
 
 // ../server/src/services/org-sync-scope.ts
 import { access as access2 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 async function isMaterialized(root) {
-  return access2(join21(root, "project.json")).then(() => true, () => false);
+  return access2(join22(root, "project.json")).then(() => true, () => false);
 }
 async function orgsToSync() {
   const cloudUrl = getCloudApiUrl();
@@ -13867,16 +14060,16 @@ async function reconcileOrgCanary(orgId) {
 
 // ../server/src/services/cloud-sync-bridge.ts
 import { randomUUID as randomUUID11 } from "crypto";
-import { mkdir as mkdir19, rm as rm5 } from "fs/promises";
+import { mkdir as mkdir20, rm as rm5 } from "fs/promises";
 import * as Y from "yjs";
 
 // ../server/src/services/org-lock.ts
-import { open as open2, readFile as readFile16, unlink as unlink4, mkdir as mkdir18 } from "fs/promises";
+import { open as open2, readFile as readFile17, unlink as unlink4, mkdir as mkdir19 } from "fs/promises";
 import { readFileSync, unlinkSync } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var held = /* @__PURE__ */ new Set();
 function lockPath(orgId) {
-  return join22(orgVaultRoot(orgId), "org.lock");
+  return join23(orgVaultRoot(orgId), "org.lock");
 }
 function isRunning(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -13889,7 +14082,7 @@ function isRunning(pid) {
 }
 async function readLock(path) {
   try {
-    const parsed = JSON.parse(await readFile16(path, "utf-8"));
+    const parsed = JSON.parse(await readFile17(path, "utf-8"));
     return typeof parsed?.pid === "number" ? parsed : null;
   } catch {
     return null;
@@ -13897,7 +14090,7 @@ async function readLock(path) {
 }
 async function acquireOrgLock(orgId) {
   const path = lockPath(orgId);
-  await mkdir18(orgVaultRoot(orgId), { recursive: true });
+  await mkdir19(orgVaultRoot(orgId), { recursive: true });
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
       const handle = await open2(path, "wx");
@@ -14308,7 +14501,7 @@ var OrgSyncConnection = class {
     }
     const isLocal = existing?.orgId === this.link.orgId;
     if (!inDoc && !isLocal) return false;
-    await mkdir19(projectVaultRoot(this.link.orgId, projectId), { recursive: true });
+    await mkdir20(projectVaultRoot(this.link.orgId, projectId), { recursive: true });
     this.tracked.add(projectId);
     if (inDoc) await this.pullFromDoc([projectId]);
     else await this.reconcileLocalToDoc();
@@ -14684,8 +14877,8 @@ var CloudSyncBridge = class {
 var cloudSyncBridge = new CloudSyncBridge();
 
 // ../server/src/services/key-adoption.ts
-import { readdir as readdir7, readFile as readFile17, writeFile as writeFile16, mkdir as mkdir20, copyFile, rename as rename13, stat as stat7 } from "fs/promises";
-import { join as join23 } from "path";
+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";
 function isAgentTriplet(value) {
@@ -14765,10 +14958,10 @@ async function adoptOrgKey(orgId, newKey, masterPassword, now) {
   const touchedRoots = /* @__PURE__ */ new Set();
   for (const vaultRoot of await rootsOfOrg(orgId)) {
     for (const name of await jsonFilesIn(vaultRoot)) {
-      const path = join23(vaultRoot, name);
+      const path = join24(vaultRoot, name);
       let parsed;
       try {
-        parsed = JSON.parse(await readFile17(path, "utf-8"));
+        parsed = JSON.parse(await readFile18(path, "utf-8"));
       } catch {
         continue;
       }
@@ -14782,22 +14975,22 @@ async function adoptOrgKey(orgId, newKey, masterPassword, now) {
   const stamp = now.toISOString().replace(/[:.]/g, "-").substring(0, 19);
   const backups = [];
   for (const vaultRoot of touchedRoots) {
-    const backupDir = join23(vaultRoot, `backup-key-${stamp}`);
-    await mkdir20(backupDir, { recursive: true });
+    const backupDir = join24(vaultRoot, `backup-key-${stamp}`);
+    await mkdir21(backupDir, { recursive: true });
     for (const name of await jsonFilesIn(vaultRoot)) {
-      await copyFile(join23(vaultRoot, name), join23(backupDir, name));
+      await copyFile(join24(vaultRoot, name), join24(backupDir, name));
     }
     for (const name of [".encryption.key.enc", ".runeya-verify"]) {
-      if (await exists(join23(vaultRoot, name))) {
-        await copyFile(join23(vaultRoot, name), join23(backupDir, name));
+      if (await exists(join24(vaultRoot, name))) {
+        await copyFile(join24(vaultRoot, name), join24(backupDir, name));
       }
     }
     backups.push(backupDir);
   }
   for (const item of pending) {
     const tmp = item.path + ".tmp";
-    await writeFile16(tmp, item.content, "utf-8");
-    await rename13(tmp, item.path);
+    await writeFile17(tmp, item.content, "utf-8");
+    await rename14(tmp, item.path);
   }
   await installOrgKey(orgId, newKey, masterPassword);
   clearVaultLock(orgId);
@@ -14858,10 +15051,10 @@ var cloudSyncRouter = router({
    * "open this project" is the whole gesture.
    */
   trackProject: protectedProcedure.input(
-    z26.object({
-      orgId: z26.string().min(1).max(128),
-      cloudUrl: z26.string().url().max(2048),
-      projectId: z26.string().min(1).max(128)
+    z27.object({
+      orgId: z27.string().min(1).max(128),
+      cloudUrl: z27.string().url().max(2048),
+      projectId: z27.string().min(1).max(128)
     })
   ).mutation(async ({ input }) => {
     await assertOrgReadable(input.orgId);
@@ -14895,10 +15088,10 @@ var cloudSyncRouter = router({
    * fusionné.
    */
   publishProject: protectedProcedure.input(
-    z26.object({
-      orgId: z26.string().min(1).max(128),
-      cloudUrl: z26.string().url().max(2048),
-      projectId: z26.string().min(1).max(128)
+    z27.object({
+      orgId: z27.string().min(1).max(128),
+      cloudUrl: z27.string().url().max(2048),
+      projectId: z27.string().min(1).max(128)
     })
   ).mutation(async ({ input }) => {
     const local = await projectStore.get({ id: input.projectId, orgId: null });
@@ -14939,9 +15132,9 @@ var cloudSyncRouter = router({
    * publié. Le cloud, lui, ne peut pas répondre — il n'a que du chiffré sous
    * les yeux — donc le canari est rapatrié et jugé ici.
    */
-  checkOrgKey: protectedProcedure.input(z26.object({
-    orgId: z26.string().min(1).max(128),
-    keyHex: z26.string().length(64).regex(/^[0-9a-f]+$/i)
+  checkOrgKey: protectedProcedure.input(z27.object({
+    orgId: z27.string().min(1).max(128),
+    keyHex: z27.string().length(64).regex(/^[0-9a-f]+$/i)
   })).query(async ({ input }) => {
     const res = await cloudFetch2(
       `/api/auth/organization/canary?organizationId=${encodeURIComponent(input.orgId)}`,
@@ -14964,10 +15157,10 @@ var cloudSyncRouter = router({
    * Bornée au coffre de l'organisation et à ceux de ses projets : les autres
    * organisations et la machine gardent leur clé.
    */
-  adoptOrgKey: protectedProcedure.input(z26.object({
-    orgId: z26.string().min(1).max(128),
-    keyHex: z26.string().length(64).regex(/^[0-9a-f]+$/i),
-    masterPassword: z26.string().min(1).max(1024)
+  adoptOrgKey: protectedProcedure.input(z27.object({
+    orgId: z27.string().min(1).max(128),
+    keyHex: z27.string().length(64).regex(/^[0-9a-f]+$/i),
+    masterPassword: z27.string().min(1).max(1024)
   })).mutation(async ({ input }) => {
     const report = await adoptOrgKey(
       input.orgId,
@@ -14991,7 +15184,7 @@ var cloudSyncRouter = router({
    * Elle ne re-chiffre rien : ce qui a déjà été synchronisé sous l'ancienne clé
    * reste illisible. L'interface le dit avant de la déclencher.
    */
-  resetOrgKey: protectedProcedure.input(z26.object({ orgId: z26.string().min(1).max(128) })).mutation(async ({ input }) => {
+  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 TRPCError22({
@@ -15021,9 +15214,9 @@ var cloudSyncRouter = router({
    * every other member and for this one on another machine.
    */
   untrackProject: protectedProcedure.input(
-    z26.object({
-      orgId: z26.string().min(1).max(128),
-      projectId: z26.string().min(1).max(128)
+    z27.object({
+      orgId: z27.string().min(1).max(128),
+      projectId: z27.string().min(1).max(128)
     })
   ).mutation(async ({ input }) => {
     await cloudSyncBridge.unfollowProject(input.orgId, input.projectId);
@@ -15039,9 +15232,9 @@ var cloudSyncRouter = router({
    * membre, ce qui évite d'effacer les fichiers si le cloud a refusé l'ordre.
    */
   deleteProjectFromOrg: protectedProcedure.input(
-    z26.object({
-      orgId: z26.string().min(1).max(128),
-      projectId: z26.string().min(1).max(128)
+    z27.object({
+      orgId: z27.string().min(1).max(128),
+      projectId: z27.string().min(1).max(128)
     })
   ).mutation(async ({ input }) => {
     let res;
@@ -15085,10 +15278,10 @@ var cloudSyncRouter = router({
    * afficher. Le nom est donc recopié dans le tampon du coffre au passage, là
    * où il est déjà lu au démarrage suivant.
    */
-  rememberOrgNames: protectedProcedure.input(z26.object({
-    orgs: z26.array(z26.object({
-      orgId: z26.string().min(1).max(128),
-      name: z26.string().min(1).max(100)
+  rememberOrgNames: protectedProcedure.input(z27.object({
+    orgs: z27.array(z27.object({
+      orgId: z27.string().min(1).max(128),
+      name: z27.string().min(1).max(100)
     })).max(200)
   })).mutation(async ({ input }) => {
     for (const { orgId, name } of input.orgs) await rememberOrgName(orgId, name);
@@ -15124,13 +15317,13 @@ var cloudSyncRouter = router({
 // ../server/src/trpc/routers/filesystem.ts
 import { readdir as readdir8, stat as stat8 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute4, join as join24, resolve as resolve5, dirname as dirname10, basename as basename2 } from "path";
-import { z as z27 } from "zod";
+import { isAbsolute as isAbsolute4, join as join25, resolve as resolve5, dirname as dirname10, basename as basename2 } from "path";
+import { z as z28 } from "zod";
 var MAX_ENTRIES2 = 500;
-var PATH_SCHEMA = z27.string().min(1).max(4096);
+var PATH_SCHEMA = z28.string().min(1).max(4096);
 function safeResolve(input) {
   if (input.includes("\0")) throw new Error("Chemin invalide");
-  const expanded = input.startsWith("~") ? join24(homedir5(), input.slice(1)) : input;
+  const expanded = input.startsWith("~") ? join25(homedir5(), input.slice(1)) : input;
   if (!isAbsolute4(expanded)) throw new Error("Le chemin doit \xEAtre absolu");
   return resolve5(expanded);
 }
@@ -15151,7 +15344,7 @@ var filesystemRouter = router({
    * Hidden entries are skipped: they are noise for choosing a workspace, and
    * `.runeya` itself would invite placing a project inside another's data.
    */
-  listDirectories: protectedProcedure.input(z27.object({ path: PATH_SCHEMA })).query(async ({ input }) => {
+  listDirectories: protectedProcedure.input(z28.object({ path: PATH_SCHEMA })).query(async ({ input }) => {
     const dir = safeResolve(input.path);
     const info = await stat8(dir).catch(() => null);
     if (!info?.isDirectory()) {
@@ -15166,7 +15359,7 @@ var filesystemRouter = router({
     const truncated = names.length > MAX_ENTRIES2;
     const entries2 = [];
     for (const name of names.slice(0, MAX_ENTRIES2)) {
-      const path = join24(dir, name);
+      const path = join25(dir, name);
       entries2.push({ name, path, hasRuneyaProject: await holdsRuneyaProject(path) });
     }
     return {
@@ -15185,10 +15378,10 @@ var filesystemRouter = router({
    * Two projects in one directory is what makes services run against the wrong
    * code, so a directory that already holds one is refused outright.
    */
-  checkProjectTarget: protectedProcedure.input(z27.object({
+  checkProjectTarget: protectedProcedure.input(z28.object({
     path: PATH_SCHEMA,
-    projectId: z27.string().min(1).max(128),
-    orgId: z27.string().max(128).nullable().optional()
+    projectId: z28.string().min(1).max(128),
+    orgId: z28.string().max(128).nullable().optional()
   })).query(async ({ input }) => {
     const dir = safeResolve(input.path);
     const info = await stat8(dir).catch(() => null);
@@ -15298,8 +15491,8 @@ async function ensureFilePermissions() {
 }
 
 // ../server/src/services/vault-migration.ts
-import { readdir as readdir9, readFile as readFile18, writeFile as writeFile17, mkdir as mkdir21, copyFile as copyFile2, unlink as unlink5, rename as rename14, stat as stat10 } from "fs/promises";
-import { join as join25 } from "path";
+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 = [
   "agents.json",
@@ -15329,17 +15522,17 @@ async function openLegacyVault(legacyRoot, masterPassword) {
 }
 async function migrateLegacyVault(legacyRoot, machineRootDir, legacyKey, machineKey, now) {
   const stamp = now.toISOString().replace(/[:.]/g, "-").substring(0, 19);
-  const backupDir = join25(legacyRoot, `backup-${stamp}`);
-  await mkdir21(backupDir, { recursive: true });
+  const backupDir = join26(legacyRoot, `backup-${stamp}`);
+  await mkdir22(backupDir, { recursive: true });
   const jsonFiles = await vaultJsonFiles(legacyRoot);
   for (const name of [...jsonFiles, ...KEY_FILES]) {
-    if (await exists2(join25(legacyRoot, name))) {
-      await copyFile2(join25(legacyRoot, name), join25(backupDir, name));
+    if (await exists2(join26(legacyRoot, name))) {
+      await copyFile2(join26(legacyRoot, name), join26(backupDir, name));
     }
   }
   const rekeyed = [];
   for (const name of jsonFiles) {
-    const raw = await readFile18(join25(legacyRoot, name), "utf-8");
+    const raw = await readFile19(join26(legacyRoot, name), "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -15349,13 +15542,13 @@ async function migrateLegacyVault(legacyRoot, machineRootDir, legacyKey, machine
     const counter = { n: 0 };
     const converted = rekeyValue(parsed, legacyKey, machineKey, counter);
     if (counter.n === 0) continue;
-    const tmp = join25(legacyRoot, `${name}.tmp`);
-    await writeFile17(tmp, JSON.stringify(converted, null, 2), "utf-8");
-    await rename14(tmp, join25(legacyRoot, name));
+    const tmp = join26(legacyRoot, `${name}.tmp`);
+    await writeFile18(tmp, JSON.stringify(converted, null, 2), "utf-8");
+    await rename15(tmp, join26(legacyRoot, name));
     rekeyed.push({ file: name, values: counter.n });
   }
   for (const { file, values } of rekeyed) {
-    const parsed = JSON.parse(await readFile18(join25(legacyRoot, file), "utf-8"));
+    const parsed = JSON.parse(await readFile19(join26(legacyRoot, file), "utf-8"));
     const check = { n: 0 };
     rekeyValue(parsed, machineKey, machineKey, check);
     if (check.n !== values) {
@@ -15364,13 +15557,13 @@ async function migrateLegacyVault(legacyRoot, machineRootDir, legacyKey, machine
       );
     }
   }
-  await mkdir21(machineRootDir, { recursive: true });
+  await mkdir22(machineRootDir, { recursive: true });
   const moved = [];
   const skipped = [];
   for (const name of MACHINE_FILES) {
-    const from = join25(legacyRoot, name);
+    const from = join26(legacyRoot, name);
     if (!await exists2(from)) continue;
-    const to = join25(machineRootDir, name);
+    const to = join26(machineRootDir, name);
     if (await exists2(to)) {
       skipped.push(name);
       continue;
@@ -15380,15 +15573,15 @@ async function migrateLegacyVault(legacyRoot, machineRootDir, legacyKey, machine
     moved.push(name);
   }
   for (const name of KEY_FILES) {
-    const path = join25(legacyRoot, name);
+    const path = join26(legacyRoot, name);
     if (await exists2(path)) await unlink5(path);
   }
   return { backupDir, rekeyed, moved, skipped };
 }
 
 // ../server/src/services/settings-migration.ts
-import { readFile as readFile19, writeFile as writeFile18, rename as rename15, unlink as unlink6, mkdir as mkdir22, chmod as chmod12, stat as stat11 } from "fs/promises";
-import { join as join26 } from "path";
+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";
 async function exists3(path) {
@@ -15401,12 +15594,12 @@ async function legacySource(filename) {
   return null;
 }
 async function moveInto(root, filename, from) {
-  await mkdir22(root, { recursive: true });
-  const to = join26(root, filename);
-  const contents = await readFile19(from, "utf-8");
+  await mkdir23(root, { recursive: true });
+  const to = join27(root, filename);
+  const contents = await readFile20(from, "utf-8");
   const tmp = to + ".tmp";
-  await writeFile18(tmp, contents, "utf-8");
-  await rename15(tmp, to);
+  await writeFile19(tmp, contents, "utf-8");
+  await rename16(tmp, to);
   await chmod12(to, 384);
   await unlink6(from);
 }
@@ -15427,7 +15620,7 @@ async function migrateSettingsIntoVaults() {
   const orgId = orgs[0];
   const root = orgVaultRoot(orgId);
   for (const { filename, from } of sources) {
-    if (await exists3(join26(root, filename))) continue;
+    if (await exists3(join27(root, filename))) continue;
     await moveInto(root, filename, from);
     report.files.push(filename);
   }
@@ -15443,14 +15636,14 @@ 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 {
-  readFile as readFile20,
-  writeFile as writeFile19,
-  rename as rename16,
-  mkdir as mkdir23,
+  readFile as readFile21,
+  writeFile as writeFile20,
+  rename as rename17,
+  mkdir as mkdir24,
   access as access3,
   readdir as readdir10
 } from "fs/promises";
-import { join as join27, dirname as dirname11 } from "path";
+import { join as join28, dirname as dirname11 } from "path";
 var _require = createRequire2(import.meta.url);
 var PARSER_ID_MAP = {
   "stack-monitor-parser-jsons": "native:json",
@@ -15559,7 +15752,7 @@ async function getSodium() {
   return _sodium;
 }
 async function decryptLegacyFile(filePath, key, sodium) {
-  const raw = (await readFile20(filePath, "utf-8")).trim();
+  const raw = (await readFile21(filePath, "utf-8")).trim();
   if (!raw || raw === "[]" || raw === "{}") {
     try {
       return JSON.parse(raw);
@@ -15579,12 +15772,12 @@ async function decryptLegacyFile(filePath, key, sodium) {
 }
 async function atomicWrite(path, data) {
   const tmp = path + ".tmp";
-  await writeFile19(tmp, JSON.stringify(data, null, 2), "utf-8");
-  await rename16(tmp, path);
+  await writeFile20(tmp, JSON.stringify(data, null, 2), "utf-8");
+  await rename17(tmp, path);
 }
 async function runLegacyMigration(dataDir) {
   const legacyRoot = env.DATA_DIR;
-  const legacyKeyPath = join27(legacyRoot, "dbs", "encryption-key.json");
+  const legacyKeyPath = join28(legacyRoot, "dbs", "encryption-key.json");
   try {
     await access3(legacyKeyPath);
   } catch {
@@ -15592,20 +15785,20 @@ 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 = join27(abCwd, ".runeya-tmp");
-  await rename16(legacyRoot, legacyTmp);
-  await mkdir23(dataDir, { recursive: true });
-  const legacyOld = join27(dataDir, `backup-${timestamp}`);
-  await rename16(legacyTmp, legacyOld);
+  const legacyTmp = join28(abCwd, ".runeya-tmp");
+  await rename17(legacyRoot, legacyTmp);
+  await mkdir24(dataDir, { recursive: true });
+  const legacyOld = join28(dataDir, `backup-${timestamp}`);
+  await rename17(legacyTmp, legacyOld);
   console.log(`[legacy-migration] Legacy data backed up to ${legacyOld}`);
-  const keyJson = JSON.parse(await readFile20(join27(legacyOld, "dbs", "encryption-key.json"), "utf-8"));
+  const keyJson = JSON.parse(await readFile21(join28(legacyOld, "dbs", "encryption-key.json"), "utf-8"));
   const sodium = await getSodium();
   const sodiumKey = sodium.from_base64(keyJson.encryptionKey);
   const keyBuffer = Buffer.from(sodiumKey);
   const runyeaKeyHex = keyBuffer.toString("hex");
   await setEncryptionKey(runyeaKeyHex);
   console.log("[legacy-migration] Encryption key loaded in memory (temporary)");
-  const dbsDir = join27(legacyOld, "dbs");
+  const dbsDir = join28(legacyOld, "dbs");
   async function readEncrypted(filePath) {
     try {
       return await decryptLegacyFile(filePath, sodiumKey, sodium);
@@ -15614,29 +15807,29 @@ async function runLegacyMigration(dataDir) {
       return null;
     }
   }
-  const envsDir = join27(dbsDir, "envs");
+  const envsDir = join28(dbsDir, "envs");
   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(join27(envsDir, file));
+    legacyEnvs[name] = await readEncrypted(join28(envsDir, file));
   }
-  const servicesDir = join27(dbsDir, "services");
+  const servicesDir = join28(dbsDir, "services");
   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", "");
     if (!name) continue;
-    const data = await readEncrypted(join27(servicesDir, file));
+    const data = await readEncrypted(join28(servicesDir, file));
     if (data?.label) legacyServices[name] = data;
   }
-  const overridesDir = join27(dbsDir, "overrides");
+  const overridesDir = join28(dbsDir, "overrides");
   const overrideFiles = (await readdir10(overridesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyServiceOverrides = {};
   const legacyEnvOverrides = {};
   for (const file of overrideFiles) {
     const baseName = file.replace(".encrypted.json", "");
-    const data = await readEncrypted(join27(overridesDir, file));
+    const data = await readEncrypted(join28(overridesDir, file));
     if (!data) continue;
     if (baseName.endsWith("-envs")) {
       legacyServiceOverrides[baseName.slice(0, -5)] = data;
@@ -15644,11 +15837,11 @@ async function runLegacyMigration(dataDir) {
       legacyEnvOverrides[baseName.slice(0, -12)] = data;
     }
   }
-  const parsersDir = join27(dbsDir, "parsers");
+  const parsersDir = join28(dbsDir, "parsers");
   const parserFiles = (await readdir10(parsersDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyParsers = [];
   for (const file of parserFiles) {
-    const data = await readEncrypted(join27(parsersDir, file));
+    const data = await readEncrypted(join28(parsersDir, file));
     if (data?.id) legacyParsers.push(data);
   }
   const projectMonoId = randomUUID12();
@@ -15989,7 +16182,7 @@ async function runLegacyMigration(dataDir) {
   }
   let existingSettings = {};
   try {
-    existingSettings = JSON.parse(await readFile20(join27(dataDir, "settings.json"), "utf-8"));
+    existingSettings = JSON.parse(await readFile21(join28(dataDir, "settings.json"), "utf-8"));
   } catch {
   }
   const migratedParsers = legacyParsers.map((p) => ({
@@ -16010,11 +16203,11 @@ ${p.transform ?? ""}`,
       ...migratedParsers
     ]
   };
-  await atomicWrite(join27(dataDir, "projects.json"), runeProjects);
-  await atomicWrite(join27(dataDir, "services.json"), runeServices);
-  await atomicWrite(join27(dataDir, "environments.json"), runeEnvs);
-  await atomicWrite(join27(dataDir, "environment-overrides.json"), flatOverrides);
-  await atomicWrite(join27(dataDir, "settings.json"), newSettings);
+  await atomicWrite(join28(dataDir, "projects.json"), runeProjects);
+  await atomicWrite(join28(dataDir, "services.json"), runeServices);
+  await atomicWrite(join28(dataDir, "environments.json"), runeEnvs);
+  await atomicWrite(join28(dataDir, "environment-overrides.json"), flatOverrides);
+  await atomicWrite(join28(dataDir, "settings.json"), newSettings);
   const svcEnvCount = runeEnvs.filter((e) => e.scope === "service").length;
   console.log(`[legacy-migration] Written: ${runeProjects.length} projects, ${runeServices.length} services, ${runeEnvs.length} environments (${svcEnvCount} service-scoped)`);
   console.log(`[legacy-migration] Overrides: ${Object.keys(flatOverrides).length}, custom parsers: ${migratedParsers.length} (all disabled \u2014 rewrite required)`);
@@ -16028,9 +16221,9 @@ async function findLegacyKeyInBackup(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 = join27(dataDir, dir, "dbs", "encryption-key.json");
+      const keyJsonPath = join28(dataDir, dir, "dbs", "encryption-key.json");
       try {
-        const raw = await readFile20(keyJsonPath, "utf-8");
+        const raw = await readFile21(keyJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!parsed.encryptionKey) continue;
         const sodium = await getSodium();
@@ -16051,8 +16244,8 @@ async function runOverrideOnlyMigration(dataDir) {
   const { resolve: resolve7 } = await import("path");
   const abDataDir = resolve7(dataDir);
   const candidateDirs = [
-    join27(dirname11(env.DATA_DIR), ".runeya", "dbs", "overrides"),
-    join27(abDataDir, "dbs", "overrides")
+    join28(dirname11(env.DATA_DIR), ".runeya", "dbs", "overrides"),
+    join28(abDataDir, "dbs", "overrides")
   ];
   let overridesDir = null;
   let overrideFiles = [];
@@ -16068,7 +16261,7 @@ async function runOverrideOnlyMigration(dataDir) {
     }
   }
   if (!overridesDir || overrideFiles.length === 0) return false;
-  const legacyKeyPath = join27(overridesDir, "..", "encryption-key.json");
+  const legacyKeyPath = join28(overridesDir, "..", "encryption-key.json");
   try {
     await access3(legacyKeyPath);
     return false;
@@ -16086,7 +16279,7 @@ async function runOverrideOnlyMigration(dataDir) {
   const envNameToId = {};
   let envsRaw;
   try {
-    envsRaw = JSON.parse(await readFile20(join27(abDataDir, "environments.json"), "utf-8"));
+    envsRaw = JSON.parse(await readFile21(join28(abDataDir, "environments.json"), "utf-8"));
     for (const _env of envsRaw) {
       const env2 = _env;
       if (env2["name"] && env2["id"]) {
@@ -16105,7 +16298,7 @@ async function runOverrideOnlyMigration(dataDir) {
   let servicesRaw = [];
   const serviceNameToId = {};
   try {
-    servicesRaw = JSON.parse(await readFile20(join27(abDataDir, "services.json"), "utf-8"));
+    servicesRaw = JSON.parse(await readFile21(join28(abDataDir, "services.json"), "utf-8"));
     for (const _svc of servicesRaw) {
       const svc = _svc;
       if (svc["name"] && svc["id"]) serviceNameToId[svc["name"]] = svc["id"];
@@ -16122,7 +16315,7 @@ async function runOverrideOnlyMigration(dataDir) {
     const envName = baseName.slice(0, -"-environment".length);
     let data;
     try {
-      data = await decryptLegacyFile(join27(overridesDir, file), sodiumKey, sodium);
+      data = await decryptLegacyFile(join28(overridesDir, file), sodiumKey, sodium);
     } catch (err) {
       console.warn(`[override-migration] Failed to decrypt ${file}: ${err.message}`);
       continue;
@@ -16149,7 +16342,7 @@ async function runOverrideOnlyMigration(dataDir) {
     }
   }
   if (Object.keys(flatOverrides).length > 0) {
-    await atomicWrite(join27(abDataDir, "environment-overrides.json"), flatOverrides);
+    await atomicWrite(join28(abDataDir, "environment-overrides.json"), flatOverrides);
     console.log(`[override-migration] Written ${Object.keys(flatOverrides).length} override(s) to environment-overrides.json`);
   }
   let envsModified = false;
@@ -16159,7 +16352,7 @@ async function runOverrideOnlyMigration(dataDir) {
     const serviceName = baseName.slice(0, -"-envs".length);
     let data;
     try {
-      data = await decryptLegacyFile(join27(overridesDir, file), sodiumKey, sodium);
+      data = await decryptLegacyFile(join28(overridesDir, file), sodiumKey, sodium);
     } catch (err) {
       console.warn(`[override-migration] Failed to decrypt ${file}: ${err.message}`);
       continue;
@@ -16218,12 +16411,12 @@ async function runOverrideOnlyMigration(dataDir) {
     }
   }
   if (envsModified) {
-    await atomicWrite(join27(abDataDir, "environments.json"), envsRaw);
+    await atomicWrite(join28(abDataDir, "environments.json"), envsRaw);
     console.log("[override-migration] Merged service overrides into environments.json");
   }
   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}`);
@@ -16233,7 +16426,7 @@ async function runOverrideOnlyMigration(dataDir) {
 }
 
 // ../server/src/services/server-state.ts
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { stat as stat12 } from "fs/promises";
 var ENCRYPTED_KEY_FILENAME2 = ".encryption.key.enc";
 var VERIFY_FILENAME2 = ".runeya-verify";
@@ -16243,22 +16436,22 @@ async function getServerState() {
   let hasVerify = false;
   let hasData = false;
   try {
-    await stat12(join28(dataDir, ENCRYPTED_KEY_FILENAME2));
+    await stat12(join29(dataDir, ENCRYPTED_KEY_FILENAME2));
     hasEncFile = true;
   } catch {
   }
   try {
-    await stat12(join28(dataDir, VERIFY_FILENAME2));
+    await stat12(join29(dataDir, VERIFY_FILENAME2));
     hasVerify = true;
   } catch {
   }
   try {
-    await stat12(join28(dataDir, "projects.json"));
+    await stat12(join29(dataDir, "projects.json"));
     hasData = true;
   } catch {
   }
   try {
-    await stat12(join28(dataDir, "project.json"));
+    await stat12(join29(dataDir, "project.json"));
     hasData = true;
   } catch {
   }
@@ -16671,6 +16864,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));
@@ -17267,6 +17461,7 @@ async function createLocalServer() {
   }));
   app.use(errorHandler);
   const server = createServer(app);
+  registerHttpServer(server);
   const wss = new WebSocketServer({ noServer: true });
   applyWSSHandler({
     wss,
@@ -17518,4 +17713,4 @@ export {
   pullEnv,
   registerInstance
 };
-//# sourceMappingURL=src-Q3PSCMS7.js.map
+//# sourceMappingURL=src-MY5W5AYS.js.map