@runeya/runeya 2.0.21 → 2.0.24

package/{src-K32WI425.js → src-EGBDYHL5.js}

@@ -10,7 +10,6 @@ import {
   HealthCheckSchema,
   JSLogParser,
   JSLogParserSchema,
-  KanbanColumnSchema,
   LOG_BUFFER_SIZE,
   LogSourceConfigSchema,
   NotificationPreferencesSchema,
@@ -27,24 +26,11 @@ import {
   SettingsSchema,
   TraefikConfigSchema,
   UpdateEnvironmentSchema,
+  VariableOverrideSchema,
   VariableSchema,
   agentManager,
   agentSpawner,
   agentStore,
-  environmentStore,
-  getCollection,
-  nativeParsers,
-  readEntity,
-  serviceStore,
-  traefikManager,
-  writeEntity
-} from "./chunk-PUNE7P6S.js";
-import {
-  generateKanbanPopulatePrompt,
-  generateKanbanSystemPrompt,
-  kanbanStore
-} from "./chunk-LZWBXYUE.js";
-import {
   clearEncryptionKey,
   clearPendingLegacyKey,
   decryptValue,
@@ -53,24 +39,32 @@ import {
   encryptVariableSlots,
   ensureEncryptionKey,
   env,
+  environmentStore,
   extractEncryptedVariableSlots,
+  getCollection,
   getEncryptionKey,
   getPendingLegacyKey,
   hasEncryptionKey,
   hasPendingLegacyKey,
   isCiMode,
+  isEncryptedValue,
   loadFromEnv,
+  nativeParsers,
+  readEntity,
+  serviceStore,
   setEncryptionKey,
   setEncryptionKeyInMemory,
   setPendingLegacyKey,
-  stableEncryptValue
-} from "./chunk-Q4N37KNN.js";
+  stableEncryptValue,
+  traefikManager,
+  writeEntity
+} from "./chunk-Y2R42AXQ.js";
 
 // ../server/src/create-server.ts
 import express from "express";
 import cors from "cors";
 import { createServer } from "http";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 import { WebSocketServer } from "ws";
 import { createExpressMiddleware } from "@trpc/server/adapters/express";
 import { applyWSSHandler } from "@trpc/server/adapters/ws";
@@ -108,6 +102,10 @@ async function verifyJwt(token) {
 import { randomBytes as randomBytes2, randomUUID, timingSafeEqual } from "crypto";
 import { readFile, writeFile, rename, mkdir, chmod } from "fs/promises";
 import { join } from "path";
+function maskApiKey(apiKey) {
+  const { key, ...rest } = apiKey;
+  return { ...rest, keyPreview: key.slice(-4) };
+}
 var FILE_PUBLIC = "api-keys.json";
 var FILE_PRIVATE = "api-keys.private.json";
 var ApiKeyStore = class {
@@ -122,7 +120,7 @@ var ApiKeyStore = class {
   async persistFile(isPublic) {
     await this.ensureDir();
     const path = this.filePath(isPublic);
-    const keys = Array.from(this.keys.values()).filter((k) => k.isPublic === isPublic);
+    const keys = Array.from(this.keys.values()).filter((k) => k.isPublic === isPublic).map((k) => ({ ...k, key: encryptValue(k.key) }));
     const tmp = path + ".tmp";
     await writeFile(tmp, JSON.stringify({ keys }, null, 2), "utf-8");
     await rename(tmp, path);
@@ -137,7 +135,8 @@ var ApiKeyStore = class {
       const parsed = ApiKeysFileSchema.safeParse(JSON.parse(raw));
       if (parsed.success) {
         for (const k of parsed.data.keys) {
-          this.keys.set(k.id, k);
+          const key = isEncryptedValue(k.key) ? decryptValue(k.key) : k.key;
+          this.keys.set(k.id, { ...k, key });
         }
       }
     } catch {
@@ -149,9 +148,18 @@ var ApiKeyStore = class {
     await this.loadFile(this.filePath(true));
     await this.loadFile(this.filePath(false));
   }
+  /**
+   * Keys as exposed to callers — secrets stripped. Use `reveal` to obtain one
+   * deliberately; never hand the whole set of secrets out at once.
+   */
   async list() {
     await this.load();
-    return Array.from(this.keys.values());
+    return Array.from(this.keys.values()).map(maskApiKey);
+  }
+  /** The plaintext secret of a single key, or null when unknown. */
+  async reveal(id) {
+    await this.load();
+    return this.keys.get(id)?.key ?? null;
   }
   async create(name, scopes, isPublic) {
     await this.load();
@@ -527,7 +535,7 @@ var ProjectStore = class {
     await this.load();
     const parsed = ProjectSchema.safeParse({ ...fields, id });
     if (!parsed.success) {
-      console.error(`[project-store] Rejected remote project ${id}:`, parsed.error.message);
+      console.error("[project-store] Rejected remote project %s:", id, parsed.error.message);
       return null;
     }
     const incoming = toDiskForm(parsed.data);
@@ -640,10 +648,13 @@ var EnvironmentOverridesStore = class {
       this.diskEncryptedSlots = extractEncryptedVariableSlots(
         parsed
       );
-      this.data = decryptVariableSlots(
+      const decrypted = decryptVariableSlots(
         parsed,
         "environment-overrides"
       );
+      this.data = Object.fromEntries(
+        Object.entries(decrypted).map(([id, override]) => [id, { value: override.value }])
+      );
     } catch {
       this.data = {};
     }
@@ -673,9 +684,9 @@ var EnvironmentOverridesStore = class {
     await this.load();
     return this.data[variableId] ?? null;
   }
-  async setOverride(variableId, variable) {
+  async setOverride(variableId, override) {
     await this.load();
-    this.data[variableId] = variable;
+    this.data[variableId] = { value: override.value };
     await this.save();
   }
   async removeOverride(variableId) {
@@ -728,10 +739,11 @@ var EnvironmentResolver = class {
   async resolveEnvironment(environmentId) {
     const visited = /* @__PURE__ */ new Set();
     const result = await this.resolveDag(environmentId, visited);
-    const allOverrides = await environmentOverridesStore.getAll();
-    for (const [varId, override] of Object.entries(allOverrides)) {
-      if (result.variables[varId]) {
-        result.variables[varId] = override;
+    const overridesByKey = await this.resolveOverridesByKey(environmentId);
+    for (const [varId, variable] of Object.entries(result.variables)) {
+      const override = overridesByKey[variable.key];
+      if (override) {
+        result.variables[varId] = { ...variable, value: override.variable.value };
       }
     }
     const rawEnv = {};
@@ -740,12 +752,13 @@ var EnvironmentResolver = class {
       rawEnv[variable.key] = slot.pre + slot.value + slot.post;
     }
     const { ctx: interpolationCtx, secretKeys: ctxSecretKeys } = await this.buildInterpolationContext(environmentId, rawEnv, result.parentEnv, result.parentSecretKeys, result.parentKeySources);
+    const secretKeys = this.collectSecretKeys(result.variables, ctxSecretKeys);
     const env2 = {};
     const envSecrets = [];
     for (const [_varId, variable] of Object.entries(result.variables)) {
       const { value, isSecret } = resolveVariable(variable, interpolationCtx);
       env2[variable.key] = value;
-      if (isSecret || this.interpolatesSecretKey(variable.value.value, ctxSecretKeys)) {
+      if (isSecret || secretKeys.has(variable.key)) {
         envSecrets.push(variable.key);
       }
     }
@@ -760,10 +773,11 @@ var EnvironmentResolver = class {
     if (!environmentId) return {};
     const visited = /* @__PURE__ */ new Set();
     const result = await this.resolveDag(environmentId, visited);
-    const allOverrides = await environmentOverridesStore.getAll();
-    for (const [varId, override] of Object.entries(allOverrides)) {
-      if (result.variables[varId]) {
-        result.variables[varId] = override;
+    const overridesByKey = await this.resolveOverridesByKey(environmentId);
+    for (const [varId, variable] of Object.entries(result.variables)) {
+      const override = overridesByKey[variable.key];
+      if (override) {
+        result.variables[varId] = { ...variable, value: override.variable.value };
       }
     }
     const rawEnv = {};
@@ -789,13 +803,15 @@ var EnvironmentResolver = class {
   async resolveEnvironmentWithSources(environmentId) {
     const visited = /* @__PURE__ */ new Set();
     const result = await this.resolveDag(environmentId, visited);
-    const allOverrides = await environmentOverridesStore.getAll();
-    for (const [varId, override] of Object.entries(allOverrides)) {
-      if (result.variables[varId]) {
-        result.variables[varId] = override;
+    const overridesByKey = await this.resolveOverridesByKey(environmentId);
+    for (const [varId, variable] of Object.entries(result.variables)) {
+      const override = overridesByKey[variable.key];
+      if (override) {
+        result.variables[varId] = { ...variable, value: override.variable.value };
         result.sources[varId] = {
           ...result.sources[varId],
-          overridden: true
+          overridden: true,
+          ...override.source ? { overriddenBy: override.source } : {}
         };
       }
     }
@@ -805,12 +821,13 @@ var EnvironmentResolver = class {
       rawEnv[variable.key] = slot.pre + slot.value + slot.post;
     }
     const { ctx: interpolationCtx, secretKeys: ctxSecretKeys, keySources } = await this.buildInterpolationContext(environmentId, rawEnv, result.parentEnv, result.parentSecretKeys, result.parentKeySources);
+    const secretKeys = this.collectSecretKeys(result.variables, ctxSecretKeys);
     const env2 = {};
     const envSecrets = [];
     for (const [_varId, variable] of Object.entries(result.variables)) {
       const { value, isSecret } = resolveVariable(variable, interpolationCtx);
       env2[variable.key] = value;
-      if (isSecret || this.interpolatesSecretKey(variable.value.value, ctxSecretKeys)) {
+      if (isSecret || secretKeys.has(variable.key)) {
         envSecrets.push(variable.key);
       }
     }
@@ -835,6 +852,37 @@ var EnvironmentResolver = class {
     };
   }
   /** Check if a raw value string interpolates any key that is secret in the context */
+  /**
+   * Toutes les clés dont la valeur est, directement ou par interpolation, un
+   * secret.
+   *
+   * Le contexte d'interpolation ne connaît que les secrets *hérités* : les
+   * secrets définis dans le même environnement n'y figurent pas, si bien qu'un
+   * `AUTH='Bearer {{environment.TOKEN}}'` voisin de son propre `TOKEN` secret
+   * ressortait non marqué — et donc non masqué par toute la chaîne en aval.
+   *
+   * On part des secrets hérités plus ceux déclarés ici, puis on propage
+   * jusqu'au point fixe : une valeur qui référence une clé secrète devient
+   * secrète à son tour, y compris en chaîne (A secret → B cite A → C cite B).
+   */
+  collectSecretKeys(variables, parentSecretKeys) {
+    const secretKeys = new Set(parentSecretKeys);
+    for (const variable of Object.values(variables)) {
+      if (variable.value.isSecret) secretKeys.add(variable.key);
+    }
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const variable of Object.values(variables)) {
+        if (secretKeys.has(variable.key)) continue;
+        if (this.interpolatesSecretKey(variable.value.value, secretKeys)) {
+          secretKeys.add(variable.key);
+          changed = true;
+        }
+      }
+    }
+    return secretKeys;
+  }
   interpolatesSecretKey(rawValue, ctxSecretKeys) {
     const refs = [...rawValue.matchAll(/\{\{environment\.([^}]+)\}\}/g)].map((m) => m[1]);
     return refs.some((ref) => ctxSecretKeys.has(ref));
@@ -905,7 +953,49 @@ var EnvironmentResolver = class {
     if (additionalIds.length === 0) return environment.parentIds;
     return [...environment.parentIds, ...additionalIds];
   }
-  async resolveDag(environmentId, visited) {
+  /**
+   * Project an environment's variables onto their overrides: keep only the
+   * variables that have one, and swap in the override's value slot. The key
+   * always comes from the definition.
+   *
+   * Feeding this projection back through `resolveDag` resolves the override
+   * chain with the exact same inheritance and dedup-by-key rules as the value
+   * chain — so an override set on a parent env is no longer swallowed when a
+   * child (or a service env) redeclares the same key.
+   */
+  projectOverrides(variables, overrides) {
+    const projected = {};
+    for (const [varId, variable] of Object.entries(variables)) {
+      const override = overrides[varId];
+      if (override) {
+        projected[varId] = { key: variable.key, value: override.value };
+      }
+    }
+    return projected;
+  }
+  /**
+   * Resolve the override chain independently of the value chain and return the
+   * winning override per variable key (empty when nothing is overridden).
+   */
+  async resolveOverridesByKey(environmentId) {
+    const allOverrides = await environmentOverridesStore.getAll();
+    if (Object.keys(allOverrides).length === 0) return {};
+    const result = await this.resolveDag(
+      environmentId,
+      /* @__PURE__ */ new Set(),
+      (variables) => this.projectOverrides(variables, allOverrides)
+    );
+    const byKey = {};
+    for (const [varId, variable] of Object.entries(result.variables)) {
+      const source = result.sources[varId];
+      byKey[variable.key] = {
+        variable,
+        ...source ? { source: { environmentId: source.environmentId, environmentName: source.environmentName } } : {}
+      };
+    }
+    return byKey;
+  }
+  async resolveDag(environmentId, visited, project) {
     if (visited.has(environmentId)) {
       throw new Error(`Circular dependency detected in environment inheritance for ${environmentId}`);
     }
@@ -918,7 +1008,7 @@ var EnvironmentResolver = class {
     const parentResults = [];
     for (const parentId of effectiveParentIds) {
       const parentVisited = new Set(visited);
-      const parentResult = await this.resolveDag(parentId, parentVisited);
+      const parentResult = await this.resolveDag(parentId, parentVisited, project);
       parentResults.push(parentResult);
     }
     const mergedVariables = {};
@@ -967,7 +1057,11 @@ var EnvironmentResolver = class {
         }
       }
     }
-    for (const [varId, variable] of Object.entries(environment.variables)) {
+    for (const key of this.collectSecretKeys(mergedVariables, parentSecretKeys)) {
+      parentSecretKeys.add(key);
+    }
+    const ownVariables = project ? project(environment.variables) : environment.variables;
+    for (const [varId, variable] of Object.entries(ownVariables)) {
       let wasInherited = varId in mergedVariables;
       for (const [existingId, existingVar] of Object.entries(mergedVariables)) {
         if (existingVar.key === variable.key && existingId !== varId) {
@@ -1763,13 +1857,13 @@ var agentRouter = router({
       yield { agentId: agent.config.id, status: agent.status };
     }
     const queue = [];
-    let resolve5 = null;
+    let resolve6 = null;
     const handler = (event) => {
       if (queue.length >= SUBSCRIPTION_QUEUE_MAX) queue.shift();
       queue.push(event);
-      if (resolve5) {
-        resolve5();
-        resolve5 = null;
+      if (resolve6) {
+        resolve6();
+        resolve6 = null;
       }
     };
     agentManager.on("status", handler);
@@ -1779,7 +1873,7 @@ var agentRouter = router({
           yield queue.shift();
         } else {
           await new Promise((r) => {
-            resolve5 = r;
+            resolve6 = r;
           });
         }
       }
@@ -1795,14 +1889,14 @@ import { TRPCError as TRPCError5 } from "@trpc/server";
 var SUBSCRIPTION_QUEUE_MAX2 = LOG_BUFFER_SIZE;
 async function* forwardEvents(eventName, filter) {
   const queue = [];
-  let resolve5 = null;
+  let resolve6 = null;
   const handler = (data) => {
     if (filter && !filter(data)) return;
     if (queue.length >= SUBSCRIPTION_QUEUE_MAX2) queue.shift();
     queue.push(data);
-    if (resolve5) {
-      resolve5();
-      resolve5 = null;
+    if (resolve6) {
+      resolve6();
+      resolve6 = null;
     }
   };
   agentManager.on(eventName, handler);
@@ -1812,7 +1906,7 @@ async function* forwardEvents(eventName, filter) {
         yield queue.shift();
       } else {
         await new Promise((r) => {
-          resolve5 = r;
+          resolve6 = r;
         });
       }
     }
@@ -1822,7 +1916,7 @@ async function* forwardEvents(eventName, filter) {
 }
 async function* forwardLogBatches(agentId, processId) {
   const queue = [];
-  let resolve5 = null;
+  let resolve6 = null;
   const handler = (data) => {
     if (data.agentId !== agentId) return;
     const batch = data.batch;
@@ -1831,9 +1925,9 @@ async function* forwardLogBatches(agentId, processId) {
     if (filtered.length === 0) return;
     if (queue.length >= SUBSCRIPTION_QUEUE_MAX2) queue.shift();
     queue.push(filtered);
-    if (resolve5) {
-      resolve5();
-      resolve5 = null;
+    if (resolve6) {
+      resolve6();
+      resolve6 = null;
     }
   };
   agentManager.on("process:log", handler);
@@ -1843,7 +1937,7 @@ async function* forwardLogBatches(agentId, processId) {
         yield queue.shift();
       } else {
         await new Promise((r) => {
-          resolve5 = r;
+          resolve6 = r;
         });
       }
     }
@@ -2315,7 +2409,9 @@ var environmentRouter = router({
   // --- Overrides (flat, by variableId) ---
   setOverride: protectedProcedure.input(z8.object({
     variableId: z8.string().max(128),
-    variable: VariableSchema
+    // Only the value slot: the env var name comes from the variable
+    // definition (a `key` sent by an older client is stripped here).
+    variable: VariableOverrideSchema
   })).mutation(async ({ input }) => {
     await environmentOverridesStore.setOverride(input.variableId, input.variable);
     return { success: true };
@@ -2341,6 +2437,72 @@ var environmentRouter = router({
     if (!result) throw new TRPCError6({ code: "INTERNAL_SERVER_ERROR", message: "Failed to update variable" });
     return result;
   }),
+  /**
+   * List everywhere a variable key is used inside a project: environments that
+   * define it, and variables that reference it through {{environment.KEY}}.
+   * Used by the UI to warn before editing a shared variable from a resolved view.
+   */
+  keyUsages: protectedProcedure.input(z8.object({
+    projectId: z8.string().max(128),
+    key: z8.string().min(1).max(256),
+    /** Environment holding the variable about to be edited — enables inherited-impact detection */
+    environmentId: z8.string().max(128).optional()
+  })).query(async ({ input }) => {
+    const environments = await environmentStore.list(input.projectId);
+    const services = await serviceStore.list();
+    const serviceName = (id) => services.find((s) => s.id === id)?.name;
+    const escaped = input.key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const refPattern = new RegExp(`\\{\\{environment\\.${escaped}\\}\\}`);
+    const definedIn = [];
+    const referencedBy = [];
+    for (const env2 of environments) {
+      const name = serviceName(env2.reference);
+      for (const variable of Object.values(env2.variables ?? {})) {
+        if (variable.key === input.key) {
+          definedIn.push({
+            environmentId: env2.id,
+            environmentName: env2.name,
+            scope: env2.scope ?? "global",
+            ...name ? { serviceName: name } : {}
+          });
+          continue;
+        }
+        const slot = variable.value;
+        if (refPattern.test(`${slot.pre}${slot.value}${slot.post}`)) {
+          referencedBy.push({
+            environmentId: env2.id,
+            environmentName: env2.name,
+            scope: env2.scope ?? "global",
+            ...name ? { serviceName: name } : {},
+            key: variable.key
+          });
+        }
+      }
+    }
+    const inheritedBy = [];
+    if (input.environmentId) {
+      for (const env2 of environments) {
+        if (env2.id === input.environmentId) continue;
+        try {
+          const resolved = await environmentResolver.resolveEnvironmentWithSources(env2.id);
+          const inherits = Object.entries(resolved.variables).some(
+            ([varId, variable]) => variable.key === input.key && resolved.sources[varId]?.environmentId === input.environmentId
+          );
+          if (inherits) {
+            const name = serviceName(env2.reference);
+            inheritedBy.push({
+              environmentId: env2.id,
+              environmentName: env2.name,
+              scope: env2.scope ?? "global",
+              ...name ? { serviceName: name } : {}
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    return { definedIn, referencedBy, inheritedBy };
+  }),
   removeVariable: protectedProcedure.input(z8.object({
     environmentId: z8.string().max(128),
     variableId: z8.string().max(128)
@@ -2355,10 +2517,11 @@ var environmentRouter = router({
 
 // ../server/src/trpc/routers/settings.ts
 import { promises as dns } from "dns";
+import { resolve } from "path";
 import { z as z9 } from "zod";
 import { TRPCError as TRPCError7 } from "@trpc/server";
 var NotificationPreferencesPatchSchema = NotificationPreferencesSchema.partial().strict();
-function maskApiKey(plaintext) {
+function maskApiKey2(plaintext) {
   if (plaintext.length <= 8) return "****";
   return plaintext.slice(0, 4) + "****" + plaintext.slice(-4);
 }
@@ -2370,6 +2533,14 @@ var settingsRouter = router({
     const settings = await settingsManager.getSettings();
     return settings;
   }),
+  /**
+   * Paths the server is running from (working directory + data directory).
+   * Read-only, purely informational for the settings UI.
+   */
+  getPaths: protectedProcedure.query(() => ({
+    cwd: process.cwd(),
+    dataDir: resolve(env.DATA_DIR)
+  })),
   /**
    * Update settings (mode, cloudUrl)
    */
@@ -2519,7 +2690,7 @@ var settingsRouter = router({
       let maskedKey = "(aucune)";
       if (p.encryptedApiKey) {
         try {
-          maskedKey = maskApiKey(decryptValue(p.encryptedApiKey));
+          maskedKey = maskApiKey2(decryptValue(p.encryptedApiKey));
         } catch {
           maskedKey = "(cl\xE9 invalide)";
         }
@@ -2559,7 +2730,7 @@ var settingsRouter = router({
       ...priv,
       aiProviders: [...priv.aiProviders ?? [], newProvider]
     });
-    return { ...newProvider, maskedKey: plainKey ? maskApiKey(plainKey) : "(aucune)", encryptedApiKey: void 0 };
+    return { ...newProvider, maskedKey: plainKey ? maskApiKey2(plainKey) : "(aucune)", encryptedApiKey: void 0 };
   }),
   /**
    * Update AI provider (apiKey optional — omit to keep existing)
@@ -2591,7 +2762,7 @@ var settingsRouter = router({
     let maskedKey = "(aucune)";
     if (updated.encryptedApiKey) {
       try {
-        maskedKey = maskApiKey(decryptValue(updated.encryptedApiKey));
+        maskedKey = maskApiKey2(decryptValue(updated.encryptedApiKey));
       } catch {
       }
     }
@@ -2729,7 +2900,7 @@ var settingsRouter = router({
         }
       } catch {
       }
-      await new Promise((resolve5) => setTimeout(resolve5, 500));
+      await new Promise((resolve6) => setTimeout(resolve6, 500));
     }
   }),
   /**
@@ -2916,7 +3087,7 @@ import { z as z11 } from "zod";
 import { TRPCError as TRPCError8 } from "@trpc/server";
 import { execFile as execFile2, spawn } from "child_process";
 import { stat as stat2 } from "fs/promises";
-import { resolve, join as join7 } from "path";
+import { resolve as resolve2, join as join7 } from "path";
 import { homedir as homedir2 } from "os";
 
 // ../server/src/services/user-config-manager.ts
@@ -3008,9 +3179,9 @@ async function getServiceCwd(serviceId) {
   return resolveCwd(rawCwd);
 }
 async function isCommandAvailable(command) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     execFile2("which", [command], { timeout: 5e3 }, (err) => {
-      resolve5(!err);
+      resolve6(!err);
     });
   });
 }
@@ -3064,7 +3235,7 @@ var editorRouter = router({
       throw new TRPCError8({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
     }
     const expanded = input.path.replace(/^~(\/|$)/, `${process.env["HOME"] ?? "/tmp"}$1`).replace(/\$\{(\w+)\}|\$(\w+)/g, (_, a, b) => process.env[a || b] ?? "");
-    const resolvedPath = resolve(expanded || ".");
+    const resolvedPath = resolve2(expanded || ".");
     try {
       await stat2(resolvedPath);
     } catch (err) {
@@ -3130,10 +3301,19 @@ var apiKeysRouter = router({
   create: protectedProcedure.input(KeyInputSchema).mutation(
     ({ input }) => apiKeyStore.create(input.name, input.scopes, input.isPublic)
   ),
+  /**
+   * 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(z12.object({ id: z12.string().max(128) })).query(async ({ input }) => {
+    const key = await apiKeyStore.reveal(input.id);
+    if (!key) throw new TRPCError9({ code: "NOT_FOUND", message: "API key not found" });
+    return { key };
+  }),
   update: protectedProcedure.input(KeyInputSchema.extend({ id: z12.string().max(128) })).mutation(async ({ input }) => {
     const updated = await apiKeyStore.update(input.id, input.name, input.scopes, input.isPublic);
     if (!updated) throw new TRPCError9({ code: "NOT_FOUND", message: "API key not found" });
-    return updated;
+    return maskApiKey(updated);
   }),
   remove: protectedProcedure.input(z12.object({ id: z12.string().max(128) })).mutation(async ({ input }) => {
     const removed = await apiKeyStore.remove(input.id);
@@ -3160,7 +3340,7 @@ var apiKeysRouter = router({
 });
 
 // ../server/src/trpc/routers/chat.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 import Anthropic2 from "@anthropic-ai/sdk";
 import OpenAI2 from "openai";
 import { execFile as execFile3 } from "child_process";
@@ -3794,6 +3974,18 @@ async function startClaudeTranscriptWatcher() {
     }
   }
 }
+function stopClaudeTranscriptWatcher() {
+  for (const w of watchers) {
+    try {
+      w.close();
+    } catch {
+    }
+  }
+  watchers.length = 0;
+  for (const t2 of pendingResyncs.values()) clearTimeout(t2);
+  pendingResyncs.clear();
+  started = false;
+}
 
 // ../server/src/services/codex-sessions.ts
 import { readdir as readdir3 } from "fs/promises";
@@ -3827,7 +4019,7 @@ async function codexSessionExists(sessionId) {
 }
 
 // ../server/src/trpc/routers/chat.ts
-import { TRPCError as TRPCError10 } from "@trpc/server";
+import { TRPCError as TRPCError11 } from "@trpc/server";
 
 // ../server/src/trpc/shared-schemas.ts
 import { z as z13 } from "zod";
@@ -4185,7 +4377,7 @@ function parse(text) {
   return result;
 }
 function getClaudeUsage() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const env2 = { ...process.env };
     delete env2["CLAUDECODE"];
     let claudeBin = "claude";
@@ -4216,7 +4408,7 @@ function getClaudeUsage() {
       clearTimeout(hardTimeout);
       term?.kill();
       const clean = buffer.replaceAll(/\x1b\[[0-9;]*X/g, "\n").replaceAll(/\x1b\[[0-9;]*[mGKHFABCDJsu]/g, "").replaceAll(/\x1b[^a-zA-Z]*[a-zA-Z]/g, "").replaceAll("\r", "");
-      resolve5(parse(clean));
+      resolve6(parse(clean));
     }
     const hardTimeout = setTimeout(() => {
       if (!done) finish();
@@ -4350,7 +4542,7 @@ function parseCodexStatusText(text) {
   return entries;
 }
 function getCodexUsageEntries() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let term = null;
     try {
       term = pty2.spawn("codex", [], {
@@ -4380,7 +4572,7 @@ function getCodexUsageEntries() {
         const debugClean = stripAnsi(buffer).slice(-6e3);
         process.stdout.write("[codex-usage] raw tail:\n" + debugClean + "\n");
       }
-      resolve5(parseCodexStatusText(buffer));
+      resolve6(parseCodexStatusText(buffer));
     };
     const hardTimeout = setTimeout(() => {
       finish();
@@ -4494,10 +4686,10 @@ var ActiveSessionRegistry = class {
     }
   }
   pushEvent(conversationId, event) {
-    if (process.env.DEBUG) console.log("[chat]: event - ", event.type);
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: event - ", event.type);
     const session = this.sessions.get(conversationId);
     if (!session) return;
-    if (process.env.DEBUG) console.log("[chat]: event - ", event.type, "session", session.conversationId);
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: event - ", event.type, "session", session.conversationId);
     if (event.type === "delta") {
       session.fullContent += event.text;
       const last = session.parts[session.parts.length - 1];
@@ -4535,15 +4727,15 @@ var ActiveSessionRegistry = class {
     if (session.buffer.length >= MAX_BUFFER) {
       session.buffer.shift();
     }
-    if (process.env.DEBUG) console.log("[chat]: event - ", event.type, "push buffer");
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: event - ", event.type, "push buffer");
     session.buffer.push(event);
     session.totalProduced++;
-    if (process.env.DEBUG) console.log("[chat]: event - ", event.type, "notify", session.notify.size);
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: event - ", event.type, "notify", session.notify.size);
     for (const cb of session.notify) cb();
     session.notify.clear();
   }
   markDone(conversationId) {
-    if (process.env.DEBUG) console.log("[chat]: markdone....", conversationId);
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: markdone....", conversationId);
     const session = this.sessions.get(conversationId);
     if (!session) return;
     session.status = "done";
@@ -4775,15 +4967,15 @@ import { join as join12 } from "path";
 
 // ../server/src/services/run-store-utils.ts
 import { chmod as chmod7, mkdir as mkdir9, rename as rename8, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname2, resolve as resolve2, sep } from "path";
+import { dirname as dirname2, resolve as resolve3, sep } from "path";
 import { readFile as readFile9 } from "fs/promises";
 var SAFE_PATH_SEGMENT_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
 function resolveConversationRunDir(rootDirName, conversationId) {
   if (!SAFE_PATH_SEGMENT_RE.test(conversationId)) {
     throw new Error("Invalid conversationId");
   }
-  const base = resolve2(env.DATA_DIR, rootDirName);
-  const dir = resolve2(base, conversationId);
+  const base = resolve3(env.DATA_DIR, rootDirName);
+  const dir = resolve3(base, conversationId);
   if (!dir.startsWith(base + sep)) {
     throw new Error("Invalid conversationId");
   }
@@ -5028,7 +5220,7 @@ async function fetchProviderModels(provider, plaintextKey) {
 import { randomUUID as randomUUID4 } from "crypto";
 import { mkdir as mkdir11, writeFile as writeFile9, readFile as readFile11, unlink as unlink2, readdir as readdir4 } from "fs/promises";
 import { existsSync } from "fs";
-import { join as join13, extname, resolve as resolve3, sep as sep2 } from "path";
+import { join as join13, extname, resolve as resolve4, sep as sep2 } from "path";
 var ALLOWED_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/png",
   "image/jpeg",
@@ -5066,8 +5258,8 @@ var ImageStorageService = class {
     const safeExt = ext.replace(/[^a-z.]/g, "");
     const fileName = `${imageId}${safeExt}`;
     const filePath = join13(this.dir, fileName);
-    const resolvedPath = resolve3(filePath);
-    const resolvedDir = resolve3(this.dir);
+    const resolvedPath = resolve4(filePath);
+    const resolvedDir = resolve4(this.dir);
     if (resolvedPath !== resolvedDir && !resolvedPath.startsWith(resolvedDir + sep2)) {
       throw new Error("Invalid file path");
     }
@@ -5076,15 +5268,25 @@ var ImageStorageService = class {
     await writeFile9(`${filePath}.meta.json`, JSON.stringify(meta), { encoding: "utf-8", mode: 384 });
     return meta;
   }
-  async getImagePath(imageId) {
+  /**
+   * Resolve an image on disk.
+   *
+   * `expectedContextId` scopes the lookup: when given, an image stored under a
+   * different context (or under none at all) is reported as missing. Callers
+   * that serve an image through a context-scoped URL MUST pass it — the id
+   * alone is not an authorization, and without the check any imageId could be
+   * fetched under any conversation.
+   */
+  async getImagePath(imageId, expectedContextId) {
     if (!UUID_RE.test(imageId)) return null;
     try {
       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 readFile11(join13(this.dir, metaFile), "utf-8"));
+      if (expectedContextId !== void 0 && raw.contextId !== expectedContextId) return null;
       if (!existsSync(raw.filePath)) return null;
-      return { filePath: raw.filePath, mimeType: raw.mimeType };
+      return { filePath: raw.filePath, mimeType: raw.mimeType, contextId: raw.contextId };
     } catch {
       return null;
     }
@@ -5119,8 +5321,8 @@ var ImageStorageService = class {
       })
     );
   }
-  async readImageAsBase64(imageId) {
-    const result = await this.getImagePath(imageId);
+  async readImageAsBase64(imageId, expectedContextId) {
+    const result = await this.getImagePath(imageId, expectedContextId);
     if (!result) return null;
     const buffer = await readFile11(result.filePath);
     return { base64: buffer.toString("base64"), mimeType: result.mimeType };
@@ -5148,8 +5350,8 @@ var ImageStorageService = class {
 var _singleton;
 function getSingleton() {
   if (!_singleton) {
-    const dataDir = process.env["DATA_DIR"] ?? ".runeya";
-    _singleton = new ImageStorageService(resolve3(dataDir, "images"));
+    const dataDir = process.env["RUNEYA_DATA_DIR"] ?? ".runeya";
+    _singleton = new ImageStorageService(resolve4(dataDir, "images"));
   }
   return _singleton;
 }
@@ -5186,10 +5388,10 @@ function mimeToExt(mime) {
 }
 
 // ../server/src/services/message-images.ts
-async function resolveImagesToBase64(images) {
+async function resolveImagesToBase64(images, contextId) {
   const results = await Promise.all(
     images.map(async (img) => {
-      const resolved = await imageStorageService.readImageAsBase64(img.imageId);
+      const resolved = await imageStorageService.readImageAsBase64(img.imageId, contextId);
       if (!resolved) {
         console.warn("[message-images] Image not found (imageId redacted from log)");
         return null;
@@ -5200,111 +5402,608 @@ async function resolveImagesToBase64(images) {
   return results.filter((r) => r !== null);
 }
 
-// ../server/src/services/ai-runners/claude-code-runner.ts
-import { spawn as spawn2 } from "child_process";
-
-// ../server/src/services/ai-runners/scenario-tokens.ts
-function parseEndToken(output) {
-  const tail = output.trimEnd().slice(-2e3);
-  const branchMatch = tail.match(/<pass\s+branch="(\d+)"\s*\/>/);
-  if (branchMatch) {
-    return { status: "pass", message: "", branchChoice: Number.parseInt(branchMatch[1], 10) };
-  }
-  if (/<pass\s*\/>/.test(tail)) {
-    return { status: "pass", message: "" };
-  }
-  const errorMatch = tail.match(/<error>([\s\S]*?)<\/error>/);
-  if (errorMatch) {
-    return { status: "error", message: errorMatch[1].trim() };
-  }
-  const askMatch = tail.match(/<ask_user>([\s\S]*?)<\/ask_user>/);
-  if (askMatch) {
-    return { status: "ask_user", message: askMatch[1].trim() };
-  }
-  return { status: "none", message: "" };
-}
-var TOKEN_INSTRUCTIONS = `
-## Instructions de signalisation (OBLIGATOIRE)
-
-\xC0 la fin de CHAQUE r\xE9ponse, tu DOIS terminer par exactement l'un de ces tags XML :
-
-- Si tu as termin\xE9 avec succ\xE8s (chemin par d\xE9faut) : \`<pass />\`
-- Si le n\u0153ud propose plusieurs branches de sortie num\xE9rot\xE9es : \`<pass branch="1" />\`, \`<pass branch="2" />\`, etc. (choisis la branche qui correspond le mieux au r\xE9sultat)
-- Si tu as rencontr\xE9 une erreur bloquante : \`<error>description courte</error>\`
-- Si tu es bloqu\xE9 par une information que personne dans l'\xE9quipe ne peut fournir (secret, d\xE9cision business, credential externe) : \`<ask_user>ta question</ask_user>\` \u2014 NE PAS utiliser pour demander une confirmation ou un accord ("es-tu pr\xEAt ?", "puis-je continuer ?")
-
-Ne jamais omettre ce tag. Il doit \xEAtre la toute derni\xE8re ligne de ta r\xE9ponse.
-`.trim();
-
-// ../server/src/services/ai-runners/claude-pty-runner.ts
+// ../server/src/services/kanban-commands.ts
 import { randomUUID as randomUUID5 } from "crypto";
 
-// ../server/src/services/ai-runners/claude-pty-tail.ts
-import { open } from "fs/promises";
-import { watch as watch2 } from "fs";
-async function waitForFile(sessionId, signal, timeoutMs) {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (signal.aborted) throw new Error("Aborted");
-    const path = await findClaudeSessionFile(sessionId);
-    if (path) return path;
-    await new Promise((r) => setTimeout(r, 150));
+// ../server/src/trpc/routers/cloud-auth.ts
+import { z as z14 } from "zod";
+import { TRPCError as TRPCError10 } from "@trpc/server";
+
+// ../server/src/services/cloud-session-store.ts
+import { readFile as readFile12, writeFile as writeFile10, rename as rename9, mkdir as mkdir12, chmod as chmod8, unlink as unlink3 } from "fs/promises";
+import { randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { join as join14 } from "path";
+var FILENAME4 = "cloud-session.json";
+var STATE_TTL_MS = 5 * 60 * 1e3;
+var CloudSessionStore = class {
+  session = null;
+  loaded = false;
+  /** Pending login states (CSRF binding between `start` and the callback). */
+  pending = /* @__PURE__ */ new Map();
+  getFilePath() {
+    return join14(env.DATA_DIR, FILENAME4);
   }
-  throw new Error(`Transcript file for session ${sessionId} never appeared (timeout ${timeoutMs}ms)`);
-}
-function tailTranscript(opts) {
-  const { sessionId, signal, onEntry, fileAppearTimeoutMs = 3e4 } = opts;
-  let stopped = false;
-  let watcher = null;
-  let fh = null;
-  let offset = 0;
-  let pendingBuf = "";
-  let reading = false;
-  let queuedRead = false;
-  const cleanup = async () => {
-    stopped = true;
-    if (watcher) {
-      try {
-        watcher.close();
-      } catch {
-      }
-      watcher = null;
-    }
-    if (fh) {
-      try {
-        await fh.close();
-      } catch {
-      }
-      fh = null;
+  async load() {
+    if (this.loaded) return;
+    try {
+      const raw = await readFile12(this.getFilePath(), "utf-8");
+      this.session = JSON.parse(raw);
+    } catch {
     }
-  };
-  const drainBuffer = () => {
-    let idx;
-    while ((idx = pendingBuf.indexOf("\n")) >= 0) {
-      const line = pendingBuf.slice(0, idx).trim();
-      pendingBuf = pendingBuf.slice(idx + 1);
-      if (!line) continue;
-      try {
-        const entry = JSON.parse(line);
-        onEntry(entry);
-      } catch {
+    this.loaded = true;
+  }
+  /**
+   * Mint a state value binding a login attempt to this server. Returned to the
+   * cloud page and echoed back on the callback, so a redirect we never
+   * initiated cannot install a token.
+   */
+  createState(returnTo) {
+    this.sweepStates();
+    const state = randomBytes3(32).toString("hex");
+    this.pending.set(state, { expiresAt: Date.now() + STATE_TTL_MS, returnTo });
+    return state;
+  }
+  /**
+   * Consume a state — single use, constant-time compare, TTL enforced. Returns
+   * the URL to send the browser back to, or null when the state is unknown or
+   * expired (i.e. a callback this server never initiated).
+   */
+  consumeState(candidate) {
+    this.sweepStates();
+    for (const [state, entry] of this.pending) {
+      const a = Buffer.from(state);
+      const b = Buffer.from(candidate);
+      if (a.length === b.length && timingSafeEqual2(a, b)) {
+        this.pending.delete(state);
+        return entry.expiresAt > Date.now() ? entry.returnTo : null;
       }
     }
-  };
-  const readMore = async () => {
-    if (!fh || stopped) return;
-    if (reading) {
-      queuedRead = true;
-      return;
+    return null;
+  }
+  sweepStates() {
+    const now = Date.now();
+    for (const [state, entry] of this.pending) {
+      if (entry.expiresAt <= now) this.pending.delete(state);
     }
-    reading = true;
+  }
+  async save() {
+    await mkdir12(env.DATA_DIR, { recursive: true });
+    const filePath = this.getFilePath();
+    const tmpPath = filePath + ".tmp";
+    await writeFile10(tmpPath, JSON.stringify(this.session, null, 2), "utf-8");
+    await rename9(tmpPath, filePath);
+    await chmod8(filePath, 384);
+  }
+  /** Store the session token obtained from the one-time-token exchange. */
+  async set(cloudUrl, token) {
+    await this.load();
+    this.session = { cloudUrl, encryptedToken: encryptValue(token) };
+    await this.save();
+  }
+  /** The decrypted session token, or null when not logged in. */
+  async getToken() {
+    await this.load();
+    if (!this.session) return null;
     try {
-      while (!stopped) {
-        const st = await fh.stat();
-        if (st.size <= offset) break;
-        const len = st.size - offset;
-        const buf = Buffer.alloc(len);
-        const { bytesRead } = await fh.read(buf, 0, len, offset);
+      return decryptValue(this.session.encryptedToken);
+    } catch {
+      return null;
+    }
+  }
+  async isLinked() {
+    return await this.getToken() !== null;
+  }
+  /** Forget the session (sign-out). */
+  async clear() {
+    await this.load();
+    this.session = null;
+    this.pending.clear();
+    try {
+      await unlink3(this.getFilePath());
+    } catch {
+    }
+  }
+};
+var cloudSessionStore = new CloudSessionStore();
+
+// ../server/src/trpc/routers/cloud-auth.ts
+var DEFAULT_CLOUD_API_URL = "https://api.runeya.dev";
+var DEFAULT_CLOUD_APP_URL = "https://runeya.dev";
+function getCloudApiUrl() {
+  return (env.CLOUD_URL ?? DEFAULT_CLOUD_API_URL).replace(/\/+$/, "");
+}
+function getCloudAppUrl() {
+  return (env.CLOUD_APP_URL ?? DEFAULT_CLOUD_APP_URL).replace(/\/+$/, "");
+}
+function isLocalOrigin(url) {
+  try {
+    const { protocol, hostname } = new URL(url);
+    return (protocol === "http:" || protocol === "https:") && (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]");
+  } catch {
+    return false;
+  }
+}
+async function cloudFetch(path, init = {}) {
+  const token = await cloudSessionStore.getToken();
+  if (!token) {
+    throw new TRPCError10({ code: "UNAUTHORIZED", message: "Not linked to the Runeya cloud." });
+  }
+  return fetch(`${getCloudApiUrl()}${path}`, {
+    method: init.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      ...init.body !== void 0 ? { "Content-Type": "application/json" } : {}
+    },
+    ...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
+    signal: AbortSignal.timeout(15e3)
+  });
+}
+var PROXY_PREFIXES = ["/organization/", "/project/", "/chat/", "/kanban/", "/user/prefs"];
+function isAllowedProxyPath(path) {
+  if (!path.startsWith("/") || path.includes("..")) return false;
+  const [pathname] = path.split("?");
+  return PROXY_PREFIXES.some((p) => pathname === p || pathname.startsWith(p));
+}
+var cloudAuthRouter = router({
+  /** Build the cloud authorization URL to open in the browser. */
+  startLogin: protectedProcedure.input(z14.object({ returnTo: z14.string().url().max(2048) })).mutation(async ({ input }) => {
+    if (!isLocalOrigin(input.returnTo)) {
+      throw new TRPCError10({ code: "BAD_REQUEST", message: "returnTo must be a local origin." });
+    }
+    const state = cloudSessionStore.createState(input.returnTo);
+    const callback = `http://127.0.0.1:${env.PORT}/api/cloud/callback`;
+    const url = `${getCloudAppUrl()}/link-local?callback=${encodeURIComponent(callback)}&state=${encodeURIComponent(state)}`;
+    return { url };
+  }),
+  /** Whether this machine holds a cloud session. */
+  status: protectedProcedure.query(async () => {
+    return { linked: await cloudSessionStore.isLinked() };
+  }),
+  /** The cloud session (user + org), fetched with the stored token. */
+  session: protectedProcedure.query(async () => {
+    if (!await cloudSessionStore.isLinked()) return null;
+    const res = await cloudFetch("/api/auth/get-session");
+    if (!res.ok) return null;
+    return await res.json();
+  }),
+  /**
+   * Forward a cloud API call, authenticated with this machine's token.
+   *
+   * This is what replaces the browser's direct, cookie-authenticated calls to
+   * the cloud: the web UI asks its own server, which holds the credential.
+   */
+  proxy: protectedProcedure.input(
+    z14.object({
+      path: z14.string().min(1).max(512),
+      method: z14.enum(["GET", "POST"]).default("GET"),
+      query: z14.record(z14.string().max(128), z14.string().max(2048)).optional(),
+      body: z14.unknown().optional()
+    })
+  ).mutation(async ({ input }) => {
+    if (!isAllowedProxyPath(input.path)) {
+      throw new TRPCError10({ code: "FORBIDDEN", message: `Path not allowed: ${input.path}` });
+    }
+    const qs = input.query ? `?${new URLSearchParams(input.query).toString()}` : "";
+    const res = await cloudFetch(`/api/auth${input.path}${qs}`, {
+      method: input.method,
+      ...input.method === "POST" ? { body: input.body ?? {} } : {}
+    });
+    const text = await res.text();
+    let data = null;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch {
+      data = text;
+    }
+    if (!res.ok) return { data: null, error: { status: res.status, ...data } };
+    return { data, error: null };
+  }),
+  /** Drop the cloud session, both here and on the cloud. */
+  signOut: protectedProcedure.mutation(async () => {
+    if (await cloudSessionStore.isLinked()) {
+      try {
+        await cloudFetch("/api/auth/sign-out", { method: "POST", body: {} });
+      } catch {
+      }
+    }
+    await cloudSessionStore.clear();
+    return { success: true };
+  })
+});
+
+// ../server/src/services/kanban-store.ts
+async function callCloud(path, init = {}) {
+  try {
+    const res = await cloudFetch(`/api/auth${path}`, init);
+    if (!res.ok) {
+      console.error("[kanban-store] cloud call failed: %s %s", res.status, path);
+      return { ok: false, data: null };
+    }
+    return { ok: true, data: await res.json() };
+  } catch (err) {
+    console.error("[kanban-store] cloud call errored:", err);
+    return { ok: false, data: null };
+  }
+}
+async function resolveOrganizationId() {
+  const session = await callCloud("/get-session");
+  const active = session.data?.session?.activeOrganizationId;
+  if (active) return active;
+  const orgs = await callCloud("/organization/list");
+  return orgs.data?.[0]?.id ?? null;
+}
+var KanbanStore = class {
+  async list(includeArchived = false) {
+    const organizationId = await resolveOrganizationId();
+    if (!organizationId) return [];
+    const query = `?organizationId=${encodeURIComponent(organizationId)}` + (includeArchived ? "&includeArchived=true" : "");
+    const res = await callCloud(`/kanban/board/list${query}`);
+    return res.data?.boards ?? [];
+  }
+  async get(id) {
+    const res = await callCloud(`/kanban/board/get?id=${encodeURIComponent(id)}`);
+    return res.data?.board ?? null;
+  }
+  async create(input) {
+    const organizationId = await resolveOrganizationId();
+    if (!organizationId) return null;
+    const res = await callCloud("/kanban/board/create", {
+      method: "POST",
+      body: { organizationId, name: input.name, description: input.description ?? "" }
+    });
+    return res.data?.board ?? null;
+  }
+  async update(input) {
+    const res = await callCloud("/kanban/board/update", {
+      method: "POST",
+      body: input
+    });
+    return res.data?.board ?? null;
+  }
+  async delete(id) {
+    const res = await callCloud("/kanban/board/delete", {
+      method: "POST",
+      body: { id }
+    });
+    return res.data?.success ?? false;
+  }
+};
+var kanbanStore = new KanbanStore();
+
+// ../server/src/services/kanban-commands.ts
+async function executeKanbanCommands(boardId, cardId, commands, conversationId) {
+  if (commands.length === 0) return;
+  let board = await kanbanStore.get(boardId);
+  if (!board) {
+    console.warn(`[kanban-commands] Board ${boardId} not found, skipping ${commands.length} command(s)`);
+    return;
+  }
+  const cardExistsInBoard = () => board.columns.some((col) => col.cards.some((c) => c.id === cardId));
+  if (!cardExistsInBoard()) {
+    for (let attempt = 1; attempt <= 5; attempt++) {
+      console.warn(`[kanban-commands] Card ${cardId} not found in board, retry ${attempt}/5...`);
+      await new Promise((r) => setTimeout(r, 500 * attempt));
+      board = await kanbanStore.get(boardId);
+      if (!board) return;
+      if (cardExistsInBoard()) break;
+    }
+    if (!cardExistsInBoard()) {
+      console.error(`[kanban-commands] Card ${cardId} still not found after retries, skipping ${commands.length} command(s)`);
+      return;
+    }
+  }
+  for (const cmd of commands) {
+    if (cmd.type === "move_card" && cmd.columnTitle) {
+      const moved = moveCard(board, cardId, cmd.columnTitle);
+      if (!moved) console.warn(`[kanban-commands] move_card failed: card=${cardId} target="${cmd.columnTitle}"`);
+    } else if (cmd.type === "add_comment" && cmd.comment) {
+      addComment(board, cardId, cmd.comment, conversationId);
+    } else if (cmd.type === "add_card" && cmd.columnTitle && cmd.cardTitle) {
+      addCardToColumn(board, cmd.columnTitle, cmd.cardTitle, cmd.cardContent);
+    }
+  }
+  await kanbanStore.update({ id: board.id, columns: board.columns });
+}
+async function executeKanbanBoardCommands(boardId, commands) {
+  if (commands.length === 0) return;
+  const board = await kanbanStore.get(boardId);
+  if (!board) return;
+  for (const cmd of commands) {
+    if (cmd.type === "add_card" && cmd.columnTitle && cmd.cardTitle) {
+      addCardToColumn(board, cmd.columnTitle, cmd.cardTitle, cmd.cardContent);
+    }
+  }
+  await kanbanStore.update({ id: board.id, columns: board.columns });
+}
+function moveCard(board, cardId, targetColTitle) {
+  let sourceCol = "";
+  let card = null;
+  let sourceColIdx = -1;
+  let cardIdx = -1;
+  for (let ci = 0; ci < board.columns.length; ci++) {
+    const col = board.columns[ci];
+    const idx = col.cards.findIndex((c) => c.id === cardId);
+    if (idx !== -1) {
+      sourceCol = col.title;
+      card = col.cards[idx];
+      sourceColIdx = ci;
+      cardIdx = idx;
+      break;
+    }
+  }
+  if (!card || sourceColIdx === -1) return false;
+  const targetCol = board.columns.find(
+    (c) => c.title.toLowerCase() === targetColTitle.toLowerCase()
+  );
+  if (!targetCol) {
+    console.warn(`[kanban-commands] Target column "${targetColTitle}" not found. Available: ${board.columns.map((c) => c.title).join(", ")}`);
+    return false;
+  }
+  if (targetCol.id === board.columns[sourceColIdx].id) return true;
+  board.columns[sourceColIdx].cards.splice(cardIdx, 1);
+  card.order = targetCol.cards.length;
+  card.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  card.history = [...card.history ?? [], {
+    type: "moved",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    detail: `"${sourceCol}" \u2192 "${targetCol.title}"`,
+    author: "ai"
+  }];
+  targetCol.cards.push(card);
+  return true;
+}
+function addCardToColumn(board, columnTitle, cardTitle, cardContent) {
+  const col = board.columns.find((c) => c.title.toLowerCase() === columnTitle.toLowerCase());
+  if (!col) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const card = {
+    id: randomUUID5(),
+    title: cardTitle,
+    markdown: cardContent ?? "",
+    images: [],
+    order: col.cards.length,
+    history: [{ type: "created", timestamp: now, detail: `AI \u2014 In column "${col.title}"` }],
+    createdAt: now,
+    updatedAt: now
+  };
+  col.cards.push(card);
+}
+function addComment(board, cardId, comment, conversationId) {
+  for (const col of board.columns) {
+    const card = col.cards.find((c) => c.id === cardId);
+    if (card) {
+      card.history = [...card.history ?? [], {
+        type: "comment",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        detail: comment,
+        author: "ai",
+        ...conversationId ? { conversationId } : {}
+      }];
+      card.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return;
+    }
+  }
+}
+function generateKanbanSystemPrompt(board, cardId) {
+  let currentColTitle = "";
+  let card = null;
+  for (const col of board.columns) {
+    const found = col.cards.find((c) => c.id === cardId);
+    if (found) {
+      currentColTitle = col.title;
+      card = found;
+      break;
+    }
+  }
+  const sortedColumns = [...board.columns].sort((a, b) => a.order - b.order);
+  const lines = [];
+  lines.push("## Kanban Board Context");
+  lines.push("");
+  lines.push(`Tu travailles dans le contexte d'une carte Kanban.`);
+  lines.push(`- **Board** : ${board.name}`);
+  if (card) {
+    lines.push(`- **Carte** : ${card.title}`);
+    lines.push(`- **Colonne actuelle** : \`${currentColTitle}\``);
+  }
+  lines.push("");
+  lines.push("### Colonnes disponibles (noms exacts \xE0 utiliser) :");
+  for (const col of sortedColumns) {
+    const cardCount = col.cards.length;
+    const isCurrent = card && col.cards.some((c) => c.id === cardId);
+    lines.push(`- \`${col.title}\` (${cardCount} carte${cardCount !== 1 ? "s" : ""})${isCurrent ? " \u2190 **colonne actuelle**" : ""}`);
+  }
+  lines.push("");
+  if (card) {
+    const comments = (card.history ?? []).filter((e) => e.type === "comment");
+    if (comments.length > 0) {
+      lines.push("### Commentaires existants sur cette carte :");
+      lines.push("");
+      for (const c of comments.slice(-20)) {
+        const who = c.author === "ai" ? "AI" : "Utilisateur";
+        const date = new Date(c.timestamp).toLocaleString("fr-FR", { day: "numeric", month: "short", hour: "2-digit", minute: "2-digit" });
+        lines.push(`- **${who}** (${date}) : ${c.detail}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("### Outils Kanban disponibles");
+  lines.push("");
+  lines.push(`- **boardId** (\xE0 passer dans tous les outils) : \`${board.id}\``);
+  if (card) lines.push(`- **cardId** (carte actuelle) : \`${card.id}\``);
+  lines.push("");
+  lines.push("Tu disposes des outils suivants pour interagir avec le board :");
+  lines.push("- `kanban_move_card(boardId, cardId, targetColumn)` \u2014 D\xE9placer la carte vers une autre colonne");
+  lines.push("- `kanban_add_comment(boardId, cardId, comment)` \u2014 Ajouter un commentaire sur la carte");
+  lines.push("");
+  lines.push("### OBLIGATOIRE \u2014 D\xE9cision Kanban");
+  lines.push("");
+  lines.push("\xC0 chaque r\xE9ponse, tu DOIS obligatoirement faire les deux actions suivantes :");
+  lines.push("");
+  lines.push("**1. \xC9valuer et d\xE9placer la carte si n\xE9cessaire** via `kanban_move_card` :");
+  lines.push("   - **Au d\xE9but** si tu sais d\xE9j\xE0 que tu vas travailler activement (ex. tu passes en `In progress`).");
+  lines.push("   - **\xC0 la fin** pour une d\xE9cision forte apr\xE8s analyse compl\xE8te (ex. tu conclus que c'est `Done`).");
+  lines.push("   - Si tu ne fais qu'analyser ou poser des questions \u2192 **ne pas d\xE9placer**.");
+  lines.push("");
+  lines.push("   > \u26A0\uFE0F **CRITIQUE** : En fin de r\xE9ponse, tu DOIS TOUJOURS \xE9valuer si la colonne actuelle est encore correcte.");
+  lines.push("");
+  lines.push("**2. Appeler `kanban_add_comment`** r\xE9sumant ce que tu as fait ou constat\xE9 (**\xE0 la fin** de ta r\xE9ponse).");
+  lines.push("");
+  lines.push("> \u{1F6AB} **INTERDIT** : Terminer une r\xE9ponse sans appeler `kanban_add_comment`. C'est non n\xE9gociable.");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateKanbanPopulatePrompt(board) {
+  const lines = [];
+  lines.push("## Kanban Board \u2014 Mode Populate");
+  lines.push("");
+  lines.push(`Tu es en mode **populate** sur le tableau Kanban **"${board.name}"**.`);
+  lines.push(`Tu es un outil de gestion de projet. Quand l'utilisateur dit "cr\xE9er une card", "ajouter une t\xE2che", "cr\xE9er une carte", ou toute demande similaire, il parle EXCLUSIVEMENT d'une carte Kanban \xE0 ajouter au tableau \u2014 PAS d'un composant UI, PAS de code HTML ou CSS, PAS d'un composant React/Vue/Angular.`);
+  lines.push("");
+  lines.push("Ton UNIQUE r\xF4le est de cr\xE9er des cartes Kanban pertinentes en r\xE9ponse \xE0 la demande de l'utilisateur.");
+  lines.push("Tu ne dois PAS r\xE9pondre \xE0 la question, ni donner d'explication, ni \xE9crire du code, ni montrer de composant.");
+  lines.push("Tu dois UNIQUEMENT produire des tags XML `<kanban_add_card>` pour cr\xE9er des cartes dans le tableau.");
+  if (board.description) {
+    lines.push("");
+    lines.push(`Description du board : ${board.description}`);
+  }
+  lines.push("");
+  const sortedCols = [...board.columns].sort((a, b) => a.order - b.order);
+  lines.push("### Colonnes existantes (noms exacts \xE0 utiliser) :");
+  for (const col of sortedCols) {
+    const cardCount = col.cards.length;
+    lines.push(`- \`${col.title}\` (${cardCount} carte${cardCount !== 1 ? "s" : ""})`);
+    for (const card of col.cards) {
+      lines.push(`  - ${card.title}`);
+    }
+  }
+  lines.push("");
+  lines.push("### Outil disponible");
+  lines.push("");
+  lines.push(`- **boardId** (\xE0 passer dans tous les outils) : \`${board.id}\``);
+  lines.push("");
+  lines.push("Pour chaque carte \xE0 cr\xE9er, appelle l'outil `kanban_add_card(boardId, column, title, content)` :");
+  lines.push("- `column` : nom exact de la colonne cible");
+  lines.push("- `title` : titre concis de la carte");
+  lines.push("- `content` : contenu markdown d\xE9taill\xE9 et actionnable");
+  lines.push("");
+  lines.push("### R\xE8gles STRICTES");
+  lines.push("");
+  lines.push("1. **NE R\xC9PONDS PAS** \xE0 la question de l'utilisateur. Ne donne aucune explication, aucun texte libre.");
+  lines.push("2. **Appelle uniquement** `kanban_add_card`, rien d'autre.");
+  lines.push("3. Tu ne peux PAS cr\xE9er de nouvelles colonnes. Dispatch les cartes dans les colonnes existantes list\xE9es ci-dessus.");
+  lines.push("4. Utilise les noms **exacts** des colonnes.");
+  lines.push("5. Chaque carte doit avoir un titre concis et un contenu markdown d\xE9taill\xE9 et actionnable.");
+  lines.push("6. D\xE9compose la demande de l'utilisateur en t\xE2ches concr\xE8tes, chacune \xE9tant une carte.");
+  lines.push("7. Dispatch chaque carte dans la colonne la plus appropri\xE9e selon sa nature.");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// ../server/src/services/ai-runners/claude-code-runner.ts
+import { spawn as spawn2 } from "child_process";
+
+// ../server/src/services/ai-runners/scenario-tokens.ts
+function parseEndToken(output) {
+  const tail = output.trimEnd().slice(-2e3);
+  const branchMatch = tail.match(/<pass\s+branch="(\d+)"\s*\/>/);
+  if (branchMatch) {
+    return { status: "pass", message: "", branchChoice: Number.parseInt(branchMatch[1], 10) };
+  }
+  if (/<pass\s*\/>/.test(tail)) {
+    return { status: "pass", message: "" };
+  }
+  const errorMatch = tail.match(/<error>([\s\S]*?)<\/error>/);
+  if (errorMatch) {
+    return { status: "error", message: errorMatch[1].trim() };
+  }
+  const askMatch = tail.match(/<ask_user>([\s\S]*?)<\/ask_user>/);
+  if (askMatch) {
+    return { status: "ask_user", message: askMatch[1].trim() };
+  }
+  return { status: "none", message: "" };
+}
+var TOKEN_INSTRUCTIONS = `
+## Instructions de signalisation (OBLIGATOIRE)
+
+\xC0 la fin de CHAQUE r\xE9ponse, tu DOIS terminer par exactement l'un de ces tags XML :
+
+- Si tu as termin\xE9 avec succ\xE8s (chemin par d\xE9faut) : \`<pass />\`
+- Si le n\u0153ud propose plusieurs branches de sortie num\xE9rot\xE9es : \`<pass branch="1" />\`, \`<pass branch="2" />\`, etc. (choisis la branche qui correspond le mieux au r\xE9sultat)
+- Si tu as rencontr\xE9 une erreur bloquante : \`<error>description courte</error>\`
+- Si tu es bloqu\xE9 par une information que personne dans l'\xE9quipe ne peut fournir (secret, d\xE9cision business, credential externe) : \`<ask_user>ta question</ask_user>\` \u2014 NE PAS utiliser pour demander une confirmation ou un accord ("es-tu pr\xEAt ?", "puis-je continuer ?")
+
+Ne jamais omettre ce tag. Il doit \xEAtre la toute derni\xE8re ligne de ta r\xE9ponse.
+`.trim();
+
+// ../server/src/services/ai-runners/claude-pty-runner.ts
+import { randomUUID as randomUUID6 } from "crypto";
+
+// ../server/src/services/ai-runners/claude-pty-tail.ts
+import { open } from "fs/promises";
+import { watch as watch2 } from "fs";
+async function waitForFile(sessionId, signal, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (signal.aborted) throw new Error("Aborted");
+    const path = await findClaudeSessionFile(sessionId);
+    if (path) return path;
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  throw new Error(`Transcript file for session ${sessionId} never appeared (timeout ${timeoutMs}ms)`);
+}
+function tailTranscript(opts) {
+  const { sessionId, signal, onEntry, fileAppearTimeoutMs = 3e4 } = opts;
+  let stopped = false;
+  let watcher = null;
+  let fh = null;
+  let offset = 0;
+  let pendingBuf = "";
+  let reading = false;
+  let queuedRead = false;
+  const cleanup = async () => {
+    stopped = true;
+    if (watcher) {
+      try {
+        watcher.close();
+      } catch {
+      }
+      watcher = null;
+    }
+    if (fh) {
+      try {
+        await fh.close();
+      } catch {
+      }
+      fh = null;
+    }
+  };
+  const drainBuffer = () => {
+    let idx;
+    while ((idx = pendingBuf.indexOf("\n")) >= 0) {
+      const line = pendingBuf.slice(0, idx).trim();
+      pendingBuf = pendingBuf.slice(idx + 1);
+      if (!line) continue;
+      try {
+        const entry = JSON.parse(line);
+        onEntry(entry);
+      } catch {
+      }
+    }
+  };
+  const readMore = async () => {
+    if (!fh || stopped) return;
+    if (reading) {
+      queuedRead = true;
+      return;
+    }
+    reading = true;
+    try {
+      while (!stopped) {
+        const st = await fh.stat();
+        if (st.size <= offset) break;
+        const len = st.size - offset;
+        const buf = Buffer.alloc(len);
+        const { bytesRead } = await fh.read(buf, 0, len, offset);
         if (bytesRead <= 0) break;
         offset += bytesRead;
         pendingBuf += buf.slice(0, bytesRead).toString("utf-8");
@@ -5337,12 +6036,12 @@ function tailTranscript(opts) {
       const poll = setInterval(() => {
         void readMore();
       }, 500);
-      await new Promise((resolve5) => {
+      await new Promise((resolve6) => {
         const tick = setInterval(() => {
           if (stopped) {
             clearInterval(tick);
             clearInterval(poll);
-            resolve5();
+            resolve6();
           }
         }, 100);
       });
@@ -5361,7 +6060,7 @@ function tailTranscript(opts) {
 
 // ../server/src/services/ai-runners/claude-pty-runner.ts
 async function getAgentManager() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-QPZUYLJA.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-2P4THUVA.js");
   return agentManager2;
 }
 function buildPtyArgs(params, sessionId, opts) {
@@ -5431,7 +6130,7 @@ function dispatchEntry(entry, state, cbs) {
 async function runClaudeViaPty(params) {
   const { agentId, signal, skipTokenInstructions } = params;
   if (!agentId) throw new Error("runClaudeViaPty requires an agentId");
-  const sessionId = params.sessionId && params.sessionId.length > 0 ? params.sessionId : randomUUID5();
+  const sessionId = params.sessionId && params.sessionId.length > 0 ? params.sessionId : randomUUID6();
   const args = buildPtyArgs(params, sessionId, { excludeMcp: true });
   const agentMgr = await getAgentManager();
   const displayArgs = args.map((a) => {
@@ -5440,7 +6139,7 @@ async function runClaudeViaPty(params) {
     return a;
   });
   params.onCommand?.(`claude ${displayArgs.join(" ")}`);
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let settled = false;
     let spawnId = null;
     const state = { assistantText: "", tools: /* @__PURE__ */ new Map() };
@@ -5463,7 +6162,7 @@ async function runClaudeViaPty(params) {
       settled = true;
       cleanup();
       void killSpawn();
-      resolve5(result);
+      resolve6(result);
     };
     const fail = (err) => {
       if (settled) return;
@@ -5536,10 +6235,6 @@ async function runClaudeViaPty(params) {
 }
 
 // ../server/src/services/ai-runners/claude-code-runner.ts
-async function getAgentManager2() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-QPZUYLJA.js");
-  return agentManager2;
-}
 function createClaudeStreamState() {
   return {
     fullContent: "",
@@ -5762,116 +6457,16 @@ function processClaudeStdoutLines(lines, streamState, params, ctx) {
 }
 var ClaudeCodeRunner = class {
   run(params) {
-    const ptyEnabled = params.usePty ?? process.env["RUNEYA_CLAUDE_PTY"] === "1";
-    if (ptyEnabled && params.agentId && !(params.images && params.images.length > 0)) {
-      return runClaudeViaPty(params);
-    }
     if (params.agentId) {
-      return this.runViaAgent(params);
+      return runClaudeViaPty(params);
     }
     return this.runLocal(params);
   }
-  // ── Run via agent (remote spawn, local parsing) ─────────────────────────
-  async runViaAgent(params) {
-    const { agentId, signal, skipTokenInstructions } = params;
-    const { args, env: env2, stdinData, sessionArg } = buildClaudeSpawnConfig(params, { excludeMcp: true });
-    const agentMgr = await getAgentManager2();
-    const totalArgSize = args.reduce((s, a) => s + a.length + 1, 0);
-    console.log(`[claude-code-runner] [agent:${agentId}] arg size: ${totalArgSize} bytes, session: ${sessionArg.join(" ")}, images: ${params.images?.length ?? 0}`);
-    const displayArgs = args.map((a) => {
-      if (a === params.prompt) return "<prompt>";
-      if (a.includes(TOKEN_INSTRUCTIONS)) return "<system-context>";
-      return a;
-    });
-    params.onCommand?.(`claude ${displayArgs.join(" ")}`);
-    return new Promise((resolve5, reject) => {
-      const streamState = createClaudeStreamState();
-      const ctx = { settled: false, earlyResult: null, lastResultError: "", rawStdoutLines: [] };
-      let stdoutBuffer = "";
-      let stderrBuffer = "";
-      let spawnId = null;
-      let unsubscribe = null;
-      const onAbort = () => {
-        if (spawnId && agentId) {
-          agentMgr.agentMutation(agentId, "ai.kill", { spawnId }).catch(() => {
-          });
-        }
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-      const cleanup = () => {
-        signal.removeEventListener("abort", onAbort);
-        if (unsubscribe) {
-          unsubscribe();
-          unsubscribe = null;
-        }
-      };
-      agentMgr.agentMutation(agentId, "ai.spawn", {
-        cli: "claude",
-        args,
-        env: env2,
-        stdinData,
-        enableMcp: !!params.mcpConfig,
-        mcpApiBaseUrl: params.apiBaseUrl || void 0
-      }).then(({ spawnId: id }) => {
-        spawnId = id;
-        if (signal.aborted) {
-          cleanup();
-          reject(new Error("Aborted"));
-          return;
-        }
-        unsubscribe = agentMgr.agentSubscribe(
-          agentId,
-          "ai.stream",
-          { spawnId, fromOffset: 0 },
-          (data) => {
-            const item = data;
-            const chunk = item.chunk;
-            if (chunk.type === "stdout") {
-              stdoutBuffer += chunk.data;
-              const lines = stdoutBuffer.split("\n");
-              stdoutBuffer = lines.pop() ?? "";
-              processClaudeStdoutLines(lines, streamState, params, ctx);
-            }
-            if (chunk.type === "stderr") {
-              stderrBuffer += chunk.data;
-            }
-            if (chunk.type === "exit") {
-              const code = chunk.code ?? 0;
-              cleanup();
-              if (ctx.earlyResult) {
-                resolve5({ ...ctx.earlyResult, actualSessionId: streamState.actualSessionId });
-                return;
-              }
-              if (signal.aborted) {
-                reject(new Error("Aborted"));
-                return;
-              }
-              if (code !== 0 && !streamState.fullContent) {
-                const stderr = stderrBuffer.trim().slice(-2e3);
-                const rawStdout = ctx.rawStdoutLines.slice(-10).join("\n").trim();
-                console.error(`[claude-code-runner] [agent] exit code ${code} | stderr: ${stderr || "(empty)"} | last stdout lines: ${rawStdout || "(empty)"}`);
-                const detail = ctx.lastResultError || stderr || rawStdout;
-                reject(new Error(`Claude Code exited with code ${code}${detail ? `: ${detail}` : ""}`));
-                return;
-              }
-              const { status, message, branchChoice } = skipTokenInstructions ? { status: "none", message: "", branchChoice: void 0 } : parseEndToken(streamState.fullContent);
-              resolve5({ output: streamState.fullContent, tokenStatus: status, tokenMessage: message, branchChoice, actualSessionId: streamState.actualSessionId });
-            }
-          },
-          () => {
-          }
-        );
-      }).catch((err) => {
-        cleanup();
-        reject(new Error(`Failed to spawn claude on agent: ${err.message}`));
-      });
-    });
-  }
   // ── Run locally (original implementation) ───────────────────────────────
   runLocal(params) {
     const { signal, skipTokenInstructions } = params;
     const { args, env: env2, stdinData, sessionArg, hasImages: _hasImages } = buildClaudeSpawnConfig(params);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const totalArgSize = args.reduce((s, a) => s + a.length + 1, 0);
       console.log(`[claude-code-runner] arg size: ${totalArgSize} bytes (${(totalArgSize / 1024 / 1024).toFixed(2)} MB), session: ${sessionArg.join(" ")}, images: ${params.images?.length ?? 0}`);
       const displayArgs = args.map((a) => {
@@ -5913,7 +6508,7 @@ var ClaudeCodeRunner = class {
       });
       proc.on("close", (code) => {
         if (ctx.earlyResult) {
-          resolve5({ ...ctx.earlyResult, actualSessionId: streamState.actualSessionId });
+          resolve6({ ...ctx.earlyResult, actualSessionId: streamState.actualSessionId });
           return;
         }
         signal.removeEventListener("abort", onAbort);
@@ -5930,7 +6525,7 @@ var ClaudeCodeRunner = class {
           return;
         }
         const { status, message, branchChoice } = skipTokenInstructions ? { status: "none", message: "", branchChoice: void 0 } : parseEndToken(streamState.fullContent);
-        resolve5({ output: streamState.fullContent, tokenStatus: status, tokenMessage: message, branchChoice, actualSessionId: streamState.actualSessionId });
+        resolve6({ output: streamState.fullContent, tokenStatus: status, tokenMessage: message, branchChoice, actualSessionId: streamState.actualSessionId });
       });
       proc.on("error", (err) => {
         if (ctx.settled) return;
@@ -5986,12 +6581,12 @@ var CodexAppServerClient = class extends EventEmitter3 {
     if (forceId !== void 0 && forceId >= this.nextId) {
       this.nextId = forceId + 1;
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`Request ${method} (id=${id}) timed out after ${this.requestTimeoutMs}ms`));
       }, this.requestTimeoutMs);
-      this.pending.set(id, { resolve: resolve5, reject, timer });
+      this.pending.set(id, { resolve: resolve6, reject, timer });
       this.writeLine({ jsonrpc: "2.0", method, id, params: params ?? {} });
     });
   }
@@ -6023,8 +6618,8 @@ var CodexAppServerClient = class extends EventEmitter3 {
     this.rl = null;
     const proc = this.proc;
     this.proc = null;
-    return new Promise((resolve5) => {
-      proc.on("exit", () => resolve5());
+    return new Promise((resolve6) => {
+      proc.on("exit", () => resolve6());
       proc.kill("SIGTERM");
       const forceTimer = setTimeout(() => {
         proc.kill("SIGKILL");
@@ -6117,8 +6712,8 @@ async function shutdownCodexAppServer() {
     await client.shutdown();
   }
 }
-async function getAgentManager3() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-QPZUYLJA.js");
+async function getAgentManager2() {
+  const { agentManager: agentManager2 } = await import("./agent-manager-2P4THUVA.js");
   return agentManager2;
 }
 function parseRuneyaCurlCommand(command) {
@@ -6187,7 +6782,7 @@ var CodexRunner = class {
   // ── Run via agent (app-server JSON-RPC via agent tRPC routes) ───────────
   async runViaAgent(params) {
     const { agentId, prompt, systemContext, signal, model, effort, isResume, images, skipTokenInstructions, apiBaseUrl, apiToken, injectedEnv } = params;
-    const agentMgr = await getAgentManager3();
+    const agentMgr = await getAgentManager2();
     if (isResume && params.sessionId && !this.lastThreadId) {
       this.lastThreadId = params.sessionId;
     }
@@ -6233,7 +6828,7 @@ ${prompt}`;
     }
     input.push({ type: "text", text: fullPrompt });
     const turnRef = { id: null };
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       let settled = false;
       let fullContent = "";
       let thinkingEmitted = false;
@@ -6282,7 +6877,7 @@ ${prompt}`;
               params.onDelta(delta);
               const { status, message, branchChoice } = parseEndToken(fullContent);
               if (status !== "none") {
-                settle(() => resolve5({ output: fullContent, tokenStatus: status, tokenMessage: message, branchChoice }));
+                settle(() => resolve6({ output: fullContent, tokenStatus: status, tokenMessage: message, branchChoice }));
               }
             }
           } else if (method === "item/reasoning/summaryTextDelta" || method === "item/reasoning/textDelta") {
@@ -6356,7 +6951,7 @@ ${prompt}`;
               return;
             }
             const { status, message, branchChoice } = parseEndToken(fullContent);
-            settle(() => resolve5({ output: fullContent, tokenStatus: status, tokenMessage: message, branchChoice }));
+            settle(() => resolve6({ output: fullContent, tokenStatus: status, tokenMessage: message, branchChoice }));
           } else if (method === "turn/errored") {
             const error = p["error"];
             const msg = typeof error?.["message"] === "string" ? error["message"] : "Codex turn errored";
@@ -6431,7 +7026,7 @@ ${prompt}`;
       sandboxPolicy: { type: "dangerFullAccess" }
     });
     const turnId = turnRes.turn.id;
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       let settled = false;
       let fullContent = "";
       let thinkingEmitted = false;
@@ -6457,7 +7052,7 @@ ${prompt}`;
             params.onDelta(delta);
             const { status, message, branchChoice } = parseEndToken(fullContent);
             if (status !== "none") {
-              settle(() => resolve5({ output: fullContent, tokenStatus: status, tokenMessage: message, branchChoice }));
+              settle(() => resolve6({ output: fullContent, tokenStatus: status, tokenMessage: message, branchChoice }));
             }
           }
         } else if (method === "item/reasoning/summaryTextDelta" || method === "item/reasoning/textDelta") {
@@ -6531,7 +7126,7 @@ ${prompt}`;
             return;
           }
           const { status, message, branchChoice } = parseEndToken(fullContent);
-          settle(() => resolve5({ output: fullContent, tokenStatus: status, tokenMessage: message, branchChoice }));
+          settle(() => resolve6({ output: fullContent, tokenStatus: status, tokenMessage: message, branchChoice }));
         } else if (method === "turn/errored") {
           const error = p["error"];
           const msg = typeof error?.["message"] === "string" ? error["message"] : "Codex turn errored";
@@ -6552,18 +7147,18 @@ ${prompt}`;
 
 // ../server/src/trpc/routers/chat.ts
 var execFileAsync2 = promisify2(execFile3);
-var MessageSchema = z14.object({
-  role: z14.enum(["user", "assistant"]),
-  content: z14.string().max(1e5)
+var MessageSchema = z15.object({
+  role: z15.enum(["user", "assistant"]),
+  content: z15.string().max(1e5)
 });
-var ImagePartSchema = z14.object({
-  type: z14.literal("image"),
-  imageId: z14.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
-  url: z14.string().max(500),
-  mimeType: z14.string().max(100),
-  altText: z14.string().max(500).optional()
+var ImagePartSchema = z15.object({
+  type: z15.literal("image"),
+  imageId: z15.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  url: z15.string().max(500),
+  mimeType: z15.string().max(100),
+  altText: z15.string().max(500).optional()
 });
-var ImagePartsSchema = z14.array(ImagePartSchema).max(5).optional();
+var ImagePartsSchema = z15.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();
@@ -6720,7 +7315,7 @@ async function* runOpenAI(client, model, initialMessages, apiKey, authToken, sig
   yield { type: "done", text: "" };
 }
 async function* drainSession(session, signal, isReconnect) {
-  if (process.env.DEBUG) console.log("[chat]: drainSession");
+  if (process.env.RUNEYA_DEBUG) console.log("[chat]: drainSession");
   if (isReconnect) {
     for (const part of session.parts) {
       if (part.type === "thinking") {
@@ -6873,7 +7468,7 @@ async function startClaudeCodeSession(convId, prompt, opts = {}) {
       if (result) capturedFinalResult = result;
     }
   }).then(() => {
-    if (process.env.DEBUG) console.log("[chat]: claude end...");
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: claude end...");
     if (activeSessionRegistry.get(convId) !== session) return;
     if (capturedFinalResult && capturedFinalResult.length > session.fullContent.length) {
       const missing = capturedFinalResult.slice(session.fullContent.length);
@@ -6882,7 +7477,7 @@ async function startClaudeCodeSession(convId, prompt, opts = {}) {
     activeSessionRegistry.pushEvent(convId, { type: "done", text: "" });
     activeSessionRegistry.markDone(convId);
   }).catch((err) => {
-    if (process.env.DEBUG) console.error("[chat]: error...", err?.message, err);
+    if (process.env.RUNEYA_DEBUG) console.error("[chat]: error...", err?.message, err);
     if (activeSessionRegistry.get(convId) !== session) return;
     activeSessionRegistry.pushEvent(convId, { type: "error", message: `Claude Code error: ${err.message}` });
     activeSessionRegistry.pushEvent(convId, { type: "done", text: "" });
@@ -6944,24 +7539,24 @@ async function startCodexSession(convId, prompt, opts = {}) {
   });
   return { session, done };
 }
-var MessagePartSchema = z14.discriminatedUnion("type", [
-  z14.object({ type: z14.literal("thinking"), text: z14.string().max(1e5) }),
-  z14.object({ type: z14.literal("text"), text: z14.string().max(1e5) }),
-  z14.object({
-    type: z14.literal("tool"),
+var MessagePartSchema = z15.discriminatedUnion("type", [
+  z15.object({ type: z15.literal("thinking"), text: z15.string().max(1e5) }),
+  z15.object({ type: z15.literal("text"), text: z15.string().max(1e5) }),
+  z15.object({
+    type: z15.literal("tool"),
     id: Id128Schema,
     name: Id128Schema,
-    input: z14.record(z14.string(), z14.unknown()).optional(),
-    rawInput: z14.string().max(1e4).optional(),
-    result: z14.unknown().optional(),
-    isError: z14.boolean().optional(),
-    pending: z14.boolean()
+    input: z15.record(z15.string(), z15.unknown()).optional(),
+    rawInput: z15.string().max(1e4).optional(),
+    result: z15.unknown().optional(),
+    isError: z15.boolean().optional(),
+    pending: z15.boolean()
   })
 ]);
-var StoredMessageSchema = z14.object({
-  role: z14.enum(["user", "assistant"]),
-  content: z14.string().max(1e5),
-  parts: z14.array(MessagePartSchema).max(200).optional()
+var StoredMessageSchema = z15.object({
+  role: z15.enum(["user", "assistant"]),
+  content: z15.string().max(1e5),
+  parts: z15.array(MessagePartSchema).max(200).optional()
 });
 var chatRouter = router({
   conversations: router({
@@ -6969,13 +7564,13 @@ var chatRouter = router({
       const initial = await conversationStore.list();
       yield { type: "initial", conversations: initial };
       const queue = [];
-      let resolve5 = null;
+      let resolve6 = null;
       const handler = (event) => {
         if (queue.length >= 500) queue.shift();
         queue.push(event);
-        if (resolve5) {
-          resolve5();
-          resolve5 = null;
+        if (resolve6) {
+          resolve6();
+          resolve6 = null;
         }
       };
       conversationStore.onChanged(handler);
@@ -6985,7 +7580,7 @@ var chatRouter = router({
             yield queue.shift();
           } else {
             await new Promise((r) => {
-              resolve5 = r;
+              resolve6 = r;
             });
           }
         }
@@ -6994,25 +7589,25 @@ var chatRouter = router({
       }
     }),
     list: protectedProcedure.query(() => conversationStore.list()),
-    get: protectedProcedure.input(z14.object({ id: Id128Schema })).query(async ({ input }) => {
+    get: protectedProcedure.input(z15.object({ id: Id128Schema })).query(async ({ input }) => {
       const conv = await conversationStore.get(input.id);
-      if (!conv) throw new TRPCError10({ code: "NOT_FOUND", message: "Conversation not found" });
+      if (!conv) throw new TRPCError11({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
     }),
-    create: protectedProcedure.input(z14.object({
+    create: protectedProcedure.input(z15.object({
       title: ShortString200Schema.optional(),
-      isCli: z14.boolean().optional(),
-      runner: z14.enum(["claude-code", "codex"]).optional(),
+      isCli: z15.boolean().optional(),
+      runner: z15.enum(["claude-code", "codex"]).optional(),
       providerId: Id128Schema.optional(),
       scenarioId: Id128Schema.optional(),
-      scenarioInput: z14.string().max(1e5).optional(),
+      scenarioInput: z15.string().max(1e5).optional(),
       kanbanBoardId: Id128Schema.optional(),
       kanbanCardId: Id128Schema.optional()
     })).mutation(async ({ input }) => {
       let scenario = null;
       if (input.scenarioId) {
         scenario = await scenarioStore.get(input.scenarioId);
-        if (!scenario) throw new TRPCError10({ code: "NOT_FOUND", message: "Scenario not found" });
+        if (!scenario) throw new TRPCError11({ code: "NOT_FOUND", message: "Scenario not found" });
       }
       const conv = await conversationStore.create(
         input.title,
@@ -7033,22 +7628,22 @@ var chatRouter = router({
       }
       return conv;
     }),
-    update: protectedProcedure.input(z14.object({
+    update: protectedProcedure.input(z15.object({
       id: Id128Schema,
       title: ShortString200Schema.optional(),
-      messages: z14.array(StoredMessageSchema).max(500).optional(),
-      contextUsage: z14.object({
-        inputTokens: z14.number().int().nonnegative(),
-        contextWindow: z14.number().int().positive()
+      messages: z15.array(StoredMessageSchema).max(500).optional(),
+      contextUsage: z15.object({
+        inputTokens: z15.number().int().nonnegative(),
+        contextWindow: z15.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 TRPCError10({ code: "NOT_FOUND", message: "Conversation not found" });
+      if (!conv) throw new TRPCError11({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
     }),
-    delete: protectedProcedure.input(z14.object({ id: Id128Schema })).mutation(async ({ input }) => {
+    delete: protectedProcedure.input(z15.object({ id: Id128Schema })).mutation(async ({ input }) => {
       const existing = await conversationStore.get(input.id);
-      if (!existing) throw new TRPCError10({ code: "NOT_FOUND", message: "Conversation not found" });
+      if (!existing) throw new TRPCError11({ code: "NOT_FOUND", message: "Conversation not found" });
       for (const agent of agentManager.listAgents()) {
         const agentId = agent.config.id;
         agentManager.agentQuery(
@@ -7068,13 +7663,13 @@ var chatRouter = router({
         (err) => console.error("[chat.delete] Image cleanup error:", err)
       );
     }),
-    archive: protectedProcedure.input(z14.object({ id: Id128Schema, archived: z14.boolean() })).mutation(async ({ input }) => {
+    archive: protectedProcedure.input(z15.object({ id: Id128Schema, archived: z15.boolean() })).mutation(async ({ input }) => {
       const conv = await conversationStore.update(input.id, { archived: input.archived });
-      if (!conv) throw new TRPCError10({ code: "NOT_FOUND", message: "Conversation not found" });
+      if (!conv) throw new TRPCError11({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
     })
   }),
-  listModels: protectedProcedure.input(z14.object({ providerId: Id128Schema.optional() }).optional()).query(async ({ input }) => {
+  listModels: protectedProcedure.input(z15.object({ providerId: Id128Schema.optional() }).optional()).query(async ({ input }) => {
     const active = await getActiveProvider(input?.providerId);
     if (!active) return [];
     try {
@@ -7083,7 +7678,7 @@ var chatRouter = router({
       return [];
     }
   }),
-  checkCliAvailability: protectedProcedure.input(z14.object({ agentId: Id128Schema.optional() }).optional()).query(async ({ input }) => {
+  checkCliAvailability: protectedProcedure.input(z15.object({ agentId: Id128Schema.optional() }).optional()).query(async ({ input }) => {
     if (input?.agentId) {
       try {
         const res = await agentManager.agentQuery(
@@ -7101,9 +7696,13 @@ var chatRouter = router({
     ]);
     return { available: claudeOk, codexAvailable: codexOk };
   }),
-  enhanceScenarioPrompt: protectedProcedure.input(z14.object({ text: z14.string().max(1e4), providerId: Id128Schema.optional() })).mutation(async ({ input }) => {
+  enhanceScenarioPrompt: protectedProcedure.input(z15.object({
+    text: z15.string().max(1e4),
+    providerId: Id128Schema.optional(),
+    model: z15.string().max(200).optional()
+  })).mutation(async ({ input }) => {
     const active = await getActiveProvider(input.providerId);
-    if (!active) throw new TRPCError10({ code: "BAD_REQUEST", message: "No AI provider configured" });
+    if (!active) throw new TRPCError11({ code: "BAD_REQUEST", message: "No AI provider configured" });
     const systemPrompt = `You are an expert at writing clear, concise user request briefs for AI-powered workflows.
 When given a rough user request, rewrite it to be:
 - Clear and well-structured
@@ -7112,7 +7711,7 @@ When given a rough user request, rewrite it to be:
 - Concise but complete (no fluff)
 Return ONLY the improved text, no explanation, no preamble.`;
     const { provider, plaintextKey } = active;
-    const model = provider.model || DEFAULT_MODELS[provider.provider] || "claude-opus-4-6";
+    const model = input.model || provider.model || DEFAULT_MODELS[provider.provider] || "claude-opus-4-6";
     if (provider.provider === "anthropic") {
       const client = new Anthropic2({ apiKey: plaintextKey });
       const res = await client.messages.create({
@@ -7154,39 +7753,39 @@ Return ONLY the improved text, no explanation, no preamble.`;
     }
   }),
   getStreamingStatus: protectedProcedure.query(() => activeSessionRegistry.listActive()),
-  stopSession: protectedProcedure.input(z14.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
-    if (process.env.DEBUG) console.log("[chat]: stopSession");
+  stopSession: protectedProcedure.input(z15.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: stopSession");
     const killed = activeSessionRegistry.kill(input.conversationId);
-    if (!killed) throw new TRPCError10({ code: "NOT_FOUND", message: "No active session for this conversation" });
+    if (!killed) throw new TRPCError11({ code: "NOT_FOUND", message: "No active session for this conversation" });
     return { ok: true };
   }),
-  streamViaClaudeCode: protectedProcedure.input(z14.object({
+  streamViaClaudeCode: protectedProcedure.input(z15.object({
     conversationId: ConversationIdSchema,
-    prompt: z14.string().max(1e5),
-    contextNote: z14.string().max(2e5).optional(),
+    prompt: z15.string().max(1e5),
+    contextNote: z15.string().max(2e5).optional(),
     model: ShortString200Schema.optional(),
-    effort: z14.enum(["low", "medium", "high"]).optional(),
-    reconnect: z14.boolean().optional(),
+    effort: z15.enum(["low", "medium", "high"]).optional(),
+    reconnect: z15.boolean().optional(),
     agentId: Id128Schema.optional(),
-    environmentId: z14.string().max(128).optional(),
-    imageIds: z14.array(z14.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: z15.string().max(128).optional(),
+    imageIds: z15.array(z15.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.DEBUG) console.log("[chat]: Reconnect");
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: Reconnect");
     const existingSession = activeSessionRegistry.get(input.conversationId);
     if (input.reconnect && existingSession) {
       yield* drainSession(existingSession, signal, true);
       return;
     }
-    if (!input.prompt) throw new TRPCError10({ code: "BAD_REQUEST", message: "Prompt is required for new messages" });
+    if (!input.prompt) throw new TRPCError11({ code: "BAD_REQUEST", message: "Prompt is required for new messages" });
     const conv = await conversationStore.get(input.conversationId);
-    if (!conv) throw new TRPCError10({ code: "NOT_FOUND", message: "Conversation not found" });
+    if (!conv) throw new TRPCError11({ code: "NOT_FOUND", message: "Conversation not found" });
     console.log(`[kanban-debug] streamViaClaudeCode start \u2014 convId=${conv.id} kanbanBoardId=${conv.kanbanBoardId ?? "null"}`);
     const isResume = conv.messages.length > 0;
     const userParts = input.imageParts && input.imageParts.length > 0 ? [...input.prompt.trim() ? [{ type: "text", text: input.prompt }] : [], ...input.imageParts] : void 0;
     conv.messages.push({ role: "user", content: input.prompt, parts: userParts, contextNote: input.contextNote });
     conv.messages.push({ role: "assistant", content: "" });
-    if (process.env.DEBUG) console.log("[chat]: update");
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: update");
     conversationStore.update(conv.id, { messages: conv.messages }, { silent: true }).catch(() => {
     });
     const cliPrompt = input.contextNote ? `${input.contextNote}
@@ -7215,7 +7814,7 @@ ${input.prompt}` : input.prompt;
     const imagePaths = [];
     if (input.imageIds && input.imageIds.length > 0) {
       for (const id of input.imageIds) {
-        const result = await imageStorageService.getImagePath(id);
+        const result = await imageStorageService.getImagePath(id, input.conversationId);
         if (result) imagePaths.push(result.filePath);
       }
     }
@@ -7228,14 +7827,14 @@ ${imagePaths.map((p) => `Image: ${p}`).join("\n")}` : cliPrompt;
     try {
       session = activeSessionRegistry.registerProviderApiSession(convId, ac);
     } catch {
-      throw new TRPCError10({ code: "CONFLICT", message: "A session is already running for this conversation. Stop it first." });
+      throw new TRPCError11({ code: "CONFLICT", message: "A session is already running for this conversation. Stop it first." });
     }
     let capturedFinalResult = "";
     const resolvedAgentId = input.agentId ?? agentManager.getDefaultAgentId();
     if (resolvedAgentId) {
       session.agentId = resolvedAgentId;
     }
-    if (process.env.DEBUG) console.log("[chat]: claude run...");
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: claude run...");
     const injectedEnv = await resolveInjectedEnv(input.environmentId);
     new ClaudeCodeRunner().run({
       agentId: resolvedAgentId ?? void 0,
@@ -7276,18 +7875,18 @@ ${imagePaths.map((p) => `Image: ${p}`).join("\n")}` : cliPrompt;
       activeSessionRegistry.pushEvent(convId, { type: "done", text: "" });
       activeSessionRegistry.markDone(convId);
     });
-    if (process.env.DEBUG) console.log("[chat]: drainSession...");
+    if (process.env.RUNEYA_DEBUG) console.log("[chat]: drainSession...");
     yield* drainSession(session, signal, false);
   }),
-  streamViaCodex: protectedProcedure.input(z14.object({
+  streamViaCodex: protectedProcedure.input(z15.object({
     conversationId: ConversationIdSchema,
-    prompt: z14.string().max(1e5),
-    contextNote: z14.string().max(2e5).optional(),
+    prompt: z15.string().max(1e5),
+    contextNote: z15.string().max(2e5).optional(),
     model: ShortString200Schema.optional(),
-    reconnect: z14.boolean().optional(),
+    reconnect: z15.boolean().optional(),
     agentId: Id128Schema.optional(),
-    environmentId: z14.string().max(128).optional(),
-    imageIds: z14.array(z14.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: z15.string().max(128).optional(),
+    imageIds: z15.array(z15.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);
@@ -7295,9 +7894,9 @@ ${imagePaths.map((p) => `Image: ${p}`).join("\n")}` : cliPrompt;
       yield* drainSession(existingSession, signal, true);
       return;
     }
-    if (!input.prompt) throw new TRPCError10({ code: "BAD_REQUEST", message: "Prompt is required" });
+    if (!input.prompt) throw new TRPCError11({ code: "BAD_REQUEST", message: "Prompt is required" });
     const conv = await conversationStore.get(input.conversationId);
-    if (!conv) throw new TRPCError10({ code: "NOT_FOUND", message: "Conversation not found" });
+    if (!conv) throw new TRPCError11({ code: "NOT_FOUND", message: "Conversation not found" });
     const isResume = !!conv.codexThreadId;
     const codexUserParts = input.imageParts && input.imageParts.length > 0 ? [...input.prompt.trim() ? [{ type: "text", text: input.prompt }] : [], ...input.imageParts] : void 0;
     conv.messages.push({ role: "user", content: input.prompt, parts: codexUserParts, contextNote: input.contextNote });
@@ -7317,14 +7916,14 @@ ${input.prompt}` : input.prompt;
         systemContext += "\n\n" + (conv.kanbanCardId ? generateKanbanSystemPrompt(kanbanBoard, conv.kanbanCardId) : generateKanbanPopulatePrompt(kanbanBoard));
       }
     }
-    const resolvedImages = input.imageIds && input.imageIds.length > 0 ? await resolveImagesToBase64(input.imageIds.map((id) => ({ imageId: id, mimeType: "" }))) : [];
+    const resolvedImages = input.imageIds && input.imageIds.length > 0 ? await resolveImagesToBase64(input.imageIds.map((id) => ({ imageId: id, mimeType: "" })), input.conversationId) : [];
     const convId = input.conversationId;
     const ac = new AbortController();
     let session;
     try {
       session = activeSessionRegistry.registerProviderApiSession(convId, ac);
     } catch {
-      throw new TRPCError10({ code: "CONFLICT", message: "A session is already running for this conversation. Stop it first." });
+      throw new TRPCError11({ code: "CONFLICT", message: "A session is already running for this conversation. Stop it first." });
     }
     const resolvedAgentId = input.agentId ?? agentManager.getDefaultAgentId();
     if (resolvedAgentId) {
@@ -7364,13 +7963,13 @@ ${input.prompt}` : input.prompt;
     });
     yield* drainSession(session, signal, false);
   }),
-  send: protectedProcedure.input(z14.object({
+  send: protectedProcedure.input(z15.object({
     conversationId: ConversationIdSchema,
-    messages: z14.array(MessageSchema).min(0).max(100),
+    messages: z15.array(MessageSchema).min(0).max(100),
     model: ShortString200Schema.optional(),
-    contextNote: z14.string().max(2e5).optional(),
-    reconnect: z14.boolean().optional(),
-    imageIds: z14.array(z14.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: z15.string().max(2e5).optional(),
+    reconnect: z15.boolean().optional(),
+    imageIds: z15.array(z15.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);
@@ -7379,12 +7978,12 @@ ${input.prompt}` : input.prompt;
       return;
     }
     if (input.messages.length === 0) {
-      throw new TRPCError10({ code: "BAD_REQUEST", message: "Messages are required for new messages" });
+      throw new TRPCError11({ code: "BAD_REQUEST", message: "Messages are required for new messages" });
     }
     const conv = await conversationStore.get(input.conversationId);
     const active = await getActiveProvider(conv?.providerId);
     if (!active) {
-      throw new TRPCError10({
+      throw new TRPCError11({
         code: "PRECONDITION_FAILED",
         message: "No AI provider configured for this conversation. Please select one when starting a new chat."
       });
@@ -7410,12 +8009,12 @@ ${input.prompt}` : input.prompt;
         system += "\n\n" + (conv.kanbanCardId ? generateKanbanSystemPrompt(kanbanBoard, conv.kanbanCardId) : generateKanbanPopulatePrompt(kanbanBoard));
       }
     }
-    const resolvedImages = input.imageIds && input.imageIds.length > 0 ? await resolveImagesToBase64(input.imageIds.map((id) => ({ imageId: id, mimeType: "" }))) : [];
+    const resolvedImages = input.imageIds && input.imageIds.length > 0 ? await resolveImagesToBase64(input.imageIds.map((id) => ({ imageId: id, mimeType: "" })), input.conversationId) : [];
     let session;
     try {
       session = activeSessionRegistry.registerDirectProviderApiSession(input.conversationId);
     } catch {
-      throw new TRPCError10({ code: "CONFLICT", message: "A session is already running for this conversation. Stop it first." });
+      throw new TRPCError11({ code: "CONFLICT", message: "A session is already running for this conversation. Stop it first." });
     }
     const apiSignal = session.abortController.signal;
     const runStream = async () => {
@@ -7487,25 +8086,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(z14.object({
-      agentId: z14.string().max(128).optional(),
-      sessionId: z14.string().max(128).optional(),
-      runner: z14.enum(["claude-code", "codex"]).default("claude-code"),
-      resume: z14.boolean().default(false),
-      model: z14.string().max(128).optional(),
-      cwd: z14.string().max(4096).optional(),
-      cols: z14.number().int().min(1).max(1e3).default(120),
-      rows: z14.number().int().min(1).max(1e3).default(30),
-      enableMcp: z14.boolean().default(false),
-      apiBaseUrl: z14.string().max(512).optional(),
-      environmentId: z14.string().max(128).optional(),
-      attachedContexts: z14.array(z14.object({
-        label: z14.string().max(200),
-        text: z14.string().max(1e6)
+    start: protectedProcedure.input(z15.object({
+      agentId: z15.string().max(128).optional(),
+      sessionId: z15.string().max(128).optional(),
+      runner: z15.enum(["claude-code", "codex"]).default("claude-code"),
+      resume: z15.boolean().default(false),
+      model: z15.string().max(128).optional(),
+      cwd: z15.string().max(4096).optional(),
+      cols: z15.number().int().min(1).max(1e3).default(120),
+      rows: z15.number().int().min(1).max(1e3).default(30),
+      enableMcp: z15.boolean().default(false),
+      apiBaseUrl: z15.string().max(512).optional(),
+      environmentId: z15.string().max(128).optional(),
+      attachedContexts: z15.array(z15.object({
+        label: z15.string().max(200),
+        text: z15.string().max(1e6)
       })).max(20).optional()
     })).mutation(async ({ input, ctx }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
-      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      if (!agentId) throw new TRPCError11({ code: "PRECONDITION_FAILED", message: "No agent available" });
       if (input.sessionId) {
         try {
           const existing = await agentManager.agentQuery(
@@ -7641,15 +8240,15 @@ Context:
       return { spawnId: res.spawnId, agentId, reattached: false };
     }),
     /** Subscribe to PTY output stream (raw text with ANSI). */
-    stream: protectedProcedure.input(z14.object({
-      agentId: z14.string().max(128).optional(),
-      spawnId: z14.string().max(128),
-      fromOffset: z14.number().int().min(0).default(0)
+    stream: protectedProcedure.input(z15.object({
+      agentId: z15.string().max(128).optional(),
+      spawnId: z15.string().max(128),
+      fromOffset: z15.number().int().min(0).default(0)
     })).subscription(async function* ({ input, signal }) {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
-      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      if (!agentId) throw new TRPCError11({ code: "PRECONDITION_FAILED", message: "No agent available" });
       const queue = [];
-      let resolve5 = null;
+      let resolve6 = null;
       let stopped = false;
       const unsub = agentManager.agentSubscribe(
         agentId,
@@ -7657,16 +8256,16 @@ Context:
         { spawnId: input.spawnId, fromOffset: input.fromOffset },
         (data) => {
           queue.push(data);
-          if (resolve5) {
-            resolve5();
-            resolve5 = null;
+          if (resolve6) {
+            resolve6();
+            resolve6 = null;
           }
         },
         () => {
           stopped = true;
-          if (resolve5) {
-            resolve5();
-            resolve5 = null;
+          if (resolve6) {
+            resolve6();
+            resolve6 = null;
           }
         }
       );
@@ -7682,7 +8281,7 @@ Context:
           }
           if (stopped) break;
           await new Promise((r) => {
-            resolve5 = r;
+            resolve6 = r;
           });
         }
       } finally {
@@ -7690,27 +8289,27 @@ Context:
       }
     }),
     /** Write input to a PTY session (keystrokes from xterm). */
-    write: protectedProcedure.input(z14.object({
-      agentId: z14.string().max(128).optional(),
-      spawnId: z14.string().max(128),
-      data: z14.string().max(1e6)
+    write: protectedProcedure.input(z15.object({
+      agentId: z15.string().max(128).optional(),
+      spawnId: z15.string().max(128),
+      data: z15.string().max(1e6)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
-      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      if (!agentId) throw new TRPCError11({ code: "PRECONDITION_FAILED", message: "No agent available" });
       return agentManager.agentMutation(agentId, "ai.writePty", {
         spawnId: input.spawnId,
         data: input.data
       });
     }),
     /** Resize a PTY session. */
-    resize: protectedProcedure.input(z14.object({
-      agentId: z14.string().max(128).optional(),
-      spawnId: z14.string().max(128),
-      cols: z14.number().int().min(1).max(1e3),
-      rows: z14.number().int().min(1).max(1e3)
+    resize: protectedProcedure.input(z15.object({
+      agentId: z15.string().max(128).optional(),
+      spawnId: z15.string().max(128),
+      cols: z15.number().int().min(1).max(1e3),
+      rows: z15.number().int().min(1).max(1e3)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
-      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      if (!agentId) throw new TRPCError11({ code: "PRECONDITION_FAILED", message: "No agent available" });
       return agentManager.agentMutation(agentId, "ai.resizePty", {
         spawnId: input.spawnId,
         cols: input.cols,
@@ -7723,14 +8322,14 @@ 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(z14.object({
-      agentId: z14.string().max(128).optional(),
-      sessionId: z14.string().max(128).optional(),
-      mimeType: z14.string().max(64),
-      base64: z14.string().max(15e6)
+    pasteImage: protectedProcedure.input(z15.object({
+      agentId: z15.string().max(128).optional(),
+      sessionId: z15.string().max(128).optional(),
+      mimeType: z15.string().max(64),
+      base64: z15.string().max(15e6)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
-      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      if (!agentId) throw new TRPCError11({ code: "PRECONDITION_FAILED", message: "No agent available" });
       const res = await agentManager.agentMutation(agentId, "ai.pasteImage", {
         sessionId: input.sessionId,
         mimeType: input.mimeType,
@@ -7745,7 +8344,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(z14.object({ sessionId: z14.string().max(128) })).query(async ({ input }) => {
+    transcript: protectedProcedure.input(z15.object({ sessionId: z15.string().max(128) })).query(async ({ input }) => {
       return readClaudeTranscript(input.sessionId);
     }),
     /**
@@ -7753,9 +8352,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(z14.object({
-      agentId: z14.string().max(128).optional(),
-      sessionId: z14.string().max(128)
+    activity: protectedProcedure.input(z15.object({
+      agentId: z15.string().max(128).optional(),
+      sessionId: z15.string().max(128)
     })).query(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       let running = false;
@@ -7781,10 +8380,10 @@ 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(z14.object({ conversationId: ConversationIdSchema })).mutation(async ({ input }) => {
+    syncTranscript: protectedProcedure.input(z15.object({ conversationId: ConversationIdSchema })).mutation(async ({ input }) => {
       const conv = await conversationStore.get(input.conversationId);
       if (!conv) {
-        throw new TRPCError10({ code: "NOT_FOUND", message: `Conversation ${input.conversationId} not found` });
+        throw new TRPCError11({ code: "NOT_FOUND", message: `Conversation ${input.conversationId} not found` });
       }
       const synced = await syncConversationFromClaudeTranscript(conv.id);
       const after = await conversationStore.get(conv.id);
@@ -7795,17 +8394,17 @@ 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(z14.object({
-      sessionId: z14.string().max(128),
-      agentId: z14.string().max(128).optional(),
-      bytesPerSec: z14.number().int().min(100).max(1e7).default(5e4),
-      chunkSize: z14.number().int().min(1).max(65536).default(256),
-      durationMs: z14.number().int().min(0).max(36e5).default(0),
-      cols: z14.number().int().min(1).max(1e3).default(120),
-      rows: z14.number().int().min(1).max(1e3).default(30)
+    debugStress: protectedProcedure.input(z15.object({
+      sessionId: z15.string().max(128),
+      agentId: z15.string().max(128).optional(),
+      bytesPerSec: z15.number().int().min(100).max(1e7).default(5e4),
+      chunkSize: z15.number().int().min(1).max(65536).default(256),
+      durationMs: z15.number().int().min(0).max(36e5).default(0),
+      cols: z15.number().int().min(1).max(1e3).default(120),
+      rows: z15.number().int().min(1).max(1e3).default(30)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
-      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      if (!agentId) throw new TRPCError11({ code: "PRECONDITION_FAILED", message: "No agent available" });
       const stressSessionId = `${input.sessionId}-stress-${Date.now().toString(36)}`;
       const { existsSync: existsSync3 } = await import("fs");
       const candidates = [
@@ -7822,7 +8421,7 @@ Context:
         }
       }
       if (!scriptPath) {
-        throw new TRPCError10({
+        throw new TRPCError11({
           code: "INTERNAL_SERVER_ERROR",
           message: `pty-stress-gen.mjs not found near ${fileURLToPath(import.meta.url)}`
         });
@@ -7847,12 +8446,12 @@ Context:
       return { spawnId: res.spawnId, agentId, stressSessionId };
     }),
     /** Kill a PTY session. */
-    kill: protectedProcedure.input(z14.object({
-      agentId: z14.string().max(128).optional(),
-      spawnId: z14.string().max(128)
+    kill: protectedProcedure.input(z15.object({
+      agentId: z15.string().max(128).optional(),
+      spawnId: z15.string().max(128)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
-      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      if (!agentId) throw new TRPCError11({ code: "PRECONDITION_FAILED", message: "No agent available" });
       return agentManager.agentMutation(agentId, "ai.kill", {
         spawnId: input.spawnId
       });
@@ -7861,125 +8460,125 @@ Context:
 });
 
 // ../server/src/trpc/routers/git.ts
-import { z as z15 } from "zod";
-import { TRPCError as TRPCError11 } from "@trpc/server";
+import { z as z16 } from "zod";
+import { TRPCError as TRPCError12 } from "@trpc/server";
 import Anthropic3 from "@anthropic-ai/sdk";
 import OpenAI3 from "openai";
-var SERVICE_ID_SCHEMA = z15.string().max(128);
-var SAFE_PATH_SCHEMA = z15.string().min(1).max(4096).refine((p) => !p.startsWith("/") && !p.includes("../"), {
+var SERVICE_ID_SCHEMA = z16.string().max(128);
+var SAFE_PATH_SCHEMA = z16.string().min(1).max(4096).refine((p) => !p.startsWith("/") && !p.includes("../"), {
   message: "Path must be relative and not traverse up"
 });
-var REMOTE_SCHEMA = z15.string().min(1).max(128).regex(/^[a-zA-Z0-9_\-.]+$/);
-var BRANCH_SCHEMA = z15.string().min(1).max(256).regex(/^[a-zA-Z0-9._\-/]+$/);
+var REMOTE_SCHEMA = z16.string().min(1).max(128).regex(/^[a-zA-Z0-9_\-.]+$/);
+var BRANCH_SCHEMA = z16.string().min(1).max(256).regex(/^[a-zA-Z0-9._\-/]+$/);
 async function resolveServiceContext(serviceId) {
   const service = await serviceStore.get(serviceId);
   if (!service) {
-    throw new TRPCError11({ code: "NOT_FOUND", message: "Service not found" });
+    throw new TRPCError12({ code: "NOT_FOUND", message: "Service not found" });
   }
   const agentId = await resolveEffectiveAgentId(service);
   if (!agentId) {
-    throw new TRPCError11({ code: "BAD_REQUEST", message: "No agent configured for this service" });
+    throw new TRPCError12({ code: "BAD_REQUEST", message: "No agent configured for this service" });
   }
   return { agentId, cwd: service.cwd || "." };
 }
 var gitTargetShape = {
   serviceId: SERVICE_ID_SCHEMA.optional(),
-  agentId: z15.string().max(128).optional()
+  agentId: z16.string().max(128).optional()
 };
 async function resolveGitContext(input) {
   if (input.serviceId) return resolveServiceContext(input.serviceId);
   const agentId = input.agentId ?? agentManager.getDefaultAgentId();
   if (!agentId) {
-    throw new TRPCError11({ code: "BAD_REQUEST", message: "No agent available" });
+    throw new TRPCError12({ code: "BAD_REQUEST", message: "No agent available" });
   }
   return { agentId, cwd: "." };
 }
 var gitRouter = router({
   /** Get full git status */
-  status: protectedProcedure.input(z15.object({ ...gitTargetShape })).query(async ({ input }) => {
+  status: protectedProcedure.input(z16.object({ ...gitTargetShape })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.status", { cwd });
   }),
   /** Get commit log */
-  log: protectedProcedure.input(z15.object({ ...gitTargetShape, limit: z15.number().int().min(1).max(200).default(50) })).query(async ({ input }) => {
+  log: protectedProcedure.input(z16.object({ ...gitTargetShape, limit: z16.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(z15.object({ ...gitTargetShape })).query(async ({ input }) => {
+  branches: protectedProcedure.input(z16.object({ ...gitTargetShape })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.branches", { cwd });
   }),
   /** Checkout a branch */
-  checkout: protectedProcedure.input(z15.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, create: z15.boolean().default(false) })).mutation(async ({ input }) => {
+  checkout: protectedProcedure.input(z16.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, create: z16.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(z15.object({ ...gitTargetShape, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  stage: protectedProcedure.input(z16.object({ ...gitTargetShape, paths: z16.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(z15.object({ ...gitTargetShape })).mutation(async ({ input }) => {
+  stageAll: protectedProcedure.input(z16.object({ ...gitTargetShape })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stageAll", { cwd });
   }),
   /** Unstage files */
-  unstage: protectedProcedure.input(z15.object({ ...gitTargetShape, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  unstage: protectedProcedure.input(z16.object({ ...gitTargetShape, paths: z16.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(z15.object({ ...gitTargetShape })).mutation(async ({ input }) => {
+  unstageAll: protectedProcedure.input(z16.object({ ...gitTargetShape })).mutation(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.unstageAll", { cwd });
   }),
   /** Commit staged changes */
-  commit: protectedProcedure.input(z15.object({ ...gitTargetShape, message: z15.string().min(1).max(4096) })).mutation(async ({ input }) => {
+  commit: protectedProcedure.input(z16.object({ ...gitTargetShape, message: z16.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(z15.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z15.boolean().default(false) })).mutation(async ({ input }) => {
+  push: protectedProcedure.input(z16.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z16.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(z15.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+  pull: protectedProcedure.input(z16.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(z15.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+  fetch: protectedProcedure.input(z16.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(z15.object({
+  diff: protectedProcedure.input(z16.object({
     ...gitTargetShape,
-    path: z15.string().max(4096).optional(),
-    staged: z15.boolean().default(false),
-    untracked: z15.boolean().default(false)
+    path: z16.string().max(4096).optional(),
+    staged: z16.boolean().default(false),
+    untracked: z16.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(z15.object({ ...gitTargetShape, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  discard: protectedProcedure.input(z16.object({ ...gitTargetShape, paths: z16.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(z15.object({ ...gitTargetShape })).mutation(async ({ input }) => {
+  generateCommitMessage: protectedProcedure.input(z16.object({ ...gitTargetShape, providerId: OptionalProviderIdSchema, model: z16.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()) {
-      throw new TRPCError11({ code: "BAD_REQUEST", message: "No staged changes to generate a commit message from" });
+      throw new TRPCError12({ code: "BAD_REQUEST", message: "No staged changes to generate a commit message from" });
     }
-    const active = await getActiveProvider();
+    const active = await getActiveProvider(input.providerId);
     if (!active) {
-      throw new TRPCError11({ code: "BAD_REQUEST", message: "No AI provider configured" });
+      throw new TRPCError12({ code: "BAD_REQUEST", message: "No AI provider configured" });
     }
     const systemPrompt = `You are a git commit message generator. Given a git diff, write a concise and meaningful conventional commit message (e.g. feat:, fix:, refactor:, chore:, docs:, style:, test:).
 Rules:
@@ -7988,7 +8587,7 @@ Rules:
 - Write in English
 - Return ONLY the commit message, nothing else`;
     const { provider, plaintextKey } = active;
-    const model = provider.model || DEFAULT_MODELS[provider.provider] || "claude-opus-4-6";
+    const model = input.model || provider.model || DEFAULT_MODELS[provider.provider] || "claude-opus-4-6";
     if (provider.provider === "anthropic") {
       const client = new Anthropic3({ apiKey: plaintextKey });
       const res = await client.messages.create({
@@ -8012,48 +8611,48 @@ Rules:
       });
       return { message: res.choices[0]?.message?.content?.trim() ?? "" };
     }
-    throw new TRPCError11({ code: "BAD_REQUEST", message: "Unsupported AI provider" });
+    throw new TRPCError12({ code: "BAD_REQUEST", message: "Unsupported AI provider" });
   }),
   /** Merge a branch into the current branch */
-  merge: protectedProcedure.input(z15.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, noFf: z15.boolean().default(false) })).mutation(async ({ input }) => {
+  merge: protectedProcedure.input(z16.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, noFf: z16.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(z15.object({ ...gitTargetShape, branch: BRANCH_SCHEMA })).mutation(async ({ input }) => {
+  rebase: protectedProcedure.input(z16.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(z15.object({ ...gitTargetShape })).query(async ({ input }) => {
+  stashList: protectedProcedure.input(z16.object({ ...gitTargetShape })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.stashList", { cwd });
   }),
   /** Stash current changes */
-  stashPush: protectedProcedure.input(z15.object({ ...gitTargetShape, message: z15.string().max(4096).optional(), includeUntracked: z15.boolean().default(true) })).mutation(async ({ input }) => {
+  stashPush: protectedProcedure.input(z16.object({ ...gitTargetShape, message: z16.string().max(4096).optional(), includeUntracked: z16.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(z15.object({ ...gitTargetShape, index: z15.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashPop: protectedProcedure.input(z16.object({ ...gitTargetShape, index: z16.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(z15.object({ ...gitTargetShape, index: z15.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashApply: protectedProcedure.input(z16.object({ ...gitTargetShape, index: z16.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(z15.object({ ...gitTargetShape, index: z15.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashDrop: protectedProcedure.input(z16.object({ ...gitTargetShape, index: z16.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(z15.object({ ...gitTargetShape })).subscription(async function* ({ input }) {
+  onStatusChange: protectedProcedure.input(z16.object({ ...gitTargetShape })).subscription(async function* ({ input }) {
     const { agentId, cwd } = await resolveGitContext(input);
     const queue = [];
-    let resolve5 = null;
+    let resolve6 = null;
     let done = false;
     let unsubscribe;
     try {
@@ -8063,21 +8662,21 @@ Rules:
         { cwd },
         (data) => {
           queue.push(data);
-          if (resolve5) {
-            resolve5();
-            resolve5 = null;
+          if (resolve6) {
+            resolve6();
+            resolve6 = null;
           }
         },
         () => {
           done = true;
-          if (resolve5) {
-            resolve5();
-            resolve5 = null;
+          if (resolve6) {
+            resolve6();
+            resolve6 = null;
           }
         }
       );
     } catch (err) {
-      throw new TRPCError11({
+      throw new TRPCError12({
         code: "BAD_REQUEST",
         message: `Cannot subscribe to git status: ${err.message}`
       });
@@ -8088,7 +8687,7 @@ Rules:
           yield queue.shift();
         } else {
           await new Promise((r) => {
-            resolve5 = r;
+            resolve6 = r;
           });
         }
       }
@@ -8097,49 +8696,49 @@ Rules:
     }
   }),
   /** List remotes */
-  remotes: protectedProcedure.input(z15.object({ ...gitTargetShape })).query(async ({ input }) => {
+  remotes: protectedProcedure.input(z16.object({ ...gitTargetShape })).query(async ({ input }) => {
     const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.remotes", { cwd });
   })
 });
 
 // ../server/src/trpc/routers/scenario.ts
-import { randomUUID as randomUUID7 } from "crypto";
-import { TRPCError as TRPCError14 } from "@trpc/server";
-import { z as z16 } from "zod";
+import { randomUUID as randomUUID8 } from "crypto";
+import { TRPCError as TRPCError15 } from "@trpc/server";
+import { z as z17 } from "zod";
 
 // ../server/src/trpc/crud-procedure-utils.ts
-import { TRPCError as TRPCError12 } from "@trpc/server";
+import { TRPCError as TRPCError13 } from "@trpc/server";
 async function getOrNotFound(getter, notFoundMessage) {
   const entity = await getter();
-  if (!entity) throw new TRPCError12({ code: "NOT_FOUND", message: notFoundMessage });
+  if (!entity) throw new TRPCError13({ code: "NOT_FOUND", message: notFoundMessage });
   return entity;
 }
 async function createOrBadRequest(creator) {
   try {
     return await creator();
   } catch (err) {
-    throw new TRPCError12({ code: "BAD_REQUEST", message: err.message });
+    throw new TRPCError13({ code: "BAD_REQUEST", message: err.message });
   }
 }
 async function updateOrThrow(updater, notFoundMessage) {
   try {
     const entity = await updater();
-    if (!entity) throw new TRPCError12({ code: "NOT_FOUND", message: notFoundMessage });
+    if (!entity) throw new TRPCError13({ code: "NOT_FOUND", message: notFoundMessage });
     return entity;
   } catch (err) {
-    if (err instanceof TRPCError12) throw err;
-    throw new TRPCError12({ code: "BAD_REQUEST", message: err.message });
+    if (err instanceof TRPCError13) throw err;
+    throw new TRPCError13({ code: "BAD_REQUEST", message: err.message });
   }
 }
 async function deleteOrNotFound(deleter, notFoundMessage) {
   const deleted = await deleter();
-  if (!deleted) throw new TRPCError12({ code: "NOT_FOUND", message: notFoundMessage });
+  if (!deleted) throw new TRPCError13({ code: "NOT_FOUND", message: notFoundMessage });
   return { ok: true };
 }
 
 // ../server/src/trpc/ai-generation-procedure-utils.ts
-import { TRPCError as TRPCError13 } from "@trpc/server";
+import { TRPCError as TRPCError14 } from "@trpc/server";
 
 // ../server/src/services/ai-generation.ts
 import Anthropic4 from "@anthropic-ai/sdk";
@@ -8195,9 +8794,9 @@ async function* streamProviderText(input) {
 // ../server/src/trpc/ai-generation-procedure-utils.ts
 async function* streamWithActiveProvider(opts) {
   const active = await getActiveProvider(opts.providerId);
-  if (!active) throw new TRPCError13({ code: "BAD_REQUEST", message: "Aucun fournisseur IA configur\xE9" });
+  if (!active) throw new TRPCError14({ code: "BAD_REQUEST", message: "Aucun fournisseur IA configur\xE9" });
   const { provider, plaintextKey } = active;
-  const model = provider.model ?? DEFAULT_MODELS[provider.provider] ?? "";
+  const model = opts.model || provider.model || DEFAULT_MODELS[provider.provider] || "";
   try {
     for await (const text of streamProviderText({
       provider,
@@ -8213,16 +8812,16 @@ async function* streamWithActiveProvider(opts) {
     yield { type: "done", text: "" };
   } catch (err) {
     if (String(err?.message ?? "").startsWith("Unsupported provider:")) {
-      throw new TRPCError13({ code: "BAD_REQUEST", message: `Fournisseur non support\xE9: ${provider.provider}` });
+      throw new TRPCError14({ code: "BAD_REQUEST", message: `Fournisseur non support\xE9: ${provider.provider}` });
     }
     throw err;
   }
 }
 
 // ../server/src/services/scenario-runner.ts
-import { mkdir as mkdir12 } from "fs/promises";
-import { randomUUID as randomUUID6 } from "crypto";
-import { join as join14 } from "path";
+import { mkdir as mkdir13 } from "fs/promises";
+import { randomUUID as randomUUID7 } from "crypto";
+import { join as join15 } from "path";
 
 // ../server/src/services/scenario-presets.ts
 var BUILT_IN_PRESETS = [
@@ -8436,21 +9035,21 @@ async function* tapBus(conversationId, signal) {
     }
     if (bus.done) return;
     if (signal.aborted) return;
-    await new Promise((resolve5) => {
+    await new Promise((resolve6) => {
       const onAbort = () => {
         bus.listeners.delete(notify);
-        resolve5();
+        resolve6();
       };
       const notify = () => {
         signal.removeEventListener("abort", onAbort);
-        resolve5();
+        resolve6();
       };
       bus.listeners.add(notify);
       signal.addEventListener("abort", onAbort, { once: true });
       if (cursor < bus.baseIndex + bus.buffer.length || bus.done || signal.aborted) {
         bus.listeners.delete(notify);
         signal.removeEventListener("abort", onAbort);
-        resolve5();
+        resolve6();
       }
     });
   }
@@ -8563,7 +9162,7 @@ function applyHireDirectivesFromOutput(manager, scenario, output) {
   }
   const hired = [];
   for (const payload of hireDirectives) {
-    const id = `hire-${randomUUID6().slice(0, 8)}`;
+    const id = `hire-${randomUUID7().slice(0, 8)}`;
     const position = computeHirePosition(manager, scenario.nodes);
     ensureGroupCanContainNode(scenario, manager.groupId ?? null, position);
     const node = {
@@ -8927,9 +9526,6 @@ async function runNodeCall(conversationId, node, systemContext, userMessage, run
       model,
       effort: "normal",
       signal,
-      // Scenarios default to interactive PTY to stay on subscription pricing.
-      // Override with RUNEYA_CLAUDE_PTY=0 to fall back to headless `-p` mode.
-      usePty: aiCli === "claude-code" && process.env["RUNEYA_CLAUDE_PTY"] !== "0",
       onDelta: (text) => {
         accumulated += text;
         onDelta(text);
@@ -8957,9 +9553,9 @@ async function runNodeCall(conversationId, node, systemContext, userMessage, run
       publish2({ type: "node_waiting_input", nodeId: node.id, question: result.tokenMessage });
       await readme?.(`- \u2753 [${formatTs()}] **${node.label}** \u2014 waiting for user input
 `);
-      const answer = await new Promise((resolve5, reject) => {
+      const answer = await new Promise((resolve6, reject) => {
         const key = pendingNodeKey(conversationId, node.id);
-        pendingNodeInputs.set(key, resolve5);
+        pendingNodeInputs.set(key, resolve6);
         signal.addEventListener("abort", () => {
           pendingNodeInputs.delete(key);
           reject(new Error("Aborted"));
@@ -8999,7 +9595,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 = join14(dir, `${slug}_${safeId}.md`);
+  const filePath = join15(dir, `${slug}_${safeId}.md`);
   const content = `## Output
 
 ${output}
@@ -9012,9 +9608,9 @@ async function appendToReadme(conversationId, bus, text) {
   const line = `${text}
 `;
   try {
-    await mkdir12(dir, { recursive: true });
+    await mkdir13(dir, { recursive: true });
     const { appendFile: appendFile2 } = await import("fs/promises");
-    await appendFile2(join14(dir, "README.md"), line, "utf-8");
+    await appendFile2(join15(dir, "README.md"), line, "utf-8");
   } catch {
   }
   publishToBus(bus, { type: "readme_append", text: line });
@@ -9034,7 +9630,7 @@ async function writeFinalMd(conversationId, bus, userRequest, content) {
 
 ${content}
 `;
-  const filePath = join14(dir, "FINAL.md");
+  const filePath = join15(dir, "FINAL.md");
   await atomicWriteSecure(filePath, fullContent);
   await appendToReadme(
     conversationId,
@@ -9364,9 +9960,9 @@ ${outputs.get(node.id) ?? ""}`.trim();
         publish2({ type: "node_waiting_input", nodeId: node.id, question });
         await readme(`- \u2753 [${ts()}] **${node.label || node.id}** \u2014 waiting for user input
 `);
-        const answer = await new Promise((resolve5, reject) => {
+        const answer = await new Promise((resolve6, reject) => {
           const key = pendingNodeKey(conversationId, node.id);
-          pendingNodeInputs.set(key, resolve5);
+          pendingNodeInputs.set(key, resolve6);
           signal.addEventListener("abort", () => {
             pendingNodeInputs.delete(key);
             reject(new Error("Aborted"));
@@ -9703,21 +10299,21 @@ Modify the scenario. Keep existing ids when possible.`;
 }
 var scenarioRouter = router({
   list: protectedProcedure.query(() => scenarioStore.list()),
-  get: protectedProcedure.input(z16.object({ id: Id128Schema })).query(({ input }) => getOrNotFound(() => scenarioStore.get(input.id), "Scenario not found")),
-  create: protectedProcedure.input(z16.object({
+  get: protectedProcedure.input(z17.object({ id: Id128Schema })).query(({ input }) => getOrNotFound(() => scenarioStore.get(input.id), "Scenario not found")),
+  create: protectedProcedure.input(z17.object({
     name: NameSchema,
-    icon: z16.string().max(64).optional(),
+    icon: z17.string().max(64).optional(),
     description: DescriptionSchema.optional(),
     leaderId: Id128Schema,
-    groups: z16.array(ScenarioGroupSchema).max(100).optional(),
-    nodes: z16.array(ScenarioNodeSchema).min(1).max(500),
-    traversalMode: z16.enum(["hierarchical", "topological"]).optional(),
-    presetId: z16.string().max(128).optional(),
-    isPublished: z16.boolean().optional()
+    groups: z17.array(ScenarioGroupSchema).max(100).optional(),
+    nodes: z17.array(ScenarioNodeSchema).min(1).max(500),
+    traversalMode: z17.enum(["hierarchical", "topological"]).optional(),
+    presetId: z17.string().max(128).optional(),
+    isPublished: z17.boolean().optional()
   })).mutation(({ input }) => {
     const now = Date.now();
     return createOrBadRequest(() => scenarioStore.create({
-      id: randomUUID7(),
+      id: randomUUID8(),
       name: input.name,
       icon: input.icon,
       description: input.description,
@@ -9731,17 +10327,17 @@ var scenarioRouter = router({
       updatedAt: now
     }));
   }),
-  update: protectedProcedure.input(z16.object({
+  update: protectedProcedure.input(z17.object({
     id: Id128Schema,
     name: NameSchema.optional(),
-    icon: z16.string().max(64).optional(),
+    icon: z17.string().max(64).optional(),
     description: DescriptionSchema.optional(),
     leaderId: Id128Schema.optional(),
-    groups: z16.array(ScenarioGroupSchema).max(100).optional(),
-    nodes: z16.array(ScenarioNodeSchema).min(1).max(500).optional(),
-    traversalMode: z16.enum(["hierarchical", "topological"]).optional(),
-    presetId: z16.string().max(128).optional(),
-    isPublished: z16.boolean().optional()
+    groups: z17.array(ScenarioGroupSchema).max(100).optional(),
+    nodes: z17.array(ScenarioNodeSchema).min(1).max(500).optional(),
+    traversalMode: z17.enum(["hierarchical", "topological"]).optional(),
+    presetId: z17.string().max(128).optional(),
+    isPublished: z17.boolean().optional()
   })).mutation(({ input }) => updateOrThrow(
     () => scenarioStore.update(input.id, {
       name: input.name,
@@ -9757,18 +10353,18 @@ var scenarioRouter = router({
     }),
     "Scenario not found"
   )),
-  delete: protectedProcedure.input(z16.object({ id: Id128Schema })).mutation(({ input }) => deleteOrNotFound(() => scenarioStore.delete(input.id), "Scenario not found")),
-  run: protectedProcedure.input(z16.object({
+  delete: protectedProcedure.input(z17.object({ id: Id128Schema })).mutation(({ input }) => deleteOrNotFound(() => scenarioStore.delete(input.id), "Scenario not found")),
+  run: protectedProcedure.input(z17.object({
     conversationId: ConversationIdSchema,
     scenarioId: Id128Schema,
-    userRequest: z16.string().max(1e5),
-    runnerOverride: z16.enum(["claude-code", "codex"]).optional(),
+    userRequest: z17.string().max(1e5),
+    runnerOverride: z17.enum(["claude-code", "codex"]).optional(),
     modelOverride: Id128Schema.optional(),
     agentId: Id128Schema.optional(),
-    resume: z16.boolean().optional()
+    resume: z17.boolean().optional()
   })).subscription(async function* ({ input, signal }) {
     const scenario = await scenarioStore.get(input.scenarioId);
-    if (!scenario) throw new TRPCError14({ code: "NOT_FOUND", message: "Scenario not found" });
+    if (!scenario) throw new TRPCError15({ code: "NOT_FOUND", message: "Scenario not found" });
     const canStart = input.userRequest.trim().length > 0 || !!input.resume;
     if (!isScenarioRunning(input.conversationId) && canStart) {
       let userRequest = input.userRequest;
@@ -9784,52 +10380,54 @@ var scenarioRouter = router({
     }
     yield* tapBus(input.conversationId, signal ?? new AbortController().signal);
   }),
-  stop: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
+  stop: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
     abortScenario(input.conversationId);
     return { ok: true };
   }),
-  sendNodeInput: protectedProcedure.input(z16.object({
+  sendNodeInput: protectedProcedure.input(z17.object({
     conversationId: ConversationIdSchema,
     nodeId: Id128Schema,
-    text: z16.string().min(1).max(1e5)
+    text: z17.string().min(1).max(1e5)
   })).mutation(({ input }) => {
     const resolved = resolveNodeInput(input.conversationId, input.nodeId, input.text);
-    if (!resolved) throw new TRPCError14({ code: "NOT_FOUND", message: "No pending input request for this node" });
+    if (!resolved) throw new TRPCError15({ code: "NOT_FOUND", message: "No pending input request for this node" });
     return { ok: true };
   }),
-  isRunning: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).query(({ input }) => ({ running: isScenarioRunning(input.conversationId) })),
-  runState: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).query(({ input }) => {
+  isRunning: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).query(({ input }) => ({ running: isScenarioRunning(input.conversationId) })),
+  runState: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).query(({ input }) => {
     const runState = scenarioRunStore.getRunState(input.conversationId);
     return runState ?? { nodeStates: {}, nodeOutputs: {}, activeNodeId: void 0 };
   }),
-  getPersistedRunState: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
+  getPersistedRunState: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
     return await scenarioRunStore.loadPersistedRunState(input.conversationId);
   }),
-  getReadme: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
+  getReadme: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
     return await scenarioRunStore.readReadme(input.conversationId);
   }),
-  getSnapshot: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
+  getSnapshot: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).query(async ({ input }) => {
     return await scenarioRunStore.loadScenarioSnapshot(input.conversationId);
   }),
-  streamGenerateWithAI: protectedProcedure.input(z16.object({
-    prompt: z16.string().min(1).max(1e4),
+  streamGenerateWithAI: protectedProcedure.input(z17.object({
+    prompt: z17.string().min(1).max(1e4),
     providerId: OptionalProviderIdSchema,
-    current: z16.object({
+    model: z17.string().max(200).optional(),
+    current: z17.object({
       leaderId: Id128Schema,
-      groups: z16.array(ScenarioGroupSchema).max(100),
-      nodes: z16.array(ScenarioNodeSchema).max(500)
+      groups: z17.array(ScenarioGroupSchema).max(100),
+      nodes: z17.array(ScenarioNodeSchema).max(500)
     }).optional()
   })).subscription(async function* ({ input, signal }) {
     const userMessage = buildScenarioUserMessage(input.prompt, input.current);
     yield* streamWithActiveProvider({
       providerId: input.providerId,
+      model: input.model,
       systemPrompt: SCENARIO_SYSTEM_PROMPT,
       userMessage,
       maxTokens: 8192,
       signal: signal ?? void 0
     });
   }),
-  streamRunEvents: protectedProcedure.input(z16.object({ conversationId: ConversationIdSchema })).subscription(async function* ({ input }) {
+  streamRunEvents: protectedProcedure.input(z17.object({ conversationId: ConversationIdSchema })).subscription(async function* ({ input }) {
     const convId = input.conversationId;
     const runState = scenarioRunStore.getRunState(convId);
     if (runState) {
@@ -9843,24 +10441,24 @@ 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(z16.object({
+  getNodeSession: protectedProcedure.input(z17.object({
     conversationId: ConversationIdSchema,
     nodeId: Id128Schema
   })).query(async ({ input }) => {
     return await scenarioRunStore.getNodeSessionPersistent(input.conversationId, input.nodeId);
   }),
   listPresets: protectedProcedure.query(() => listPresets()),
-  getPreset: protectedProcedure.input(z16.object({ id: Id128Schema })).query(({ input }) => {
+  getPreset: protectedProcedure.input(z17.object({ id: Id128Schema })).query(({ input }) => {
     const preset = getPreset(input.id);
-    if (!preset) throw new TRPCError14({ code: "NOT_FOUND", message: "Preset not found" });
+    if (!preset) throw new TRPCError15({ code: "NOT_FOUND", message: "Preset not found" });
     return preset;
   })
 });
 
 // ../server/src/trpc/routers/debug.ts
-import { randomUUID as randomUUID8 } from "crypto";
-import { TRPCError as TRPCError15 } from "@trpc/server";
-import { z as z17 } from "zod";
+import { randomUUID as randomUUID9 } from "crypto";
+import { TRPCError as TRPCError16 } from "@trpc/server";
+import { z as z18 } from "zod";
 var MAX_BUFFER3 = 300;
 var jobs = /* @__PURE__ */ new Map();
 function publish(job, event) {
@@ -9897,31 +10495,31 @@ async function* tapJob(job, signal) {
       yield evt;
     }
     if (job.done || signal.aborted) return;
-    await new Promise((resolve5) => {
+    await new Promise((resolve6) => {
       const onAbort = () => {
         job.listeners.delete(notify);
-        resolve5();
+        resolve6();
       };
       const notify = () => {
         signal.removeEventListener("abort", onAbort);
-        resolve5();
+        resolve6();
       };
       job.listeners.add(notify);
       signal.addEventListener("abort", onAbort, { once: true });
       if (cursor < job.baseIndex + job.buffer.length || job.done || signal.aborted) {
         job.listeners.delete(notify);
         signal.removeEventListener("abort", onAbort);
-        resolve5();
+        resolve6();
       }
     });
   }
 }
 var debugRouter = router({
-  startRandomJob: protectedProcedure.input(z17.object({
-    intervalMs: z17.number().int().min(100).max(5e3).optional(),
-    maxTicks: z17.number().int().min(1).max(1e4).optional()
+  startRandomJob: protectedProcedure.input(z18.object({
+    intervalMs: z18.number().int().min(100).max(5e3).optional(),
+    maxTicks: z18.number().int().min(1).max(1e4).optional()
   }).optional()).mutation(({ input }) => {
-    const jobId = randomUUID8();
+    const jobId = randomUUID9();
     const intervalMs = input?.intervalMs ?? 400;
     const maxTicks = input?.maxTicks ?? 500;
     const job = {
@@ -9953,15 +10551,15 @@ var debugRouter = router({
     jobs.set(jobId, job);
     return { jobId, intervalMs, maxTicks, startedAt: job.startedAt };
   }),
-  streamRandomJob: protectedProcedure.input(z17.object({ jobId: z17.string().max(128) })).subscription(async function* ({ input, signal }) {
+  streamRandomJob: protectedProcedure.input(z18.object({ jobId: z18.string().max(128) })).subscription(async function* ({ input, signal }) {
     const job = jobs.get(input.jobId);
     if (!job) {
-      throw new TRPCError15({ code: "NOT_FOUND", message: "Random job not found" });
+      throw new TRPCError16({ code: "NOT_FOUND", message: "Random job not found" });
     }
     yield* tapJob(job, signal ?? new AbortController().signal);
   }),
-  stopRandomJob: protectedProcedure.input(z17.object({ jobId: z17.string().max(128) })).mutation(({ input }) => ({ ok: stopJob(input.jobId, "stopped") })),
-  randomJobStatus: protectedProcedure.input(z17.object({ jobId: z17.string().max(128) })).query(({ input }) => {
+  stopRandomJob: protectedProcedure.input(z18.object({ jobId: z18.string().max(128) })).mutation(({ input }) => ({ ok: stopJob(input.jobId, "stopped") })),
+  randomJobStatus: protectedProcedure.input(z18.object({ jobId: z18.string().max(128) })).query(({ input }) => {
     const job = jobs.get(input.jobId);
     return {
       running: !!job && !job.done,
@@ -9970,132 +10568,11 @@ var debugRouter = router({
   })
 });
 
-// ../server/src/trpc/routers/kanban.ts
-import { z as z18 } from "zod";
-import { TRPCError as TRPCError16 } from "@trpc/server";
-async function deleteConversationsForIds(conversationIds) {
-  await Promise.all(conversationIds.map(async (id) => {
-    await conversationStore.delete(id);
-    await scenarioRunStore.deleteRunDir(id);
-    imageStorageService.deleteByContextId(id).catch(
-      (err) => console.error("[kanban] Image cleanup error:", err)
-    );
-  }));
-}
-var kanbanRouter = router({
-  list: protectedProcedure.input(z18.object({ includeArchived: z18.boolean().optional() }).optional()).query(async ({ input }) => {
-    return kanbanStore.list(input?.includeArchived ?? false);
-  }),
-  get: protectedProcedure.input(z18.object({ id: z18.string().max(128) })).query(async ({ input }) => {
-    const board = await kanbanStore.get(input.id);
-    if (!board) throw new TRPCError16({ code: "NOT_FOUND", message: `Board ${input.id} not found` });
-    return board;
-  }),
-  create: protectedProcedure.input(z18.object({
-    name: z18.string().min(1).max(200),
-    description: z18.string().max(1e4).optional()
-  })).mutation(async ({ input }) => {
-    return kanbanStore.create(input);
-  }),
-  update: protectedProcedure.input(z18.object({
-    id: z18.string().max(128),
-    name: z18.string().min(1).max(200).optional(),
-    description: z18.string().max(1e4).optional(),
-    columns: z18.array(KanbanColumnSchema).optional(),
-    archived: z18.boolean().optional()
-  })).mutation(async ({ input }) => {
-    let removedCardIds = [];
-    if (input.columns !== void 0) {
-      const existing = await kanbanStore.get(input.id);
-      if (existing) {
-        const oldCardIds = new Set(existing.columns.flatMap((col) => col.cards.map((c) => c.id)));
-        const newCardIds = new Set(input.columns.flatMap((col) => col.cards.map((c) => c.id)));
-        removedCardIds = Array.from(oldCardIds).filter((id) => !newCardIds.has(id));
-      }
-    }
-    const board = await kanbanStore.update(input);
-    if (!board) throw new TRPCError16({ code: "NOT_FOUND", message: `Board ${input.id} not found` });
-    if (removedCardIds.length > 0) {
-      const convsByCard = await Promise.all(removedCardIds.map((cardId) => conversationStore.listByKanbanCardId(cardId)));
-      const convIds = convsByCard.flat().map((c) => c.id);
-      if (convIds.length > 0) await deleteConversationsForIds(convIds);
-    }
-    return board;
-  }),
-  moveCard: protectedProcedure.input(z18.object({
-    boardId: z18.string().max(128),
-    cardId: z18.string().max(128),
-    targetColumn: z18.string().min(1).max(200)
-  })).mutation(async ({ input }) => {
-    const board = await kanbanStore.get(input.boardId);
-    if (!board) throw new TRPCError16({ code: "NOT_FOUND", message: `Board ${input.boardId} not found` });
-    const { executeKanbanCommands } = await import("./kanban-commands-53WWMCHQ.js");
-    await executeKanbanCommands(input.boardId, input.cardId, [{ type: "move_card", columnTitle: input.targetColumn }]);
-    return { success: true };
-  }),
-  addComment: protectedProcedure.input(z18.object({
-    boardId: z18.string().max(128),
-    cardId: z18.string().max(128),
-    comment: z18.string().min(1).max(1e4)
-  })).mutation(async ({ input }) => {
-    const board = await kanbanStore.get(input.boardId);
-    if (!board) throw new TRPCError16({ code: "NOT_FOUND", message: `Board ${input.boardId} not found` });
-    const { executeKanbanCommands } = await import("./kanban-commands-53WWMCHQ.js");
-    await executeKanbanCommands(input.boardId, input.cardId, [{ type: "add_comment", comment: input.comment }]);
-    return { success: true };
-  }),
-  addCard: protectedProcedure.input(z18.object({
-    boardId: z18.string().max(128),
-    column: z18.string().min(1).max(200),
-    title: z18.string().min(1).max(500),
-    content: z18.string().max(5e4).optional()
-  })).mutation(async ({ input }) => {
-    const board = await kanbanStore.get(input.boardId);
-    if (!board) throw new TRPCError16({ code: "NOT_FOUND", message: `Board ${input.boardId} not found` });
-    const { executeKanbanBoardCommands } = await import("./kanban-commands-53WWMCHQ.js");
-    await executeKanbanBoardCommands(input.boardId, [{ type: "add_card", columnTitle: input.column, cardTitle: input.title, cardContent: input.content }]);
-    return { success: true };
-  }),
-  delete: protectedProcedure.input(z18.object({ id: z18.string().max(128) })).mutation(async ({ input }) => {
-    const conversations = await conversationStore.listByKanbanBoardId(input.id);
-    const deleted = await kanbanStore.delete(input.id);
-    if (!deleted) throw new TRPCError16({ code: "NOT_FOUND", message: `Board ${input.id} not found` });
-    await deleteConversationsForIds(conversations.map((c) => c.id));
-    return { success: true };
-  }),
-  onChanged: protectedProcedure.subscription(async function* () {
-    const queue = [];
-    let resolve5 = null;
-    const handler = (event) => {
-      if (queue.length >= 200) queue.shift();
-      queue.push(event);
-      if (resolve5) {
-        resolve5();
-        resolve5 = null;
-      }
-    };
-    kanbanStore.onChanged(handler);
-    try {
-      while (true) {
-        if (queue.length > 0) {
-          yield queue.shift();
-        } else {
-          await new Promise((r) => {
-            resolve5 = r;
-          });
-        }
-      }
-    } finally {
-      kanbanStore.offChanged(handler);
-    }
-  })
-});
-
 // ../server/src/trpc/routers/kanban-queue.ts
 import { z as z19 } from "zod";
 
 // ../server/src/services/kanban-queue.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { EventEmitter as EventEmitter4 } from "events";
 var KanbanQueueService = class extends EventEmitter4 {
   items = [];
@@ -10118,7 +10595,7 @@ var KanbanQueueService = class extends EventEmitter4 {
       return { id: alreadyRunning.id, addedAt: alreadyRunning.startedAt, ...item };
     }
     const queueItem = {
-      id: randomUUID9(),
+      id: randomUUID10(),
       ...item,
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -10310,13 +10787,13 @@ var kanbanQueueRouter = router({
   }),
   onChanged: protectedProcedure.subscription(async function* () {
     const queue = [];
-    let resolve5 = null;
+    let resolve6 = null;
     const handler = () => {
       if (queue.length >= 50) queue.shift();
       queue.push(kanbanQueue.getState());
-      if (resolve5) {
-        resolve5();
-        resolve5 = null;
+      if (resolve6) {
+        resolve6();
+        resolve6 = null;
       }
     };
     kanbanQueue.on("changed", handler);
@@ -10327,7 +10804,7 @@ var kanbanQueueRouter = router({
           yield queue.shift();
         } else {
           await new Promise((r) => {
-            resolve5 = r;
+            resolve6 = r;
           });
         }
       }
@@ -10337,16 +10814,52 @@ var kanbanQueueRouter = router({
   })
 });
 
-// ../server/src/trpc/routers/terminal.ts
+// ../server/src/trpc/routers/kanban.ts
 import { z as z20 } from "zod";
+var kanbanRouter = router({
+  moveCard: protectedProcedure.input(z20.object({
+    boardId: z20.string().max(128),
+    cardId: z20.string().max(128),
+    targetColumn: z20.string().max(256)
+  })).mutation(async ({ input }) => {
+    await executeKanbanCommands(input.boardId, input.cardId, [
+      { type: "move_card", columnTitle: input.targetColumn }
+    ]);
+    return { ok: true };
+  }),
+  addComment: protectedProcedure.input(z20.object({
+    boardId: z20.string().max(128),
+    cardId: z20.string().max(128),
+    comment: z20.string().max(2e4)
+  })).mutation(async ({ input }) => {
+    await executeKanbanCommands(input.boardId, input.cardId, [
+      { type: "add_comment", comment: input.comment }
+    ]);
+    return { ok: true };
+  }),
+  addCard: protectedProcedure.input(z20.object({
+    boardId: z20.string().max(128),
+    column: z20.string().max(256),
+    title: z20.string().max(512),
+    content: z20.string().max(2e4).optional()
+  })).mutation(async ({ input }) => {
+    await executeKanbanBoardCommands(input.boardId, [
+      { type: "add_card", columnTitle: input.column, cardTitle: input.title, cardContent: input.content }
+    ]);
+    return { ok: true };
+  })
+});
+
+// ../server/src/trpc/routers/terminal.ts
+import { z as z21 } from "zod";
 import { TRPCError as TRPCError17 } from "@trpc/server";
 var terminalRouter = router({
   /** Create a PTY shell session on the target agent */
-  create: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    cwd: z20.string().max(512).optional(),
-    cols: z20.number().int().min(1).max(512).optional(),
-    rows: z20.number().int().min(1).max(256).optional()
+  create: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    cwd: z21.string().max(512).optional(),
+    cols: z21.number().int().min(1).max(512).optional(),
+    rows: z21.number().int().min(1).max(256).optional()
   })).mutation(async ({ input }) => {
     const result = await agentManager.agentMutation(
       input.agentId,
@@ -10356,10 +10869,10 @@ var terminalRouter = router({
     return result;
   }),
   /** Send keystrokes / data to a PTY session */
-  write: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    sessionId: z20.string().max(128),
-    data: z20.string().max(65536)
+  write: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    sessionId: z21.string().max(128),
+    data: z21.string().max(65536)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -10369,11 +10882,11 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Resize the PTY */
-  resize: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    sessionId: z20.string().max(128),
-    cols: z20.number().int().min(1).max(512),
-    rows: z20.number().int().min(1).max(256)
+  resize: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    sessionId: z21.string().max(128),
+    cols: z21.number().int().min(1).max(512),
+    rows: z21.number().int().min(1).max(256)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -10383,9 +10896,9 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Destroy a PTY session */
-  destroy: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    sessionId: z20.string().max(128)
+  destroy: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    sessionId: z21.string().max(128)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -10395,12 +10908,12 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Stream PTY output — proxied via AgentWSBridge dynamic subscription */
-  onData: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    sessionId: z20.string().max(128)
+  onData: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    sessionId: z21.string().max(128)
   })).subscription(async function* ({ input }) {
     const queue = [];
-    let resolve5 = null;
+    let resolve6 = null;
     let done = false;
     let unsubscribe;
     try {
@@ -10410,16 +10923,16 @@ var terminalRouter = router({
         { sessionId: input.sessionId },
         (data) => {
           if (typeof data === "string") queue.push(data);
-          if (resolve5) {
-            resolve5();
-            resolve5 = null;
+          if (resolve6) {
+            resolve6();
+            resolve6 = null;
           }
         },
         () => {
           done = true;
-          if (resolve5) {
-            resolve5();
-            resolve5 = null;
+          if (resolve6) {
+            resolve6();
+            resolve6 = null;
           }
         }
       );
@@ -10435,7 +10948,7 @@ var terminalRouter = router({
           yield queue.shift();
         } else {
           await new Promise((r) => {
-            resolve5 = r;
+            resolve6 = r;
           });
         }
       }
@@ -10446,27 +10959,27 @@ var terminalRouter = router({
 });
 
 // ../server/src/trpc/routers/utility.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var MAX_WAIT_MS = 5 * 60 * 1e3;
 var utilityRouter = router({
-  wait: protectedProcedure.input(z21.object({
-    ms: z21.number().int().min(0).max(MAX_WAIT_MS)
+  wait: protectedProcedure.input(z22.object({
+    ms: z22.number().int().min(0).max(MAX_WAIT_MS)
   })).mutation(async ({ input }) => {
-    await new Promise((resolve5) => setTimeout(resolve5, input.ms));
+    await new Promise((resolve6) => setTimeout(resolve6, input.ms));
     return { waited: input.ms };
   })
 });
 
 // ../server/src/trpc/routers/wiki.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 import { TRPCError as TRPCError18 } from "@trpc/server";
-import { readFile as readFile12, readdir as readdir5, stat as stat3, realpath, writeFile as writeFile10, mkdir as mkdir13, rename as rename9, rm as rm2 } from "fs/promises";
-import { resolve as resolvePath, join as join15, relative, sep as sep3, dirname as dirname3 } from "path";
-var SCOPE_SCHEMA = z22.union([
-  z22.literal("global"),
-  z22.string().regex(/^service:[A-Za-z0-9_-]{1,128}$/, "Invalid service scope")
+import { readFile as readFile13, readdir as readdir5, stat as stat3, realpath, writeFile as writeFile11, mkdir as mkdir14, rename as rename10, rm as rm2 } from "fs/promises";
+import { resolve as resolvePath, join as join16, relative, sep as sep3, dirname as dirname3 } from "path";
+var SCOPE_SCHEMA = z23.union([
+  z23.literal("global"),
+  z23.string().regex(/^service:[A-Za-z0-9_-]{1,128}$/, "Invalid service scope")
 ]);
-var REL_PATH_SCHEMA = z22.string().min(1).max(512).regex(/^[A-Za-z0-9_./-]+$/).refine((p) => !p.includes("..") && !p.startsWith("/"), {
+var REL_PATH_SCHEMA = z23.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;
@@ -10486,9 +10999,9 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "target",
   "out"
 ]);
-var DocsEntrySchema = z22.lazy(() => z22.union([
-  z22.object({ type: z22.literal("file"), name: z22.string(), path: z22.string() }),
-  z22.object({ type: z22.literal("dir"), name: z22.string(), path: z22.string(), children: z22.array(DocsEntrySchema) })
+var DocsEntrySchema = z23.lazy(() => z23.union([
+  z23.object({ type: z23.literal("file"), name: z23.string(), path: z23.string() }),
+  z23.object({ type: z23.literal("dir"), name: z23.string(), path: z23.string(), children: z23.array(DocsEntrySchema) })
 ]));
 async function resolveScope(scope) {
   if (scope === "global") {
@@ -10498,13 +11011,13 @@ async function resolveScope(scope) {
       throw new TRPCError18({ code: "BAD_REQUEST", message: "Sous-chemin invalide" });
     }
     const dataDirAbs = resolvePath(env.DATA_DIR);
-    await mkdir13(dataDirAbs, { recursive: true });
+    await mkdir14(dataDirAbs, { recursive: true });
     const base = dirname3(await realpath(dataDirAbs));
     const target = resolvePath(base, sub);
     if (target !== base && !(target + sep3).startsWith(base + sep3)) {
       throw new TRPCError18({ code: "FORBIDDEN", message: "Hors du dossier de donn\xE9es du serveur" });
     }
-    await mkdir13(target, { recursive: true });
+    await mkdir14(target, { recursive: true });
     const root = await realpath(target);
     if (root !== base && !(root + sep3).startsWith(base + sep3)) {
       throw new TRPCError18({ code: "FORBIDDEN", message: "Le dossier wiki r\xE9sout hors du dossier de donn\xE9es" });
@@ -10531,7 +11044,7 @@ async function walkLocal(root, dir, depth, counter) {
   for (const e of entries) {
     if (counter.n >= MAX_FILES) break;
     if (e.name.startsWith(".") && e.name !== ".") continue;
-    const abs = join15(dir, e.name);
+    const abs = join16(dir, e.name);
     const rel = relative(root, abs).split(sep3).join("/");
     if (e.isDirectory()) {
       if (IGNORED_DIRS.has(e.name)) continue;
@@ -10578,7 +11091,7 @@ async function resolveSafeLocal(root, relPath, requireExist) {
   return resolvePath(realParent, target.slice(parent.length).replace(/^[\\/]+/, ""));
 }
 var wikiRouter = router({
-  list: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA })).output(z22.object({ root: z22.string(), entries: z22.array(DocsEntrySchema), truncated: z22.boolean() })).query(async ({ input }) => {
+  list: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA })).output(z23.object({ root: z23.string(), entries: z23.array(DocsEntrySchema), truncated: z23.boolean() })).query(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentQuery(target.agentId, "wiki.listRepoMarkdown", { cwd: target.cwd });
@@ -10587,7 +11100,7 @@ var wikiRouter = router({
     const entries = await walkLocal(target.root, target.root, 0, counter);
     return { root: target.root, entries, truncated: counter.n >= MAX_FILES };
   }),
-  read: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).output(z22.object({ path: z22.string(), content: z22.string() })).query(async ({ input }) => {
+  read: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).output(z23.object({ path: z23.string(), content: z23.string() })).query(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -10599,10 +11112,10 @@ var wikiRouter = router({
     const s = await stat3(file);
     if (!s.isFile()) throw new TRPCError18({ code: "BAD_REQUEST", message: "Pas un fichier" });
     if (s.size > MAX_FILE_BYTES) throw new TRPCError18({ code: "PAYLOAD_TOO_LARGE", message: "Fichier trop volumineux" });
-    const content = await readFile12(file, "utf-8");
+    const content = await readFile13(file, "utf-8");
     return { path: input.path, content };
   }),
-  write: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA, content: z22.string().max(5e6) })).mutation(async ({ input }) => {
+  write: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA, content: z23.string().max(5e6) })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -10611,11 +11124,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 mkdir13(dirname3(file), { recursive: true });
-    await writeFile10(file, input.content, "utf-8");
+    await mkdir14(dirname3(file), { recursive: true });
+    await writeFile11(file, input.content, "utf-8");
     return { path: input.path, ok: true };
   }),
-  createFile: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createFile: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -10630,20 +11143,20 @@ var wikiRouter = router({
     } catch (err) {
       if (err instanceof TRPCError18) throw err;
     }
-    await mkdir13(dirname3(file), { recursive: true });
-    await writeFile10(file, "", "utf-8");
+    await mkdir14(dirname3(file), { recursive: true });
+    await writeFile11(file, "", "utf-8");
     return { path: input.path, ok: true };
   }),
-  createDir: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createDir: protectedProcedure.input(z23.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 mkdir13(dir, { recursive: true });
+    await mkdir14(dir, { recursive: true });
     return { path: input.path, ok: true };
   }),
-  rename: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, fromPath: REL_PATH_SCHEMA, toPath: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  rename: protectedProcedure.input(z23.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 });
@@ -10656,11 +11169,11 @@ var wikiRouter = router({
     } catch (err) {
       if (err instanceof TRPCError18) throw err;
     }
-    await mkdir13(dirname3(to), { recursive: true });
-    await rename9(from, to);
+    await mkdir14(dirname3(to), { recursive: true });
+    await rename10(from, to);
     return { fromPath: input.fromPath, toPath: input.toPath, ok: true };
   }),
-  ensureRoot: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA })).mutation(async ({ input }) => {
+  ensureRoot: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA })).mutation(async ({ input }) => {
     if (input.scope === "global") {
       await resolveScope("global");
       return { ok: true };
@@ -10673,7 +11186,7 @@ var wikiRouter = router({
     const cwd = (service.docsPath?.trim() || service.cwd || ".").toString();
     return agentManager.agentMutation(agentId, "wiki.ensureRoot", { cwd });
   }),
-  delete: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  delete: protectedProcedure.input(z23.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 });
@@ -10686,83 +11199,24 @@ var wikiRouter = router({
 });
 
 // ../server/src/trpc/routers/config.ts
-var configRouter = router({
-  cloud: publicProcedure.query(() => ({
-    apiUrl: env.CLOUD_URL,
-    appUrl: env.CLOUD_APP_URL
-  }))
-});
-
-// ../server/src/trpc/routers/cloud-sync.ts
-import { z as z24 } from "zod";
-import { TRPCError as TRPCError20 } from "@trpc/server";
-
-// ../server/src/services/cloud-sync-store.ts
-import { readFile as readFile13, writeFile as writeFile11, rename as rename10, mkdir as mkdir14, chmod as chmod8 } from "fs/promises";
-import { join as join16 } from "path";
-var FILENAME4 = "cloud-sync.json";
-var CloudSyncStore = class {
-  links = /* @__PURE__ */ new Map();
-  loaded = false;
-  getFilePath() {
-    return join16(env.DATA_DIR, FILENAME4);
-  }
-  async load() {
-    if (this.loaded) return;
-    try {
-      const raw = await readFile13(this.getFilePath(), "utf-8");
-      const data = JSON.parse(raw);
-      for (const l of data) this.links.set(l.orgId, { orgId: l.orgId, cloudUrl: l.cloudUrl });
-    } catch {
-    }
-    this.loaded = true;
-  }
-  async save() {
-    await mkdir14(env.DATA_DIR, { recursive: true });
-    const filePath = this.getFilePath();
-    const tmpPath = filePath + ".tmp";
-    const data = JSON.stringify(Array.from(this.links.values()), null, 2);
-    await writeFile11(tmpPath, data, "utf-8");
-    await rename10(tmpPath, filePath);
-    await chmod8(filePath, 384);
-  }
-  /** Store (or replace) the sync link for an organization. */
-  async upsert(orgId, cloudUrl) {
-    await this.load();
-    this.links.set(orgId, { orgId, cloudUrl });
-    await this.save();
-  }
-  async remove(orgId) {
-    await this.load();
-    if (this.links.delete(orgId)) await this.save();
-  }
-  /** All sync links (for the bridge on startup). */
-  async list() {
-    await this.load();
-    return Array.from(this.links.values());
-  }
-  async get(orgId) {
-    await this.load();
-    return this.links.get(orgId) ?? null;
-  }
-};
-var cloudSyncStore = new CloudSyncStore();
+var configRouter = router({
+  cloud: publicProcedure.query(() => ({
+    apiUrl: env.CLOUD_URL,
+    appUrl: env.CLOUD_APP_URL
+  }))
+});
 
-// ../server/src/services/cloud-sync-bridge.ts
-import { randomUUID as randomUUID10 } from "crypto";
-import * as Y from "yjs";
+// ../server/src/trpc/routers/cloud-sync.ts
+import { z as z24 } from "zod";
+import { TRPCError as TRPCError19 } from "@trpc/server";
 
-// ../server/src/services/cloud-session-store.ts
-import { readFile as readFile14, writeFile as writeFile12, rename as rename11, mkdir as mkdir15, chmod as chmod9, unlink as unlink3 } from "fs/promises";
-import { randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from "crypto";
+// ../server/src/services/cloud-sync-store.ts
+import { readFile as readFile14, writeFile as writeFile12, rename as rename11, mkdir as mkdir15, chmod as chmod9 } from "fs/promises";
 import { join as join17 } from "path";
-var FILENAME5 = "cloud-session.json";
-var STATE_TTL_MS = 5 * 60 * 1e3;
-var CloudSessionStore = class {
-  session = null;
+var FILENAME5 = "cloud-sync.json";
+var CloudSyncStore = class {
+  links = /* @__PURE__ */ new Map();
   loaded = false;
-  /** Pending login states (CSRF binding between `start` and the callback). */
-  pending = /* @__PURE__ */ new Map();
   getFilePath() {
     return join17(env.DATA_DIR, FILENAME5);
   }
@@ -10770,86 +11224,46 @@ var CloudSessionStore = class {
     if (this.loaded) return;
     try {
       const raw = await readFile14(this.getFilePath(), "utf-8");
-      this.session = JSON.parse(raw);
+      const data = JSON.parse(raw);
+      for (const l of data) this.links.set(l.orgId, { orgId: l.orgId, cloudUrl: l.cloudUrl });
     } catch {
     }
     this.loaded = true;
   }
-  /**
-   * Mint a state value binding a login attempt to this server. Returned to the
-   * cloud page and echoed back on the callback, so a redirect we never
-   * initiated cannot install a token.
-   */
-  createState(returnTo) {
-    this.sweepStates();
-    const state = randomBytes3(32).toString("hex");
-    this.pending.set(state, { expiresAt: Date.now() + STATE_TTL_MS, returnTo });
-    return state;
-  }
-  /**
-   * Consume a state — single use, constant-time compare, TTL enforced. Returns
-   * the URL to send the browser back to, or null when the state is unknown or
-   * expired (i.e. a callback this server never initiated).
-   */
-  consumeState(candidate) {
-    this.sweepStates();
-    for (const [state, entry] of this.pending) {
-      const a = Buffer.from(state);
-      const b = Buffer.from(candidate);
-      if (a.length === b.length && timingSafeEqual2(a, b)) {
-        this.pending.delete(state);
-        return entry.expiresAt > Date.now() ? entry.returnTo : null;
-      }
-    }
-    return null;
-  }
-  sweepStates() {
-    const now = Date.now();
-    for (const [state, entry] of this.pending) {
-      if (entry.expiresAt <= now) this.pending.delete(state);
-    }
-  }
   async save() {
     await mkdir15(env.DATA_DIR, { recursive: true });
     const filePath = this.getFilePath();
     const tmpPath = filePath + ".tmp";
-    await writeFile12(tmpPath, JSON.stringify(this.session, null, 2), "utf-8");
+    const data = JSON.stringify(Array.from(this.links.values()), null, 2);
+    await writeFile12(tmpPath, data, "utf-8");
     await rename11(tmpPath, filePath);
     await chmod9(filePath, 384);
   }
-  /** Store the session token obtained from the one-time-token exchange. */
-  async set(cloudUrl, token) {
+  /** Store (or replace) the sync link for an organization. */
+  async upsert(orgId, cloudUrl) {
     await this.load();
-    this.session = { cloudUrl, encryptedToken: encryptValue(token) };
+    this.links.set(orgId, { orgId, cloudUrl });
     await this.save();
   }
-  /** The decrypted session token, or null when not logged in. */
-  async getToken() {
+  async remove(orgId) {
     await this.load();
-    if (!this.session) return null;
-    try {
-      return decryptValue(this.session.encryptedToken);
-    } catch {
-      return null;
-    }
+    if (this.links.delete(orgId)) await this.save();
   }
-  async isLinked() {
-    return await this.getToken() !== null;
+  /** All sync links (for the bridge on startup). */
+  async list() {
+    await this.load();
+    return Array.from(this.links.values());
   }
-  /** Forget the session (sign-out). */
-  async clear() {
+  async get(orgId) {
     await this.load();
-    this.session = null;
-    this.pending.clear();
-    try {
-      await unlink3(this.getFilePath());
-    } catch {
-    }
+    return this.links.get(orgId) ?? null;
   }
 };
-var cloudSessionStore = new CloudSessionStore();
+var cloudSyncStore = new CloudSyncStore();
 
 // ../server/src/services/cloud-sync-bridge.ts
+import { randomUUID as randomUUID11 } from "crypto";
+import * as Y from "yjs";
 var LOCAL_ORIGIN = "local-bridge";
 var REMOTE_ORIGIN = "remote";
 var RECONNECT_DELAY_MS = 3e3;
@@ -10865,7 +11279,7 @@ var OrgSyncConnection = class {
   projects = getCollection(this.doc, "projects");
   services = getCollection(this.doc, "services");
   environments = getCollection(this.doc, "environments");
-  conn = randomUUID10();
+  conn = randomUUID11();
   link;
   stopped = false;
   initializing = true;
@@ -10965,7 +11379,7 @@ var OrgSyncConnection = class {
       await this.pushUpdate(diff);
     } catch (err) {
       if (err instanceof SyncAuthError) throw err;
-      console.error(`[cloud-sync] initial push failed for org ${this.link.orgId}:`, err.message);
+      console.error("[cloud-sync] initial push failed for org %s:", this.link.orgId, err.message);
     }
   }
   async pushUpdate(update) {
@@ -10983,7 +11397,7 @@ var OrgSyncConnection = class {
         this.abort?.abort();
         return;
       }
-      if (!this.stopped) console.error(`[cloud-sync] push failed for org ${this.link.orgId}:`, err.message);
+      if (!this.stopped) console.error("[cloud-sync] push failed for org %s:", this.link.orgId, err.message);
     }
   }
   /**
@@ -11005,7 +11419,7 @@ var OrgSyncConnection = class {
           await this.delay(UNAUTHENTICATED_RETRY_MS);
           continue;
         }
-        if (!this.stopped) console.error(`[cloud-sync] stream error for org ${this.link.orgId}:`, err.message);
+        if (!this.stopped) console.error("[cloud-sync] stream error for org %s:", this.link.orgId, err.message);
       }
       await this.delay(RECONNECT_DELAY_MS);
     }
@@ -11095,7 +11509,7 @@ var OrgSyncConnection = class {
       });
       await projectStore.addEnvironment(projectId, localEnv.id);
     } catch (err) {
-      console.error(`[cloud-sync] env bootstrap failed for project ${projectId}:`, err.message);
+      console.error("[cloud-sync] env bootstrap failed for project %s:", projectId, err.message);
     }
   }
   /**
@@ -11198,7 +11612,7 @@ var CloudSyncBridge = class {
     try {
       await conn.start();
     } catch (err) {
-      console.error(`[cloud-sync] failed to start org ${link.orgId}:`, err.message);
+      console.error("[cloud-sync] failed to start org %s:", link.orgId, err.message);
     }
   }
   disconnect(orgId) {
@@ -11215,113 +11629,6 @@ var CloudSyncBridge = class {
 };
 var cloudSyncBridge = new CloudSyncBridge();
 
-// ../server/src/trpc/routers/cloud-auth.ts
-import { z as z23 } from "zod";
-import { TRPCError as TRPCError19 } from "@trpc/server";
-var DEFAULT_CLOUD_API_URL = "https://api.runeya.dev";
-var DEFAULT_CLOUD_APP_URL = "https://runeya.dev";
-function getCloudApiUrl() {
-  return (env.CLOUD_URL ?? DEFAULT_CLOUD_API_URL).replace(/\/+$/, "");
-}
-function getCloudAppUrl() {
-  return (env.CLOUD_APP_URL ?? DEFAULT_CLOUD_APP_URL).replace(/\/+$/, "");
-}
-function isLocalOrigin(url) {
-  try {
-    const { protocol, hostname } = new URL(url);
-    return (protocol === "http:" || protocol === "https:") && (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]");
-  } catch {
-    return false;
-  }
-}
-async function cloudFetch(path, init = {}) {
-  const token = await cloudSessionStore.getToken();
-  if (!token) {
-    throw new TRPCError19({ code: "UNAUTHORIZED", message: "Not linked to the Runeya cloud." });
-  }
-  return fetch(`${getCloudApiUrl()}${path}`, {
-    method: init.method ?? "GET",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      ...init.body !== void 0 ? { "Content-Type": "application/json" } : {}
-    },
-    ...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
-    signal: AbortSignal.timeout(15e3)
-  });
-}
-var PROXY_PREFIXES = ["/organization/", "/project/", "/chat/", "/user/prefs"];
-function isAllowedProxyPath(path) {
-  if (!path.startsWith("/") || path.includes("..")) return false;
-  const [pathname] = path.split("?");
-  return PROXY_PREFIXES.some((p) => pathname === p || pathname.startsWith(p));
-}
-var cloudAuthRouter = router({
-  /** Build the cloud authorization URL to open in the browser. */
-  startLogin: protectedProcedure.input(z23.object({ returnTo: z23.string().url().max(2048) })).mutation(async ({ input }) => {
-    if (!isLocalOrigin(input.returnTo)) {
-      throw new TRPCError19({ code: "BAD_REQUEST", message: "returnTo must be a local origin." });
-    }
-    const state = cloudSessionStore.createState(input.returnTo);
-    const callback = `http://127.0.0.1:${env.PORT}/api/cloud/callback`;
-    const url = `${getCloudAppUrl()}/link-local?callback=${encodeURIComponent(callback)}&state=${encodeURIComponent(state)}`;
-    return { url };
-  }),
-  /** Whether this machine holds a cloud session. */
-  status: protectedProcedure.query(async () => {
-    return { linked: await cloudSessionStore.isLinked() };
-  }),
-  /** The cloud session (user + org), fetched with the stored token. */
-  session: protectedProcedure.query(async () => {
-    if (!await cloudSessionStore.isLinked()) return null;
-    const res = await cloudFetch("/api/auth/get-session");
-    if (!res.ok) return null;
-    return await res.json();
-  }),
-  /**
-   * Forward a cloud API call, authenticated with this machine's token.
-   *
-   * This is what replaces the browser's direct, cookie-authenticated calls to
-   * the cloud: the web UI asks its own server, which holds the credential.
-   */
-  proxy: protectedProcedure.input(
-    z23.object({
-      path: z23.string().min(1).max(512),
-      method: z23.enum(["GET", "POST"]).default("GET"),
-      query: z23.record(z23.string().max(128), z23.string().max(2048)).optional(),
-      body: z23.unknown().optional()
-    })
-  ).mutation(async ({ input }) => {
-    if (!isAllowedProxyPath(input.path)) {
-      throw new TRPCError19({ code: "FORBIDDEN", message: `Path not allowed: ${input.path}` });
-    }
-    const qs = input.query ? `?${new URLSearchParams(input.query).toString()}` : "";
-    const res = await cloudFetch(`/api/auth${input.path}${qs}`, {
-      method: input.method,
-      ...input.method === "POST" ? { body: input.body ?? {} } : {}
-    });
-    const text = await res.text();
-    let data = null;
-    try {
-      data = text ? JSON.parse(text) : null;
-    } catch {
-      data = text;
-    }
-    if (!res.ok) return { data: null, error: { status: res.status, ...data } };
-    return { data, error: null };
-  }),
-  /** Drop the cloud session, both here and on the cloud. */
-  signOut: protectedProcedure.mutation(async () => {
-    if (await cloudSessionStore.isLinked()) {
-      try {
-        await cloudFetch("/api/auth/sign-out", { method: "POST", body: {} });
-      } catch {
-      }
-    }
-    await cloudSessionStore.clear();
-    return { success: true };
-  })
-});
-
 // ../server/src/services/master-password.ts
 import { randomBytes as randomBytes4, createCipheriv, createDecipheriv } from "crypto";
 import { readFile as readFile15, writeFile as writeFile13, chmod as chmod10, stat as stat4, rename as rename12 } from "fs/promises";
@@ -11492,25 +11799,25 @@ async function hasEncryptedKeyFile(dataDir) {
 async function reconcileOrgCanary(orgId) {
   const key = getEncryptionKey();
   if (!key) {
-    throw new TRPCError20({ code: "PRECONDITION_FAILED", message: "Encryption key not loaded." });
+    throw new TRPCError19({ code: "PRECONDITION_FAILED", message: "Encryption key not loaded." });
   }
   const local = await readVerifyFile(env.DATA_DIR);
   if (!local) {
-    throw new TRPCError20({ code: "PRECONDITION_FAILED", message: "This machine has no key canary yet." });
+    throw new TRPCError19({ code: "PRECONDITION_FAILED", message: "This machine has no key canary yet." });
   }
   const res = await cloudFetch("/api/auth/organization/canary", {
     method: "POST",
     body: { organizationId: orgId, canary: local }
   });
   if (!res.ok) {
-    throw new TRPCError20({ code: "BAD_GATEWAY", message: "Could not reach the organization on the cloud." });
+    throw new TRPCError19({ code: "BAD_GATEWAY", message: "Could not reach the organization on the cloud." });
   }
   const { canary } = await res.json();
   if (typeof canary !== "string") {
-    throw new TRPCError20({ code: "BAD_GATEWAY", message: "The cloud returned no key canary." });
+    throw new TRPCError19({ code: "BAD_GATEWAY", message: "The cloud returned no key canary." });
   }
   if (!matchesCanary(canary, key)) {
-    throw new TRPCError20({
+    throw new TRPCError19({
       code: "FORBIDDEN",
       message: "This organization uses a different encryption key. Ask a member for the key already in use, then set it up on this machine before syncing."
     });
@@ -11572,8 +11879,8 @@ var appRouter = router({
   scenario: scenarioRouter,
   git: gitRouter,
   debug: debugRouter,
-  kanban: kanbanRouter,
   kanbanQueue: kanbanQueueRouter,
+  kanban: kanbanRouter,
   terminal: terminalRouter,
   utility: utilityRouter,
   wiki: wikiRouter,
@@ -11689,7 +11996,7 @@ async function ensureDataGitignore(dataDir) {
 // ../server/src/migrations/migrate-from-legacy.ts
 import { createRequire } from "module";
 import { randomBytes as randomBytes5, createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2 } from "crypto";
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import {
   readFile as readFile16,
   writeFile as writeFile15,
@@ -11831,8 +12138,8 @@ async function atomicWrite(path, data) {
   await rename13(tmp, path);
 }
 async function runLegacyMigration(dataDir) {
-  const { resolve: resolve5 } = await import("path");
-  const abCwd = resolve5(process.cwd());
+  const { resolve: resolve6 } = await import("path");
+  const abCwd = resolve6(process.cwd());
   const legacyRoot = join21(abCwd, env.DATA_DIR);
   const legacyKeyPath = join21(legacyRoot, "dbs", "encryption-key.json");
   try {
@@ -11901,11 +12208,11 @@ async function runLegacyMigration(dataDir) {
     const data = await readEncrypted(join21(parsersDir, file));
     if (data?.id) legacyParsers.push(data);
   }
-  const projectMonoId = randomUUID11();
+  const projectMonoId = randomUUID12();
   const envIdMap = {};
   const labelToKey = {};
   for (const [name, legacyEnv] of Object.entries(legacyEnvs)) {
-    envIdMap[name] = randomUUID11();
+    envIdMap[name] = randomUUID12();
     if (legacyEnv?.label) labelToKey[legacyEnv.label] = name;
   }
   const runeEnvs = [];
@@ -11930,7 +12237,7 @@ async function runLegacyMigration(dataDir) {
         if (hasInvalidInterpolation(value)) continue;
         const cleaned = cleanVarKey(key);
         if (inheritedVars[cleaned] === value) continue;
-        const varId = randomUUID11();
+        const varId = randomUUID12();
         variables[varId] = makeVariable(cleaned, value);
         varIdLookup.set(`${envIdMap[name]}:${cleaned}`, varId);
       }
@@ -11951,7 +12258,7 @@ async function runLegacyMigration(dataDir) {
   const serviceIdMap = {};
   const runeServices = [];
   for (const [name, legacy] of Object.entries(legacyServices)) {
-    const id = randomUUID11();
+    const id = randomUUID12();
     serviceIdMap[name] = id;
     const rootPath = legacy.rootPath || "";
     const rootPathCwd = rootPath && rootPath !== "." ? rootPath : "";
@@ -11960,7 +12267,7 @@ async function runLegacyMigration(dataDir) {
       const parts = [cmd.spawnCmd, ...cmd.spawnArgs || []].filter(Boolean);
       if (!parts.length) continue;
       commands.push({
-        id: cmd.id || randomUUID11(),
+        id: cmd.id || randomUUID12(),
         label: "Launch",
         command: parts.join(" "),
         cwd: cmd.spawnOptions?.cwd || "",
@@ -12021,7 +12328,7 @@ async function runLegacyMigration(dataDir) {
       const legacyBootstrapCmds = container.bootstrap?.commands || [];
       if (legacyBootstrapCmds.length > 0) {
         dockerConfig.bootstrapCommands = legacyBootstrapCmds.filter((bs) => bs.cmd || bs.entrypoint).map((bs, idx) => ({
-          id: bs.id || randomUUID11(),
+          id: bs.id || randomUUID12(),
           label: bs.label || `Bootstrap ${idx + 1}`,
           command: bs.cmd || "",
           ...bs.entrypoint ? { entrypoint: bs.entrypoint } : {},
@@ -12069,7 +12376,7 @@ async function runLegacyMigration(dataDir) {
       cwd: serviceCwd,
       runner: dockerConfig ? "docker" : "native",
       shortcuts: (legacy.shortcuts || []).filter((s) => s.spawnCmd || s.label).map((s) => ({
-        id: s.id || randomUUID11(),
+        id: s.id || randomUUID12(),
         label: s.label || s.spawnCmd || "",
         command: [s.spawnCmd, ...s.spawnArgs || []].filter(Boolean).join(" "),
         ...s.spawnOptions?.cwd ? { cwd: s.spawnOptions.cwd } : {}
@@ -12109,7 +12416,7 @@ async function runLegacyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID11(),
+          id: randomUUID12(),
           projectId: projectMonoId,
           name: `${service?.name || name} (${globalEnv.name})`,
           scope: "service",
@@ -12133,7 +12440,7 @@ async function runLegacyMigration(dataDir) {
         const varPost = typeof varData === "object" ? String(varData.suffix ?? "") : "";
         if (!varKey || existingKeys.has(cleanVarKey(varKey))) continue;
         const cleaned = cleanVarKey(varKey);
-        const varId = randomUUID11();
+        const varId = randomUUID12();
         svcScopedEnv.variables[varId] = makeVariable(cleaned, varValue, varPre, varPost);
         existingKeys.add(cleaned);
       }
@@ -12153,7 +12460,7 @@ async function runLegacyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID11(),
+          id: randomUUID12(),
           projectId: projectMonoId,
           name: `${service?.name || serviceName} (${globalEnv.name})`,
           scope: "service",
@@ -12174,7 +12481,7 @@ async function runLegacyMigration(dataDir) {
         const baseEntry = Object.entries(svcScopedEnv.variables).find(([, v]) => v.key === cleaned);
         let varId = baseEntry?.[0];
         if (!varId) {
-          varId = randomUUID11();
+          varId = randomUUID12();
           svcScopedEnv.variables[varId] = {
             key: cleaned,
             value: { value: "", pre: "", post: "", isSecret: false, injectIntoAi: false }
@@ -12204,13 +12511,13 @@ async function runLegacyMigration(dataDir) {
             flatOverrides[varId] = makeVariable(cleaned, value);
           }
         } else {
-          flatOverrides[randomUUID11()] = makeVariable(cleaned, value);
+          flatOverrides[randomUUID12()] = makeVariable(cleaned, value);
         }
       } else {
         const cleaned = cleanVarKey(key);
         const existingVarId = Object.entries(env2.variables).find(([, v]) => v.key === cleaned)?.[0];
         if (!existingVarId) {
-          const varId = randomUUID11();
+          const varId = randomUUID12();
           env2.variables[varId] = makeVariable(cleaned, value);
           varIdLookup.set(`${envId}:${cleaned}`, varId);
         }
@@ -12298,9 +12605,9 @@ async function findLegacyKeyInBackup(dataDir) {
   return null;
 }
 async function runOverrideOnlyMigration(dataDir) {
-  const { resolve: resolve5 } = await import("path");
-  const abDataDir = resolve5(dataDir);
-  const abCwd = resolve5(process.cwd());
+  const { resolve: resolve6 } = await import("path");
+  const abDataDir = resolve6(dataDir);
+  const abCwd = resolve6(process.cwd());
   const candidateDirs = [
     join21(abCwd, ".runeya", "dbs", "overrides"),
     join21(abDataDir, "dbs", "overrides")
@@ -12395,7 +12702,7 @@ async function runOverrideOnlyMigration(dataDir) {
         if (isSameAsBase(value, baseVar)) continue;
         flatOverrides[varId] = makeVariable(cleaned, value);
       } else {
-        flatOverrides[randomUUID11()] = makeVariable(cleaned, value);
+        flatOverrides[randomUUID12()] = makeVariable(cleaned, value);
       }
     }
   }
@@ -12432,7 +12739,7 @@ async function runOverrideOnlyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID11(),
+          id: randomUUID12(),
           projectId: globalEnv["projectId"],
           name: `${service?.["name"] || serviceName} (${globalEnv["name"]})`,
           scope: "service",
@@ -12454,7 +12761,7 @@ async function runOverrideOnlyMigration(dataDir) {
         const baseEntry = Object.entries(svcScopedEnv["variables"]).find(([, v]) => v.key === cleaned);
         let varId = baseEntry?.[0];
         if (!varId) {
-          varId = randomUUID11();
+          varId = randomUUID12();
           svcScopedEnv["variables"][varId] = {
             key: cleaned,
             value: { value: "", pre: "", post: "", isSecret: false, injectIntoAi: false }
@@ -12903,7 +13210,7 @@ async function createLocalServer() {
     }
   }
   if (!existsSync2(env.DATA_DIR)) await mkdir17(env.DATA_DIR);
-  const absoluteDataDir = resolve4(env.DATA_DIR);
+  const absoluteDataDir = resolve5(env.DATA_DIR);
   console.log(`[server] Data directory: ${absoluteDataDir}`);
   await ensureDataGitignore(env.DATA_DIR);
   await settingsManager.getSettings();
@@ -13012,7 +13319,102 @@ async function createLocalServer() {
       res.status(502).send("Could not reach the Runeya cloud.");
     }
   });
-  app.get("/api/cloud/chat/stream", async (req, res) => {
+  function proxyCloudStream(localPath, upstreamPath) {
+    app.get(localPath, async (req, res) => {
+      const jwt = typeof req.query["token"] === "string" ? req.query["token"] : "";
+      try {
+        await verifyJwt(jwt);
+      } catch {
+        res.status(401).end();
+        return;
+      }
+      const organizationId = typeof req.query["organizationId"] === "string" ? req.query["organizationId"] : "";
+      if (!organizationId) {
+        res.status(400).end();
+        return;
+      }
+      const token = await cloudSessionStore.getToken();
+      if (!token) {
+        res.status(401).end();
+        return;
+      }
+      const upstreamAbort = new AbortController();
+      req.on("close", () => upstreamAbort.abort());
+      try {
+        const upstream = await fetch(
+          `${getCloudApiUrl()}${upstreamPath}?organizationId=${encodeURIComponent(organizationId)}`,
+          {
+            headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" },
+            signal: upstreamAbort.signal
+          }
+        );
+        if (!upstream.ok || !upstream.body) {
+          res.status(upstream.status === 401 ? 401 : 502).end();
+          return;
+        }
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          "X-Accel-Buffering": "no"
+        });
+        const reader = upstream.body.getReader();
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(value);
+        }
+        res.end();
+      } catch {
+        if (!res.headersSent) res.status(502).end();
+        else res.end();
+      }
+    });
+  }
+  app.post(
+    "/api/cloud/kanban/image",
+    express.raw({ type: () => true, limit: "64mb" }),
+    async (req, res) => {
+      const jwt = typeof req.query["token"] === "string" ? req.query["token"] : "";
+      try {
+        await verifyJwt(jwt);
+      } catch {
+        res.status(401).end();
+        return;
+      }
+      const organizationId = typeof req.query["organizationId"] === "string" ? req.query["organizationId"] : "";
+      if (!organizationId) {
+        res.status(400).end();
+        return;
+      }
+      const token = await cloudSessionStore.getToken();
+      if (!token) {
+        res.status(401).end();
+        return;
+      }
+      const upstreamQuery = new URLSearchParams({ organizationId });
+      if (typeof req.query["name"] === "string") upstreamQuery.set("name", req.query["name"]);
+      try {
+        const upstream = await fetch(
+          `${getCloudApiUrl()}/api/kanban/image?${upstreamQuery.toString()}`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${token}`,
+              "Content-Type": String(req.headers["content-type"] ?? "application/octet-stream")
+            },
+            body: req.body,
+            // A 55 MB body over a home upstream link takes minutes, not seconds.
+            signal: AbortSignal.timeout(3e5)
+          }
+        );
+        res.status(upstream.status).json(await upstream.json().catch(() => ({})));
+      } catch {
+        res.status(502).json({ error: "upload-failed" });
+      }
+    }
+  );
+  app.delete("/api/cloud/kanban/file/:id", async (req, res) => {
     const jwt = typeof req.query["token"] === "string" ? req.query["token"] : "";
     try {
       await verifyJwt(jwt);
@@ -13020,9 +13422,27 @@ async function createLocalServer() {
       res.status(401).end();
       return;
     }
-    const organizationId = typeof req.query["organizationId"] === "string" ? req.query["organizationId"] : "";
-    if (!organizationId) {
-      res.status(400).end();
+    const token = await cloudSessionStore.getToken();
+    if (!token) {
+      res.status(401).end();
+      return;
+    }
+    try {
+      const upstream = await fetch(
+        `${getCloudApiUrl()}/api/kanban/file/${encodeURIComponent(req.params.id)}`,
+        { method: "DELETE", headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(15e3) }
+      );
+      res.status(upstream.status).end();
+    } catch {
+      res.status(502).end();
+    }
+  });
+  app.get("/api/cloud/kanban/file/:id", async (req, res) => {
+    const jwt = typeof req.query["token"] === "string" ? req.query["token"] : "";
+    try {
+      await verifyJwt(jwt);
+    } catch {
+      res.status(401).end();
       return;
     }
     const token = await cloudSessionStore.getToken();
@@ -13030,38 +13450,27 @@ async function createLocalServer() {
       res.status(401).end();
       return;
     }
-    const upstreamAbort = new AbortController();
-    req.on("close", () => upstreamAbort.abort());
     try {
       const upstream = await fetch(
-        `${getCloudApiUrl()}/api/chat/stream?organizationId=${encodeURIComponent(organizationId)}`,
-        {
-          headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" },
-          signal: upstreamAbort.signal
-        }
+        `${getCloudApiUrl()}/api/kanban/file/${encodeURIComponent(req.params.id)}`,
+        { headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(3e5) }
       );
-      if (!upstream.ok || !upstream.body) {
-        res.status(upstream.status === 401 ? 401 : 502).end();
+      if (!upstream.ok) {
+        res.status(upstream.status).end();
         return;
       }
-      res.writeHead(200, {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-        "X-Accel-Buffering": "no"
-      });
-      const reader = upstream.body.getReader();
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        res.write(value);
-      }
-      res.end();
+      res.set("Content-Type", upstream.headers.get("content-type") ?? "application/octet-stream");
+      const disposition = upstream.headers.get("content-disposition");
+      if (disposition) res.set("Content-Disposition", disposition);
+      res.set("X-Content-Type-Options", "nosniff");
+      res.set("Content-Security-Policy", "default-src 'none'; sandbox");
+      res.send(Buffer.from(await upstream.arrayBuffer()));
     } catch {
-      if (!res.headersSent) res.status(502).end();
-      else res.end();
+      res.status(502).end();
     }
   });
+  proxyCloudStream("/api/cloud/chat/stream", "/api/chat/stream");
+  proxyCloudStream("/api/cloud/kanban/stream", "/api/kanban/stream");
   app.post("/api/unlock", authLimiter, csrfMiddleware, express.json({ limit: "10kb" }), async (req, res) => {
     try {
       const body = req.body;
@@ -13242,7 +13651,18 @@ async function createLocalServer() {
   });
   const CONV_ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
   const IMAGE_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  app.post("/api/images/upload", upload.single("image"), async (req, res) => {
+  const uploadSingleImage = (req, res, next) => {
+    upload.single("image")(req, res, (err) => {
+      if (err) {
+        const isTooLarge = err.code === "LIMIT_FILE_SIZE";
+        const message = err instanceof Error ? err.message : "Upload failed";
+        res.status(isTooLarge ? 413 : 400).json({ error: message });
+        return;
+      }
+      next();
+    });
+  };
+  app.post("/api/images/upload", uploadSingleImage, async (req, res) => {
     try {
       if (!req.file) {
         res.status(400).json({ error: "No image file provided" });
@@ -13280,7 +13700,7 @@ async function createLocalServer() {
         res.status(400).json({ error: "Invalid imageId" });
         return;
       }
-      const result = await imageStorageService.getImagePath(imageId);
+      const result = await imageStorageService.getImagePath(imageId, conversationId);
       if (!result) {
         res.status(404).json({ error: "Image not found" });
         return;
@@ -13362,6 +13782,7 @@ async function createLocalServer() {
   const shutdown = async () => {
     console.log("[server] Shutting down...");
     clearInterval(wsTickInterval);
+    stopClaudeTranscriptWatcher();
     imageCleanupService.stop();
     cloudSyncBridge.stopAll();
     await Promise.all([
@@ -13370,12 +13791,12 @@ async function createLocalServer() {
     ]);
     server.closeAllConnections();
     await Promise.race([
-      new Promise((resolve5) => wss.close(() => resolve5())),
-      new Promise((resolve5) => setTimeout(resolve5, 2e3))
+      new Promise((resolve6) => wss.close(() => resolve6())),
+      new Promise((resolve6) => setTimeout(resolve6, 2e3))
     ]);
     await Promise.race([
-      new Promise((resolve5) => server.close(() => resolve5())),
-      new Promise((resolve5) => setTimeout(resolve5, 2e3))
+      new Promise((resolve6) => server.close(() => resolve6())),
+      new Promise((resolve6) => setTimeout(resolve6, 2e3))
     ]);
     console.log("[server] Shutdown complete");
   };
@@ -13396,7 +13817,7 @@ var PullEnvError = class extends Error {
 };
 async function promptPassword() {
   process.stderr.write("Master password: ");
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const stdin = process.stdin;
     const wasRaw = stdin.isRaw;
     if (stdin.isTTY) stdin.setRawMode(true);
@@ -13409,7 +13830,7 @@ async function promptPassword() {
         stdin.pause();
         stdin.removeListener("data", onData);
         process.stderr.write("\n");
-        resolve5(input);
+        resolve6(input);
       } else if (ch === "") {
         process.exit(1);
       } else if (ch === "\x7F" || ch === "\b") {
@@ -13466,13 +13887,13 @@ async function pullEnv(opts) {
 
 // ../server/src/index.ts
 dotenv.config({ quiet: true });
-if (process.env["DATA_DIR"]) {
-  const resolved = resolvePath2(process.env["DATA_DIR"], "..");
+if (process.env["RUNEYA_DATA_DIR"]) {
+  const resolved = resolvePath2(process.env["RUNEYA_DATA_DIR"], "..");
   process.chdir(resolved);
-  console.log(`[server] Working directory: ${resolved} (from DATA_DIR)`);
+  console.log(`[server] Working directory: ${resolved} (from RUNEYA_DATA_DIR)`);
 }
 function listenWithRetry(server, port, host, wss, maxRetries = 20, delay = 500) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let attempts = 0;
     const wssErrorHandler = () => {
     };
@@ -13493,7 +13914,7 @@ function listenWithRetry(server, port, host, wss, maxRetries = 20, delay = 500)
       server.listen(port, host, () => {
         server.removeListener("error", onError);
         wss?.removeListener("error", wssErrorHandler);
-        resolve5();
+        resolve6();
       });
     };
     tryListen();
@@ -13540,4 +13961,4 @@ export {
   createLocalServer,
   pullEnv
 };
-//# sourceMappingURL=src-K32WI425.js.map
+//# sourceMappingURL=src-EGBDYHL5.js.map