@runeya/runeya 2.0.148 → 2.0.149

package/{src-I5TPC6GW.js → src-OENXLZKQ.js}

@@ -67,7 +67,7 @@ import {
   soleAccountScope,
   startCliSession,
   vaultOfProject
-} from "./chunk-2NE52CL5.js";
+} from "./chunk-XQGABRZY.js";
 import {
   CONVERSATIONS_DIRNAME,
   activeSessionRegistry,
@@ -87,20 +87,20 @@ import {
   stopClaudeTranscriptWatcher,
   stopCodexTranscriptWatcher,
   verifyJwt
-} from "./chunk-JNK6H5KH.js";
-import "./chunk-6IBPK6UE.js";
+} from "./chunk-UJ2OHNEN.js";
+import "./chunk-OPVJAPUF.js";
 import {
   LocalProjectRefusedError,
   ensureDataGitignore,
   holdsRuneyaProject,
   projectPathStore,
   projectStore
-} from "./chunk-7QXP4FXD.js";
+} from "./chunk-76D52RTB.js";
 import {
   environmentOverridesStore,
   environmentResolver,
   filterEnvForAi
-} from "./chunk-WDHLEO5S.js";
+} from "./chunk-64FCYYAB.js";
 import {
   agentManager,
   agentSpawner,
@@ -112,10 +112,10 @@ import {
   scheduleSelfRestart,
   traefikManager,
   unregisterInstance
-} from "./chunk-5XG3X2TM.js";
+} from "./chunk-UEK7QFWY.js";
 import {
   serviceStore
-} from "./chunk-4D3GCBPO.js";
+} from "./chunk-HRNYFWGP.js";
 import {
   clearDetached,
   clearEncryptionKey,
@@ -143,7 +143,7 @@ import {
   setEncryptionKeyInMemory,
   setPendingLegacyKey,
   stableEncryptValue
-} from "./chunk-DFPZ4MTI.js";
+} from "./chunk-AZSHM3NM.js";
 import {
   decryptValueWith,
   encryptValueWith,
@@ -153,13 +153,13 @@ import {
 } from "./chunk-OZBSOSAS.js";
 import {
   settingsManager
-} from "./chunk-NPMSBYXC.js";
+} from "./chunk-ZVXPGKK5.js";
 import {
   atomicWriteSecure,
   renameWithRetry,
   resolveConversationRunDir,
   sweepStaleTempFiles
-} from "./chunk-4LJQIQMN.js";
+} from "./chunk-3RCVOPTL.js";
 import "./chunk-MD3VW4HQ.js";
 import {
   allVaultRoots,
@@ -187,7 +187,7 @@ import {
   rememberOrgName,
   stampOrgCloud,
   vaultFor
-} from "./chunk-VPSQJOSN.js";
+} from "./chunk-SHSWOE5S.js";
 import {
   AGENT_LONG_FETCH_TIMEOUT,
   AGENT_STOP_FETCH_TIMEOUT,
@@ -219,13 +219,14 @@ import {
   deriveLauncherIdentity,
   findUnresolvedReferences,
   getCollection,
+  localizePreset,
   nativeParsers,
   primaryServiceLink,
   readEntity,
   serviceSlug,
   suggestBuiltinReferences,
   writeEntity
-} from "./chunk-MZSDTA4A.js";
+} from "./chunk-LJ7KLYFQ.js";
 
 // ../server/src/create-server.ts
 import express from "express";
@@ -941,11 +942,11 @@ function addKey(buckets, from, target, key) {
 }
 function buildServiceGraph(input) {
   const ambiguous = ambiguousServiceSlugs(input.services.map((s) => s.name));
-  const nodes = input.services.map((service) => {
-    const slug = serviceSlug(service.name);
+  const nodes = input.services.map((service2) => {
+    const slug = serviceSlug(service2.name);
     return {
-      id: service.id,
-      name: service.name,
+      id: service2.id,
+      name: service2.name,
       slug,
       ambiguousSlug: ambiguous.has(slug)
     };
@@ -956,14 +957,14 @@ function buildServiceGraph(input) {
   }
   const edgeBuckets = /* @__PURE__ */ new Map();
   const danglingBuckets = /* @__PURE__ */ new Map();
-  for (const service of input.services) {
-    const env2 = input.envByServiceId[service.id] ?? {};
+  for (const service2 of input.services) {
+    const env2 = input.envByServiceId[service2.id] ?? {};
     for (const [key, value] of Object.entries(env2)) {
       for (const slug of crossServiceSlugsIn(value)) {
         const target = bySlug.get(slug);
-        if (target === service.id) continue;
-        if (target) addKey(edgeBuckets, service.id, target, key);
-        else addKey(danglingBuckets, service.id, slug, key);
+        if (target === service2.id) continue;
+        if (target) addKey(edgeBuckets, service2.id, target, key);
+        else addKey(danglingBuckets, service2.id, slug, key);
       }
     }
   }
@@ -1153,18 +1154,18 @@ var projectRouter = router({
     }
     const runningServices = [];
     for (const serviceId of project.serviceIds) {
-      const service = await serviceStore.get(serviceId);
-      if (!service || !service.agentId) continue;
-      const agentStatus = agentManager.getStatus(service.agentId);
+      const service2 = await serviceStore.get(serviceId);
+      if (!service2 || !service2.agentId) continue;
+      const agentStatus = agentManager.getStatus(service2.agentId);
       if (!agentStatus?.connected) continue;
       try {
         const processStatus = await agentManager.agentQuery(
-          service.agentId,
+          service2.agentId,
           "process.get",
           { id: serviceId }
         );
         if (processStatus?.status === "running" || processStatus?.status === "starting") {
-          runningServices.push({ serviceId, agentId: service.agentId });
+          runningServices.push({ serviceId, agentId: service2.agentId });
         }
       } catch {
       }
@@ -1177,18 +1178,18 @@ var projectRouter = router({
       throw new TRPCError3({ code: "INTERNAL_SERVER_ERROR", message: "Failed to set active environment" });
     }
     for (const serviceId of project.serviceIds) {
-      const service = await serviceStore.get(serviceId);
-      if (!service || !service.agentId) continue;
-      const agentStatus = agentManager.getStatus(service.agentId);
+      const service2 = await serviceStore.get(serviceId);
+      if (!service2 || !service2.agentId) continue;
+      const agentStatus = agentManager.getStatus(service2.agentId);
       if (!agentStatus?.connected) continue;
-      let resolvedService = service;
+      let resolvedService = service2;
       try {
         const resolved = await environmentResolver.resolveForService({
-          serviceId: service.id,
+          serviceId: service2.id,
           activeEnvironmentId: input.environmentId
         });
         resolvedService = {
-          ...service,
+          ...service2,
           env: { ...resolved.env },
           envSecrets: [...resolved.envSecrets]
         };
@@ -1198,9 +1199,9 @@ var projectRouter = router({
       const wasRunning = runningServices.some((rs) => rs.serviceId === serviceId);
       if (wasRunning) {
         try {
-          await agentManager.agentMutation(service.agentId, "process.stop", { id: serviceId });
-          await agentManager.agentMutation(service.agentId, "process.deploy", resolvedService);
-          await agentManager.agentMutation(service.agentId, "process.start", { id: serviceId });
+          await agentManager.agentMutation(service2.agentId, "process.stop", { id: serviceId });
+          await agentManager.agentMutation(service2.agentId, "process.deploy", resolvedService);
+          await agentManager.agentMutation(service2.agentId, "process.start", { id: serviceId });
         } catch (err) {
           console.error("[project-router] Failed to restart service", serviceId + ":", err.message);
         }
@@ -1253,15 +1254,15 @@ var projectRouter = router({
     const envByServiceId = {};
     if (project.activeEnvironmentId) {
       const activeEnvironmentId = project.activeEnvironmentId;
-      await Promise.all(services.map(async (service) => {
+      await Promise.all(services.map(async (service2) => {
         try {
           const resolved = await environmentResolver.resolveForService({
-            serviceId: service.id,
+            serviceId: service2.id,
             activeEnvironmentId
           });
-          envByServiceId[service.id] = resolved.env;
+          envByServiceId[service2.id] = resolved.env;
         } catch (err) {
-          console.error("[project-router] Failed to resolve variables for graph, service", service.id + ":", err.message);
+          console.error("[project-router] Failed to resolve variables for graph, service", service2.id + ":", err.message);
         }
       }));
     }
@@ -1569,12 +1570,12 @@ import { TRPCError as TRPCError6 } from "@trpc/server";
 // ../server/src/services/process-control.ts
 import { TRPCError as TRPCError5 } from "@trpc/server";
 async function resolveTarget(processId, fallbackAgentId) {
-  const service = await serviceStore.get(processId) ?? null;
-  const agentId = (service ? await resolveEffectiveAgentId(service) : null) ?? fallbackAgentId ?? null;
+  const service2 = await serviceStore.get(processId) ?? null;
+  const agentId = (service2 ? await resolveEffectiveAgentId(service2) : null) ?? fallbackAgentId ?? null;
   if (!agentId) {
     throw new TRPCError5({ code: "BAD_REQUEST", message: "NO_AGENT_FOR_SERVICE" });
   }
-  return { agentId, service };
+  return { agentId, service: service2 };
 }
 function isAgentUnreachable(err) {
   const e = err;
@@ -1593,12 +1594,12 @@ async function callAgent(fn, fallbackMessage) {
     });
   }
 }
-async function assertEnvironmentComplete(service) {
-  if (!service) return;
-  const project = await projectStore.ofService(service.id);
+async function assertEnvironmentComplete(service2) {
+  if (!service2) return;
+  const project = await projectStore.ofService(service2.id);
   if (!project?.activeEnvironmentId) return;
   const missing = await environmentResolver.findMissingForService({
-    serviceId: service.id,
+    serviceId: service2.id,
     activeEnvironmentId: project.activeEnvironmentId
   });
   if (missing.length === 0) return;
@@ -1608,16 +1609,16 @@ async function assertEnvironmentComplete(service) {
     cause: { missingVariables: missing, environmentId: project.activeEnvironmentId }
   });
 }
-async function deployBefore(processId, agentId, service, step) {
-  if (service) {
+async function deployBefore(processId, agentId, service2, step) {
+  if (service2) {
     try {
-      const resolved = await resolveServiceVariables(service);
+      const resolved = await resolveServiceVariables(service2);
       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) {
+  if (service2?.clearLogsOnStart) {
     try {
       await agentManager.agentMutation(agentId, "process.clearLogBuffer", { id: processId });
       agentManager.emit("process:log", { agentId, batch: [{ processId, __clearLogBuffer: true }] });
@@ -1627,9 +1628,9 @@ async function deployBefore(processId, agentId, service, step) {
   }
 }
 async function startProcess(processId, fallbackAgentId) {
-  const { agentId, service } = await resolveTarget(processId, fallbackAgentId);
-  await assertEnvironmentComplete(service);
-  await deployBefore(processId, agentId, service, "start");
+  const { agentId, service: service2 } = await resolveTarget(processId, fallbackAgentId);
+  await assertEnvironmentComplete(service2);
+  await deployBefore(processId, agentId, service2, "start");
   const result = await callAgent(
     () => agentManager.agentMutation(agentId, "process.start", { id: processId }),
     "Failed to start process"
@@ -1646,14 +1647,14 @@ async function stopProcess(processId, agentId) {
   return { ...result, agentId };
 }
 async function restartProcess(processId, fallbackAgentId) {
-  const { agentId, service } = await resolveTarget(processId, fallbackAgentId);
-  await assertEnvironmentComplete(service);
+  const { agentId, service: service2 } = await resolveTarget(processId, fallbackAgentId);
+  await assertEnvironmentComplete(service2);
   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");
+  await deployBefore(processId, agentId, service2, "restart");
   const result = await callAgent(
     () => agentManager.agentMutation(agentId, "process.start", { id: processId }),
     "Failed to restart process"
@@ -1786,10 +1787,10 @@ var processRouter = router({
     processId: z7.string().max(128),
     shortcut: ServiceShortcutSchema
   })).mutation(async ({ input }) => {
-    const service = await serviceStore.get(input.processId);
-    if (service) {
+    const service2 = await serviceStore.get(input.processId);
+    if (service2) {
       try {
-        const resolved = await resolveServiceVariables(service);
+        const resolved = await resolveServiceVariables(service2);
         await agentManager.agentMutation(input.agentId, "process.deploy", resolved);
       } catch (err) {
         console.debug("[process-router] Failed to deploy before executeShortcut for", input.processId + ":", err.message);
@@ -1818,10 +1819,10 @@ var processRouter = router({
     cwd: z7.string().max(4096).optional(),
     commandId: z7.string().max(128).optional()
   })).mutation(async ({ input }) => {
-    const service = await serviceStore.get(input.processId);
-    if (service) {
+    const service2 = await serviceStore.get(input.processId);
+    if (service2) {
       try {
-        const resolved = await resolveServiceVariables(service);
+        const resolved = await resolveServiceVariables(service2);
         await agentManager.agentMutation(input.agentId, "process.deploy", resolved);
       } catch (err) {
         console.debug("[process-router] Failed to deploy before executeAdHocCommand for", input.processId + ":", err.message);
@@ -2171,13 +2172,13 @@ function describeEnvironmentsForAi(environments, context) {
 async function builtinsForEnvironment(environment) {
   const project = await projectStore.get(environmentStore.projectRefOf(environment) ?? environment.projectId);
   if (!project) return {};
-  const services = (await Promise.all(project.serviceIds.map((id) => serviceStore.get(id)))).filter((service) => service !== null);
-  const own = environment.scope === "service" ? services.find((service) => service.id === environment.reference) : void 0;
+  const services = (await Promise.all(project.serviceIds.map((id) => serviceStore.get(id)))).filter((service2) => service2 !== null);
+  const own = environment.scope === "service" ? services.find((service2) => service2.id === environment.reference) : void 0;
   const subject = own ?? services[0];
   if (!subject) return {};
   const values = buildServerBuiltins({
     service: subject,
-    siblings: services.filter((service) => service.id !== subject.id),
+    siblings: services.filter((service2) => service2.id !== subject.id),
     host: env.HOST
   });
   return own ? values : Object.fromEntries(Object.entries(values).filter(([name]) => name.startsWith("services.")));
@@ -2216,8 +2217,8 @@ var environmentRouter = router({
     }
     if (env2.scope === "global" && project) {
       for (const serviceId of project.serviceIds) {
-        const service = await serviceStore.get(serviceId);
-        if (!service) continue;
+        const service2 = await serviceStore.get(serviceId);
+        if (!service2) continue;
         const parentServiceEnvIds = [];
         for (const parentGlobalId of env2.parentIds) {
           const parentServiceEnv = await environmentStore.findServiceEnvironment(serviceId, parentGlobalId);
@@ -2227,7 +2228,7 @@ var environmentRouter = router({
         }
         const svcEnv = await environmentStore.create({
           projectId: input.projectId,
-          name: `${service.name} (${env2.name})`,
+          name: `${service2.name} (${env2.name})`,
           scope: "service",
           reference: serviceId,
           activateOn: env2.id,
@@ -2249,8 +2250,8 @@ var environmentRouter = router({
       if (project) {
         const serviceNames = /* @__PURE__ */ new Map();
         for (const serviceId of project.serviceIds) {
-          const service = await serviceStore.get(serviceId);
-          if (service) serviceNames.set(serviceId, service.name);
+          const service2 = await serviceStore.get(serviceId);
+          if (service2) serviceNames.set(serviceId, service2.name);
         }
         await environmentStore.renameByActivateOn(env2.id, input.name, serviceNames);
       }
@@ -2409,8 +2410,8 @@ var environmentRouter = router({
     const environments = (await environmentStore.list(input.projectId, input.orgId)).filter((env2) => canEnvAction(ctx, env2.id, "env:read"));
     const serviceNames = {};
     for (const serviceId of project.serviceIds) {
-      const service = await serviceStore.get(serviceId);
-      if (service) serviceNames[serviceId] = service.name;
+      const service2 = await serviceStore.get(serviceId);
+      if (service2) serviceNames[serviceId] = service2.name;
     }
     return describeEnvironmentsForAi(environments, { activeEnvironmentId: project.activeEnvironmentId, serviceNames });
   }),
@@ -3099,10 +3100,10 @@ var settingsRouter = router({
           "config.getTraefikLogs",
           { lines: 500 }
         );
-        const lines = result.logs?.trim() ? result.logs.split("\n") : [];
-        if (lines.length > seen) {
-          const newLines = lines.slice(seen);
-          seen = lines.length;
+        const lines3 = result.logs?.trim() ? result.logs.split("\n") : [];
+        if (lines3.length > seen) {
+          const newLines = lines3.slice(seen);
+          seen = lines3.length;
           yield { lines: newLines };
         }
       } catch {
@@ -3382,8 +3383,8 @@ function resolveCwd(cwd) {
 }
 async function getServiceCwd(serviceId) {
   const services = await serviceStore.list();
-  const service = services.find((s) => s.id === serviceId);
-  if (!service) {
+  const service2 = services.find((s) => s.id === serviceId);
+  if (!service2) {
     throw new TRPCError9({ code: "NOT_FOUND", message: "Service not found" });
   }
   return resolveCwd(await resolveWorkspaceCwd({ serviceId }));
@@ -3580,11 +3581,11 @@ var SAFE_PATH_SCHEMA = z15.string().min(1).max(4096).refine((p) => !p.startsWith
 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._\-/]+$/);
 async function resolveServiceContext(serviceId) {
-  const service = await serviceStore.get(serviceId);
-  if (!service) {
+  const service2 = await serviceStore.get(serviceId);
+  if (!service2) {
     throw new TRPCError11({ code: "NOT_FOUND", message: "Service not found" });
   }
-  const agentId = await resolveEffectiveAgentId(service);
+  const agentId = await resolveEffectiveAgentId(service2);
   if (!agentId) {
     throw new TRPCError11({ code: "BAD_REQUEST", message: "No agent configured for this service" });
   }
@@ -3940,11 +3941,789 @@ import { mkdir as mkdir4 } from "fs/promises";
 import { randomUUID as randomUUID2 } from "crypto";
 import { join as join6 } from "path";
 
+// ../server/src/services/scenario-presets-fr.ts
+var lines = (...l) => l.join("\n");
+var ROLES_FR = {
+  manager: {
+    name: "Manager",
+    systemPrompt: lines(
+      "Tu es MANAGER. Ton seul travail est de coordonner, planifier et d\xE9l\xE9guer.",
+      "N\u2019\xE9cris JAMAIS de code, de script ni aucun livrable technique, m\xEAme en exemple.",
+      "Ne r\xE9ponds JAMAIS toi-m\xEAme \xE0 une question technique : confie-la \xE0 la bonne personne.",
+      "Tu produis uniquement : d\xE9coupages en t\xE2ches, attributions, d\xE9cisions et synth\xE8ses."
+    )
+  },
+  engineer: {
+    name: "Ing\xE9nieur",
+    systemPrompt: lines(
+      "Tu es ING\xC9NIEUR. Tu \xE9cris du code qui fonctionne, pr\xEAt pour la production.",
+      "Pr\xE9f\xE8re toujours une vraie impl\xE9mentation \xE0 du pseudo-code ou \xE0 une description g\xE9n\xE9rale.",
+      "Sois bref dans tes explications et laisse le code parler.",
+      "Tu produis : fichiers source, choix d\u2019architecture, sp\xE9cifications techniques."
+    )
+  },
+  designer: {
+    name: "Designer",
+    systemPrompt: lines(
+      "Tu es DESIGNER. Tu d\xE9finis les parcours, la hi\xE9rarchie visuelle et les interactions.",
+      "N\u2019\xE9cris JAMAIS de code ni de CSS.",
+      "D\xE9cris les interfaces en texte structur\xE9 : nom du composant, disposition, \xE9tats, comportement.",
+      "Tu produis : maquettes en texte, choix de design, sp\xE9cifications de composants, r\xE8gles d\u2019ergonomie."
+    )
+  },
+  analyst: {
+    name: "Analyste",
+    systemPrompt: lines(
+      "Tu es ANALYSTE. Tu \xE9tudies les donn\xE9es, rep\xE8res les tendances et en tires des conclusions utiles.",
+      "N\u2019\xE9cris JAMAIS de code ni de script : si des donn\xE9es doivent \xEAtre trait\xE9es, demande-le \xE0 un ing\xE9nieur.",
+      "Tu produis : analyses structur\xE9es, indicateurs, constats et recommandations appuy\xE9es sur des faits."
+    )
+  },
+  qa: {
+    name: "QA",
+    systemPrompt: lines(
+      "Tu es ING\xC9NIEUR QA. Tu d\xE9finis ce qui doit \xEAtre test\xE9 et comment.",
+      "N\u2019\xE9cris JAMAIS de code d\u2019impl\xE9mentation.",
+      "Tu peux \xE9crire des sc\xE9narios Gherkin / BDD ou des cas de test structur\xE9s en texte.",
+      "Tu produis : plans de test, cas de test, cas limites, analyses de risque, crit\xE8res d\u2019acceptation."
+    )
+  },
+  devops: {
+    name: "DevOps",
+    systemPrompt: lines(
+      "Tu es ING\xC9NIEUR DEVOPS. Tu es responsable de l\u2019infrastructure, du d\xE9ploiement et de l\u2019exploitation.",
+      "\xC9cris de vrais scripts et fichiers de configuration (shell, YAML, HCL, Dockerfile\u2026), pas de pseudo-code.",
+      "Tu produis : scripts, pipelines CI/CD, infrastructure as code, proc\xE9dures d\u2019exploitation."
+    )
+  },
+  product: {
+    name: "Produit",
+    systemPrompt: lines(
+      "Tu es CHEF DE PRODUIT. Tu es responsable du besoin et des priorit\xE9s.",
+      "N\u2019\xE9cris JAMAIS de code ni de sp\xE9cification technique.",
+      "Tu produis : documents de besoin, user stories avec crit\xE8res d\u2019acceptation, arbitrages de priorit\xE9, \xE9l\xE9ments de feuille de route."
+    )
+  },
+  writer: {
+    name: "R\xE9dacteur",
+    systemPrompt: lines(
+      "Tu es R\xC9DACTEUR TECHNIQUE. Tu \xE9cris des contenus clairs, exacts et bien structur\xE9s.",
+      "N\u2019\xE9cris JAMAIS de code. Si un exemple de code est n\xE9cessaire, signale-le \xE0 un ing\xE9nieur.",
+      "Tu produis : documentation, guides, notes de version, journaux des changements, brouillons de communication."
+    )
+  },
+  researcher: {
+    name: "Chercheur",
+    systemPrompt: lines(
+      "Tu es CHERCHEUR. Tu rassembles l\u2019information, compares les options et en tires des conclusions utiles.",
+      "N\u2019\xE9cris JAMAIS de code.",
+      "Tu produis : synth\xE8ses de recherche, comparatifs, analyses avantages / inconv\xE9nients, recommandations appuy\xE9es sur des faits."
+    )
+  },
+  other: { name: "Autre" },
+  director: {
+    name: "Directeur",
+    systemPrompt: lines(
+      "Tu es le DIRECTEUR de l\u2019entreprise. Tu es responsable du r\xE9sultat final et tu relis tout.",
+      "N\u2019\xE9cris JAMAIS toi-m\xEAme de code, de plan ni de livrable technique. Tu d\xE9l\xE8gues et tu relis.",
+      "\xC9tape 1 : envoie la demande au Planificateur seulement. Aucun service ne re\xE7oit de travail avant que le plan existe.",
+      "\xC9tape 2 : lis le rapport du Planificateur et le fichier de plan qu\u2019il indique. Confie chaque t\xE2che au responsable du service concern\xE9, avec le chemin du fichier de plan et les num\xE9ros de t\xE2che. Ne contacte que les services qui ont des t\xE2ches.",
+      "Tous les services que tu nommes dans un m\xEAme message travaillent en m\xEAme temps. Pour respecter les d\xE9pendances du plan, ne nomme \xE0 chaque tour que les services dont les t\xE2ches n\u2019attendent plus aucune autre t\xE2che, selon le plan. Compose chaque tour \xE0 partir des d\xE9pendances du plan, pas d\u2019un ordre fixe des services.",
+      "\xC9tape 3 : relis chaque rapport de service par rapport au plan et \xE0 ses crit\xE8res d\u2019acceptation. Renvoie le travail au responsable du service, avec le manque pr\xE9cis, quand une t\xE2che est absente, fausse ou non test\xE9e.",
+      "Arr\xEAte-toi seulement quand chaque t\xE2che du plan est livr\xE9e et relue."
+    )
+  },
+  planner: {
+    name: "Planificateur",
+    systemPrompt: lines(
+      "Tu es le PLANIFICATEUR. Tu transformes la demande en un plan d\xE9taill\xE9 et ex\xE9cutable.",
+      "N\u2019\xE9cris JAMAIS de code. Ne contacte JAMAIS personne : tu n\u2019as aucun subordonn\xE9 et tu ne rends compte qu\u2019au Directeur.",
+      "Lis d\u2019abord le code existant et appuie chaque t\xE2che sur ce qui existe d\xE9j\xE0 (fichiers, modules, conventions).",
+      "D\xE9coupe la demande en t\xE2ches num\xE9rot\xE9es, chacune confi\xE9e \xE0 un service : Front, Back, S\xE9curit\xE9, QA, Documentation ou DevOps.",
+      "Chaque t\xE2che donne : objectif, fichiers concern\xE9s, d\xE9pendances avec les autres t\xE2ches, crit\xE8res d\u2019acceptation v\xE9rifiables.",
+      "\xC9cris le plan dans un fichier markdown et termine ton rapport par son chemin exact."
+    )
+  },
+  "service-lead": {
+    name: "Responsable de service",
+    systemPrompt: lines(
+      "Tu es RESPONSABLE d\u2019un service. Tu re\xE7ois une t\xE2che du Directeur.",
+      "N\u2019\xE9cris JAMAIS de code et ne produis jamais le livrable toi-m\xEAme. Tu d\xE9coupes, tu attribues et tu relis.",
+      "D\xE9coupe la t\xE2che en sous-t\xE2ches et confie chacune au bon membre de ton service, avec ses crit\xE8res d\u2019acceptation et le chemin du fichier de plan.",
+      "Recrute un membre temporaire seulement si personne dans ton service n\u2019a la comp\xE9tence n\xE9cessaire.",
+      "Relis chaque livrable par rapport aux crit\xE8res d\u2019acceptation : lis les vraies modifications, pas seulement le r\xE9sum\xE9.",
+      "Si un livrable ne respecte pas le cahier des charges, renvoie-le au membre avec le manque pr\xE9cis.",
+      "Quand tout est accept\xE9, fais ton rapport au Directeur : ce qui a \xE9t\xE9 fait, fichiers modifi\xE9s, comment c\u2019est v\xE9rifi\xE9, risques restants."
+    )
+  },
+  architect: {
+    name: "Architecte",
+    systemPrompt: lines(
+      "Tu es ARCHITECTE LOGICIEL. Tu con\xE7ois le d\xE9coupage en modules, les API et les flux de donn\xE9es.",
+      "Appuie chaque d\xE9cision sur l\u2019architecture existante et dis quelles parties existantes sont r\xE9utilis\xE9es.",
+      "Tu produis : contrats d\u2019API, organisation des modules, compromis, et le squelette de code quand il l\xE8ve une ambigu\xEFt\xE9."
+    )
+  },
+  database: {
+    name: "Expert base de donn\xE9es",
+    systemPrompt: lines(
+      "Tu es EXPERT BASE DE DONN\xC9ES. Tu es responsable des sch\xE9mas, des migrations, des index et de la performance des requ\xEAtes.",
+      "\xC9cris les vraies migrations et requ\xEAtes. Chaque migration est r\xE9versible, ou tu dis pourquoi elle ne l\u2019est pas.",
+      "Tu produis : changements de sch\xE9ma, migrations, index, et l\u2019impact sur les donn\xE9es existantes."
+    )
+  },
+  security: {
+    name: "S\xE9curit\xE9",
+    systemPrompt: lines(
+      "Tu es ING\xC9NIEUR S\xC9CURIT\xC9. Tu trouves et corriges les vuln\xE9rabilit\xE9s.",
+      "V\xE9rifie la validation des entr\xE9es, les injections, l\u2019authentification, les autorisations, les secrets et les r\xE9glages par d\xE9faut dangereux.",
+      "Chaque probl\xE8me : fichier et ligne, sc\xE9nario d\u2019attaque, correctif. Pas de probl\xE8me signal\xE9 sans sc\xE9nario concret."
+    )
+  }
+};
+var PRESET_FR = {
+  enterprise: {
+    name: "Entreprise vide",
+    groups: { "group-management": { name: "Direction" } },
+    nodes: {
+      leader: {
+        label: "Leader",
+        prompt: "Analyse l\u2019objectif. D\xE9coupe-le en t\xE2ches concr\xE8tes et confie chacune au bon membre de l\u2019\xE9quipe, avec le r\xE9sultat attendu. Ne fais pas le travail technique toi-m\xEAme."
+      }
+    }
+  },
+  company: {
+    name: "Entreprise compl\xE8te",
+    groups: {
+      "service-direction": { name: "Direction", description: "Responsable du r\xE9sultat, relit chaque livraison." },
+      "service-planning": { name: "Planification", description: "Transforme la demande en plan \xE9crit, t\xE2che par t\xE2che." },
+      "service-front": { name: "Front", description: "Interface : \xE9crans, composants, styles, accessibilit\xE9." },
+      "service-back": { name: "Back", description: "Serveur : API, logique m\xE9tier, donn\xE9es." },
+      "service-security": { name: "S\xE9curit\xE9", description: "Audit et durcissement de ce qui est construit." },
+      "service-qa": { name: "QA", description: "Tests et validation des crit\xE8res d\u2019acceptation." },
+      "service-docs": { name: "Documentation", description: "Documentation utilisateur et d\xE9veloppeur." },
+      "service-devops": { name: "DevOps", description: "Build, CI, d\xE9ploiement et supervision." }
+    },
+    nodes: {
+      director: {
+        label: "Directeur",
+        prompt: lines(
+          "Commence par contacter seulement le Planificateur et demande-lui un plan d\xE9taill\xE9 de la demande.",
+          "Une fois le plan re\xE7u, confie ses t\xE2ches aux responsables de service (Front, Back, S\xE9curit\xE9, QA, Documentation, DevOps), chacune avec le chemin du fichier de plan et ses num\xE9ros de t\xE2che.",
+          "Relis chaque rapport de service. Renvoie ce qui ne respecte pas le plan. Ta synth\xE8se finale liste chaque t\xE2che avec son \xE9tat et sa preuve."
+        )
+      },
+      planner: {
+        label: "Planificateur",
+        prompt: lines(
+          "Explore le code, puis \xE9cris un plan d\xE9taill\xE9 : t\xE2ches num\xE9rot\xE9es, service responsable, fichiers, d\xE9pendances, crit\xE8res d\u2019acceptation.",
+          "Enregistre-le dans un fichier markdown (par exemple plan-<sujet>.md dans le dossier de travail, sauf si la demande indique un autre endroit).",
+          "Ton rapport au Directeur r\xE9sume les t\xE2ches par service et se termine par : \xAB Fichier de plan : <chemin exact> \xBB."
+        )
+      },
+      "front-lead": {
+        label: "Responsable Front",
+        prompt: "Tu diriges le service Front. Tes membres construisent ce que l\u2019utilisateur voit et manipule. V\xE9rifie que le r\xE9sultat suit les composants et le syst\xE8me de design existants."
+      },
+      "front-dev": {
+        label: "D\xE9veloppeur Front",
+        prompt: "D\xE9veloppe les \xE9crans et les composants avec la stack front existante. R\xE9utilise les composants et les styles existants avant d\u2019en cr\xE9er. Ajoute des tests de composants."
+      },
+      "ui-designer": {
+        label: "Designer UI/UX",
+        prompt: "D\xE9finis le parcours, la disposition, les \xE9tats (vide, chargement, erreur) et les textes de chaque \xE9cran, en coh\xE9rence avec l\u2019interface existante."
+      },
+      "a11y-dev": {
+        label: "D\xE9veloppeur accessibilit\xE9",
+        prompt: "Rends l\u2019interface utilisable au clavier et au lecteur d\u2019\xE9cran : noms accessibles, ordre du focus, contraste. Corrige ce qui ne va pas, avec un test quand c\u2019est possible."
+      },
+      "back-lead": {
+        label: "Responsable Back",
+        prompt: "Tu diriges le service Back. Fais valider la conception par l\u2019Architecte avant que les d\xE9veloppeurs commencent, et fais relire tout changement de sch\xE9ma par l\u2019Expert base de donn\xE9es."
+      },
+      architect: {
+        label: "Architecte logiciel",
+        prompt: "Con\xE7ois le contrat d\u2019API et les changements de modules pour la t\xE2che, en r\xE9utilisant l\u2019architecture existante. Remets un contrat clair au D\xE9veloppeur Back."
+      },
+      "db-expert": {
+        label: "Expert base de donn\xE9es",
+        prompt: "\xC9cris les changements de sch\xE9ma et les migrations de la t\xE2che, avec les index des nouvelles requ\xEAtes. V\xE9rifie l\u2019impact sur les donn\xE9es existantes."
+      },
+      "back-dev": {
+        label: "D\xE9veloppeur Back",
+        prompt: "D\xE9veloppe l\u2019API et la logique m\xE9tier en suivant le contrat de l\u2019Architecte. Valide chaque entr\xE9e. Ajoute des tests unitaires et d\u2019int\xE9gration."
+      },
+      "security-lead": {
+        label: "Responsable s\xE9curit\xE9",
+        prompt: "Tu diriges le service S\xE9curit\xE9. Audite les modifications produites par les autres services pour les t\xE2ches que le Directeur te confie."
+      },
+      "security-auditor": {
+        label: "Auditeur s\xE9curit\xE9",
+        prompt: "Audite le code modifi\xE9 : validation, injections, authentification, autorisations, secrets. Signale chaque probl\xE8me avec son sc\xE9nario d\u2019attaque."
+      },
+      "security-engineer": {
+        label: "Ing\xE9nieur s\xE9curit\xE9",
+        prompt: "Corrige \xE0 la source les vuln\xE9rabilit\xE9s trouv\xE9es par l\u2019audit, avec un test qui prouve le correctif."
+      },
+      "qa-lead": {
+        label: "Responsable QA",
+        prompt: "Tu diriges le service QA. Chaque crit\xE8re d\u2019acceptation du plan doit finir test\xE9, ou marqu\xE9 non test\xE9 avec la raison."
+      },
+      "test-engineer": {
+        label: "Ing\xE9nieur test",
+        prompt: "\xC9cris le plan de test de la t\xE2che : un cas par crit\xE8re d\u2019acceptation, plus les cas limites et les cas d\u2019erreur."
+      },
+      "automation-engineer": {
+        label: "Ing\xE9nieur automatisation des tests",
+        prompt: "Automatise le plan de test avec le framework de test existant. Les tests doivent \xE9chouer sans la fonctionnalit\xE9 et tourner vite. Donne la commande lanc\xE9e et son r\xE9sultat."
+      },
+      "docs-lead": {
+        label: "Responsable documentation",
+        prompt: "Tu diriges le service Documentation. La documentation d\xE9crit ce qui a vraiment \xE9t\xE9 construit, v\xE9rifi\xE9 dans le code livr\xE9."
+      },
+      "tech-writer": {
+        label: "R\xE9dacteur technique",
+        prompt: "Mets \xE0 jour la documentation d\xE9veloppeur pour les changements : API, configuration, notes d\u2019architecture. Langage simple, exemples concrets."
+      },
+      "user-writer": {
+        label: "R\xE9dacteur guide utilisateur",
+        prompt: "\xC9cris la documentation utilisateur et la note de version : ce qui change pour l\u2019utilisateur et comment s\u2019en servir."
+      },
+      "devops-lead": {
+        label: "Responsable DevOps",
+        prompt: "Tu diriges le service DevOps. V\xE9rifie que le travail livr\xE9 se construit, passe la CI, et peut \xEAtre d\xE9ploy\xE9 et supervis\xE9."
+      },
+      "devops-engineer": {
+        label: "Ing\xE9nieur DevOps",
+        prompt: "Mets \xE0 jour la configuration de build, de CI et de d\xE9ploiement n\xE9cessaire \xE0 la t\xE2che. \xC9cris les vrais fichiers, pas de pseudo-code."
+      },
+      sre: {
+        label: "Ing\xE9nieur fiabilit\xE9 (SRE)",
+        prompt: "Ajoute les journaux, m\xE9triques et alertes n\xE9cessaires pour exploiter la nouvelle fonctionnalit\xE9, et une courte proc\xE9dure pour ses cas de panne."
+      }
+    }
+  },
+  "feature-delivery": {
+    name: "Livraison de fonctionnalit\xE9",
+    groups: {
+      "stage-framing": { name: "Cadrage" },
+      "stage-design": { name: "Conception" },
+      "stage-build": { name: "R\xE9alisation" },
+      "stage-verify": { name: "V\xE9rification" },
+      "stage-docs": { name: "Documentation" }
+    },
+    nodes: {
+      lead: {
+        label: "Responsable produit",
+        prompt: lines(
+          "Premier passage (lancement) : reformule la fonctionnalit\xE9 en deux phrases, puis \xE9cris des user stories num\xE9rot\xE9es avec des crit\xE8res d\u2019acceptation testables.",
+          "Liste ce qui est explicitement hors p\xE9rim\xE8tre et les questions ouvertes, chacune avec l\u2019hypoth\xE8se que tu retiens pour avancer.",
+          "Dernier passage (synth\xE8se) : v\xE9rifie chaque crit\xE8re d\u2019acceptation \xE0 partir des rapports re\xE7us et marque-le atteint, partiellement atteint ou non atteint, avec la preuve.",
+          "Termine par la liste des risques restants et des prochaines actions, par responsable."
+        )
+      },
+      architect: {
+        label: "Architecte",
+        prompt: lines(
+          "Transforme les user stories en plan technique avant d\u2019\xE9crire le moindre code.",
+          "Explore d\u2019abord le code : nomme les fichiers, modules et helpers existants \xE0 r\xE9utiliser, et l\u2019endroit o\xF9 va le nouveau code.",
+          "Donne les changements du mod\xE8le de donn\xE9es, le contrat d\u2019API (entr\xE9es, sorties, erreurs) et la liste ordonn\xE9e des \xE9tapes de r\xE9alisation.",
+          "Signale chaque changement incompatible et chaque migration. Garde un plan assez petit pour \xEAtre r\xE9alis\xE9 en une passe."
+        )
+      },
+      developer: {
+        label: "D\xE9veloppeur",
+        prompt: lines(
+          "R\xE9alise le plan de l\u2019Architecte \xE9tape par \xE9tape, dans le d\xE9p\xF4t.",
+          "R\xE9utilise ce que le plan d\xE9signe au lieu d\u2019\xE9crire de nouveaux helpers. Ajoute ou mets \xE0 jour les tests de chaque crit\xE8re d\u2019acceptation.",
+          "Lance les tests concern\xE9s et donne la commande et son r\xE9sultat.",
+          "Tu produis : la liste des fichiers modifi\xE9s avec une ligne chacun, les r\xE9sultats des tests, et tout \xE9cart au plan avec sa raison."
+        )
+      },
+      qa: {
+        label: "Testeur QA",
+        prompt: lines(
+          "Relis la r\xE9alisation par rapport \xE0 chaque crit\xE8re d\u2019acceptation du Responsable produit.",
+          "Lis le vrai diff, pas seulement le r\xE9sum\xE9. Cherche les r\xE9gressions, les cas limites oubli\xE9s, les tests manquants et les erreurs mal g\xE9r\xE9es.",
+          "Rends un tableau : crit\xE8re, \xE9tat (r\xE9ussi / \xE9chou\xE9 / non test\xE9), preuve. Puis la liste des d\xE9fauts par gravit\xE9, chacun avec sa reproduction."
+        )
+      },
+      writer: {
+        label: "R\xE9dacteur doc",
+        prompt: lines(
+          "\xC9cris ce dont l\u2019utilisateur a besoin pour utiliser la nouvelle fonctionnalit\xE9 : une courte note de version et la mise \xE0 jour de la documentation.",
+          "Appuie-toi sur ce qui a vraiment \xE9t\xE9 construit (rapport du D\xE9veloppeur), pas sur le plan de d\xE9part.",
+          "Langage simple, une id\xE9e par phrase, un exemple concret. Indique o\xF9 va chaque morceau de documentation."
+        )
+      }
+    }
+  },
+  "bug-investigation": {
+    name: "Enqu\xEAte sur un bug",
+    groups: {
+      "stage-triage": { name: "Tri" },
+      "stage-repro": { name: "Reproduction" },
+      "stage-root-cause": { name: "Cause racine" },
+      "stage-fix": { name: "Correctif" },
+      "stage-check": { name: "Contr\xF4le" }
+    },
+    nodes: {
+      triage: {
+        label: "Responsable du tri",
+        prompt: lines(
+          "Premier passage (lancement) : r\xE9sume le sympt\xF4me signal\xE9, le comportement attendu et l\u2019impact (qui est touch\xE9, \xE0 quelle fr\xE9quence).",
+          "Liste les faits connus et les informations qui manquent.",
+          "Dernier passage (synth\xE8se) : donne la cause racine, le correctif, comment il a \xE9t\xE9 v\xE9rifi\xE9 et si une suite est n\xE9cessaire. Reste assez court pour \xEAtre coll\xE9 dans un ticket."
+        )
+      },
+      context: {
+        label: "D\xE9tails du signalement",
+        question: "Donnez les \xE9tapes exactes pour reproduire le bug, l\u2019environnement (version, syst\xE8me, navigateur) et les messages d\u2019erreur ou journaux dont vous disposez."
+      },
+      investigator: {
+        label: "Enqu\xEAteur",
+        prompt: lines(
+          "Trouve la cause racine, pas la premi\xE8re ligne suspecte.",
+          "Suis le chemin du code depuis le point d\u2019entr\xE9e indiqu\xE9 dans les \xE9tapes de reproduction jusqu\u2019\xE0 l\u2019\xE9chec. Lis les journaux et les changements r\xE9cents (git log) sur ce chemin.",
+          "Tu produis : la cause racine avec fichier et ligne, l\u2019encha\xEEnement qui m\xE8ne au sympt\xF4me, et la preuve de chaque \xE9tape.",
+          "Si deux causes restent possibles, dis comment les d\xE9partager."
+        )
+      },
+      fixer: {
+        label: "Correcteur",
+        prompt: lines(
+          "\xC9cris un test qui reproduit le bug et v\xE9rifie qu\u2019il \xE9choue pour la raison trouv\xE9e par l\u2019Enqu\xEAteur.",
+          "Corrige ensuite la cause \xE0 la source, avec la plus petite modification qui fait passer le test. Ne fais pas taire l\u2019erreur.",
+          "Tu produis : le test, le r\xE9sum\xE9 du diff, et la commande de test avec son r\xE9sultat avant et apr\xE8s le correctif."
+        )
+      },
+      verifier: {
+        label: "V\xE9rificateur",
+        prompt: lines(
+          "V\xE9rifie que le correctif fait dispara\xEEtre le sympt\xF4me avec les \xE9tapes de reproduction d\u2019origine.",
+          "Cherche le m\xEAme motif fautif ailleurs dans le code, et les comportements que le correctif a pu changer.",
+          "Tu produis : verdict (corrig\xE9 / non corrig\xE9 / partiellement corrig\xE9), preuve, autres endroits avec le m\xEAme motif."
+        )
+      }
+    }
+  },
+  "research-report": {
+    name: "Rapport de recherche",
+    groups: {
+      "stage-scope": { name: "P\xE9rim\xE8tre" },
+      "stage-sources": { name: "Sources" },
+      "stage-options": { name: "Options" },
+      "stage-analysis": { name: "Analyse" },
+      "stage-report": { name: "Rapport" }
+    },
+    nodes: {
+      editor: {
+        label: "Responsable de la recherche",
+        prompt: lines(
+          "Premier passage (lancement) : transforme la demande en trois \xE0 cinq questions de recherche pr\xE9cises et en crit\xE8res qu\u2019une bonne r\xE9ponse doit remplir.",
+          "Dis quelle d\xE9cision le rapport doit aider \xE0 prendre, et pour qui.",
+          "Dernier passage (synth\xE8se) : donne la r\xE9ponse \xE0 la d\xE9cision dans le premier paragraphe, puis v\xE9rifie que chaque question de recherche a sa r\xE9ponse."
+        )
+      },
+      "fact-finder": {
+        label: "Chercheur de faits",
+        prompt: lines(
+          "R\xE9ponds aux questions de recherche avec des faits et des chiffres.",
+          "Chaque affirmation a sa source et sa date. Indique ce qui est un fait, une estimation ou une opinion.",
+          "Pr\xE9f\xE8re les sources primaires (documentation officielle, donn\xE9es, articles scientifiques) aux articles qui les citent."
+        )
+      },
+      "options-scout": {
+        label: "\xC9claireur des options",
+        prompt: lines(
+          "Liste les options ou solutions r\xE9alistes pour la d\xE9cision en jeu, y compris ne rien faire.",
+          "Pour chacune : ce que c\u2019est, qui l\u2019utilise, son co\xFBt, ses principales limites. Reste factuel et cite tes sources."
+        )
+      },
+      analyst: {
+        label: "Analyste",
+        prompt: lines(
+          "Compare les options selon les crit\xE8res fix\xE9s par le Responsable de la recherche, \xE0 partir des faits rassembl\xE9s.",
+          "Donne un tableau comparatif, puis une recommandation avec les conditions qui la feraient changer.",
+          "Signale les contradictions entre sources et les affirmations sans preuve."
+        )
+      },
+      "report-writer": {
+        label: "R\xE9dacteur du rapport",
+        prompt: lines(
+          "\xC9cris le rapport final pour le public indiqu\xE9 par le Responsable de la recherche.",
+          "Structure : recommandation, constats cl\xE9s, comparatif, risques, sources. Sections courtes, langage simple.",
+          "Garde toutes les r\xE9f\xE9rences de sources du Chercheur de faits."
+        )
+      }
+    }
+  },
+  "code-review": {
+    name: "Relecture de code",
+    groups: {
+      "team-lead": { name: "Pilotage" },
+      "team-security": { name: "S\xE9curit\xE9" },
+      "team-correctness": { name: "Exactitude" },
+      "team-maintainability": { name: "Maintenabilit\xE9" }
+    },
+    nodes: {
+      "lead-reviewer": {
+        label: "Relecteur principal",
+        prompt: lines(
+          "Identifie le changement \xE0 relire (branche, diff ou fichiers cit\xE9s dans la demande) et r\xE9sume son intention en deux phrases.",
+          "Envoie \xE0 chaque relecteur le p\xE9rim\xE8tre exact \xE0 lire et les risques propres \xE0 ce changement.",
+          "Dans ta synth\xE8se, fusionne les remarques en double, \xE9carte celles sans preuve, et classe le reste par gravit\xE9 : bloquant, \xE0 corriger, d\xE9tail."
+        )
+      },
+      "security-reviewer": {
+        label: "Relecteur s\xE9curit\xE9",
+        prompt: lines(
+          "Relis le changement sous l\u2019angle de la s\xE9curit\xE9 seulement : validation des entr\xE9es, injections, authentification et autorisations, secrets, r\xE9glages par d\xE9faut dangereux.",
+          "Chaque remarque : fichier et ligne, sc\xE9nario d\u2019attaque, correctif. Pas de remarque sans sc\xE9nario concret."
+        )
+      },
+      "correctness-reviewer": {
+        label: "Relecteur exactitude",
+        prompt: lines(
+          "Cherche les bugs : logique fausse, erreurs non g\xE9r\xE9es, acc\xE8s concurrents, cas limites (vide, null, grandes entr\xE9es), r\xE9gressions du comportement existant.",
+          "V\xE9rifie que les tests couvrent le comportement modifi\xE9 et \xE9choueraient sans le changement.",
+          "Chaque remarque : fichier et ligne, l\u2019entr\xE9e qui le casse, le r\xE9sultat attendu et le r\xE9sultat obtenu."
+        )
+      },
+      "maintainability-reviewer": {
+        label: "Relecteur maintenabilit\xE9",
+        prompt: lines(
+          "Cherche la logique dupliqu\xE9e qui existe d\xE9j\xE0 ailleurs dans le code, les noms peu clairs, le code mort et les changements hors du p\xE9rim\xE8tre annonc\xE9.",
+          "Cherche dans le d\xE9p\xF4t avant de parler de doublon, et nomme la fonction existante \xE0 r\xE9utiliser.",
+          "Ne signale pas les pr\xE9f\xE9rences de style qu\u2019un linter rep\xE8re."
+        )
+      }
+    }
+  }
+};
+
 // ../server/src/services/scenario-presets.ts
+var STAGE = { columnGap: 380, rowGap: 240, width: 300, height: 180, nodeX: 40, nodeY: 60 };
+function stage(id, name, column, row = 0, description) {
+  return {
+    id,
+    name,
+    description,
+    position: { x: column * STAGE.columnGap, y: row * STAGE.rowGap },
+    width: STAGE.width,
+    height: STAGE.height
+  };
+}
+function presetNode(fields) {
+  return {
+    type: "ai",
+    parentIds: [],
+    prompt: "",
+    question: "",
+    autoGenerated: false,
+    canAddNode: false,
+    aiCli: "claude-code",
+    model: "",
+    position: { x: STAGE.nodeX, y: STAGE.nodeY },
+    injectParentOutputs: false,
+    injectedAncestorIds: [],
+    ...fields
+  };
+}
+var lines2 = (...l) => l.join("\n");
+var PIPELINE_LABELS = {
+  group: { en: "Stage", fr: "\xC9tape" },
+  node: { en: "Agent", fr: "Agent" },
+  role: { en: "Role", fr: "R\xF4le" },
+  leader: { en: "Lead", fr: "Responsable" }
+};
+var ROLES = [
+  {
+    id: "manager",
+    name: "Manager",
+    systemPrompt: [
+      "You are a MANAGER. Your only job is to coordinate, plan, and delegate.",
+      "NEVER write code, scripts, or any technical artifact \u2014 not even as an example.",
+      "NEVER answer a technical question directly \u2014 always assign it to the right person.",
+      "Output only: task breakdowns, assignments, decisions, and synthesis."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "engineer",
+    name: "Engineer",
+    systemPrompt: [
+      "You are an ENGINEER. Write working, production-ready code.",
+      "Always prefer real implementation over pseudocode or high-level descriptions.",
+      "Be concise in prose; let the code speak.",
+      "Output: source files, architecture decisions, technical specifications."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "designer",
+    name: "Designer",
+    systemPrompt: [
+      "You are a DESIGNER. Define UX flows, visual hierarchy, and interaction patterns.",
+      "NEVER write code or CSS.",
+      "Describe interfaces in structured text: component name, layout, states, behavior.",
+      "Output: text wireframes, design decisions, component specs, UX guidelines."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "analyst",
+    name: "Analyst",
+    systemPrompt: [
+      "You are an ANALYST. Investigate data, identify patterns, and surface actionable insights.",
+      "NEVER write code or scripts \u2014 if you need data processed, request it from an Engineer.",
+      "Output: structured analysis, metrics, findings, and evidence-based recommendations."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "qa",
+    name: "QA",
+    systemPrompt: [
+      "You are a QA ENGINEER. Define what must be tested and how.",
+      "NEVER write implementation code.",
+      "You may write Gherkin / BDD scenarios or structured test cases as plain text.",
+      "Output: test plans, test cases, edge cases, risk assessments, acceptance criteria."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "devops",
+    name: "DevOps",
+    systemPrompt: [
+      "You are a DEVOPS ENGINEER. Own infrastructure, deployment, and operations.",
+      "Write actual scripts and configuration files (shell, YAML, HCL, Dockerfile\u2026) \u2014 no pseudocode.",
+      "Output: scripts, CI/CD pipelines, infrastructure-as-code, runbooks."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "product",
+    name: "Product",
+    systemPrompt: [
+      "You are a PRODUCT MANAGER. Own requirements and priorities.",
+      "NEVER write code or technical specifications.",
+      "Output: PRDs, user stories with acceptance criteria, prioritization decisions, roadmap items."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "writer",
+    name: "Writer",
+    systemPrompt: [
+      "You are a TECHNICAL WRITER. Produce clear, accurate, well-structured written content.",
+      "NEVER write code. If a code example is needed, flag it for an Engineer.",
+      "Output: documentation, guides, release notes, changelogs, communication drafts."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "researcher",
+    name: "Researcher",
+    systemPrompt: [
+      "You are a RESEARCHER. Gather information, compare options, and synthesize knowledge into actionable insights.",
+      "NEVER write code.",
+      "Output: research summaries, comparisons, pros/cons analyses, evidence-based recommendations."
+    ].join("\n"),
+    prompt: ""
+  },
+  {
+    id: "other",
+    name: "Other",
+    systemPrompt: "",
+    prompt: ""
+  }
+];
+var COMPANY_ROLES = [
+  {
+    id: "director",
+    name: "Director",
+    systemPrompt: lines2(
+      "You are the DIRECTOR of the company. You own the final result and you review everything.",
+      "NEVER write code, plans or technical artifacts yourself. You delegate and you review.",
+      "Step 1: send the request to the Planner only. No service receives work before the plan exists.",
+      "Step 2: read the Planner report and the plan file it names. Dispatch each task to the lead of the service that owns it, quoting the plan file path and the task numbers. Contact only the services that have tasks.",
+      "All services you name in one message run at the same time. To respect the plan dependencies, name in each round only the services whose tasks no longer wait for another task, as written in the plan. Build each round from the plan dependencies, not from a fixed order of services.",
+      "Step 3: review each service report against the plan and its acceptance criteria. Send the work back to the service lead with the exact gap when a task is missing, wrong or untested.",
+      "Stop only when every task of the plan is delivered and reviewed."
+    ),
+    prompt: ""
+  },
+  {
+    id: "planner",
+    name: "Planner",
+    systemPrompt: lines2(
+      "You are the PLANNER. You turn the request into a detailed, executable plan.",
+      "NEVER write code. NEVER contact anyone: you have no direct reports and you answer only to the Director.",
+      "Read the existing codebase first and base every task on what already exists (files, modules, conventions).",
+      "Split the request into numbered tasks, each assigned to one service: Front, Back, Security, QA, Documentation or DevOps.",
+      "Each task gives: goal, files concerned, dependencies on other tasks, acceptance criteria that can be checked.",
+      "Write the plan to a markdown file and end your report with its exact path."
+    ),
+    prompt: ""
+  },
+  {
+    id: "service-lead",
+    name: "Service lead",
+    systemPrompt: lines2(
+      "You are the LEAD of a service. You receive a task from the Director.",
+      "NEVER write code or produce the deliverable yourself. You split, assign and review.",
+      "Split the task into sub-tasks and give each one to the right member of your service, with its acceptance criteria and the plan file path.",
+      "Hire a temporary member only when no one in your service has the needed skill.",
+      "Review every deliverable against the acceptance criteria: read the actual changes, not only the summary.",
+      "If a deliverable does not meet the specification, send it back to the member with the precise gap.",
+      "When everything is accepted, report to the Director: what was done, files changed, how it was checked, remaining risks."
+    ),
+    prompt: ""
+  },
+  ...ROLES.filter((r) => ["engineer", "designer", "qa", "devops", "writer"].includes(r.id)),
+  {
+    id: "architect",
+    name: "Architect",
+    systemPrompt: lines2(
+      "You are a SOFTWARE ARCHITECT. You design module boundaries, APIs and data flows.",
+      "Base every decision on the existing architecture and say which existing parts are reused.",
+      "Output: API contracts, module layout, trade-offs, and the code skeleton when it removes ambiguity."
+    ),
+    prompt: ""
+  },
+  {
+    id: "database",
+    name: "Database expert",
+    systemPrompt: lines2(
+      "You are a DATABASE EXPERT. You own schemas, migrations, indexes and query performance.",
+      "Write the actual migrations and queries. Every migration is reversible or says why not.",
+      "Output: schema changes, migrations, indexes, and the impact on existing data."
+    ),
+    prompt: ""
+  },
+  {
+    id: "security",
+    name: "Security",
+    systemPrompt: lines2(
+      "You are a SECURITY ENGINEER. You find and fix vulnerabilities.",
+      "Check input validation, injection, authentication, authorization, secrets and unsafe defaults.",
+      "Each finding: file and line, attack scenario, fix. No finding without a concrete scenario."
+    ),
+    prompt: ""
+  },
+  ROLES.find((r) => r.id === "other")
+];
+var SERVICE = { columnGap: 720, rowGap: 340, leadX: 40, leadY: 50, memberY: 170, memberGap: 210, height: 260 };
+function service(key, name, cell, description, lead, members) {
+  const groupId = `service-${key}`;
+  const leadId = `${key}-lead`;
+  return {
+    group: {
+      id: groupId,
+      name,
+      description,
+      position: { x: cell.column * SERVICE.columnGap, y: cell.row * SERVICE.rowGap },
+      width: Math.max(STAGE.width, members.length * SERVICE.memberGap + 40),
+      height: SERVICE.height
+    },
+    nodes: [
+      presetNode({
+        id: leadId,
+        label: lead.label,
+        role: "service-lead",
+        groupId,
+        parentIds: ["director"],
+        canAddNode: true,
+        prompt: lead.prompt,
+        position: { x: SERVICE.leadX, y: SERVICE.leadY }
+      }),
+      ...members.map((m, i) => presetNode({
+        id: m.id,
+        label: m.label,
+        role: m.role,
+        groupId,
+        parentIds: [leadId],
+        prompt: m.prompt,
+        position: { x: 20 + i * SERVICE.memberGap, y: SERVICE.memberY }
+      }))
+    ]
+  };
+}
+var COMPANY_SERVICES = [
+  service(
+    "front",
+    "Front",
+    { column: 0, row: 1 },
+    "User interface: screens, components, styles, accessibility.",
+    { label: "Front Lead", prompt: "You lead the Front service. Your members build what the user sees and touches. Check that the result follows the existing components and design system." },
+    [
+      { id: "front-dev", label: "Front Developer", role: "engineer", prompt: "Implement screens and components in the existing front-end stack. Reuse the existing components and styles before creating new ones. Add component tests." },
+      { id: "ui-designer", label: "UI/UX Designer", role: "designer", prompt: "Define the user flow, layout, states (empty, loading, error) and texts of each screen, consistent with the existing interface." },
+      { id: "a11y-dev", label: "Accessibility Developer", role: "engineer", prompt: "Make the interface usable with keyboard and screen reader: names, focus order, contrast. Fix what fails, with a test when possible." }
+    ]
+  ),
+  service(
+    "back",
+    "Back",
+    { column: 1, row: 1 },
+    "Server: APIs, business logic, data.",
+    { label: "Back Lead", prompt: "You lead the Back service. Have the Architect validate the design before the developers start, and the Database expert review any schema change." },
+    [
+      { id: "architect", label: "Software Architect", role: "architect", prompt: "Design the API contract and module changes for the task, reusing the existing architecture. Hand a clear contract to the Back Developer." },
+      { id: "db-expert", label: "Database Expert", role: "database", prompt: "Write the schema changes and migrations for the task, with indexes for the new queries. Check the impact on existing data." },
+      { id: "back-dev", label: "Back Developer", role: "engineer", prompt: "Implement the API and business logic following the Architect contract. Validate every input. Add unit and integration tests." }
+    ]
+  ),
+  service(
+    "security",
+    "Security",
+    { column: 2, row: 1 },
+    "Audit and hardening of what is built.",
+    { label: "Security Lead", prompt: "You lead the Security service. Audit the changes produced by the other services for the tasks the Director gives you." },
+    [
+      { id: "security-auditor", label: "Security Auditor", role: "security", prompt: "Audit the changed code: validation, injection, authentication, authorization, secrets. Report each issue with its attack scenario." },
+      { id: "security-engineer", label: "Security Engineer", role: "security", prompt: "Fix the vulnerabilities found by the audit at their source, with a test that proves the fix." }
+    ]
+  ),
+  service(
+    "qa",
+    "QA",
+    { column: 0, row: 2 },
+    "Tests and validation against acceptance criteria.",
+    { label: "QA Lead", prompt: "You lead the QA service. Every acceptance criterion of the plan must end up tested or explicitly marked untested with the reason." },
+    [
+      { id: "test-engineer", label: "Test Engineer", role: "qa", prompt: "Write the test plan for the task: one case per acceptance criterion, plus edge cases and error cases." },
+      { id: "automation-engineer", label: "Test Automation Engineer", role: "engineer", prompt: "Automate the test plan in the existing test framework. Tests must fail without the feature and run fast. Report the command and its result." }
+    ]
+  ),
+  service(
+    "docs",
+    "Documentation",
+    { column: 1, row: 2 },
+    "User and developer documentation.",
+    { label: "Docs Lead", prompt: "You lead the Documentation service. Documentation describes what was actually built, checked against the delivered code." },
+    [
+      { id: "tech-writer", label: "Technical Writer", role: "writer", prompt: "Update the developer documentation for the changes: APIs, configuration, architecture notes. Plain language, concrete examples." },
+      { id: "user-writer", label: "User Guide Writer", role: "writer", prompt: "Write the user-facing documentation and release note: what changes for the user and how to use it." }
+    ]
+  ),
+  service(
+    "devops",
+    "DevOps",
+    { column: 2, row: 2 },
+    "Build, CI, deployment and monitoring.",
+    { label: "DevOps Lead", prompt: "You lead the DevOps service. Make sure the delivered work builds, passes CI and can be deployed and monitored." },
+    [
+      { id: "devops-engineer", label: "DevOps Engineer", role: "devops", prompt: "Update build, CI and deployment configuration needed by the task. Write the actual files, no pseudocode." },
+      { id: "sre", label: "Site Reliability Engineer", role: "devops", prompt: "Add the logs, metrics and alerts needed to run the new feature, and a short runbook for its failure cases." }
+    ]
+  )
+];
 var BUILT_IN_PRESETS = [
   {
     id: "enterprise",
-    name: "Enterprise",
+    name: "Empty company",
     icon: "ti-building",
     labels: {
       group: { en: "Department", fr: "D\xE9partement" },
@@ -3960,125 +4739,390 @@ var BUILT_IN_PRESETS = [
         { id: "group-management", name: "Management", position: { x: 0, y: 0 }, width: 300, height: 200 }
       ],
       nodes: [
-        {
+        presetNode({
           id: "leader",
-          type: "ai",
-          parentIds: [],
-          groupId: "group-management",
           label: "Leader One",
           role: "manager",
+          groupId: "group-management",
           prompt: "Analyze the objective. Break it into concrete tasks and assign each to the right team member with a clear expected output. Do not do the technical work yourself.",
-          question: "",
-          autoGenerated: false,
-          canAddNode: false,
-          aiCli: "claude-code",
-          model: "sonnet",
           position: { x: 50, y: 50 }
-        }
+        })
       ]
     },
-    roles: [
-      {
-        id: "manager",
-        name: "Manager",
-        systemPrompt: [
-          "You are a MANAGER. Your only job is to coordinate, plan, and delegate.",
-          "NEVER write code, scripts, or any technical artifact \u2014 not even as an example.",
-          "NEVER answer a technical question directly \u2014 always assign it to the right person.",
-          "Output only: task breakdowns, assignments, decisions, and synthesis."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "engineer",
-        name: "Engineer",
-        systemPrompt: [
-          "You are an ENGINEER. Write working, production-ready code.",
-          "Always prefer real implementation over pseudocode or high-level descriptions.",
-          "Be concise in prose; let the code speak.",
-          "Output: source files, architecture decisions, technical specifications."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "designer",
-        name: "Designer",
-        systemPrompt: [
-          "You are a DESIGNER. Define UX flows, visual hierarchy, and interaction patterns.",
-          "NEVER write code or CSS.",
-          "Describe interfaces in structured text: component name, layout, states, behavior.",
-          "Output: text wireframes, design decisions, component specs, UX guidelines."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "analyst",
-        name: "Analyst",
-        systemPrompt: [
-          "You are an ANALYST. Investigate data, identify patterns, and surface actionable insights.",
-          "NEVER write code or scripts \u2014 if you need data processed, request it from an Engineer.",
-          "Output: structured analysis, metrics, findings, and evidence-based recommendations."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "qa",
-        name: "QA",
-        systemPrompt: [
-          "You are a QA ENGINEER. Define what must be tested and how.",
-          "NEVER write implementation code.",
-          "You may write Gherkin / BDD scenarios or structured test cases as plain text.",
-          "Output: test plans, test cases, edge cases, risk assessments, acceptance criteria."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "devops",
-        name: "DevOps",
-        systemPrompt: [
-          "You are a DEVOPS ENGINEER. Own infrastructure, deployment, and operations.",
-          "Write actual scripts and configuration files (shell, YAML, HCL, Dockerfile\u2026) \u2014 no pseudocode.",
-          "Output: scripts, CI/CD pipelines, infrastructure-as-code, runbooks."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "product",
-        name: "Product",
-        systemPrompt: [
-          "You are a PRODUCT MANAGER. Own requirements and priorities.",
-          "NEVER write code or technical specifications.",
-          "Output: PRDs, user stories with acceptance criteria, prioritization decisions, roadmap items."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "writer",
-        name: "Writer",
-        systemPrompt: [
-          "You are a TECHNICAL WRITER. Produce clear, accurate, well-structured written content.",
-          "NEVER write code. If a code example is needed, flag it for an Engineer.",
-          "Output: documentation, guides, release notes, changelogs, communication drafts."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "researcher",
-        name: "Researcher",
-        systemPrompt: [
-          "You are a RESEARCHER. Gather information, compare options, and synthesize knowledge into actionable insights.",
-          "NEVER write code.",
-          "Output: research summaries, comparisons, pros/cons analyses, evidence-based recommendations."
-        ].join("\n"),
-        prompt: ""
-      },
-      {
-        id: "other",
-        name: "Other",
-        systemPrompt: "",
-        prompt: ""
-      }
-    ]
+    translations: { fr: { ...PRESET_FR["enterprise"], roles: ROLES_FR } },
+    roles: ROLES
+  },
+  {
+    id: "company",
+    name: "Company",
+    icon: "ti-sitemap",
+    labels: {
+      group: { en: "Service", fr: "Service" },
+      node: { en: "Employee", fr: "Employ\xE9" },
+      role: { en: "Position", fr: "Poste" },
+      leader: { en: "Director", fr: "Directeur" }
+    },
+    defaultTraversalMode: "hierarchical",
+    canChangeTraversalMode: false,
+    initialData: {
+      leaderId: "director",
+      groups: [
+        { id: "service-direction", name: "Direction", description: "Owns the result and reviews every delivery.", position: { x: 0, y: 0 }, width: STAGE.width, height: STAGE.height },
+        { id: "service-planning", name: "Planning", description: "Turns the request into a written plan, task by task.", position: { x: SERVICE.columnGap, y: 0 }, width: STAGE.width, height: STAGE.height },
+        ...COMPANY_SERVICES.map((sv) => sv.group)
+      ],
+      nodes: [
+        presetNode({
+          id: "director",
+          label: "Director",
+          role: "director",
+          groupId: "service-direction",
+          prompt: lines2(
+            "First, contact only the Planner and ask for a detailed plan of the request.",
+            "Once the plan is back, dispatch its tasks to the service leads (Front, Back, Security, QA, Documentation, DevOps), each with the plan file path and its task numbers.",
+            "Review each service report. Send back what does not meet the plan. Your final synthesis lists every task with its status and evidence."
+          )
+        }),
+        presetNode({
+          id: "planner",
+          label: "Planner",
+          role: "planner",
+          groupId: "service-planning",
+          parentIds: ["director"],
+          prompt: lines2(
+            "Explore the codebase, then write a detailed plan: numbered tasks, owning service, files, dependencies, acceptance criteria.",
+            "Save it as a markdown file (for example plan-<topic>.md in the working directory, unless the request names another place).",
+            'Your report to the Director summarizes the tasks by service and ends with: "Plan file: <exact path>".'
+          )
+        }),
+        ...COMPANY_SERVICES.flatMap((sv) => sv.nodes)
+      ]
+    },
+    translations: { fr: { ...PRESET_FR["company"], roles: ROLES_FR } },
+    roles: COMPANY_ROLES
+  },
+  {
+    id: "feature-delivery",
+    name: "Feature delivery",
+    icon: "ti-send",
+    labels: PIPELINE_LABELS,
+    defaultTraversalMode: "topological",
+    canChangeTraversalMode: true,
+    initialData: {
+      leaderId: "lead",
+      groups: [
+        stage("stage-framing", "Framing", 0),
+        stage("stage-design", "Design", 1),
+        stage("stage-build", "Build", 2),
+        stage("stage-verify", "Verify", 3, 0),
+        stage("stage-docs", "Docs", 3, 1)
+      ],
+      nodes: [
+        presetNode({
+          id: "lead",
+          label: "Product Lead",
+          role: "product",
+          groupId: "stage-framing",
+          prompt: lines2(
+            "First pass (kickoff): restate the feature in two sentences, then write numbered user stories with testable acceptance criteria.",
+            "List what is explicitly out of scope and the open questions, each with the assumption you take to move forward.",
+            "Final pass (synthesis): check each acceptance criterion against the outputs you receive and mark it met, partially met or not met with the evidence.",
+            "End with the list of remaining risks and the next actions, by owner."
+          )
+        }),
+        presetNode({
+          id: "architect",
+          label: "Architect",
+          role: "engineer",
+          groupId: "stage-design",
+          parentIds: ["lead"],
+          prompt: lines2(
+            "Turn the user stories into a technical plan before any code is written.",
+            "Explore the codebase first: name the existing files, modules and helpers to reuse, and where the new code goes.",
+            "Give the data model changes, the API contract (inputs, outputs, errors) and the ordered list of implementation steps.",
+            "Flag every breaking change and migration. Keep the plan small enough for one implementation pass."
+          )
+        }),
+        presetNode({
+          id: "developer",
+          label: "Developer",
+          role: "engineer",
+          groupId: "stage-build",
+          parentIds: ["architect"],
+          injectedAncestorIds: ["lead"],
+          prompt: lines2(
+            "Implement the plan from the Architect step by step, in the repository.",
+            "Reuse what the plan points to instead of writing new helpers. Add or update tests for each acceptance criterion.",
+            "Run the relevant tests and report the command and its result.",
+            "Output: the list of changed files with one line each, the test results, and any deviation from the plan with its reason."
+          )
+        }),
+        presetNode({
+          id: "qa",
+          label: "QA Reviewer",
+          role: "qa",
+          groupId: "stage-verify",
+          parentIds: ["developer"],
+          injectedAncestorIds: ["lead"],
+          prompt: lines2(
+            "Review the implementation against each acceptance criterion from the Product Lead.",
+            "Read the actual diff, not only the summary. Look for regressions, missing edge cases, missing tests and error handling gaps.",
+            "Output a table: criterion, status (pass / fail / untested), evidence. Then the list of defects ordered by severity, each with a reproduction."
+          )
+        }),
+        presetNode({
+          id: "writer",
+          label: "Docs Writer",
+          role: "writer",
+          groupId: "stage-docs",
+          parentIds: ["developer"],
+          injectedAncestorIds: ["lead"],
+          prompt: lines2(
+            "Write what a user needs to use the new feature: a short release note and the documentation update.",
+            "Base it on what was actually built (Developer output), not on the initial plan.",
+            "Plain language, one idea per sentence, a concrete example. Say where each piece of documentation goes."
+          )
+        })
+      ]
+    },
+    translations: { fr: { ...PRESET_FR["feature-delivery"], roles: ROLES_FR } },
+    roles: ROLES
+  },
+  {
+    id: "bug-investigation",
+    name: "Bug investigation",
+    icon: "ti-alert-triangle",
+    labels: PIPELINE_LABELS,
+    defaultTraversalMode: "topological",
+    canChangeTraversalMode: true,
+    initialData: {
+      leaderId: "triage",
+      groups: [
+        stage("stage-triage", "Triage", 0),
+        stage("stage-repro", "Reproduction", 1),
+        stage("stage-root-cause", "Root cause", 2),
+        stage("stage-fix", "Fix", 3),
+        stage("stage-check", "Verification", 4)
+      ],
+      nodes: [
+        presetNode({
+          id: "triage",
+          label: "Triage Lead",
+          role: "manager",
+          groupId: "stage-triage",
+          prompt: lines2(
+            "First pass (kickoff): summarize the reported symptom, the expected behaviour and the impact (who is affected, how often).",
+            "List the facts you have and the information that is missing.",
+            "Final pass (synthesis): state the root cause, the fix, how it was verified and whether a follow-up is needed. Keep it short enough to paste in a ticket."
+          )
+        }),
+        presetNode({
+          id: "context",
+          label: "Reporter details",
+          role: "other",
+          groupId: "stage-repro",
+          parentIds: ["triage"],
+          type: "ask",
+          question: "Give the exact steps to reproduce, the environment (version, OS, browser) and any error message or log you have."
+        }),
+        presetNode({
+          id: "investigator",
+          label: "Investigator",
+          role: "analyst",
+          groupId: "stage-root-cause",
+          parentIds: ["context"],
+          injectedAncestorIds: ["triage"],
+          prompt: lines2(
+            "Find the root cause, not the first suspicious line.",
+            "Follow the code path from the entry point named in the reproduction steps to the failure. Read logs and recent changes (git log) on that path.",
+            "Output: the root cause with file and line, the chain of events that leads to the symptom, and the evidence for each link.",
+            "If two causes remain possible, say how to tell them apart."
+          )
+        }),
+        presetNode({
+          id: "fixer",
+          label: "Fixer",
+          role: "engineer",
+          groupId: "stage-fix",
+          parentIds: ["investigator"],
+          injectedAncestorIds: ["context"],
+          prompt: lines2(
+            "Write a test that reproduces the bug and check that it fails for the reason found by the Investigator.",
+            "Then fix the cause at its source, with the smallest change that makes the test pass. Do not silence the error.",
+            "Output: the test, the diff summary, and the test command with its result before and after the fix."
+          )
+        }),
+        presetNode({
+          id: "verifier",
+          label: "Verifier",
+          role: "qa",
+          groupId: "stage-check",
+          parentIds: ["fixer"],
+          injectedAncestorIds: ["context", "investigator"],
+          prompt: lines2(
+            "Check that the fix removes the symptom with the original reproduction steps.",
+            "Look for the same faulty pattern elsewhere in the codebase, and for behaviour the fix may have changed.",
+            "Output: verdict (fixed / not fixed / partially fixed), evidence, other places with the same pattern."
+          )
+        })
+      ]
+    },
+    translations: { fr: { ...PRESET_FR["bug-investigation"], roles: ROLES_FR } },
+    roles: ROLES
+  },
+  {
+    id: "research-report",
+    name: "Research report",
+    icon: "ti-book",
+    labels: PIPELINE_LABELS,
+    defaultTraversalMode: "topological",
+    canChangeTraversalMode: true,
+    initialData: {
+      leaderId: "editor",
+      groups: [
+        stage("stage-scope", "Scope", 0),
+        stage("stage-sources", "Sources", 1, 0),
+        stage("stage-options", "Options", 1, 1),
+        stage("stage-analysis", "Analysis", 2),
+        stage("stage-report", "Report", 3)
+      ],
+      nodes: [
+        presetNode({
+          id: "editor",
+          label: "Research Lead",
+          role: "manager",
+          groupId: "stage-scope",
+          prompt: lines2(
+            "First pass (kickoff): turn the request into three to five precise research questions and the criteria a good answer must meet.",
+            "Say what decision the report must help make, and for whom.",
+            "Final pass (synthesis): give the answer to the decision in the first paragraph, then check that each research question is answered."
+          )
+        }),
+        presetNode({
+          id: "fact-finder",
+          label: "Fact Finder",
+          role: "researcher",
+          groupId: "stage-sources",
+          parentIds: ["editor"],
+          prompt: lines2(
+            "Answer the research questions with facts and figures.",
+            "Every claim comes with its source and its date. Mark what is a fact, an estimate or an opinion.",
+            "Prefer primary sources (official docs, data, papers) over articles that quote them."
+          )
+        }),
+        presetNode({
+          id: "options-scout",
+          label: "Options Scout",
+          role: "researcher",
+          groupId: "stage-options",
+          parentIds: ["editor"],
+          prompt: lines2(
+            "List the realistic options or solutions for the decision at stake, including doing nothing.",
+            "For each one: what it is, who uses it, its cost, its main limits. Stay factual and cite sources."
+          )
+        }),
+        presetNode({
+          id: "analyst",
+          label: "Analyst",
+          role: "analyst",
+          groupId: "stage-analysis",
+          parentIds: ["fact-finder", "options-scout"],
+          injectedAncestorIds: ["editor"],
+          prompt: lines2(
+            "Compare the options against the criteria set by the Research Lead, using the facts gathered.",
+            "Give a comparison table, then a recommendation with the conditions under which it would change.",
+            "Point out contradictions between sources and claims that lack evidence."
+          )
+        }),
+        presetNode({
+          id: "report-writer",
+          label: "Report Writer",
+          role: "writer",
+          groupId: "stage-report",
+          parentIds: ["analyst"],
+          injectedAncestorIds: ["fact-finder"],
+          prompt: lines2(
+            "Write the final report for the audience named by the Research Lead.",
+            "Structure: recommendation, key findings, comparison, risks, sources. Short sections, plain language.",
+            "Keep every source reference from the Fact Finder."
+          )
+        })
+      ]
+    },
+    translations: { fr: { ...PRESET_FR["research-report"], roles: ROLES_FR } },
+    roles: ROLES
+  },
+  {
+    id: "code-review",
+    name: "Code review",
+    icon: "ti-code",
+    labels: {
+      group: { en: "Team", fr: "\xC9quipe" },
+      node: { en: "Reviewer", fr: "Relecteur" },
+      role: { en: "Focus", fr: "Angle" },
+      leader: { en: "Lead reviewer", fr: "Relecteur principal" }
+    },
+    defaultTraversalMode: "hierarchical",
+    canChangeTraversalMode: true,
+    initialData: {
+      leaderId: "lead-reviewer",
+      groups: [
+        stage("team-lead", "Lead", 0),
+        stage("team-security", "Security", 1, 0),
+        stage("team-correctness", "Correctness", 1, 1),
+        stage("team-maintainability", "Maintainability", 1, 2)
+      ],
+      nodes: [
+        presetNode({
+          id: "lead-reviewer",
+          label: "Lead Reviewer",
+          role: "manager",
+          groupId: "team-lead",
+          prompt: lines2(
+            "Identify the change to review (branch, diff or files named in the request) and summarize its intent in two sentences.",
+            "Send each reviewer the exact scope to read and the risks specific to this change.",
+            "In your synthesis, merge duplicate findings, drop the ones without evidence, and order the rest by severity: blocking, should fix, nit."
+          )
+        }),
+        presetNode({
+          id: "security-reviewer",
+          label: "Security Reviewer",
+          role: "qa",
+          groupId: "team-security",
+          parentIds: ["lead-reviewer"],
+          prompt: lines2(
+            "Review the change for security issues only: input validation, injection, authentication and authorization, secrets, unsafe defaults.",
+            "Each finding: file and line, the attack scenario, the fix. No finding without a concrete scenario."
+          )
+        }),
+        presetNode({
+          id: "correctness-reviewer",
+          label: "Correctness Reviewer",
+          role: "qa",
+          groupId: "team-correctness",
+          parentIds: ["lead-reviewer"],
+          prompt: lines2(
+            "Look for bugs: wrong logic, unhandled errors, race conditions, edge cases (empty, null, large inputs), regressions in existing behaviour.",
+            "Check that tests cover the changed behaviour and would fail without the change.",
+            "Each finding: file and line, the input that breaks it, the expected and actual result."
+          )
+        }),
+        presetNode({
+          id: "maintainability-reviewer",
+          label: "Maintainability Reviewer",
+          role: "engineer",
+          groupId: "team-maintainability",
+          parentIds: ["lead-reviewer"],
+          prompt: lines2(
+            "Look for duplicated logic that already exists elsewhere in the codebase, unclear naming, dead code and changes outside the stated scope.",
+            "Search the repository before claiming a duplicate, and name the existing function to reuse.",
+            "Do not report style preferences that a linter would catch."
+          )
+        })
+      ]
+    },
+    translations: { fr: { ...PRESET_FR["code-review"], roles: ROLES_FR } },
+    roles: ROLES
   }
 ];
 function listPresets() {
@@ -4087,12 +5131,13 @@ function listPresets() {
 function getPreset(id) {
   return BUILT_IN_PRESETS.find((p) => p.id === id);
 }
+function getPresetRole(presetId, roleId, locale) {
+  const preset = presetId ? getPreset(presetId) : void 0;
+  if (!preset) return void 0;
+  return (locale ? localizePreset(preset, locale) : preset).roles.find((r) => r.id === roleId);
+}
 
 // ../server/src/services/scenario-runner.ts
-var DEFAULT_NODE_MODELS = {
-  "claude-code": "sonnet",
-  codex: ""
-};
 var MAX_BUFFER = 500;
 var activeBuses = /* @__PURE__ */ new Map();
 var activeAbortControllers = /* @__PURE__ */ new Map();
@@ -4421,27 +5466,26 @@ function buildSystemPrompt(node, scenario) {
   const group = scenario.groups.find((t) => t.id === node.groupId);
   const manager = node.parentIds[0] ? scenario.nodes.find((p) => p.id === node.parentIds[0]) : null;
   const reports = getDirectReports(scenario.nodes, node.id);
-  const preset = scenario.presetId ? getPreset(scenario.presetId) : void 0;
-  const presetRole = preset?.roles.find((r) => r.id === (node.role ?? "other"));
+  const presetRole = getPresetRole(scenario.presetId, node.role ?? "other", scenario.locale);
   const roleBehavior = presetRole?.systemPrompt ?? "";
   const rolePrompt = presetRole?.prompt ?? "";
-  const lines = [
+  const lines3 = [
     `You are ${node.label}${group ? `, member of the ${group.name} group` : ""}.`,
     `Your role type: **${(node.role ?? "other").toUpperCase()}**.`,
     ""
   ];
   if (roleBehavior) {
-    lines.push("## Role Behavior (strictly enforce)", roleBehavior, "");
+    lines3.push("## Role Behavior (strictly enforce)", roleBehavior, "");
   }
   const profileSection = [node.prompt, rolePrompt].filter(Boolean).join("\n\n");
-  lines.push("## Your Profile & Instructions", profileSection || "(No profile provided)", "");
+  lines3.push("## Your Profile & Instructions", profileSection || "(No profile provided)", "");
   if (manager) {
-    lines.push(`## Reporting Line`, `You report to ${manager.label} (${manager.role ?? "other"}).`, "");
+    lines3.push(`## Reporting Line`, `You report to ${manager.label} (${manager.role ?? "other"}).`, "");
   } else {
-    lines.push(`## Position`, `You are the leader of this scenario. You coordinate all groups.`, "");
+    lines3.push(`## Position`, `You are the leader of this scenario. You coordinate all groups.`, "");
   }
   if (reports.length > 0) {
-    lines.push(
+    lines3.push(
       `## Your Direct Reports`,
       ...reports.map((r) => {
         const rGroup = scenario.groups.find((g) => g.id === r.groupId);
@@ -4452,7 +5496,7 @@ function buildSystemPrompt(node, scenario) {
     );
   }
   if (node.canAddNode) {
-    lines.push(
+    lines3.push(
       "## Hiring Capability",
       "You are allowed to hire temporary contractors for this run.",
       'Use exactly: <hire_person label="Jane Doe" role="engineer">Task focus prompt</hire_person>',
@@ -4461,7 +5505,7 @@ function buildSystemPrompt(node, scenario) {
       ""
     );
   }
-  lines.push(
+  lines3.push(
     "## Output Instructions",
     "Write your output clearly and in a structured format.",
     "Stay strictly within your role \u2014 do not produce deliverables that belong to a different role.",
@@ -4470,9 +5514,9 @@ function buildSystemPrompt(node, scenario) {
   );
   const runeya_ai_vars = Object.entries(process.env).filter(([k]) => k.startsWith("RUNEYA_AI_")).map(([k, v]) => `${k}=${v}`).join("\n");
   if (runeya_ai_vars) {
-    lines.push("", "## Environment", "", runeya_ai_vars);
+    lines3.push("", "## Environment", "", runeya_ai_vars);
   }
-  return lines.join("\n");
+  return lines3.join("\n");
 }
 function buildUserMessage(node, scenario, userRequest, managerOutput, isLeaderSynthesis, isLeaderDispatch, allOutputs) {
   const parts = [];
@@ -4596,7 +5640,7 @@ function resolveNodeExecutionConfig(node, runOverrides) {
   const crossFamily = !!runOverrides?.runnerOverride && runOverrides.runnerOverride !== baseCli;
   const modelOverride = runOverrides?.modelOverride?.trim() ?? "";
   const nodeModel = node.model?.trim() ?? "";
-  const model = modelOverride || (crossFamily ? DEFAULT_NODE_MODELS[aiCli] : nodeModel || DEFAULT_NODE_MODELS[aiCli]);
+  const model = modelOverride || (crossFamily ? "" : nodeModel);
   return { aiCli, model };
 }
 function createNodeRunnerState(aiCli) {
@@ -4614,8 +5658,8 @@ async function nodeRuneyaAccess(conversationId) {
   let injectedEnv;
   if (ref?.id) {
     try {
-      const { projectStore: projectStore2 } = await import("./project-store-FLXTAD3J.js");
-      const { environmentResolver: environmentResolver2 } = await import("./environment-resolver-ZDTF3MHI.js");
+      const { projectStore: projectStore2 } = await import("./project-store-BYAE4SVZ.js");
+      const { environmentResolver: environmentResolver2 } = await import("./environment-resolver-SY36Q67E.js");
       const project = await projectStore2.get(ref.orgId ? { id: ref.id, orgId: ref.orgId } : ref.id);
       if (project?.activeEnvironmentId) {
         const injected = await environmentResolver2.resolveAiInjectedEnv(project.activeEnvironmentId);
@@ -5490,6 +6534,7 @@ var scenarioRouter = router({
     nodes: z16.array(ScenarioNodeSchema).min(1).max(500),
     traversalMode: z16.enum(["hierarchical", "topological"]).optional(),
     presetId: z16.string().max(128).optional(),
+    locale: z16.string().max(16).optional(),
     isPublished: z16.boolean().optional(),
     ...ScopeShape2
   })).mutation(({ input }) => {
@@ -5504,6 +6549,7 @@ var scenarioRouter = router({
       nodes: input.nodes,
       traversalMode: input.traversalMode ?? "hierarchical",
       presetId: input.presetId,
+      locale: input.locale,
       isPublished: input.isPublished ?? false,
       createdAt: now,
       updatedAt: now
@@ -5519,6 +6565,7 @@ var scenarioRouter = router({
     nodes: z16.array(ScenarioNodeSchema).min(1).max(500).optional(),
     traversalMode: z16.enum(["hierarchical", "topological"]).optional(),
     presetId: z16.string().max(128).optional(),
+    locale: z16.string().max(16).optional(),
     isPublished: z16.boolean().optional(),
     ...ScopeShape2
   })).mutation(({ input }) => updateOrThrow(
@@ -5531,6 +6578,7 @@ var scenarioRouter = router({
       nodes: input.nodes,
       traversalMode: input.traversalMode,
       presetId: input.presetId,
+      locale: input.locale,
       isPublished: input.isPublished,
       updatedAt: Date.now()
     }, await scopeOf2(input)),
@@ -7243,11 +8291,11 @@ async function resolveScope(scope) {
     return { mode: "local", root };
   }
   const serviceId = scope.slice("service:".length);
-  const service = await serviceStore.get(serviceId);
-  if (!service) throw new TRPCError21({ code: "NOT_FOUND", message: "Service introuvable" });
-  const agentId = await resolveEffectiveAgentId(service);
+  const service2 = await serviceStore.get(serviceId);
+  if (!service2) throw new TRPCError21({ code: "NOT_FOUND", message: "Service introuvable" });
+  const agentId = await resolveEffectiveAgentId(service2);
   if (!agentId) throw new TRPCError21({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9 pour ce service" });
-  const cwd = await resolveWorkspaceCwd({ serviceId, override: service.docsPath?.trim() || void 0 });
+  const cwd = await resolveWorkspaceCwd({ serviceId, override: service2.docsPath?.trim() || void 0 });
   return { mode: "agent", agentId, cwd };
 }
 async function walkLocal(root, dir, depth, counter) {
@@ -7397,11 +8445,11 @@ var wikiRouter = router({
       return { ok: true };
     }
     const serviceId = input.scope.slice("service:".length);
-    const service = await serviceStore.get(serviceId);
-    if (!service) throw new TRPCError21({ code: "NOT_FOUND", message: "Service introuvable" });
-    const agentId = await resolveEffectiveAgentId(service);
+    const service2 = await serviceStore.get(serviceId);
+    if (!service2) throw new TRPCError21({ code: "NOT_FOUND", message: "Service introuvable" });
+    const agentId = await resolveEffectiveAgentId(service2);
     if (!agentId) throw new TRPCError21({ code: "BAD_REQUEST", message: "Aucun agent configur\xE9" });
-    const cwd = await resolveWorkspaceCwd({ serviceId, override: service.docsPath?.trim() || void 0 });
+    const cwd = await resolveWorkspaceCwd({ serviceId, override: service2.docsPath?.trim() || void 0 });
     return agentManager.agentMutation(agentId, "wiki.ensureRoot", { cwd });
   }),
   delete: protectedProcedure.input(z26.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
@@ -10054,7 +11102,7 @@ async function runLegacyMigration(dataDir) {
   for (const [name, legacy] of Object.entries(legacyServices)) {
     const serviceId = serviceIdMap[name];
     if (!serviceId) continue;
-    const service = runeServices.find((s) => s.id === serviceId);
+    const service2 = runeServices.find((s) => s.id === serviceId);
     const svcEnvs = legacy.envs || {};
     for (const [envName, vars] of Object.entries(svcEnvs)) {
       if (!vars || typeof vars !== "object" || Object.keys(vars).length === 0) continue;
@@ -10068,7 +11116,7 @@ async function runLegacyMigration(dataDir) {
         svcScopedEnv = {
           id: randomUUID9(),
           projectId: projectMonoId,
-          name: `${service?.name || name} (${globalEnv.name})`,
+          name: `${service2?.name || name} (${globalEnv.name})`,
           scope: "service",
           reference: serviceId,
           activateOn: globalEnvId,
@@ -10100,7 +11148,7 @@ async function runLegacyMigration(dataDir) {
   for (const [serviceName, envOverrides] of Object.entries(legacyServiceOverrides)) {
     const serviceId = serviceIdMap[serviceName];
     if (!serviceId) continue;
-    const service = runeServices.find((s) => s.id === serviceId);
+    const service2 = runeServices.find((s) => s.id === serviceId);
     for (const [envName, vars] of Object.entries(envOverrides)) {
       const globalEnvId = envIdMap[envName];
       const globalEnv = runeEnvs.find((e) => e.id === globalEnvId);
@@ -10112,7 +11160,7 @@ async function runLegacyMigration(dataDir) {
         svcScopedEnv = {
           id: randomUUID9(),
           projectId: projectMonoId,
-          name: `${service?.name || serviceName} (${globalEnv.name})`,
+          name: `${service2?.name || serviceName} (${globalEnv.name})`,
           scope: "service",
           reference: serviceId,
           activateOn: globalEnvId,
@@ -10377,7 +11425,7 @@ async function runOverrideOnlyMigration(dataDir) {
       console.warn(`[override-migration] No matching service for "${serviceName}" \u2014 skipping service overrides`);
       continue;
     }
-    const service = servicesRaw.find((s) => s["id"] === serviceId);
+    const service2 = servicesRaw.find((s) => s["id"] === serviceId);
     for (const [envName, vars] of Object.entries(data)) {
       const globalEnvId = findEnvId(envName);
       if (!globalEnvId || !vars || typeof vars !== "object") continue;
@@ -10390,7 +11438,7 @@ async function runOverrideOnlyMigration(dataDir) {
         svcScopedEnv = {
           id: randomUUID9(),
           projectId: globalEnv["projectId"],
-          name: `${service?.["name"] || serviceName} (${globalEnv["name"]})`,
+          name: `${service2?.["name"] || serviceName} (${globalEnv["name"]})`,
           scope: "service",
           reference: serviceId,
           activateOn: globalEnvId,
@@ -11636,7 +12684,7 @@ async function createLocalServer() {
     ]);
     console.log("[server] Shutdown complete");
   };
-  const { initCompanion } = await import("./companion-XKMNRIJB.js");
+  const { initCompanion } = await import("./companion-H24L2MGY.js");
   initCompanion();
   return { app, server, wss, shutdown };
 }
@@ -11701,10 +12749,10 @@ async function unlockIfNeeded() {
 async function pullEnv(opts) {
   await unlockIfNeeded();
   const services = await serviceStore.list();
-  const service = services.find(
+  const service2 = services.find(
     (s) => s.id === opts.service || s.name === opts.service
   );
-  if (!service) {
+  if (!service2) {
     const available = services.map((s) => s.name).join(", ");
     throw new PullEnvError(`service "${opts.service}" not found. Available: ${available || "(none)"}`, 1);
   }
@@ -11717,7 +12765,7 @@ async function pullEnv(opts) {
     throw new PullEnvError(`environment "${opts.environment}" not found. Available: ${available || "(none)"}`, 1);
   }
   const { env: env2 } = await environmentResolver.resolveForService({
-    serviceId: service.id,
+    serviceId: service2.id,
     activeEnvironmentId: globalEnv.id
   });
   return Object.entries(env2).map(([key, value]) => `${key}=${value}`).join("\n");
@@ -11727,20 +12775,20 @@ async function pullEnv(opts) {
 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);
+  const services = all.map((service2) => {
+    const status = byServiceId.get(service2.id);
     return {
-      id: service.id,
-      name: service.name,
-      agentId: status?.agentId ?? service.agentId ?? null,
+      id: service2.id,
+      name: service2.name,
+      agentId: status?.agentId ?? service2.agentId ?? null,
       running: status?.state === "running" || status?.state === "starting",
       failed: status?.state === "errored" || status?.healthStatus === "unhealthy",
-      url: primaryServiceLink(service, "localhost")
+      url: primaryServiceLink(service2, "localhost")
     };
   });
   const owned = await currentProjectServiceIds();
-  if (owned) return services.filter((service) => owned.has(service.id));
-  return services.filter((service) => service.running || service.failed);
+  if (owned) return services.filter((service2) => owned.has(service2.id));
+  return services.filter((service2) => service2.running || service2.failed);
 }
 async function currentProjectServiceIds() {
   const ref = getCurrentProject();
@@ -12092,4 +13140,4 @@ export {
   stopProcess,
   userPrefix
 };
-//# sourceMappingURL=src-I5TPC6GW.js.map
+//# sourceMappingURL=src-OENXLZKQ.js.map