@runeya/runeya 2.0.102 → 2.0.103

package/{src-HZ2XO6TV.js → src-V7DPPFCF.js}

@@ -57,7 +57,11 @@ import {
   shutdownCodexAppServer,
   startCliSession,
   vaultOfProject
-} from "./chunk-BDVQB5RK.js";
+} from "./chunk-UYOWIH4R.js";
+import {
+  resolveCliInvocation,
+  whichCommand
+} from "./chunk-B7MABGQN.js";
 import {
   LocalProjectExistsError,
   activeSessionRegistry,
@@ -76,12 +80,7 @@ import {
   stopClaudeTranscriptWatcher,
   stopCodexTranscriptWatcher,
   verifyJwt
-} from "./chunk-PSTMO7EE.js";
-import "./chunk-MD3VW4HQ.js";
-import {
-  resolveCliInvocation,
-  whichCommand
-} from "./chunk-B7MABGQN.js";
+} from "./chunk-NZNIWJDT.js";
 import {
   agentManager,
   agentSpawner,
@@ -107,6 +106,7 @@ import {
   listInstances,
   loadFromEnv,
   markVaultLocked,
+  onVaultUnlocked,
   projectKey,
   registerInstance,
   restartInstance,
@@ -118,10 +118,29 @@ import {
   stableEncryptValue,
   traefikManager,
   unregisterInstance
-} from "./chunk-BHLCBARP.js";
+} from "./chunk-QIBUMYR6.js";
 import {
   settingsManager
-} from "./chunk-F3HKV5AU.js";
+} from "./chunk-Z67WBWKD.js";
+import {
+  env,
+  forgetOrgLogo,
+  keyRoot,
+  legacyMachineFilePath,
+  legacyVaultRoot,
+  listCloudVaults,
+  listOrgVaults,
+  machineFilePath,
+  machineRoot,
+  orgVaultRoot,
+  projectVaultRoot,
+  readOrgClouds,
+  readOrgLogos,
+  readOrgNames,
+  rememberOrgLogo,
+  rememberOrgName,
+  stampOrgCloud
+} from "./chunk-KY6KYSOU.js";
 import {
   AGENT_LONG_FETCH_TIMEOUT,
   AGENT_STOP_FETCH_TIMEOUT,
@@ -145,28 +164,14 @@ import {
   UpdateEnvironmentSchema,
   VariableOverrideSchema,
   VariableSchema,
-  env,
-  forgetOrgLogo,
+  deriveLauncherIdentity,
   getCollection,
-  keyRoot,
-  legacyMachineFilePath,
-  legacyVaultRoot,
-  listCloudVaults,
-  listOrgVaults,
-  machineFilePath,
-  machineRoot,
   nativeParsers,
-  orgVaultRoot,
-  projectVaultRoot,
+  primaryServiceLink,
   readEntity,
-  readOrgClouds,
-  readOrgLogos,
-  readOrgNames,
-  rememberOrgLogo,
-  rememberOrgName,
-  stampOrgCloud,
   writeEntity
-} from "./chunk-NDO5VFZY.js";
+} from "./chunk-QRMG6GMX.js";
+import "./chunk-MD3VW4HQ.js";
 
 // ../server/src/create-server.ts
 import express from "express";
@@ -319,8 +324,8 @@ function resolveNpm() {
     // Unix : node est dans `bin/`, npm sous `lib/node_modules/`.
     join(nodeDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
   ];
-  for (const cli of candidates) {
-    if (existsSync(cli)) return { command: process.execPath, args: [cli], shell: false };
+  for (const cli2 of candidates) {
+    if (existsSync(cli2)) return { command: process.execPath, args: [cli2], shell: false };
   }
   return process.platform === "win32" ? { command: "npm.cmd", args: [], shell: true } : { command: "npm", args: [], shell: false };
 }
@@ -484,6 +489,27 @@ var changelogRouter = router({
 import { z as z4 } from "zod";
 import { TRPCError as TRPCError2 } from "@trpc/server";
 
+// ../server/src/services/current-project.ts
+var current = null;
+var listeners = /* @__PURE__ */ new Set();
+function getCurrentProject() {
+  return current;
+}
+function setCurrentProject(next) {
+  if (current?.id === next?.id && current?.orgId === next?.orgId) return;
+  current = next;
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+}
+function onCurrentProjectChanged(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
 // ../server/src/services/org-keys.ts
 import { mkdir } from "fs/promises";
 
@@ -974,6 +1000,18 @@ var projectRouter = router({
    * machine, and the cloud sync pushes projects wholesale — a path stored on the
    * project itself would travel with it.
    */
+  /**
+   * Le projet que cet onglet regarde.
+   *
+   * Le choix vit dans le navigateur ; le serveur ne le connaîtrait pas sans
+   * cette annonce. Il n'en fait rien de persistant — seule l'icône de barre
+   * système s'en sert, pour montrer les services du projet ouvert plutôt que
+   * ceux de toute la machine.
+   */
+  setCurrent: protectedProcedure.input(z4.object({ id: z4.string().max(128), orgId: z4.string().max(128).nullable().default(null) }).nullable()).mutation(({ input }) => {
+    setCurrentProject(input ? { id: input.id, orgId: input.orgId } : null);
+    return { ok: true };
+  }),
   localPaths: protectedProcedure.query(async () => {
     return projectPathStore.all();
   }),
@@ -1180,7 +1218,93 @@ var agentRouter = router({
 
 // ../server/src/trpc/routers/process.ts
 import { z as z6 } from "zod";
+import { TRPCError as TRPCError5 } from "@trpc/server";
+
+// ../server/src/services/process-control.ts
 import { TRPCError as TRPCError4 } from "@trpc/server";
+async function resolveTarget(processId, fallbackAgentId) {
+  const service = await serviceStore.get(processId) ?? null;
+  const agentId = (service ? await resolveEffectiveAgentId(service) : null) ?? fallbackAgentId ?? null;
+  if (!agentId) {
+    throw new TRPCError4({
+      code: "BAD_REQUEST",
+      message: "No agent assigned to this service. Set an agent on the service or on the active environment."
+    });
+  }
+  return { agentId, service };
+}
+async function deployBefore(processId, agentId, service, step) {
+  if (service) {
+    try {
+      const resolved = await resolveServiceVariables(service);
+      await agentManager.agentMutation(agentId, "process.deploy", resolved);
+    } catch (err) {
+      console.debug(`[process-control] Failed to deploy before ${step} for`, processId + ":", err.message);
+    }
+  }
+  if (service?.clearLogsOnStart) {
+    try {
+      await agentManager.agentMutation(agentId, "process.clearLogBuffer", { id: processId });
+      agentManager.emit("process:log", { agentId, batch: [{ processId, __clearLogBuffer: true }] });
+    } catch (err) {
+      console.debug(`[process-control] Failed to clear logs before ${step} for`, processId + ":", err.message);
+    }
+  }
+}
+async function startProcess(processId, fallbackAgentId) {
+  const { agentId, service } = await resolveTarget(processId, fallbackAgentId);
+  await deployBefore(processId, agentId, service, "start");
+  let result;
+  try {
+    result = await agentManager.agentMutation(agentId, "process.start", { id: processId });
+  } catch (err) {
+    const err_ = err;
+    const isFetchError = err_?.cause?.code === "ECONNREFUSED" || err_?.message === "fetch failed" || err_?.name === "TypeError";
+    throw new TRPCError4({
+      code: "INTERNAL_SERVER_ERROR",
+      message: isFetchError ? `Cannot reach agent \u2014 make sure the agent is running` : err_?.message ?? "Failed to start process"
+    });
+  }
+  await auditService.log({ userId: "local", action: "start", entityType: "process", entityId: processId, metadata: { agentId } });
+  return { ...result, agentId };
+}
+async function stopProcess(processId, agentId) {
+  const result = await agentManager.agentMutation(
+    agentId,
+    "process.stop",
+    { id: processId },
+    AGENT_STOP_FETCH_TIMEOUT
+  );
+  await auditService.log({ userId: "local", action: "stop", entityType: "process", entityId: processId, metadata: { agentId } });
+  return { ...result, agentId };
+}
+async function restartProcess(processId, fallbackAgentId) {
+  const { agentId, service } = await resolveTarget(processId, fallbackAgentId);
+  try {
+    await agentManager.agentMutation(agentId, "process.stop", { id: processId }, AGENT_STOP_FETCH_TIMEOUT);
+  } catch (err) {
+    console.debug("[process-control] Stop before restart ignored (process not found on agent?):", err.message);
+  }
+  await deployBefore(processId, agentId, service, "restart");
+  const result = await agentManager.agentMutation(agentId, "process.start", { id: processId });
+  await auditService.log({ userId: "local", action: "restart", entityType: "process", entityId: processId, metadata: { agentId } });
+  return { ...result, agentId };
+}
+async function listAllProcesses() {
+  const results = [];
+  await Promise.allSettled(
+    agentManager.listAgents().filter((a) => a.status.connected).map(async (a) => {
+      try {
+        const processes = await agentManager.agentQuery(a.config.id, "process.list");
+        for (const proc of processes) results.push({ ...proc, agentId: a.config.id });
+      } catch {
+      }
+    })
+  );
+  return results;
+}
+
+// ../server/src/trpc/routers/process.ts
 var SUBSCRIPTION_QUEUE_MAX2 = LOG_BUFFER_SIZE;
 async function* forwardEvents(eventName, filter) {
   const queue = [];
@@ -1242,28 +1366,13 @@ async function* forwardLogBatches(agentId, processId) {
 }
 var processRouter = router({
   /** List all processes across all connected agents */
-  list: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes", tags: ["processes"], summary: "List all processes", protect: true } }).output(z6.any()).query(async () => {
-    const agents = agentManager.listAgents();
-    const results = [];
-    await Promise.allSettled(
-      agents.filter((a) => a.status.connected).map(async (a) => {
-        try {
-          const processes = await agentManager.agentQuery(a.config.id, "process.list");
-          for (const proc of processes) {
-            results.push({ ...proc, agentId: a.config.id });
-          }
-        } catch {
-        }
-      })
-    );
-    return results;
-  }),
+  list: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes", tags: ["processes"], summary: "List all processes", protect: true } }).output(z6.any()).query(() => listAllProcesses()),
   /** Get a single process from a specific agent */
   get: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes/{agentId}/{id}", tags: ["processes"], summary: "Get a process by agent and ID", protect: true } }).input(z6.object({ agentId: z6.string().max(128), id: z6.string().max(128) })).output(z6.any()).query(async ({ input, ctx }) => {
     requireServiceAction(ctx, input.id, "service:read");
     const status = agentManager.getStatus(input.agentId);
     if (!status) {
-      throw new TRPCError4({ code: "NOT_FOUND", message: `Agent ${input.agentId} not found` });
+      throw new TRPCError5({ code: "NOT_FOUND", message: `Agent ${input.agentId} not found` });
     }
     const proc = await agentManager.agentQuery(input.agentId, "process.get", { id: input.id });
     return { ...proc, agentId: input.agentId };
@@ -1275,82 +1384,19 @@ var processRouter = router({
    *  The deploy call is idempotent — creates the process if missing, updates config if it exists. */
   start: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/start", tags: ["processes"], summary: "Start a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128).optional(), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
     requireServiceAction(ctx, input.processId, "service:start");
-    const service = await serviceStore.get(input.processId);
-    const effectiveAgentId = (service ? await resolveEffectiveAgentId(service) : null) ?? input.agentId ?? null;
-    if (!effectiveAgentId) {
-      throw new TRPCError4({ code: "BAD_REQUEST", message: "No agent assigned to this service. Set an agent on the service or on the active environment." });
-    }
-    if (service) {
-      try {
-        const resolved = await resolveServiceVariables(service);
-        await agentManager.agentMutation(effectiveAgentId, "process.deploy", resolved);
-      } catch (err) {
-        console.debug("[process-router] Failed to deploy before start for", input.processId + ":", err.message);
-      }
-    }
-    if (service?.clearLogsOnStart) {
-      try {
-        await agentManager.agentMutation(effectiveAgentId, "process.clearLogBuffer", { id: input.processId });
-        agentManager.emit("process:log", { agentId: effectiveAgentId, batch: [{ processId: input.processId, __clearLogBuffer: true }] });
-      } catch (err) {
-        console.debug("[process-router] Failed to clear logs before start for", input.processId + ":", err.message);
-      }
-    }
-    let result;
-    try {
-      result = await agentManager.agentMutation(effectiveAgentId, "process.start", { id: input.processId });
-    } catch (err) {
-      const err_ = err;
-      const isFetchError = err_?.cause?.code === "ECONNREFUSED" || err_?.message === "fetch failed" || err_?.name === "TypeError";
-      throw new TRPCError4({
-        code: "INTERNAL_SERVER_ERROR",
-        message: isFetchError ? `Cannot reach agent \u2014 make sure the agent is running` : err_?.message ?? "Failed to start process"
-      });
-    }
-    await auditService.log({ userId: "local", action: "start", entityType: "process", entityId: input.processId, metadata: { agentId: effectiveAgentId } });
-    return { ...result, agentId: effectiveAgentId };
+    return startProcess(input.processId, input.agentId);
   }),
   /** Stop a process on an agent */
   stop: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/stop", tags: ["processes"], summary: "Stop a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
     requireServiceAction(ctx, input.processId, "service:stop");
-    const result = await agentManager.agentMutation(input.agentId, "process.stop", { id: input.processId }, AGENT_STOP_FETCH_TIMEOUT);
-    await auditService.log({ userId: "local", action: "stop", entityType: "process", entityId: input.processId, metadata: { agentId: input.agentId } });
-    return { ...result, agentId: input.agentId };
+    return stopProcess(input.processId, input.agentId);
   }),
   /** Restart a process on an agent.
    *  Sends stop → deploy (latest resolved config) → start so that
    *  config/variable changes take effect. Same lazy deploy pattern as start. */
   restart: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/restart", tags: ["processes"], summary: "Restart a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128).optional(), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
     requireServiceAction(ctx, input.processId, "service:restart");
-    const service = await serviceStore.get(input.processId);
-    const effectiveAgentId = (service ? await resolveEffectiveAgentId(service) : null) ?? input.agentId ?? null;
-    if (!effectiveAgentId) {
-      throw new TRPCError4({ code: "BAD_REQUEST", message: "No agent assigned to this service. Set an agent on the service or on the active environment." });
-    }
-    try {
-      await agentManager.agentMutation(effectiveAgentId, "process.stop", { id: input.processId }, AGENT_STOP_FETCH_TIMEOUT);
-    } catch (err) {
-      console.debug("[process-router] Stop before restart ignored (process not found on agent?):", err.message);
-    }
-    if (service) {
-      try {
-        const resolved = await resolveServiceVariables(service);
-        await agentManager.agentMutation(effectiveAgentId, "process.deploy", resolved);
-      } catch (err) {
-        console.debug("[process-router] Failed to deploy before restart for", input.processId + ":", err.message);
-      }
-    }
-    if (service?.clearLogsOnStart) {
-      try {
-        await agentManager.agentMutation(effectiveAgentId, "process.clearLogBuffer", { id: input.processId });
-        agentManager.emit("process:log", { agentId: effectiveAgentId, batch: [{ processId: input.processId, __clearLogBuffer: true }] });
-      } catch (err) {
-        console.debug("[process-router] Failed to clear logs before restart for", input.processId + ":", err.message);
-      }
-    }
-    const result = await agentManager.agentMutation(effectiveAgentId, "process.start", { id: input.processId });
-    await auditService.log({ userId: "local", action: "restart", entityType: "process", entityId: input.processId, metadata: { agentId: effectiveAgentId } });
-    return { ...result, agentId: effectiveAgentId };
+    return restartProcess(input.processId, input.agentId);
   }),
   /** Get buffered logs for a process from an agent */
   logs: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes/{agentId}/{processId}/logs", tags: ["processes"], summary: "Get buffered logs for a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).output(z6.any()).query(async ({ input, ctx }) => {
@@ -1680,7 +1726,7 @@ var setupRouter = router({
 
 // ../server/src/trpc/routers/environment.ts
 import { z as z9 } from "zod";
-import { TRPCError as TRPCError5 } from "@trpc/server";
+import { TRPCError as TRPCError6 } from "@trpc/server";
 var environmentRouter = router({
   list: protectedProcedure.input(z9.object({
     projectId: z9.string().max(128),
@@ -1690,7 +1736,7 @@ var environmentRouter = router({
   }),
   get: protectedProcedure.input(z9.object({ id: z9.string().max(128) })).query(async ({ input }) => {
     const env2 = await environmentStore.get(input.id);
-    if (!env2) throw new TRPCError5({ code: "NOT_FOUND", message: `Environment ${input.id} not found` });
+    if (!env2) throw new TRPCError6({ code: "NOT_FOUND", message: `Environment ${input.id} not found` });
     return env2;
   }),
   listByScope: protectedProcedure.input(z9.object({
@@ -1740,9 +1786,9 @@ var environmentRouter = router({
   }),
   update: protectedProcedure.input(UpdateEnvironmentSchema).mutation(async ({ input }) => {
     const existing = await environmentStore.get(input.id);
-    if (!existing) throw new TRPCError5({ code: "NOT_FOUND", message: `Environment ${input.id} not found` });
+    if (!existing) throw new TRPCError6({ code: "NOT_FOUND", message: `Environment ${input.id} not found` });
     const env2 = await environmentStore.update(input);
-    if (!env2) throw new TRPCError5({ code: "NOT_FOUND", message: `Environment ${input.id} not found` });
+    if (!env2) throw new TRPCError6({ code: "NOT_FOUND", message: `Environment ${input.id} not found` });
     if (env2.scope === "global" && input.name && input.name !== existing.name) {
       const project = await projectStore.get(environmentStore.projectRefOf(env2) ?? env2.projectId);
       if (project) {
@@ -1758,22 +1804,22 @@ var environmentRouter = router({
   }),
   delete: protectedProcedure.input(z9.object({ id: z9.string().max(128) })).mutation(async ({ input }) => {
     const env2 = await environmentStore.get(input.id);
-    if (!env2) throw new TRPCError5({ code: "NOT_FOUND", message: `Environment ${input.id} not found` });
+    if (!env2) throw new TRPCError6({ code: "NOT_FOUND", message: `Environment ${input.id} not found` });
     if (env2.immutable) {
-      throw new TRPCError5({ code: "FORBIDDEN", message: "Cannot delete immutable environment" });
+      throw new TRPCError6({ code: "FORBIDDEN", message: "Cannot delete immutable environment" });
     }
     if (env2.scope === "global") {
       await environmentStore.deleteByActivateOn(input.id);
     }
     const deleted = await environmentStore.delete(input.id);
-    if (!deleted) throw new TRPCError5({ code: "INTERNAL_SERVER_ERROR", message: "Failed to delete environment" });
+    if (!deleted) throw new TRPCError6({ code: "INTERNAL_SERVER_ERROR", message: "Failed to delete environment" });
     await projectStore.removeEnvironment(environmentStore.projectRefOf(env2) ?? env2.projectId, input.id);
     return { success: true };
   }),
   resolve: protectedProcedure.input(z9.object({ environmentId: z9.string().max(128) })).query(async ({ input, ctx }) => {
     const { includeSecrets } = requireEnvAction(ctx, input.environmentId, "env:read");
     const env2 = await environmentStore.get(input.environmentId);
-    if (!env2) throw new TRPCError5({ code: "NOT_FOUND", message: `Environment ${input.environmentId} not found` });
+    if (!env2) throw new TRPCError6({ code: "NOT_FOUND", message: `Environment ${input.environmentId} not found` });
     const resolved = await environmentResolver.resolveEnvironmentWithSources(input.environmentId);
     if (!includeSecrets) {
       const sanitized = { ...resolved };
@@ -1792,7 +1838,7 @@ var environmentRouter = router({
   resolveFlat: protectedProcedure.meta({ openapi: { method: "GET", path: "/environments/{environmentId}/resolve-flat", tags: ["environments"], summary: "Resolve environment variables as a flat key-value map", protect: true } }).input(z9.object({ environmentId: z9.string().max(128) })).output(z9.record(z9.string(), z9.string())).query(async ({ input, ctx }) => {
     const { includeSecrets } = requireEnvAction(ctx, input.environmentId, "env:read");
     const env2 = await environmentStore.get(input.environmentId);
-    if (!env2) throw new TRPCError5({ code: "NOT_FOUND", message: `Environment ${input.environmentId} not found` });
+    if (!env2) throw new TRPCError6({ code: "NOT_FOUND", message: `Environment ${input.environmentId} not found` });
     const { env: resolved, envSecrets } = await environmentResolver.resolveEnvironment(input.environmentId);
     const result = {};
     for (const [key, value] of Object.entries(resolved)) {
@@ -1830,9 +1876,9 @@ var environmentRouter = router({
   })).mutation(async ({ input, ctx }) => {
     requireEnvAction(ctx, input.environmentId, "env:write");
     const env2 = await environmentStore.get(input.environmentId);
-    if (!env2) throw new TRPCError5({ code: "NOT_FOUND", message: `Environment ${input.environmentId} not found` });
+    if (!env2) throw new TRPCError6({ code: "NOT_FOUND", message: `Environment ${input.environmentId} not found` });
     const result = await environmentStore.upsertVariable(input.environmentId, input.variableId, input.variable);
-    if (!result) throw new TRPCError5({ code: "INTERNAL_SERVER_ERROR", message: "Failed to update variable" });
+    if (!result) throw new TRPCError6({ code: "INTERNAL_SERVER_ERROR", message: "Failed to update variable" });
     return result;
   }),
   /**
@@ -1907,9 +1953,9 @@ var environmentRouter = router({
     variableId: z9.string().max(128)
   })).mutation(async ({ input }) => {
     const env2 = await environmentStore.get(input.environmentId);
-    if (!env2) throw new TRPCError5({ code: "NOT_FOUND", message: `Environment ${input.environmentId} not found` });
+    if (!env2) throw new TRPCError6({ code: "NOT_FOUND", message: `Environment ${input.environmentId} not found` });
     const result = await environmentStore.removeVariable(input.environmentId, input.variableId);
-    if (!result) throw new TRPCError5({ code: "INTERNAL_SERVER_ERROR", message: "Failed to remove variable" });
+    if (!result) throw new TRPCError6({ code: "INTERNAL_SERVER_ERROR", message: "Failed to remove variable" });
     return result;
   })
 });
@@ -1917,7 +1963,7 @@ var environmentRouter = router({
 // ../server/src/trpc/routers/settings.ts
 import { promises as dns } from "dns";
 import { z as z10 } from "zod";
-import { TRPCError as TRPCError6 } from "@trpc/server";
+import { TRPCError as TRPCError7 } from "@trpc/server";
 var NotificationPreferencesPatchSchema = NotificationPreferencesSchema.partial().strict();
 function listWithOrigin(parsers, vault) {
   return [
@@ -1973,7 +2019,7 @@ var settingsRouter = router({
     try {
       return await setLanMode(input.enabled);
     } catch (err) {
-      throw new TRPCError6({
+      throw new TRPCError7({
         code: "INTERNAL_SERVER_ERROR",
         message: `Impossible de changer l'adresse d'\xE9coute : ${err.message}`
       });
@@ -1983,9 +2029,9 @@ var settingsRouter = router({
    * Update settings (mode, cloudUrl)
    */
   update: protectedProcedure.input(SettingsSchema.pick({ mode: true, cloudUrl: true, globalDocsPath: true }).partial()).mutation(async ({ input }) => {
-    const current = await settingsManager.getSettings();
+    const current2 = await settingsManager.getSettings();
     const updated = {
-      ...current,
+      ...current2,
       ...input
     };
     await settingsManager.saveSettings(updated);
@@ -2075,7 +2121,7 @@ var settingsRouter = router({
   getParser: protectedProcedure.input(z10.object({ id: z10.string().max(128), ...ScopeShape })).query(async ({ input }) => {
     const parser = await logParserStore.get(input.id, await scopeOf(input));
     if (!parser) {
-      throw new TRPCError6({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
+      throw new TRPCError7({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
     }
     return parser;
   }),
@@ -2091,7 +2137,7 @@ var settingsRouter = router({
   ).mutation(async ({ input }) => {
     const { orgId, projectId, ...fields } = input;
     if (!fields.code.trim()) {
-      throw new TRPCError6({ code: "BAD_REQUEST", message: "Parser code cannot be empty" });
+      throw new TRPCError7({ code: "BAD_REQUEST", message: "Parser code cannot be empty" });
     }
     return logParserStore.create(fields, await scopeOf({ orgId, projectId }));
   }),
@@ -2106,14 +2152,14 @@ var settingsRouter = router({
   ).mutation(async ({ input }) => {
     const { id, orgId, projectId, ...patch } = input;
     if (id.startsWith("native:")) {
-      throw new TRPCError6({ code: "FORBIDDEN", message: "Cannot modify built-in parsers" });
+      throw new TRPCError7({ code: "FORBIDDEN", message: "Cannot modify built-in parsers" });
     }
     if (patch.code !== void 0 && !patch.code.trim()) {
-      throw new TRPCError6({ code: "BAD_REQUEST", message: "Parser code cannot be empty" });
+      throw new TRPCError7({ code: "BAD_REQUEST", message: "Parser code cannot be empty" });
     }
     const updated = await logParserStore.update(id, patch, await scopeOf({ orgId, projectId }));
     if (!updated) {
-      throw new TRPCError6({ code: "NOT_FOUND", message: `Parser not found: ${id}` });
+      throw new TRPCError7({ code: "NOT_FOUND", message: `Parser not found: ${id}` });
     }
     return updated;
   }),
@@ -2122,11 +2168,11 @@ var settingsRouter = router({
    */
   deleteParser: protectedProcedure.input(z10.object({ id: z10.string().max(128), ...ScopeShape })).mutation(async ({ input }) => {
     if (input.id.startsWith("native:")) {
-      throw new TRPCError6({ code: "FORBIDDEN", message: "Cannot delete built-in parsers" });
+      throw new TRPCError7({ code: "FORBIDDEN", message: "Cannot delete built-in parsers" });
     }
     const deleted = await logParserStore.delete(input.id, await scopeOf(input));
     if (!deleted) {
-      throw new TRPCError6({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
+      throw new TRPCError7({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
     }
     return { deleted: true };
   }),
@@ -2165,15 +2211,15 @@ var settingsRouter = router({
     prompt: z10.string().max(2e4).optional()
   })).mutation(async ({ input }) => {
     const settings = await settingsManager.getSettings();
-    const current = settings.companion ?? { enabledByDefault: false };
+    const current2 = settings.companion ?? { enabledByDefault: false };
     const prompt = input.prompt?.trim();
     await settingsManager.saveSettings({
       ...settings,
       companion: {
-        enabledByDefault: input.enabledByDefault ?? current.enabledByDefault ?? false,
+        enabledByDefault: input.enabledByDefault ?? current2.enabledByDefault ?? false,
         // Vide = « celles de Runeya » : on efface le réglage plutôt que d'y
         // ranger une chaîne vide qui signifierait « aucune consigne ».
-        ...input.prompt === void 0 ? current.prompt ? { prompt: current.prompt } : {} : prompt ? { prompt } : {}
+        ...input.prompt === void 0 ? current2.prompt ? { prompt: current2.prompt } : {} : prompt ? { prompt } : {}
       }
     });
     return { ok: true };
@@ -2208,7 +2254,7 @@ var settingsRouter = router({
     ...ScopeShape
   })).mutation(async ({ input }) => {
     if (input.provider !== "ollama" && !input.apiKey?.trim()) {
-      throw new TRPCError6({ code: "BAD_REQUEST", message: "Une cl\xE9 API est requise pour ce provider." });
+      throw new TRPCError7({ code: "BAD_REQUEST", message: "Une cl\xE9 API est requise pour ce provider." });
     }
     const vault = await scopeOf(input);
     const priv = await settingsManager.getPrivateSettings(vault);
@@ -2249,7 +2295,7 @@ var settingsRouter = router({
     const priv = await settingsManager.getPrivateSettings(vault);
     const providers = priv.aiProviders ?? [];
     const idx = providers.findIndex((p) => p.id === input.id);
-    if (idx === -1) throw new TRPCError6({ code: "NOT_FOUND", message: `AI provider not found: ${input.id}` });
+    if (idx === -1) throw new TRPCError7({ code: "NOT_FOUND", message: `AI provider not found: ${input.id}` });
     const existing = providers[idx];
     const encryptedApiKey = input.apiKey ? stableEncryptValue(input.apiKey, existing.encryptedApiKey, vault) : existing.encryptedApiKey;
     const updated = {
@@ -2280,7 +2326,7 @@ var settingsRouter = router({
     const priv = await settingsManager.getPrivateSettings(vault);
     const providers = priv.aiProviders ?? [];
     const filtered = providers.filter((p) => p.id !== input.id);
-    if (filtered.length === providers.length) throw new TRPCError6({ code: "NOT_FOUND", message: `AI provider not found: ${input.id}` });
+    if (filtered.length === providers.length) throw new TRPCError7({ code: "NOT_FOUND", message: `AI provider not found: ${input.id}` });
     const deletedWasActive = providers.find((p) => p.id === input.id)?.active ?? false;
     if (deletedWasActive && filtered.length > 0) filtered[0].active = true;
     await settingsManager.savePrivateSettings({ ...priv, aiProviders: filtered }, vault);
@@ -2294,7 +2340,7 @@ var settingsRouter = router({
     const priv = await settingsManager.getPrivateSettings(vault);
     const providers = priv.aiProviders ?? [];
     const idx = providers.findIndex((p) => p.id === input.id);
-    if (idx === -1) throw new TRPCError6({ code: "NOT_FOUND", message: `AI provider not found: ${input.id}` });
+    if (idx === -1) throw new TRPCError7({ code: "NOT_FOUND", message: `AI provider not found: ${input.id}` });
     const updated = providers.map((p) => ({ ...p, active: p.id === input.id }));
     await settingsManager.savePrivateSettings({ ...priv, aiProviders: updated }, vault);
     return { id: input.id, active: true };
@@ -2416,7 +2462,7 @@ var settingsRouter = router({
     const raw = agentStore.getTraefikConfig(input.agentId);
     const parsed = raw ? TraefikConfigSchema.safeParse(raw) : null;
     const config = parsed?.success ? parsed.data : null;
-    if (!config?.enabled) throw new TRPCError6({ code: "BAD_REQUEST", message: "Traefik non activ\xE9 sur cet agent" });
+    if (!config?.enabled) throw new TRPCError7({ code: "BAD_REQUEST", message: "Traefik non activ\xE9 sur cet agent" });
     const decrypted = { ...config, dnsCredentials: traefikManager.decryptDnsCredentials(config.dnsCredentials ?? {}) };
     await agentManager.agentMutation(input.agentId, "config.initTraefikConfig", decrypted, 5e3);
     await agentManager.agentMutation(input.agentId, "config.restartTraefik", void 0, 3e4);
@@ -2429,7 +2475,7 @@ var settingsRouter = router({
     const raw = agentStore.getTraefikConfig(input.agentId);
     const parsed = raw ? TraefikConfigSchema.safeParse(raw) : null;
     const config = parsed?.success ? parsed.data : null;
-    if (!config?.enabled) throw new TRPCError6({ code: "BAD_REQUEST", message: "Traefik non activ\xE9 sur cet agent" });
+    if (!config?.enabled) throw new TRPCError7({ code: "BAD_REQUEST", message: "Traefik non activ\xE9 sur cet agent" });
     const decrypted = { ...config, dnsCredentials: traefikManager.decryptDnsCredentials(config.dnsCredentials ?? {}) };
     await agentManager.agentMutation(input.agentId, "config.initTraefikConfig", decrypted, 5e3);
     await agentManager.agentMutation(input.agentId, "config.renewTraefikCert", void 0, 3e4);
@@ -2561,7 +2607,7 @@ var settingsRouter = router({
         updatedAt: /* @__PURE__ */ new Date()
       }]);
     } catch (err) {
-      throw new TRPCError6({
+      throw new TRPCError7({
         code: "BAD_REQUEST",
         message: err instanceof Error ? err.message : String(err)
       });
@@ -2590,7 +2636,7 @@ var settingsRouter = router({
 
 // ../server/src/trpc/routers/editor.ts
 import { z as z12 } from "zod";
-import { TRPCError as TRPCError7 } from "@trpc/server";
+import { TRPCError as TRPCError8 } from "@trpc/server";
 import { execFile as execFile3, spawn as spawn2 } from "child_process";
 import { stat as stat2 } from "fs/promises";
 import { resolve, join as join4 } from "path";
@@ -2683,7 +2729,7 @@ async function getServiceCwd(serviceId) {
   const services = await serviceStore.list();
   const service = services.find((s) => s.id === serviceId);
   if (!service) {
-    throw new TRPCError7({ code: "NOT_FOUND", message: "Service not found" });
+    throw new TRPCError8({ code: "NOT_FOUND", message: "Service not found" });
   }
   return resolveCwd(await resolveWorkspaceCwd({ serviceId }));
 }
@@ -2716,7 +2762,7 @@ var editorRouter = router({
     editorKey: z12.string().max(64)
   })).mutation(async ({ input }) => {
     if (!EDITOR_BY_KEY.has(input.editorKey)) {
-      throw new TRPCError7({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
+      throw new TRPCError8({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
     }
     await userConfigManager.setEditorPreference(
       { id: input.projectId, orgId: input.orgId },
@@ -2732,7 +2778,7 @@ var editorRouter = router({
     editorKey: z12.string().max(64)
   })).mutation(async ({ input }) => {
     if (!EDITOR_BY_KEY.has(input.editorKey)) {
-      throw new TRPCError7({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
+      throw new TRPCError8({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
     }
     await userConfigManager.setEditorPreference(
       { id: input.projectId, orgId: input.orgId },
@@ -2758,15 +2804,15 @@ var editorRouter = router({
   })).mutation(async ({ input }) => {
     const editor = EDITOR_BY_KEY.get(input.editorKey);
     if (!editor) {
-      throw new TRPCError7({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
+      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 || ".");
     try {
       await stat2(resolvedPath);
     } catch (err) {
-      if (err instanceof TRPCError7) throw err;
-      throw new TRPCError7({ code: "BAD_REQUEST", message: `Path does not exist: ${resolvedPath}` });
+      if (err instanceof TRPCError8) throw err;
+      throw new TRPCError8({ code: "BAD_REQUEST", message: `Path does not exist: ${resolvedPath}` });
     }
     const invocation = resolveCliInvocation(editor.command, [resolvedPath]);
     const child = spawn2(invocation.command, invocation.args, {
@@ -2785,17 +2831,17 @@ var editorRouter = router({
   })).mutation(async ({ input }) => {
     const editor = EDITOR_BY_KEY.get(input.editorKey);
     if (!editor) {
-      throw new TRPCError7({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
+      throw new TRPCError8({ code: "BAD_REQUEST", message: `Unknown editor: ${input.editorKey}` });
     }
     const cwd = await getServiceCwd(input.serviceId);
     const filePath = join4(cwd, input.relativePath);
     if (!filePath.startsWith(cwd)) {
-      throw new TRPCError7({ code: "BAD_REQUEST", message: "Path traversal not allowed" });
+      throw new TRPCError8({ code: "BAD_REQUEST", message: "Path traversal not allowed" });
     }
     try {
       await stat2(filePath);
     } catch {
-      throw new TRPCError7({ code: "BAD_REQUEST", message: `File does not exist: ${filePath}` });
+      throw new TRPCError8({ code: "BAD_REQUEST", message: `File does not exist: ${filePath}` });
     }
     const invocation = resolveCliInvocation(editor.command, [filePath]);
     const child = spawn2(invocation.command, invocation.args, {
@@ -2811,7 +2857,7 @@ var editorRouter = router({
 
 // ../server/src/trpc/routers/api-keys.ts
 import { z as z13 } from "zod";
-import { TRPCError as TRPCError8 } from "@trpc/server";
+import { TRPCError as TRPCError9 } from "@trpc/server";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import { join as join5, dirname as dirname2 } from "path";
 var ALLOWED_SKILL_PATHS = /* @__PURE__ */ new Set([
@@ -2835,22 +2881,22 @@ var apiKeysRouter = router({
    */
   reveal: protectedProcedure.input(z13.object({ id: z13.string().max(128) })).query(async ({ input }) => {
     const key = await apiKeyStore.reveal(input.id);
-    if (!key) throw new TRPCError8({ code: "NOT_FOUND", message: "API key not found" });
+    if (!key) throw new TRPCError9({ code: "NOT_FOUND", message: "API key not found" });
     return { key };
   }),
   update: protectedProcedure.input(KeyInputSchema.extend({ id: z13.string().max(128) })).mutation(async ({ input }) => {
     const updated = await apiKeyStore.update(input.id, input.name, input.scopes, input.isPublic);
-    if (!updated) throw new TRPCError8({ code: "NOT_FOUND", message: "API key not found" });
+    if (!updated) throw new TRPCError9({ code: "NOT_FOUND", message: "API key not found" });
     return maskApiKey(updated);
   }),
   remove: protectedProcedure.input(z13.object({ id: z13.string().max(128) })).mutation(async ({ input }) => {
     const removed = await apiKeyStore.remove(input.id);
-    if (!removed) throw new TRPCError8({ code: "NOT_FOUND", message: "API key not found" });
+    if (!removed) throw new TRPCError9({ code: "NOT_FOUND", message: "API key not found" });
     return { success: true };
   }),
   renewKey: protectedProcedure.input(z13.object({ id: z13.string().max(128) })).mutation(async ({ input }) => {
     const renewed = await apiKeyStore.renewKey(input.id);
-    if (!renewed) throw new TRPCError8({ code: "NOT_FOUND", message: "API key not found" });
+    if (!renewed) throw new TRPCError9({ code: "NOT_FOUND", message: "API key not found" });
     return renewed;
   }),
   writeSkillFile: protectedProcedure.input(z13.object({
@@ -2858,7 +2904,7 @@ var apiKeysRouter = router({
     content: z13.string().max(32768)
   })).mutation(async ({ input }) => {
     if (!ALLOWED_SKILL_PATHS.has(input.relativePath)) {
-      throw new TRPCError8({ code: "BAD_REQUEST", message: "Chemin non autoris\xE9" });
+      throw new TRPCError9({ code: "BAD_REQUEST", message: "Chemin non autoris\xE9" });
     }
     const abs = join5(await resolveWorkspaceCwd({}), input.relativePath);
     await mkdir3(dirname2(abs), { recursive: true });
@@ -2869,7 +2915,7 @@ var apiKeysRouter = router({
 
 // ../server/src/trpc/routers/git.ts
 import { z as z14 } from "zod";
-import { TRPCError as TRPCError9 } from "@trpc/server";
+import { TRPCError as TRPCError10 } from "@trpc/server";
 import Anthropic from "@anthropic-ai/sdk";
 import OpenAI from "openai";
 var SERVICE_ID_SCHEMA = z14.string().max(128);
@@ -2881,11 +2927,11 @@ var BRANCH_SCHEMA = z14.string().min(1).max(256).regex(/^[a-zA-Z0-9._\-/]+$/);
 async function resolveServiceContext(serviceId) {
   const service = await serviceStore.get(serviceId);
   if (!service) {
-    throw new TRPCError9({ code: "NOT_FOUND", message: "Service not found" });
+    throw new TRPCError10({ code: "NOT_FOUND", message: "Service not found" });
   }
   const agentId = await resolveEffectiveAgentId(service);
   if (!agentId) {
-    throw new TRPCError9({ code: "BAD_REQUEST", message: "No agent configured for this service" });
+    throw new TRPCError10({ code: "BAD_REQUEST", message: "No agent configured for this service" });
   }
   return { agentId, cwd: await resolveWorkspaceCwd({ serviceId }) };
 }
@@ -2901,7 +2947,7 @@ async function resolveGitContext(input) {
   if (input.serviceId) return resolveServiceContext(input.serviceId);
   const agentId = input.agentId ?? agentManager.getDefaultAgentId();
   if (!agentId) {
-    throw new TRPCError9({ code: "BAD_REQUEST", message: "No agent available" });
+    throw new TRPCError10({ code: "BAD_REQUEST", message: "No agent available" });
   }
   const cwd = await resolveAgentCwd({ projectId: input.projectId, orgId: input.orgId }) ?? ".";
   return { agentId, cwd };
@@ -2987,14 +3033,14 @@ var gitRouter = router({
     const { agentId, cwd } = await resolveGitContext(input);
     const { diff } = await agentManager.agentQuery(agentId, "git.stagedDiff", { cwd });
     if (!diff.trim()) {
-      throw new TRPCError9({ code: "BAD_REQUEST", message: "No staged changes to generate a commit message from" });
+      throw new TRPCError10({ code: "BAD_REQUEST", message: "No staged changes to generate a commit message from" });
     }
     const active = await getActiveProvider(
       input.providerId,
       input.orgId ?? await vaultOfProject(input.projectId)
     );
     if (!active) {
-      throw new TRPCError9({ code: "BAD_REQUEST", message: "No AI provider configured" });
+      throw new TRPCError10({ 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:
@@ -3027,7 +3073,7 @@ Rules:
       });
       return { message: res.choices[0]?.message?.content?.trim() ?? "" };
     }
-    throw new TRPCError9({ code: "BAD_REQUEST", message: "Unsupported AI provider" });
+    throw new TRPCError10({ code: "BAD_REQUEST", message: "Unsupported AI provider" });
   }),
   /** Merge a branch into the current branch */
   merge: protectedProcedure.input(z14.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, noFf: z14.boolean().default(false) })).mutation(async ({ input }) => {
@@ -3092,7 +3138,7 @@ Rules:
         }
       );
     } catch (err) {
-      throw new TRPCError9({
+      throw new TRPCError10({
         code: "BAD_REQUEST",
         message: `Cannot subscribe to git status: ${err.message}`
       });
@@ -3120,41 +3166,41 @@ Rules:
 
 // ../server/src/trpc/routers/scenario.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { TRPCError as TRPCError12 } from "@trpc/server";
+import { TRPCError as TRPCError13 } from "@trpc/server";
 import { z as z15 } from "zod";
 
 // ../server/src/trpc/crud-procedure-utils.ts
-import { TRPCError as TRPCError10 } from "@trpc/server";
+import { TRPCError as TRPCError11 } from "@trpc/server";
 async function getOrNotFound(getter, notFoundMessage) {
   const entity = await getter();
-  if (!entity) throw new TRPCError10({ code: "NOT_FOUND", message: notFoundMessage });
+  if (!entity) throw new TRPCError11({ code: "NOT_FOUND", message: notFoundMessage });
   return entity;
 }
 async function createOrBadRequest(creator) {
   try {
     return await creator();
   } catch (err) {
-    throw new TRPCError10({ code: "BAD_REQUEST", message: err.message });
+    throw new TRPCError11({ code: "BAD_REQUEST", message: err.message });
   }
 }
 async function updateOrThrow(updater, notFoundMessage) {
   try {
     const entity = await updater();
-    if (!entity) throw new TRPCError10({ code: "NOT_FOUND", message: notFoundMessage });
+    if (!entity) throw new TRPCError11({ code: "NOT_FOUND", message: notFoundMessage });
     return entity;
   } catch (err) {
-    if (err instanceof TRPCError10) throw err;
-    throw new TRPCError10({ code: "BAD_REQUEST", message: err.message });
+    if (err instanceof TRPCError11) throw err;
+    throw new TRPCError11({ code: "BAD_REQUEST", message: err.message });
   }
 }
 async function deleteOrNotFound(deleter, notFoundMessage) {
   const deleted = await deleter();
-  if (!deleted) throw new TRPCError10({ code: "NOT_FOUND", message: notFoundMessage });
+  if (!deleted) throw new TRPCError11({ code: "NOT_FOUND", message: notFoundMessage });
   return { ok: true };
 }
 
 // ../server/src/trpc/ai-generation-procedure-utils.ts
-import { TRPCError as TRPCError11 } from "@trpc/server";
+import { TRPCError as TRPCError12 } from "@trpc/server";
 
 // ../server/src/services/ai-generation.ts
 import Anthropic2 from "@anthropic-ai/sdk";
@@ -3210,7 +3256,7 @@ async function* streamProviderText(input) {
 // ../server/src/trpc/ai-generation-procedure-utils.ts
 async function* streamWithActiveProvider(opts) {
   const active = await getActiveProvider(opts.providerId, opts.vault);
-  if (!active) throw new TRPCError11({ code: "BAD_REQUEST", message: "Aucun fournisseur IA configur\xE9" });
+  if (!active) throw new TRPCError12({ code: "BAD_REQUEST", message: "Aucun fournisseur IA configur\xE9" });
   const { provider, plaintextKey } = active;
   const model = opts.model || provider.model || DEFAULT_MODELS[provider.provider] || "";
   try {
@@ -3228,7 +3274,7 @@ async function* streamWithActiveProvider(opts) {
     yield { type: "done", text: "" };
   } catch (err) {
     if (String(err?.message ?? "").startsWith("Unsupported provider:")) {
-      throw new TRPCError11({ code: "BAD_REQUEST", message: `Fournisseur non support\xE9: ${provider.provider}` });
+      throw new TRPCError12({ code: "BAD_REQUEST", message: `Fournisseur non support\xE9: ${provider.provider}` });
     }
     throw err;
   }
@@ -4708,10 +4754,10 @@ Rules:
 - Groups: position spaced 400px apart (e.g. x=0, x=400, x=800). width >= 300, height >= 200.
 - Nodes positions are relative to their group: x/y in 30-260 range.
 - The "prompt" field must be detailed: role, responsibilities, communication style, expected outputs.`;
-function buildScenarioUserMessage(userPrompt, current) {
-  if (current && (current.groups.length > 0 || current.nodes.length > 0)) {
+function buildScenarioUserMessage(userPrompt, current2) {
+  if (current2 && (current2.groups.length > 0 || current2.nodes.length > 0)) {
     return `Current scenario:
-${JSON.stringify(current, null, 2)}
+${JSON.stringify(current2, null, 2)}
 
 User request: ${userPrompt}
 
@@ -4805,7 +4851,7 @@ var scenarioRouter = router({
     resume: z15.boolean().optional()
   })).subscription(async function* ({ input, signal }) {
     const scenario = await scenarioStore.get(input.scenarioId, await scopeOf2(input));
-    if (!scenario) throw new TRPCError12({ code: "NOT_FOUND", message: "Scenario not found" });
+    if (!scenario) throw new TRPCError13({ 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;
@@ -4832,7 +4878,7 @@ var scenarioRouter = router({
     text: z15.string().min(1).max(1e5)
   })).mutation(({ input }) => {
     const resolved = resolveNodeInput(input.conversationId, input.nodeId, input.text);
-    if (!resolved) throw new TRPCError12({ code: "NOT_FOUND", message: "No pending input request for this node" });
+    if (!resolved) throw new TRPCError13({ code: "NOT_FOUND", message: "No pending input request for this node" });
     return { ok: true };
   }),
   isRunning: protectedProcedure.input(z15.object({ conversationId: ConversationIdSchema })).query(({ input }) => ({ running: isScenarioRunning(input.conversationId) })),
@@ -4892,14 +4938,14 @@ var scenarioRouter = router({
   listPresets: protectedProcedure.query(() => listPresets()),
   getPreset: protectedProcedure.input(z15.object({ id: Id128Schema })).query(({ input }) => {
     const preset = getPreset(input.id);
-    if (!preset) throw new TRPCError12({ code: "NOT_FOUND", message: "Preset not found" });
+    if (!preset) throw new TRPCError13({ code: "NOT_FOUND", message: "Preset not found" });
     return preset;
   })
 });
 
 // ../server/src/trpc/routers/debug.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { TRPCError as TRPCError13 } from "@trpc/server";
+import { TRPCError as TRPCError14 } from "@trpc/server";
 import { z as z16 } from "zod";
 var MAX_BUFFER2 = 300;
 var jobs = /* @__PURE__ */ new Map();
@@ -4972,17 +5018,17 @@ var debugRouter = router({
       tick: 0,
       done: false,
       timer: setInterval(() => {
-        const current = jobs.get(jobId);
-        if (!current || current.done) return;
-        current.tick += 1;
-        publish(current, {
+        const current2 = jobs.get(jobId);
+        if (!current2 || current2.done) return;
+        current2.tick += 1;
+        publish(current2, {
           type: "tick",
           jobId,
-          index: current.tick,
+          index: current2.tick,
           value: Math.random(),
           at: Date.now()
         });
-        if (current.tick >= current.maxTicks) {
+        if (current2.tick >= current2.maxTicks) {
           stopJob(jobId, "max_ticks");
         }
       }, intervalMs),
@@ -4996,7 +5042,7 @@ var debugRouter = router({
   streamRandomJob: protectedProcedure.input(z16.object({ jobId: z16.string().max(128) })).subscription(async function* ({ input, signal }) {
     const job = jobs.get(input.jobId);
     if (!job) {
-      throw new TRPCError13({ code: "NOT_FOUND", message: "Random job not found" });
+      throw new TRPCError14({ code: "NOT_FOUND", message: "Random job not found" });
     }
     yield* tapJob(job, signal ?? new AbortController().signal);
   }),
@@ -5012,7 +5058,7 @@ var debugRouter = router({
 
 // ../server/src/trpc/routers/diagnostics.ts
 import { z as z17 } from "zod";
-import { TRPCError as TRPCError14 } from "@trpc/server";
+import { TRPCError as TRPCError15 } from "@trpc/server";
 
 // ../server/src/services/log-buffer.ts
 import { EventEmitter } from "events";
@@ -5132,12 +5178,12 @@ var diagnosticsRouter = router({
     } catch (err) {
       const reason = err.message;
       if (reason === "instance-not-found") {
-        throw new TRPCError14({ code: "NOT_FOUND", message: "No live Runeya instance with this pid." });
+        throw new TRPCError15({ code: "NOT_FOUND", message: "No live Runeya instance with this pid." });
       }
       if (reason === "instance-is-current") {
-        throw new TRPCError14({ code: "BAD_REQUEST", message: "This instance cannot stop itself." });
+        throw new TRPCError15({ code: "BAD_REQUEST", message: "This instance cannot stop itself." });
       }
-      throw new TRPCError14({ code: "INTERNAL_SERVER_ERROR", message: reason });
+      throw new TRPCError15({ code: "INTERNAL_SERVER_ERROR", message: reason });
     }
   }),
   /**
@@ -5164,15 +5210,15 @@ var diagnosticsRouter = router({
     } catch (err) {
       const reason = err.message;
       if (reason === "instance-not-found") {
-        throw new TRPCError14({ code: "NOT_FOUND", message: "No live Runeya instance with this pid." });
+        throw new TRPCError15({ code: "NOT_FOUND", message: "No live Runeya instance with this pid." });
       }
       if (reason.startsWith("instance-not-restartable:")) {
-        throw new TRPCError14({
+        throw new TRPCError15({
           code: "BAD_REQUEST",
           message: `This instance cannot be restarted (${reason.split(":")[1]}).`
         });
       }
-      throw new TRPCError14({ code: "INTERNAL_SERVER_ERROR", message: reason });
+      throw new TRPCError15({ code: "INTERNAL_SERVER_ERROR", message: reason });
     }
   })
 });
@@ -5435,7 +5481,7 @@ import { createHash } from "crypto";
 import { tmpdir } from "os";
 import { join as join7 } from "path";
 import { z as z19 } from "zod";
-import { TRPCError as TRPCError15 } from "@trpc/server";
+import { TRPCError as TRPCError16 } from "@trpc/server";
 function summarizeCard(card, boardId, columnTitle) {
   return {
     boardId,
@@ -5506,7 +5552,7 @@ async function storeAttachment(id, name, body, dirs = attachmentCacheDirs()) {
       refusals.push(`${dir} (${err instanceof Error ? err.message : String(err)})`);
     }
   }
-  throw new TRPCError15({
+  throw new TRPCError16({
     code: "INTERNAL_SERVER_ERROR",
     message: `Impossible d'\xE9crire la pi\xE8ce jointe sur cette machine. Emplacements essay\xE9s : ${refusals.join(" ; ")}. V\xE9rifiez les droits d'\xE9criture, ou l'espace disque.`
   });
@@ -5657,7 +5703,7 @@ var kanbanRouter = router({
       input.parentCardId ? { boardId: input.parentBoardId ?? input.boardId, cardId: input.parentCardId } : null
     );
     if (!ok) {
-      throw new TRPCError15({ code: "BAD_REQUEST", message: "The cloud refused the link (unknown card, or a cycle)." });
+      throw new TRPCError16({ code: "BAD_REQUEST", message: "The cloud refused the link (unknown card, or a cycle)." });
     }
     return { ok: true };
   }),
@@ -5756,25 +5802,25 @@ var kanbanRouter = router({
   downloadAttachment: protectedProcedure.input(z19.object({ attachmentId: z19.string().max(128) })).mutation(async ({ input }) => {
     const id = input.attachmentId;
     if (!ATTACHMENT_ID_REGEX.test(id)) {
-      throw new TRPCError15({ code: "BAD_REQUEST", message: "Invalid attachment id" });
+      throw new TRPCError16({ code: "BAD_REQUEST", message: "Invalid attachment id" });
     }
     const res = await cloudFetch2(`/api/kanban/file/${id}`, { timeoutMs: 12e4 });
     if (res.status === 404) {
-      throw new TRPCError15({ code: "NOT_FOUND", message: `Attachment ${id} not found` });
+      throw new TRPCError16({ code: "NOT_FOUND", message: `Attachment ${id} not found` });
     }
     if (!res.ok) {
-      throw new TRPCError15({
+      throw new TRPCError16({
         code: res.status === 403 ? "FORBIDDEN" : "INTERNAL_SERVER_ERROR",
         message: `Cloud refused the attachment (HTTP ${res.status})`
       });
     }
     const declared = Number(res.headers.get("content-length") ?? 0);
     if (declared > MAX_ATTACHMENT_BYTES) {
-      throw new TRPCError15({ code: "PAYLOAD_TOO_LARGE", message: "Attachment too large to download" });
+      throw new TRPCError16({ code: "PAYLOAD_TOO_LARGE", message: "Attachment too large to download" });
     }
     const body = Buffer.from(await res.arrayBuffer());
     if (body.length > MAX_ATTACHMENT_BYTES) {
-      throw new TRPCError15({ code: "PAYLOAD_TOO_LARGE", message: "Attachment too large to download" });
+      throw new TRPCError16({ code: "PAYLOAD_TOO_LARGE", message: "Attachment too large to download" });
     }
     const contentType = res.headers.get("content-type") ?? "application/octet-stream";
     const disposition = res.headers.get("content-disposition") ?? "";
@@ -5787,7 +5833,7 @@ var kanbanRouter = router({
 
 // ../server/src/trpc/routers/terminal.ts
 import { z as z20 } from "zod";
-import { TRPCError as TRPCError16 } from "@trpc/server";
+import { TRPCError as TRPCError17 } from "@trpc/server";
 var terminalRouter = router({
   /** Create a PTY shell session on the target agent */
   create: protectedProcedure.input(z20.object({
@@ -5911,7 +5957,7 @@ var terminalRouter = router({
         }
       );
     } catch (err) {
-      throw new TRPCError16({
+      throw new TRPCError17({
         code: "BAD_REQUEST",
         message: `Cannot subscribe to terminal: ${err.message}`
       });
@@ -5946,7 +5992,7 @@ var utilityRouter = router({
 
 // ../server/src/trpc/routers/wiki.ts
 import { z as z22 } from "zod";
-import { TRPCError as TRPCError17 } from "@trpc/server";
+import { TRPCError as TRPCError18 } from "@trpc/server";
 import { readFile as readFile3, readdir as readdir2, stat as stat4, realpath, writeFile as writeFile5, mkdir as mkdir6, rename as rename3, rm as rm2 } from "fs/promises";
 import { resolve as resolvePath, join as join8, relative, sep, dirname as dirname3 } from "path";
 var SCOPE_SCHEMA = z22.union([
@@ -5982,27 +6028,27 @@ async function resolveScope(scope) {
     const settings = await settingsManager.getSettings();
     const sub = (settings.globalDocsPath?.trim() || "wiki").replace(/^[\\/]+|[\\/]+$/g, "");
     if (sub.includes("..") || sub.includes("\0")) {
-      throw new TRPCError17({ code: "BAD_REQUEST", message: "Sous-chemin invalide" });
+      throw new TRPCError18({ code: "BAD_REQUEST", message: "Sous-chemin invalide" });
     }
     const dataDirAbs = resolvePath(env.DATA_DIR);
     await mkdir6(dataDirAbs, { recursive: true });
     const base = dirname3(await realpath(dataDirAbs));
     const target = resolvePath(base, sub);
     if (target !== base && !(target + sep).startsWith(base + sep)) {
-      throw new TRPCError17({ code: "FORBIDDEN", message: "Hors du dossier de donn\xE9es du serveur" });
+      throw new TRPCError18({ code: "FORBIDDEN", message: "Hors du dossier de donn\xE9es du serveur" });
     }
     await mkdir6(target, { recursive: true });
     const root = await realpath(target);
     if (root !== base && !(root + sep).startsWith(base + sep)) {
-      throw new TRPCError17({ code: "FORBIDDEN", message: "Le dossier wiki r\xE9sout hors du dossier de donn\xE9es" });
+      throw new TRPCError18({ code: "FORBIDDEN", message: "Le dossier wiki r\xE9sout hors du dossier de donn\xE9es" });
     }
     return { mode: "local", root };
   }
   const serviceId = scope.slice("service:".length);
   const service = await serviceStore.get(serviceId);
-  if (!service) throw new TRPCError17({ code: "NOT_FOUND", message: "Service introuvable" });
+  if (!service) throw new TRPCError18({ code: "NOT_FOUND", message: "Service introuvable" });
   const agentId = await resolveEffectiveAgentId(service);
-  if (!agentId) throw new TRPCError17({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9 pour ce service" });
+  if (!agentId) throw new TRPCError18({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9 pour ce service" });
   const cwd = await resolveWorkspaceCwd({ serviceId, override: service.docsPath?.trim() || void 0 });
   return { mode: "agent", agentId, cwd };
 }
@@ -6037,7 +6083,7 @@ async function walkLocal(root, dir, depth, counter) {
 }
 async function resolveSafeLocal(root, relPath, requireExist) {
   if (relPath.includes("..") || relPath.startsWith("/")) {
-    throw new TRPCError17({ code: "BAD_REQUEST", message: "Chemin invalide" });
+    throw new TRPCError18({ code: "BAD_REQUEST", message: "Chemin invalide" });
   }
   const target = resolvePath(root, relPath);
   if (requireExist) {
@@ -6045,10 +6091,10 @@ async function resolveSafeLocal(root, relPath, requireExist) {
     try {
       real = await realpath(target);
     } catch {
-      throw new TRPCError17({ code: "NOT_FOUND", message: "Chemin introuvable" });
+      throw new TRPCError18({ code: "NOT_FOUND", message: "Chemin introuvable" });
     }
     if (real !== root && !(real + sep).startsWith(root + sep)) {
-      throw new TRPCError17({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
+      throw new TRPCError18({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
     }
     return real;
   }
@@ -6060,7 +6106,7 @@ async function resolveSafeLocal(root, relPath, requireExist) {
     realParent = parent;
   }
   if (realParent !== root && !(realParent + sep).startsWith(root + sep)) {
-    throw new TRPCError17({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
+    throw new TRPCError18({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
   }
   return resolvePath(realParent, target.slice(parent.length).replace(/^[\\/]+/, ""));
 }
@@ -6076,7 +6122,7 @@ var wikiRouter = router({
   }),
   read: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).output(z22.object({ path: z22.string(), content: z22.string() })).query(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
-      throw new TRPCError17({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
+      throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
@@ -6084,14 +6130,14 @@ var wikiRouter = router({
     }
     const file = await resolveSafeLocal(target.root, input.path, true);
     const s = await stat4(file);
-    if (!s.isFile()) throw new TRPCError17({ code: "BAD_REQUEST", message: "Pas un fichier" });
-    if (s.size > MAX_FILE_BYTES) throw new TRPCError17({ code: "PAYLOAD_TOO_LARGE", message: "Fichier trop volumineux" });
+    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 readFile3(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 }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
-      throw new TRPCError17({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
+      throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
@@ -6104,7 +6150,7 @@ var wikiRouter = router({
   }),
   createFile: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
-      throw new TRPCError17({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
+      throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
@@ -6113,9 +6159,9 @@ var wikiRouter = router({
     const file = await resolveSafeLocal(target.root, input.path, false);
     try {
       await stat4(file);
-      throw new TRPCError17({ code: "CONFLICT", message: "Fichier d\xE9j\xE0 existant" });
+      throw new TRPCError18({ code: "CONFLICT", message: "Fichier d\xE9j\xE0 existant" });
     } catch (err) {
-      if (err instanceof TRPCError17) throw err;
+      if (err instanceof TRPCError18) throw err;
     }
     await mkdir6(dirname3(file), { recursive: true });
     await writeFile5(file, "", "utf-8");
@@ -6139,9 +6185,9 @@ var wikiRouter = router({
     const to = await resolveSafeLocal(target.root, input.toPath, false);
     try {
       await stat4(to);
-      throw new TRPCError17({ code: "CONFLICT", message: "La cible existe d\xE9j\xE0" });
+      throw new TRPCError18({ code: "CONFLICT", message: "La cible existe d\xE9j\xE0" });
     } catch (err) {
-      if (err instanceof TRPCError17) throw err;
+      if (err instanceof TRPCError18) throw err;
     }
     await mkdir6(dirname3(to), { recursive: true });
     await rename3(from, to);
@@ -6154,9 +6200,9 @@ var wikiRouter = router({
     }
     const serviceId = input.scope.slice("service:".length);
     const service = await serviceStore.get(serviceId);
-    if (!service) throw new TRPCError17({ code: "NOT_FOUND", message: "Service introuvable" });
+    if (!service) throw new TRPCError18({ code: "NOT_FOUND", message: "Service introuvable" });
     const agentId = await resolveEffectiveAgentId(service);
-    if (!agentId) throw new TRPCError17({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9" });
+    if (!agentId) throw new TRPCError18({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9" });
     const cwd = await resolveWorkspaceCwd({ serviceId, override: service.docsPath?.trim() || void 0 });
     return agentManager.agentMutation(agentId, "wiki.ensureRoot", { cwd });
   }),
@@ -6166,7 +6212,7 @@ var wikiRouter = router({
       return agentManager.agentMutation(target.agentId, "wiki.deletePath", { cwd: target.cwd, path: input.path });
     }
     const fp = await resolveSafeLocal(target.root, input.path, true);
-    if (fp === target.root) throw new TRPCError17({ code: "FORBIDDEN", message: "Impossible de supprimer la racine" });
+    if (fp === target.root) throw new TRPCError18({ code: "FORBIDDEN", message: "Impossible de supprimer la racine" });
     await rm2(fp, { recursive: true, force: true });
     return { path: input.path, ok: true };
   })
@@ -6187,7 +6233,7 @@ var configRouter = router({
 
 // ../server/src/trpc/routers/cloud-sync.ts
 import { z as z23 } from "zod";
-import { TRPCError as TRPCError18 } from "@trpc/server";
+import { TRPCError as TRPCError19 } from "@trpc/server";
 
 // ../server/src/services/org-sync-scope.ts
 import { access } from "fs/promises";
@@ -7319,7 +7365,7 @@ async function assertOrgReadable(orgId) {
     await assertOrgVaultReadable(orgId);
   } catch (err) {
     if (err instanceof OrgVaultUnreadableError) {
-      throw new TRPCError18({ code: "FORBIDDEN", message: err.message });
+      throw new TRPCError19({ code: "FORBIDDEN", message: err.message });
     }
     throw err;
   }
@@ -7329,10 +7375,10 @@ async function assertOrgKey(orgId) {
     await reconcileOrgCanary(orgId);
   } catch (err) {
     if (err instanceof OrgKeyMismatchError) {
-      throw new TRPCError18({ code: "FORBIDDEN", message: err.message });
+      throw new TRPCError19({ code: "FORBIDDEN", message: err.message });
     }
     if (err instanceof CanaryUnavailableError) {
-      throw new TRPCError18({ code: "PRECONDITION_FAILED", message: err.message });
+      throw new TRPCError19({ code: "PRECONDITION_FAILED", message: err.message });
     }
     throw err;
   }
@@ -7371,7 +7417,7 @@ var cloudSyncRouter = router({
       return { pulled, state: syncState(input.orgId), heldBy: await syncLockHolder(input.orgId) };
     } catch (err) {
       if (err instanceof ProjectHeldElsewhereError) {
-        throw new TRPCError18({ code: "CONFLICT", message: err.code, cause: err });
+        throw new TRPCError19({ code: "CONFLICT", message: err.code, cause: err });
       }
       throw err;
     }
@@ -7398,10 +7444,10 @@ var cloudSyncRouter = router({
   ).mutation(async ({ input }) => {
     const local = await projectStore.get({ id: input.projectId, orgId: null });
     if (!local) {
-      throw new TRPCError18({ code: "NOT_FOUND", message: "PROJECT_NOT_LOCAL" });
+      throw new TRPCError19({ code: "NOT_FOUND", message: "PROJECT_NOT_LOCAL" });
     }
     if (await projectStore.get({ id: input.projectId, orgId: input.orgId })) {
-      throw new TRPCError18({ code: "CONFLICT", message: "PROJECT_ALREADY_IN_ORG" });
+      throw new TRPCError19({ code: "CONFLICT", message: "PROJECT_ALREADY_IN_ORG" });
     }
     await assertOrgReadable(input.orgId);
     const connected = cloudSyncBridge.states().some((s) => s.orgId === input.orgId);
@@ -7420,7 +7466,7 @@ var cloudSyncRouter = router({
       await cloudSyncBridge.followProject(input.orgId, input.projectId);
     } catch (err) {
       if (err instanceof ProjectHeldElsewhereError) {
-        throw new TRPCError18({ code: "CONFLICT", message: err.code, cause: err });
+        throw new TRPCError19({ code: "CONFLICT", message: err.code, cause: err });
       }
       throw err;
     }
@@ -7443,7 +7489,7 @@ var cloudSyncRouter = router({
       { method: "GET" }
     );
     if (!res.ok) {
-      throw new TRPCError18({ code: "BAD_GATEWAY", message: await cloudMessage(res) || `CANARY_READ_FAILED (${res.status})` });
+      throw new TRPCError19({ code: "BAD_GATEWAY", message: await cloudMessage(res) || `CANARY_READ_FAILED (${res.status})` });
     }
     const { canary } = await res.json();
     if (typeof canary !== "string") return { matches: false, published: false };
@@ -7510,7 +7556,7 @@ var cloudSyncRouter = router({
   resetOrgKey: protectedProcedure.input(z23.object({ orgId: z23.string().min(1).max(128) })).mutation(async ({ input }) => {
     const canary = await readVerifyFile(orgVaultRoot(input.orgId)) ?? await readVerifyFile(await keyRoot());
     if (!canary) {
-      throw new TRPCError18({
+      throw new TRPCError19({
         code: "PRECONDITION_FAILED",
         message: "Cette machine n'a pas encore de cl\xE9 de chiffrement."
       });
@@ -7521,7 +7567,7 @@ var cloudSyncRouter = router({
     });
     if (!res.ok) {
       const detail = await cloudMessage(res);
-      throw new TRPCError18({
+      throw new TRPCError19({
         code: res.status === 403 ? "FORBIDDEN" : "BAD_GATEWAY",
         message: detail || `ORG_KEY_RESET_FAILED (${res.status})`
       });
@@ -7567,8 +7613,8 @@ var cloudSyncRouter = router({
         body: { organizationId: input.orgId, projectId: input.projectId }
       });
     } catch (err) {
-      if (err instanceof TRPCError18 && err.code === "PRECONDITION_FAILED") {
-        throw new TRPCError18({ code: "PRECONDITION_FAILED", message: "CLOUD_NOT_LINKED" });
+      if (err instanceof TRPCError19 && err.code === "PRECONDITION_FAILED") {
+        throw new TRPCError19({ code: "PRECONDITION_FAILED", message: "CLOUD_NOT_LINKED" });
       }
       throw err;
     }
@@ -7576,12 +7622,12 @@ var cloudSyncRouter = router({
     const detail = await cloudMessage(res);
     if (res.status === 403) {
       const code = /not a member/i.test(detail) ? "PROJECT_NOT_MEMBER" : "PROJECT_DELETE_FORBIDDEN";
-      throw new TRPCError18({ code: "FORBIDDEN", message: code, cause: new Error(detail) });
+      throw new TRPCError19({ code: "FORBIDDEN", message: code, cause: new Error(detail) });
     }
     if (res.status === 404) {
-      throw new TRPCError18({ code: "NOT_FOUND", message: "PROJECT_NOT_IN_ORG", cause: new Error(detail) });
+      throw new TRPCError19({ code: "NOT_FOUND", message: "PROJECT_NOT_IN_ORG", cause: new Error(detail) });
     }
-    throw new TRPCError18({
+    throw new TRPCError19({
       code: "BAD_GATEWAY",
       message: detail || `PROJECT_DELETE_FAILED (${res.status})`
     });
@@ -7777,6 +7823,97 @@ var filesystemRouter = router({
   })
 });
 
+// ../server/src/trpc/routers/desktop.ts
+import { z as z25 } from "zod";
+import { isAbsolute as isAbsolute3 } from "path";
+import { TRPCError as TRPCError20 } from "@trpc/server";
+
+// ../server/src/services/desktop-launcher.ts
+import { execFile as execFile4 } from "child_process";
+import { isAbsolute as isAbsolute2 } from "path";
+import { promisify as promisify3 } from "util";
+var exec = promisify3(execFile4);
+var INSTALL_TIMEOUT_MS2 = 3e4;
+var cli = null;
+function registerCli(location) {
+  cli = location;
+}
+function suggestLauncher() {
+  const workingDir = process.cwd();
+  return {
+    available: cli !== null,
+    fromDesktop: env.FROM_DESKTOP,
+    workingDir,
+    name: deriveLauncherIdentity(void 0, workingDir).name,
+    port: env.PORT,
+    agentPort: env.RUNEYA_AGENT_PORT
+  };
+}
+async function installLauncher(input) {
+  if (!cli) throw new Error("launcher-unavailable");
+  if (input.workingDir !== null && !isAbsolute2(input.workingDir)) {
+    throw new Error("launcher-working-dir-not-absolute");
+  }
+  const args = [
+    cli.cliEntry,
+    "install-desktop",
+    ...input.workingDir === null ? ["--no-cwd"] : [input.workingDir],
+    "--name",
+    input.name,
+    "--port",
+    String(input.port),
+    "--agent-port",
+    String(input.agentPort)
+  ];
+  const { stdout, stderr } = await exec(cli.execPath, args, {
+    timeout: INSTALL_TIMEOUT_MS2,
+    windowsHide: true,
+    // Le rapport tient en quelques lignes ; au-delà, quelque chose a dérapé.
+    maxBuffer: 1024 * 1024,
+    // Sans terminal, le CLI n'ajoute pas de couleurs : la sortie est lisible telle quelle.
+    env: { ...process.env, NO_COLOR: "1" }
+  });
+  return { name: input.name, output: [stdout, stderr].filter((s) => s.trim()).join("\n").trim() };
+}
+
+// ../server/src/trpc/routers/desktop.ts
+var desktopRouter = router({
+  /** Ce que le CLI demanderait, prérempli avec l'instance en cours. */
+  suggestLauncher: protectedProcedure.query(() => suggestLauncher()),
+  installLauncher: protectedProcedure.input(z25.object({
+    name: z25.string().trim().min(1).max(120),
+    /**
+     * `null` : raccourci global, sans dossier épinglé. Sinon un chemin
+     * absolu, refusé autrement : le dossier devient un argument positionnel
+     * du CLI, où une valeur commençant par un tiret passerait pour un drapeau.
+     */
+    workingDir: z25.string().max(4096).refine(isAbsolute3, {
+      message: "Le dossier de travail doit \xEAtre un chemin absolu."
+    }).nullable(),
+    port: z25.number().int().min(1).max(65535),
+    agentPort: z25.number().int().min(1).max(65535)
+  })).mutation(async ({ input }) => {
+    try {
+      return await installLauncher(input);
+    } catch (err) {
+      const message = err.message;
+      if (message === "launcher-working-dir-not-absolute") {
+        throw new TRPCError20({
+          code: "BAD_REQUEST",
+          message: "Le dossier de travail doit \xEAtre un chemin absolu."
+        });
+      }
+      if (message === "launcher-unavailable") {
+        throw new TRPCError20({
+          code: "PRECONDITION_FAILED",
+          message: "Cette Runeya ne sait pas o\xF9 trouver son CLI : cr\xE9ez le raccourci avec `runeya install-desktop`."
+        });
+      }
+      throw new TRPCError20({ code: "INTERNAL_SERVER_ERROR", message });
+    }
+  })
+});
+
 // ../server/src/trpc/router.ts
 var appRouter = router({
   health: healthRouter,
@@ -7805,7 +7942,8 @@ var appRouter = router({
   config: configRouter,
   cloudSync: cloudSyncRouter,
   cloudAuth: cloudAuthRouter,
-  filesystem: filesystemRouter
+  filesystem: filesystemRouter,
+  desktop: desktopRouter
 });
 
 // ../server/src/middleware/error-handler.ts
@@ -9347,6 +9485,9 @@ async function createLocalServer() {
       console.warn("[server] Failed to start Claude transcript watcher:", err);
     });
     startCodexTranscriptWatcher();
+    await serviceStore.list().catch((err) => {
+      console.warn("[server] Failed to preload services:", err);
+    });
     cloudSyncBridge.start().catch((err) => {
       console.warn("[server] Failed to start cloud sync bridge:", err);
     });
@@ -9939,7 +10080,7 @@ async function createLocalServer() {
     ]);
     console.log("[server] Shutdown complete");
   };
-  const { initCompanion } = await import("./companion-JQGNL4U7.js");
+  const { initCompanion } = await import("./companion-6J6NK7H7.js");
   initCompanion();
   return { app, server, wss, shutdown };
 }
@@ -10026,6 +10167,46 @@ async function pullEnv(opts) {
   return Object.entries(env2).map(([key, value]) => `${key}=${value}`).join("\n");
 }
 
+// ../server/src/services/tray-services.ts
+async function listTrayServices() {
+  const [all, processes] = await Promise.all([serviceStore.list(), listAllProcesses()]);
+  const byServiceId = new Map(processes.map((p) => [p.serviceId, p]));
+  const services = all.map((service) => {
+    const status = byServiceId.get(service.id);
+    return {
+      id: service.id,
+      name: service.name,
+      agentId: status?.agentId ?? service.agentId ?? null,
+      running: status?.state === "running" || status?.state === "starting",
+      failed: status?.state === "errored" || status?.healthStatus === "unhealthy",
+      url: primaryServiceLink(service, "localhost")
+    };
+  });
+  const owned = await currentProjectServiceIds();
+  if (owned) return services.filter((service) => owned.has(service.id));
+  return services.filter((service) => service.running || service.failed);
+}
+async function currentProjectServiceIds() {
+  const ref = getCurrentProject();
+  if (!ref) return null;
+  const project = await projectStore.get(ref);
+  if (!project) return null;
+  return new Set(project.serviceIds);
+}
+function onTrayServicesChanged(listener) {
+  const onStatus = () => listener();
+  agentManager.on("process:status", onStatus);
+  const offServices = serviceStore.onChange(onStatus);
+  const offUnlock = onVaultUnlocked(onStatus);
+  const offProject = onCurrentProjectChanged(onStatus);
+  return () => {
+    agentManager.off("process:status", onStatus);
+    offServices();
+    offUnlock();
+    offProject();
+  };
+}
+
 // ../server/src/index.ts
 dotenv.config({ quiet: true });
 if (process.env["RUNEYA_DATA_DIR"]) {
@@ -10103,7 +10284,19 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 export {
   PullEnvError,
   createLocalServer,
+  killInstance,
+  listInstances,
+  listTrayServices,
+  networkInfo,
+  onTrayServicesChanged,
   pullEnv,
-  registerInstance
+  registerCli as registerCliLocation,
+  registerInstance,
+  restartInstance,
+  restartProcess,
+  scheduleSelfRestart,
+  setLanMode,
+  startProcess,
+  stopProcess
 };
-//# sourceMappingURL=src-HZ2XO6TV.js.map
+//# sourceMappingURL=src-V7DPPFCF.js.map