@runeya/runeya 2.0.68 → 2.0.70

package/{src-WT7HSY3I.js → src-6WVQ2FQV.js}

@@ -2555,1440 +2555,1448 @@ var settingsManager = new SettingsManager();
 import { isAbsolute as isAbsolute3 } from "path";
 
 // ../server/src/services/workspace-cwd.ts
-import { isAbsolute as isAbsolute2, join as join9, dirname as dirname4 } from "path";
-async function projectRoot(ref) {
-  const project = await projectStore.get(ref);
-  if (!project?.orgId) return null;
-  return projectPathStore.get(project);
+import { isAbsolute as isAbsolute2, join as join10, dirname as dirname5 } from "path";
+
+// ../server/src/services/conversation-store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { readFile as readFile8, writeFile as writeFile8, rename as rename8, mkdir as mkdir8, chmod as chmod7 } from "fs/promises";
+import { dirname as dirname4, join as join9 } from "path";
+import { EventEmitter as EventEmitter2 } from "events";
+var FILENAME4 = "conversations.private.json";
+async function localProjectId() {
+  const projects = await projectStore.list().catch(() => []);
+  return projects.find((p) => !p.orgId)?.id ?? null;
 }
-async function resolveWorkspaceCwd(target) {
-  const launchDir = localVaultRootParent();
-  if (target.serviceId) {
-    const service = await serviceStore.get(target.serviceId);
-    if (service) {
-      const raw = (target.override ?? service.cwd ?? "").trim();
-      const projects = await projectStore.list();
-      const owner = projects.find((p) => p.serviceIds.includes(service.id));
-      const root = owner ? await projectRoot(owner) : null;
-      return root ? anchor(root, raw) : raw || ".";
-    }
+var ConversationStore = class {
+  conversations = /* @__PURE__ */ new Map();
+  /** Which vault each conversation was read from, until its project is known. */
+  roots = /* @__PURE__ */ new Map();
+  /**
+   * Les conversations qu'on n'a pas su déchiffrer, par coffre, sous leur forme
+   * de disque.
+   *
+   * Une entrée illisible était simplement ignorée. Tant qu'aucune de ses
+   * voisines ne se chargeait, le fichier n'était jamais réécrit et la donnée
+   * survivait par accident ; dès qu'une seule s'ouvrait, la sauvegarde suivante
+   * réécrivait le fichier avec elle seule — et effaçait les autres. Elles sont
+   * donc gardées ici, telles quelles, et réémises à l'identique.
+   */
+  unreadable = /* @__PURE__ */ new Map();
+  loaded = false;
+  events = new EventEmitter2().setMaxListeners(0);
+  saveQueue = Promise.resolve();
+  snapshotConversation(conv) {
+    return structuredClone(conv);
   }
-  if (target.projectId) {
-    const root = await projectRoot({ id: target.projectId, orgId: target.orgId });
-    const raw = (target.override ?? "").trim();
-    return root ? anchor(root, raw) : raw || launchDir;
+  /**
+   * Encrypted, so it lives beside the key that opens it — usually the machine
+   * root, but a launch directory owning its own key keeps both together.
+   */
+  getFilePath() {
+    return keyedFilePath(FILENAME4);
   }
-  return anchor(launchDir, (target.override ?? "").trim());
-}
-function anchor(base, raw) {
-  if (!raw || raw === ".") return base;
-  if (raw.startsWith("~") || raw.startsWith("$") || isAbsolute2(raw)) return raw;
-  return join9(base, raw);
-}
-function localVaultRootParent() {
-  return dirname4(localVaultRoot());
-}
-async function resolveAgentCwd(target) {
-  if (target.serviceId) {
-    const service = await serviceStore.get(target.serviceId);
-    if (service) {
-      const projects = await projectStore.list();
-      const owner = projects.find((p) => p.serviceIds.includes(service.id));
-      const root = owner ? await projectRoot(owner) : null;
-      if (!root) return void 0;
-      return anchor(root, (target.override ?? service.cwd ?? "").trim());
-    }
+  /** Where older versions kept it — read only, so an older Runeya keeps working. */
+  getLegacyFilePath() {
+    return legacyMachineFilePath(FILENAME4);
   }
-  if (target.projectId) {
-    const root = await projectRoot({ id: target.projectId, orgId: target.orgId });
-    if (!root) return void 0;
-    return anchor(root, (target.override ?? "").trim());
+  /**
+   * Read the machine file, falling back to the launch directory of old.
+   *
+   * The legacy file is left in place: the next save writes the new location,
+   * and a directory still opened by an older Runeya keeps working meanwhile.
+   */
+  async readFromDisk() {
+    try {
+      return await readFile8(await this.getFilePath(), "utf-8");
+    } catch {
+      return readFile8(this.getLegacyFilePath(), "utf-8");
+    }
   }
-  return void 0;
-}
-
-// ../server/src/trpc/routers/service.ts
-async function resolveEffectiveAgentId(service) {
-  const known = /* @__PURE__ */ new Set([
-    ...agentManager.listAgents().map((a) => a.config.id),
-    ...(await agentStore.list()).map((a) => a.id)
-  ]);
-  if (service.agentId && known.has(service.agentId)) return service.agentId;
-  const projects = await projectStore.list();
-  const project = projects.find((p) => p.serviceIds.includes(service.id));
-  if (project?.activeEnvironmentId) {
-    const activeEnv = await environmentStore.get(project.activeEnvironmentId);
-    if (activeEnv?.agentId && known.has(activeEnv.agentId)) return activeEnv.agentId;
+  async ensureDir() {
+    await mkdir8(dirname4(await this.getFilePath()), { recursive: true });
   }
-  return agentManager.getDefaultAgentId();
-}
-async function resolveServiceVariables(service) {
-  const projects = await projectStore.list();
-  const project = projects.find((p) => p.serviceIds.includes(service.id));
-  let resolvedService = service;
-  const anchored = await resolveWorkspaceCwd({ serviceId: service.id });
-  if (anchored !== (service.cwd ?? "").trim() && isAbsolute3(anchored)) {
-    resolvedService = { ...resolvedService, resolvedCwd: anchored };
+  encryptMessages(messages, vault) {
+    return encryptValue(JSON.stringify(messages), vault);
   }
-  try {
-    if (service.parserIds && service.parserIds.length > 0) {
-      const settings = await settingsManager.getSettings();
-      const allParsers = [...nativeParsers, ...settings.logParsers || []];
-      const resolvedParsers = service.parserIds.map((id) => allParsers.find((p) => p.id === id)).filter((p) => p !== void 0);
-      resolvedService = { ...resolvedService, resolvedLogParsers: resolvedParsers };
-    }
-  } catch (err) {
-    console.error("[service-router] Failed to resolve parsers for service", service.id + ":", err.message);
+  decryptMessages(encrypted, vault) {
+    const json = decryptValue(encrypted, vault);
+    return JSON.parse(json);
   }
-  if (!project || !project.activeEnvironmentId) {
-    return resolvedService;
+  /**
+   * Refuser d'écrire dans le coffre d'une organisation sans nommer sa clé.
+   *
+   * `getEncryptionKey(undefined)` rend la clé machine, et c'est le bon défaut
+   * pour le coffre local. Appliqué à un fichier rangé sous `orgs/<org>/`, il
+   * produit un chiffré que ce coffre n'emploie pas — lisible par personne à la
+   * relecture, et impossible à distinguer d'une corruption.
+   *
+   * Le cas a été observé plusieurs fois sans qu'on parvienne à nommer le
+   * chemin fautif : les garde-fous en place traitent le coffre fermé, le
+   * coffre mal résolu et la copie périmée, aucun ne couvrait « coffre non
+   * précisé ». Ces écritures-là n'ont jamais fonctionné — elles échouaient en
+   * silence, ce qui est pire. On les saute désormais en le disant, avec la
+   * pile d'appels qui manquait pour remonter au chemin fautif.
+   */
+  isVaultNamed(root, vault) {
+    const orgId = orgIdOfRoot(root);
+    if (!orgId || vault) return true;
+    console.error(
+      `[conversation-store] \xC9criture ignor\xE9e dans le coffre de l'organisation ${orgId} (${root}) : aucune cl\xE9 d'organisation nomm\xE9e, le contenu serait chiffr\xE9 par la cl\xE9 machine et illisible \xE0 la relecture.
+${new Error("trace").stack}`
+    );
+    return false;
   }
-  try {
-    const resolved = await environmentResolver.resolveForService({
-      serviceId: service.id,
-      activeEnvironmentId: project.activeEnvironmentId
-    });
-    const serviceBuiltins = {
-      HOST: env.HOST,
-      HOST_LAN: "0.0.0.0"
+  toDisk(conv, vault) {
+    return {
+      id: conv.id,
+      projectId: conv.projectId,
+      title: conv.title,
+      encryptedMessages: this.encryptMessages(conv.messages, vault),
+      isCli: conv.isCli,
+      runner: conv.runner,
+      providerId: conv.providerId,
+      codexThreadId: conv.codexThreadId,
+      contextUsage: conv.contextUsage,
+      workflowId: conv.workflowId,
+      workflowType: conv.workflowType,
+      kanbanBoardId: conv.kanbanBoardId,
+      kanbanCardId: conv.kanbanCardId,
+      archived: conv.archived,
+      createdAt: conv.createdAt,
+      updatedAt: conv.updatedAt
     };
-    const interpolatedEnv = {};
-    for (const [key, value] of Object.entries(resolved.env)) {
-      interpolatedEnv[key] = value.replace(
-        /\{\{service\.([^}]+)\}\}/g,
-        (match, k) => serviceBuiltins[k] !== void 0 ? serviceBuiltins[k] : match
-      );
-    }
-    resolvedService = {
-      ...resolvedService,
-      env: interpolatedEnv,
-      envSecrets: [...resolved.envSecrets]
+  }
+  fromDisk(disk, vault) {
+    const workflowType = (disk.workflowType === "scenario" ? "scenario" : void 0) ?? (disk.scenarioId ? "scenario" : void 0);
+    return {
+      id: disk.id,
+      projectId: disk.projectId,
+      title: disk.title,
+      messages: this.decryptMessages(disk.encryptedMessages, vault),
+      isCli: disk.isCli ?? disk.isClaudeCode ?? false,
+      runner: disk.runner,
+      providerId: disk.providerId,
+      codexThreadId: disk.codexThreadId,
+      contextUsage: disk.contextUsage,
+      workflowId: disk.workflowId ?? disk.scenarioId,
+      workflowType,
+      kanbanBoardId: disk.kanbanBoardId,
+      kanbanCardId: disk.kanbanCardId,
+      archived: disk.archived,
+      createdAt: disk.createdAt,
+      updatedAt: disk.updatedAt
     };
-  } catch (err) {
-    console.error("[service-router] Failed to resolve variables for service", service.id + ":", err.message);
   }
-  return resolvedService;
-}
-var DockerConfigInput = DockerConfigSchema;
-var serviceRouter = router({
-  list: protectedProcedure.meta({ openapi: { method: "GET", path: "/services", tags: ["services"], summary: "List all services", protect: true } }).output(z4.any()).query(async ({ ctx }) => {
-    const all = await serviceStore.list();
-    const allowedIds = getAllowedServiceIds(ctx);
-    const filtered = allowedIds ? all.filter((s) => allowedIds.has(s.id)) : all;
-    return Promise.all(filtered.map(async (s) => ({
-      ...s,
-      effectiveAgentId: await resolveEffectiveAgentId(s)
-    })));
-  }),
-  get: protectedProcedure.meta({ openapi: { method: "GET", path: "/services/{id}", tags: ["services"], summary: "Get a service by ID", protect: true } }).input(z4.object({ id: z4.string().max(128) })).output(z4.any()).query(async ({ input, ctx }) => {
-    requireServiceAction(ctx, input.id, "service:read");
-    const service = await serviceStore.get(input.id);
-    if (!service) {
-      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
+  /**
+   * Read every project vault, then the homes older versions used.
+   *
+   * A conversation found in a legacy file is attributed to the local project of
+   * that directory — which is what it was about, back when one directory meant
+   * one project. With no local project to point at, it is left unattributed
+   * rather than filed under a project picked at random.
+   */
+  async load() {
+    if (this.loaded) return;
+    if (!getEncryptionKey()) {
+      return;
     }
-    return service;
-  }),
-  create: protectedProcedure.meta({ openapi: { method: "POST", path: "/services", tags: ["services"], summary: "Create a new service", protect: true } }).output(z4.any()).input(
-    z4.object({
-      agentId: z4.string().max(128).optional(),
-      name: z4.string().min(1).max(200),
-      commands: z4.array(ServiceCommandSchema).max(50).optional(),
-      cwd: z4.string().max(4096).optional(),
-      ports: z4.array(z4.number().int().min(1).max(65535)).max(20).optional(),
-      groups: z4.array(z4.string().max(200)).max(20).optional(),
-      description: z4.string().max(2e3).optional(),
-      docsPath: z4.string().max(4096).optional(),
-      url: z4.string().max(2048).optional(),
-      localUrls: z4.array(z4.object({
-        url: z4.string().max(253),
-        port: z4.number().int().min(1).max(65535)
-      })).max(20).optional(),
-      openapiUrl: z4.string().max(2048).optional(),
-      git: z4.object({ remote: z4.string().max(2048).optional(), home: z4.string().max(2048).optional() }).optional(),
-      meta: z4.record(z4.string().max(256), z4.string().max(2e3)).optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
-      runner: z4.enum(["native", "docker"]).optional().default("native"),
-      dockerConfig: DockerConfigInput.optional(),
-      healthCheck: HealthCheckSchema.optional(),
-      autoRestart: z4.boolean().optional().default(false),
-      restartStrategy: RestartStrategySchema.optional(),
-      maxRestarts: z4.number().int().nonnegative().optional(),
-      restartBackoffMs: z4.number().int().positive().optional().default(1e3),
-      orgId: z4.string().max(128).nullable().optional(),
-      shortcuts: z4.array(ServiceShortcutSchema).max(50).optional(),
-      parserIds: z4.array(z4.string().max(128)).max(50).optional()
-    })
-  ).mutation(async ({ input }) => {
-    if (input.agentId) {
-      const status = agentManager.getStatus(input.agentId);
-      if (!status) {
-        throw new TRPCError4({
-          code: "NOT_FOUND",
-          message: `Agent ${input.agentId} not found`
-        });
+    this.loaded = true;
+    this.unreadable.clear();
+    await ensureProjectsLoaded();
+    const vaults = await allVaultRoots();
+    const legacyPaths = [this.getLegacyFilePath(), await keyedFilePath(FILENAME4)];
+    const sources = [
+      ...legacyPaths.map((path) => ({ path, legacy: true })),
+      ...vaults.map((root) => ({ path: join9(root, FILENAME4), legacy: false }))
+    ];
+    for (const { path, legacy } of sources) {
+      let data;
+      try {
+        data = JSON.parse(await readFile8(path, "utf-8"));
+      } catch {
+        continue;
       }
-    }
-    if (input.runner === "docker") {
-      throw new TRPCError4({ code: "BAD_REQUEST", message: 'Docker runner is not yet supported. Use "native" runner.' });
-    }
-    const service = await serviceStore.create({
-      ...input,
-      agentId: input.agentId
-    });
-    await auditService.log({ userId: "local", action: "create", entityType: "service", entityId: service.id, metadata: { name: input.name } });
-    return service;
-  }),
-  update: protectedProcedure.meta({ openapi: { method: "PATCH", path: "/services/{id}", tags: ["services"], summary: "Update a service", protect: true } }).output(z4.any()).input(
-    z4.object({
-      id: z4.string().max(128),
-      agentId: z4.string().max(128).nullable().optional(),
-      // null = clear (inherit from env)
-      name: z4.string().min(1).max(200).optional(),
-      commands: z4.array(ServiceCommandSchema).max(50).optional(),
-      cwd: z4.string().max(4096).nullable().optional(),
-      ports: z4.array(z4.number().int().min(1).max(65535)).max(20).optional(),
-      groups: z4.array(z4.string().max(200)).max(20).optional(),
-      description: z4.string().max(2e3).optional(),
-      docsPath: z4.string().max(4096).optional(),
-      url: z4.string().max(2048).optional(),
-      localUrls: z4.array(z4.object({
-        url: z4.string().max(253),
-        port: z4.number().int().min(1).max(65535)
-      })).max(20).optional(),
-      openapiUrl: z4.string().max(2048).optional(),
-      git: z4.object({ remote: z4.string().max(2048).optional(), home: z4.string().max(2048).optional() }).nullable().optional(),
-      meta: z4.record(z4.string().max(256), z4.string().max(2e3)).nullable().optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
-      runner: z4.enum(["native", "docker"]).optional(),
-      dockerConfig: DockerConfigInput.optional(),
-      healthCheck: HealthCheckSchema.nullable().optional(),
-      autoRestart: z4.boolean().optional(),
-      clearLogsOnStart: z4.boolean().optional(),
-      restartStrategy: RestartStrategySchema.optional(),
-      maxRestarts: z4.number().int().nonnegative().optional(),
-      restartBackoffMs: z4.number().int().positive().optional(),
-      orgId: z4.string().max(128).nullable().optional(),
-      shortcuts: z4.array(ServiceShortcutSchema).max(50).optional(),
-      parserIds: z4.array(z4.string().max(128)).max(50).optional(),
-      logSources: z4.array(LogSourceConfigSchema).max(20).optional()
-    })
-  ).mutation(async ({ input }) => {
-    const existing = await serviceStore.get(input.id);
-    if (!existing) {
-      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
-    }
-    let stoppedForAgentChange = false;
-    if (input.agentId !== void 0 && input.agentId !== existing.agentId && existing.agentId) {
-      const oldAgentStatus = agentManager.getStatus(existing.agentId);
-      if (oldAgentStatus?.connected) {
+      const inherited = legacy ? await localProjectId() : null;
+      const root = dirname4(path);
+      await rememberFile(path);
+      for (const item of data) {
         try {
-          const processes = await agentManager.agentQuery(existing.agentId, "process.list");
-          const proc = processes.find((p) => p.serviceId === input.id);
-          if (proc && (proc.state === "running" || proc.state === "starting")) {
-            await agentManager.agentMutation(existing.agentId, "process.stop", { id: input.id }, AGENT_STOP_FETCH_TIMEOUT);
-            stoppedForAgentChange = true;
-          }
+          const conv = this.fromDisk(item, vaultIdOfRoot(root));
+          if (!conv.projectId && inherited) conv.projectId = inherited;
+          this.conversations.set(item.id, conv);
+          this.roots.set(item.id, root);
         } catch {
-        }
-      }
-      if (input.agentId) {
-        const newAgentStatus = agentManager.getStatus(input.agentId);
-        if (!newAgentStatus) {
-          throw new TRPCError4({
-            code: "NOT_FOUND",
-            message: `Agent ${input.agentId} not found`
-          });
-        }
-      }
-    }
-    const service = await serviceStore.update(input);
-    if (!service) {
-      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
-    }
-    if (input.name && input.name !== existing.name) {
-      await environmentStore.renameByReference(input.id, input.name);
-    }
-    if (service.agentId) {
-      const agentStatus = agentManager.getStatus(service.agentId);
-      if (agentStatus?.connected) {
-        try {
-          const resolvedService = await resolveServiceVariables(service);
-          await agentManager.agentMutation(service.agentId, "process.updateConfig", {
-            serviceId: service.id,
-            config: resolvedService
-          });
-        } catch (err) {
-          console.debug("[service-router] Failed to propagate config to agent", service.agentId + ":", err.message);
+          const bucket = this.unreadable.get(root) ?? [];
+          bucket.push(item);
+          this.unreadable.set(root, bucket);
         }
       }
     }
-    await auditService.log({ userId: "local", action: "update", entityType: "service", entityId: input.id });
-    return { ...service, effectiveAgentId: await resolveEffectiveAgentId(service), stoppedForAgentChange };
-  }),
-  delete: protectedProcedure.meta({ openapi: { method: "DELETE", path: "/services/{id}", tags: ["services"], summary: "Delete a service", protect: true } }).input(z4.object({ id: z4.string().max(128) })).output(z4.object({ success: z4.literal(true) })).mutation(async ({ input }) => {
-    const deleted = await serviceStore.delete(input.id);
-    if (!deleted) {
-      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
+  }
+  /**
+   * Oublier ce qui a été lu, pour tout relire sous la clé courante.
+   *
+   * Appelé après l'adoption d'une clé d'organisation : le disque vient d'être
+   * re-chiffré sous les pieds du store, si bien que sa mémoire décrit un état
+   * qui n'existe plus. La laisser en place n'affichait pas seulement des
+   * comptes périmés — la sauvegarde suivante réécrivait l'ancien chiffré
+   * par-dessus le nouveau, et défaisait l'adoption.
+   */
+  resetCache() {
+    this.conversations.clear();
+    this.roots.clear();
+    this.unreadable.clear();
+    this.loaded = false;
+    this.events.emit("changed", { type: "reloaded" });
+  }
+  /**
+   * Combien de conversations ce coffre garde sans savoir les lire, par
+   * organisation. La machine elle-même est rangée sous `null`.
+   */
+  async unreadableByVault() {
+    await this.load();
+    const out = /* @__PURE__ */ new Map();
+    for (const [root, items] of this.unreadable) {
+      const vault = vaultIdOfRoot(root) ?? null;
+      out.set(vault, (out.get(vault) ?? 0) + items.length);
     }
-    await auditService.log({ userId: "local", action: "delete", entityType: "service", entityId: input.id });
-    return { success: true };
-  }),
-  checkCwd: protectedProcedure.input(z4.object({ id: z4.string().max(128), checkReachability: z4.boolean().optional() })).query(async ({ input }) => {
-    const service = await serviceStore.get(input.id);
-    if (!service) {
-      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
+    return out;
+  }
+  /**
+   * Write each vault that holds — or held — a conversation.
+   *
+   * A vault emptied by this save is still written, as an empty list: a
+   * conversation that found its project must not survive in the file it was
+   * read from.
+   */
+  async saveInternal() {
+    if (!getEncryptionKey()) return;
+    const byRoot = /* @__PURE__ */ new Map();
+    for (const root of this.roots.values()) byRoot.set(root, []);
+    for (const conv of this.conversations.values()) {
+      const root = await this.rootFor(conv);
+      this.roots.set(conv.id, root);
+      const bucket = byRoot.get(root) ?? [];
+      const vault = vaultIdOfRoot(root);
+      if (!this.isVaultNamed(root, vault)) continue;
+      bucket.push(this.toDisk(conv, vault));
+      byRoot.set(root, bucket);
     }
-    const effectiveAgentId = await resolveEffectiveAgentId(service);
-    if (!effectiveAgentId) {
-      throw new TRPCError4({ code: "BAD_REQUEST", message: "No agent configured for this service" });
+    for (const [root, items] of this.unreadable) {
+      byRoot.set(root, [...items, ...byRoot.get(root) ?? []]);
     }
-    const agentResult = await agentManager.agentQuery(effectiveAgentId, "git.checkCwd", {
-      // Anchored on the project, so the check answers about the directory the
-      // service will actually run in.
-      cwd: await resolveWorkspaceCwd({ serviceId: service.id }),
-      remote: service.git?.remote,
-      checkReachability: input.checkReachability
-    });
-    const { exists: exists4, actualRemote, unreachable, resolvedCwd, unresolvedVars } = agentResult;
-    if (unresolvedVars.length > 0) {
-      return { exists: false, canClone: false, unresolvedVars, resolvedCwd, gitMismatch: null };
+    const stale = /* @__PURE__ */ new Set();
+    for (const root of byRoot.keys()) {
+      const path = join9(root, FILENAME4);
+      if (wasRead(path) && await hasChangedSinceRead(path)) stale.add(root);
     }
-    const canClone = !!service.git?.remote && (!exists4 || actualRemote === null);
-    let gitMismatch = null;
-    if (exists4 && service.git?.remote && !canClone) {
-      if (actualRemote === null) {
-        gitMismatch = { actual: null, configured: service.git.remote };
-      } else if (actualRemote !== service.git.remote) {
-        gitMismatch = { actual: actualRemote, configured: service.git.remote };
-      } else if (unreachable) {
-        gitMismatch = { actual: actualRemote, configured: service.git.remote, unreachable: true };
+    for (const [root, data] of byRoot) {
+      const filePath = join9(root, FILENAME4);
+      if (stale.has(root)) {
+        console.warn(
+          `[conversation-store] ${filePath} a chang\xE9 depuis sa lecture \u2014 \xE9criture ignor\xE9e pour ne pas \xE9craser une r\xE9paration faite en dehors du serveur.`
+        );
+        continue;
       }
+      await mkdir8(root, { recursive: true });
+      const tmpPath = `${filePath}.tmp`;
+      await writeFile8(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+      await rename8(tmpPath, filePath);
+      await chmod7(filePath, 384);
+      await rememberFile(filePath);
     }
-    return { exists: exists4, canClone, unresolvedVars: [], resolvedCwd, gitMismatch };
-  }),
-  cloneRepository: protectedProcedure.input(z4.object({ id: z4.string().max(128) })).mutation(async ({ input }) => {
-    const service = await serviceStore.get(input.id);
-    if (!service) {
-      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
-    }
-    if (!service.git?.remote) {
-      throw new TRPCError4({ code: "BAD_REQUEST", message: "Service has no git remote configured" });
-    }
-    const effectiveAgentId = await resolveEffectiveAgentId(service);
-    if (!effectiveAgentId) {
-      throw new TRPCError4({ code: "BAD_REQUEST", message: "No agent configured for this service" });
-    }
-    await agentManager.agentMutation(effectiveAgentId, "git.clone", {
-      remote: service.git.remote,
-      // Clones WRITE: landing this in the launch directory instead of the
-      // project's is how a repository ends up in the wrong place.
-      cwd: await resolveWorkspaceCwd({ serviceId: service.id })
-    }, 5 * 60 * 1e3);
-    return { success: true };
-  })
-});
-
-// ../server/src/trpc/routers/agent.ts
-import { z as z5 } from "zod";
-import { TRPCError as TRPCError5 } from "@trpc/server";
-var SUBSCRIPTION_QUEUE_MAX = LOG_BUFFER_SIZE;
-var agentRouter = router({
-  /** List all registered agents with their connection status */
-  list: protectedProcedure.query(() => {
-    return agentManager.listAgents();
-  }),
-  /** Get a single agent's config and status */
-  get: protectedProcedure.input(z5.object({ id: z5.string().max(128) })).query(({ input }) => {
-    const agent = agentManager.getAgent(input.id);
-    if (!agent) {
-      throw new TRPCError5({ code: "NOT_FOUND", message: `Agent ${input.id} not found` });
-    }
-    return {
-      config: { ...agent.config, passphrase: "***" },
-      status: agent.status
-    };
-  }),
-  /** Test connectivity to an agent given url + passphrase */
-  testConnection: protectedProcedure.input(
-    z5.object({
-      url: z5.string().url().max(2048),
-      passphrase: z5.string().min(1).max(1024).optional(),
-      agentId: z5.string().max(128).optional()
-    })
-  ).mutation(async ({ input }) => {
-    let passphrase = input.passphrase;
-    let targetUrl = input.url;
-    if (!passphrase && input.agentId) {
-      const agent = agentManager.getAgentConfig(input.agentId);
-      if (!agent) {
-        throw new TRPCError5({ code: "NOT_FOUND", message: "Agent not found" });
-      }
-      passphrase = agent.passphrase;
-      targetUrl = agent.url;
-    }
-    if (!passphrase) {
-      throw new TRPCError5({ code: "BAD_REQUEST", message: "Passphrase is required" });
-    }
-    const url = new URL("/api/trpc/health.check", targetUrl);
-    try {
-      const res = await fetch(url.toString(), {
-        headers: { "Authorization": `Bearer ${passphrase}`, "Content-Type": "application/json" },
-        signal: AbortSignal.timeout(5e3)
-      });
-      if (!res.ok) {
-        return { success: false, error: `HTTP ${res.status} ${res.statusText}` };
-      }
-      const json = await res.json();
-      if (json.error) {
-        return { success: false, error: json.error.message ?? "Agent returned an error" };
-      }
-      return { success: true, uptime: json.result?.data?.uptime };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : "Unknown error";
-      return { success: false, error: msg };
-    }
-  }),
-  /** Register a new agent */
-  register: protectedProcedure.input(
-    z5.object({
-      name: z5.string().min(1).max(100),
-      url: z5.string().url().max(2048),
-      passphrase: z5.string().min(1).max(1024),
-      // À quelle organisation rattacher l'agent. Absent = la machine, ce que
-      // font l'agent local et tout client antérieur à ce champ.
-      orgId: z5.string().min(1).max(128).nullable().optional()
-    })
-  ).mutation(async ({ input }) => {
-    const config = await agentManager.register(
-      input.name,
-      input.url,
-      input.passphrase,
-      input.orgId ?? null
-    );
-    return { ...config, passphrase: "***" };
-  }),
-  /** Update an existing agent */
-  update: protectedProcedure.input(
-    z5.object({
-      id: z5.string().max(128),
-      name: z5.string().min(1).max(100).optional(),
-      url: z5.string().url().max(2048).optional(),
-      passphrase: z5.string().min(1).max(1024).optional(),
-      passthroughEnv: z5.array(
-        z5.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256)
-      ).max(100).optional()
-    })
-  ).mutation(async ({ input }) => {
-    try {
-      const { id, ...fields } = input;
-      const config = await agentManager.update(id, fields);
-      return { ...config, passphrase: "***" };
-    } catch (err) {
-      if (err instanceof Error) {
-        if (err.message.includes("not found")) {
-          throw new TRPCError5({ code: "NOT_FOUND", message: err.message });
-        }
-        if (err.message.includes("Cannot modify")) {
-          throw new TRPCError5({ code: "FORBIDDEN", message: err.message });
-        }
-      }
-      throw err;
-    }
-  }),
-  /** Get resolved passthrough env values from an agent */
-  getPassthroughEnv: protectedProcedure.input(z5.object({ id: z5.string().max(128) })).query(async ({ input }) => {
+  }
+  /**
+   * The vault a conversation is written to: its project's.
+   *
+   * One that names no project stays where it was read, falling back to the
+   * key's own directory — never lost for want of an owner.
+   */
+  async rootFor(conv) {
+    const known = this.roots.get(conv.id) ?? null;
+    if (conv.projectId) return rootOfProjectAmong(conv.projectId, known);
+    return known ?? dirname4(await keyedFilePath(FILENAME4));
+  }
+  /**
+   * Le projet d'une conversation, organisation comprise.
+   *
+   * Ce que la conversation ne dit pas d'elle-même : elle ne nomme que l'id.
+   * Le coffre d'où elle vient fournit l'organisation, et c'est ce couple qu'il
+   * faut pour retrouver le répertoire de travail du projet.
+   */
+  async projectRefOf(conv) {
+    if (!conv.projectId) return null;
+    const known = this.roots.get(conv.id) ?? null;
+    const ref = refOfProjectAmong(conv.projectId, known);
+    return { id: ref.id, orgId: ref.orgId ?? null };
+  }
+  /**
+   * Réécrire chaque coffre, en déplaçant ce qui appartient désormais ailleurs.
+   *
+   * Appelé quand un projet a changé de coffre : ses conversations sont écrites
+   * dans le nouveau, et le fichier d'où elles viennent est réécrit sans elles.
+   */
+  async relocateAll() {
+    await this.load();
+    await this.save();
+  }
+  async save() {
+    const write = this.saveQueue.then(() => this.saveInternal());
+    this.saveQueue = write.catch(() => {
+    });
+    return write;
+  }
+  async list() {
+    await this.load();
+    return Array.from(this.conversations.values()).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  /**
+   * Les conversations d'un projet.
+   *
+   * Celle qui ne nomme aucun projet — écrite avant le champ, ou qu'une
+   * migration n'a pas su attribuer — n'est rendue que dans les projets de son
+   * propre coffre : elle reste atteignable là où elle a été écrite, sans se
+   * déverser dans toutes les organisations de la machine.
+   */
+  async listForProject(ref) {
+    const belongs = await this.matcherForProject(ref);
+    return (await this.list()).filter(belongs);
+  }
+  /**
+   * Le test d'appartenance à un projet, préparé une fois.
+   *
+   * Le flux temps réel en a besoin autant que la liste : une conversation qui
+   * arrive par événement doit passer le même filtre, sans quoi elle se
+   * réinvite dans un projet qui ne l'a jamais demandée.
+   */
+  async matcherForProject(ref) {
+    await this.load();
+    let projectRoot2 = null;
     try {
-      return await agentManager.agentQuery(input.id, "config.getPassthroughEnv");
+      projectRoot2 = ref.orgId === void 0 ? rootOfProjectAmong(ref.id, null) : rootOfProjectRef({ id: ref.id, orgId: ref.orgId ?? null });
     } catch {
-      return {};
-    }
-  }),
-  /** Remove a registered agent */
-  remove: protectedProcedure.input(z5.object({ id: z5.string().max(128) })).mutation(async ({ input }) => {
-    try {
-      const removed = await agentManager.remove(input.id);
-      if (!removed) {
-        throw new TRPCError5({ code: "NOT_FOUND", message: `Agent ${input.id} not found` });
-      }
-      return { success: true };
-    } catch (err) {
-      if (err instanceof Error && err.message === "Cannot remove the local agent") {
-        throw new TRPCError5({ code: "FORBIDDEN", message: err.message });
-      }
-      throw err;
-    }
-  }),
-  /** Subscribe to real-time agent status changes */
-  onStatus: protectedProcedure.subscription(async function* () {
-    for (const agent of agentManager.listAgents()) {
-      yield { agentId: agent.config.id, status: agent.status };
+      projectRoot2 = null;
     }
-    const queue = [];
-    let resolve7 = null;
-    const handler = (event) => {
-      if (queue.length >= SUBSCRIPTION_QUEUE_MAX) queue.shift();
-      queue.push(event);
-      if (resolve7) {
-        resolve7();
-        resolve7 = null;
-      }
+    return (conv) => {
+      if (conv.projectId) return conv.projectId === ref.id;
+      if (!projectRoot2) return true;
+      return this.roots.get(conv.id) === projectRoot2;
     };
-    agentManager.on("status", handler);
-    try {
-      while (true) {
-        if (queue.length > 0) {
-          yield queue.shift();
-        } else {
-          await new Promise((r) => {
-            resolve7 = r;
-          });
-        }
-      }
-    } finally {
-      agentManager.off("status", handler);
-    }
-  })
-});
-
-// ../server/src/trpc/routers/process.ts
-import { z as z6 } from "zod";
-import { TRPCError as TRPCError6 } from "@trpc/server";
-var SUBSCRIPTION_QUEUE_MAX2 = LOG_BUFFER_SIZE;
-async function* forwardEvents(eventName, filter) {
-  const queue = [];
-  let resolve7 = null;
-  const handler = (data) => {
-    if (filter && !filter(data)) return;
-    if (queue.length >= SUBSCRIPTION_QUEUE_MAX2) queue.shift();
-    queue.push(data);
-    if (resolve7) {
-      resolve7();
-      resolve7 = null;
+  }
+  async get(id) {
+    await this.load();
+    return this.conversations.get(id) ?? null;
+  }
+  async create(title, isCli = false, workflowId, workflowType, runner, kanbanBoardId, kanbanCardId, providerId, projectId, orgId) {
+    await this.load();
+    const now = Date.now();
+    const conv = {
+      id: randomUUID3(),
+      projectId,
+      title: title ?? "New conversation",
+      messages: [],
+      isCli,
+      runner,
+      providerId,
+      workflowId,
+      workflowType,
+      kanbanBoardId,
+      kanbanCardId,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.conversations.set(conv.id, conv);
+    if (projectId && orgId !== void 0) {
+      this.roots.set(conv.id, vaultFor({ id: projectId, orgId }).root);
     }
-  };
-  agentManager.on(eventName, handler);
-  try {
-    while (true) {
-      if (queue.length > 0) {
-        yield queue.shift();
-      } else {
-        await new Promise((r) => {
-          resolve7 = r;
-        });
-      }
+    await this.save();
+    this.events.emit("changed", { type: "created", conversation: this.snapshotConversation(conv) });
+    return conv;
+  }
+  async update(id, patch, options) {
+    await this.load();
+    const conv = this.conversations.get(id);
+    if (!conv) return null;
+    if (patch.title !== void 0) conv.title = patch.title;
+    if (patch.messages !== void 0) conv.messages = patch.messages;
+    if (patch.contextUsage !== void 0) conv.contextUsage = patch.contextUsage;
+    if (patch.workflowId !== void 0) conv.workflowId = patch.workflowId;
+    if (patch.archived !== void 0) conv.archived = patch.archived;
+    if (patch.codexThreadId !== void 0) conv.codexThreadId = patch.codexThreadId;
+    if (options?.touch !== false) conv.updatedAt = Date.now();
+    await this.save();
+    if (!options?.silent) {
+      this.events.emit("changed", { type: "updated", conversation: this.snapshotConversation(conv) });
     }
-  } finally {
-    agentManager.off(eventName, handler);
+    return conv;
   }
-}
-async function* forwardLogBatches(agentId, processId) {
-  const queue = [];
-  let resolve7 = null;
-  const handler = (data) => {
-    if (data.agentId !== agentId) return;
-    const batch = data.batch;
-    if (!Array.isArray(batch)) return;
-    const filtered = batch.filter((log) => log.processId === processId);
-    if (filtered.length === 0) return;
-    if (queue.length >= SUBSCRIPTION_QUEUE_MAX2) queue.shift();
-    queue.push(filtered);
-    if (resolve7) {
-      resolve7();
-      resolve7 = null;
-    }
-  };
-  agentManager.on("process:log", handler);
-  try {
-    while (true) {
-      if (queue.length > 0) {
-        yield queue.shift();
-      } else {
-        await new Promise((r) => {
-          resolve7 = r;
-        });
-      }
+  /**
+   * Synchronously update the last assistant message content in memory, then schedule a save.
+   * Used by activeSessionRegistry.persistNow() to avoid the async get() → .then() race.
+   */
+  updateLastAssistantContent(id, content, parts) {
+    const conv = this.conversations.get(id);
+    if (!conv) return;
+    const lastMsg = conv.messages[conv.messages.length - 1];
+    if (!lastMsg || lastMsg.role !== "assistant") return;
+    lastMsg.content = content;
+    if (parts !== void 0) lastMsg.parts = parts;
+    conv.updatedAt = Date.now();
+    this.save().catch(() => {
+    });
+  }
+  async listByKanbanBoardId(boardId) {
+    await this.load();
+    return Array.from(this.conversations.values()).filter((c) => c.kanbanBoardId === boardId);
+  }
+  async listByKanbanCardId(cardId) {
+    await this.load();
+    return Array.from(this.conversations.values()).filter((c) => c.kanbanCardId === cardId);
+  }
+  async delete(id) {
+    await this.load();
+    const existed = this.conversations.delete(id);
+    await this.save();
+    if (existed) {
+      this.events.emit("changed", { type: "deleted", id });
     }
-  } finally {
-    agentManager.off("process:log", handler);
   }
+  onChanged(handler) {
+    this.events.on("changed", handler);
+  }
+  offChanged(handler) {
+    this.events.off("changed", handler);
+  }
+};
+var conversationStore = new ConversationStore();
+
+// ../server/src/services/workspace-cwd.ts
+async function projectRoot(ref) {
+  const project = await projectStore.get(ref);
+  if (!project?.orgId) return null;
+  return projectPathStore.get(project);
 }
-var processRouter = router({
-  /** List all processes across all connected agents */
-  list: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes", tags: ["processes"], summary: "List all processes", protect: true } }).output(z6.any()).query(async () => {
-    const agents = agentManager.listAgents();
-    const results = [];
-    await Promise.allSettled(
-      agents.filter((a) => a.status.connected).map(async (a) => {
-        try {
-          const processes = await agentManager.agentQuery(a.config.id, "process.list");
-          for (const proc of processes) {
-            results.push({ ...proc, agentId: a.config.id });
-          }
-        } catch {
-        }
-      })
-    );
-    return results;
-  }),
-  /** Get a single process from a specific agent */
-  get: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes/{agentId}/{id}", tags: ["processes"], summary: "Get a process by agent and ID", protect: true } }).input(z6.object({ agentId: z6.string().max(128), id: z6.string().max(128) })).output(z6.any()).query(async ({ input, ctx }) => {
-    requireServiceAction(ctx, input.id, "service:read");
-    const status = agentManager.getStatus(input.agentId);
-    if (!status) {
-      throw new TRPCError6({ code: "NOT_FOUND", message: `Agent ${input.agentId} not found` });
-    }
-    const proc = await agentManager.agentQuery(input.agentId, "process.get", { id: input.id });
-    return { ...proc, agentId: input.agentId };
-  }),
-  /** Start a process on an agent.
-   *  Lazy deploy: the agent only learns about a service when it is first started
-   *  (or restarted). This avoids pushing configs for every service at agent boot,
-   *  which would be wasteful when many services are never started.
-   *  The deploy call is idempotent — creates the process if missing, updates config if it exists. */
-  start: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/start", tags: ["processes"], summary: "Start a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128).optional(), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
-    requireServiceAction(ctx, input.processId, "service:start");
-    const service = await serviceStore.get(input.processId);
-    const effectiveAgentId = (service ? await resolveEffectiveAgentId(service) : null) ?? input.agentId ?? null;
-    if (!effectiveAgentId) {
-      throw new TRPCError6({ code: "BAD_REQUEST", message: "No agent assigned to this service. Set an agent on the service or on the active environment." });
-    }
+async function resolveWorkspaceCwd(target) {
+  const launchDir = localVaultRootParent();
+  if (target.serviceId) {
+    const service = await serviceStore.get(target.serviceId);
     if (service) {
-      try {
-        const resolved = await resolveServiceVariables(service);
-        await agentManager.agentMutation(effectiveAgentId, "process.deploy", resolved);
-      } catch (err) {
-        console.debug("[process-router] Failed to deploy before start for", input.processId + ":", err.message);
-      }
-    }
-    if (service?.clearLogsOnStart) {
-      try {
-        await agentManager.agentMutation(effectiveAgentId, "process.clearLogBuffer", { id: input.processId });
-        agentManager.emit("process:log", { agentId: effectiveAgentId, batch: [{ processId: input.processId, __clearLogBuffer: true }] });
-      } catch (err) {
-        console.debug("[process-router] Failed to clear logs before start for", input.processId + ":", err.message);
-      }
-    }
-    let result;
-    try {
-      result = await agentManager.agentMutation(effectiveAgentId, "process.start", { id: input.processId });
-    } catch (err) {
-      const err_ = err;
-      const isFetchError = err_?.cause?.code === "ECONNREFUSED" || err_?.message === "fetch failed" || err_?.name === "TypeError";
-      throw new TRPCError6({
-        code: "INTERNAL_SERVER_ERROR",
-        message: isFetchError ? `Cannot reach agent \u2014 make sure the agent is running` : err_?.message ?? "Failed to start process"
-      });
-    }
-    await auditService.log({ userId: "local", action: "start", entityType: "process", entityId: input.processId, metadata: { agentId: effectiveAgentId } });
-    return { ...result, agentId: effectiveAgentId };
-  }),
-  /** Stop a process on an agent */
-  stop: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/stop", tags: ["processes"], summary: "Stop a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
-    requireServiceAction(ctx, input.processId, "service:stop");
-    const result = await agentManager.agentMutation(input.agentId, "process.stop", { id: input.processId }, AGENT_STOP_FETCH_TIMEOUT);
-    await auditService.log({ userId: "local", action: "stop", entityType: "process", entityId: input.processId, metadata: { agentId: input.agentId } });
-    return { ...result, agentId: input.agentId };
-  }),
-  /** Restart a process on an agent.
-   *  Sends stop → deploy (latest resolved config) → start so that
-   *  config/variable changes take effect. Same lazy deploy pattern as start. */
-  restart: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/restart", tags: ["processes"], summary: "Restart a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128).optional(), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
-    requireServiceAction(ctx, input.processId, "service:restart");
-    const service = await serviceStore.get(input.processId);
-    const effectiveAgentId = (service ? await resolveEffectiveAgentId(service) : null) ?? input.agentId ?? null;
-    if (!effectiveAgentId) {
-      throw new TRPCError6({ code: "BAD_REQUEST", message: "No agent assigned to this service. Set an agent on the service or on the active environment." });
-    }
-    try {
-      await agentManager.agentMutation(effectiveAgentId, "process.stop", { id: input.processId }, AGENT_STOP_FETCH_TIMEOUT);
-    } catch (err) {
-      console.debug("[process-router] Stop before restart ignored (process not found on agent?):", err.message);
+      const raw = (target.override ?? service.cwd ?? "").trim();
+      const projects = await projectStore.list();
+      const owner = projects.find((p) => p.serviceIds.includes(service.id));
+      const root = owner ? await projectRoot(owner) : null;
+      return root ? anchor(root, raw) : raw || ".";
     }
+  }
+  if (target.projectId) {
+    const root = await projectRoot({ id: target.projectId, orgId: target.orgId });
+    const raw = (target.override ?? "").trim();
+    return root ? anchor(root, raw) : raw || launchDir;
+  }
+  return anchor(launchDir, (target.override ?? "").trim());
+}
+function anchor(base, raw) {
+  if (!raw || raw === ".") return base;
+  if (raw.startsWith("~") || raw.startsWith("$") || isAbsolute2(raw)) return raw;
+  return join10(base, raw);
+}
+function localVaultRootParent() {
+  return dirname5(localVaultRoot());
+}
+async function resolveAgentCwd(target) {
+  if (target.serviceId) {
+    const service = await serviceStore.get(target.serviceId);
     if (service) {
-      try {
-        const resolved = await resolveServiceVariables(service);
-        await agentManager.agentMutation(effectiveAgentId, "process.deploy", resolved);
-      } catch (err) {
-        console.debug("[process-router] Failed to deploy before restart for", input.processId + ":", err.message);
-      }
+      const projects = await projectStore.list();
+      const owner = projects.find((p) => p.serviceIds.includes(service.id));
+      const root = owner ? await projectRoot(owner) : null;
+      if (!root) return void 0;
+      return anchor(root, (target.override ?? service.cwd ?? "").trim());
     }
-    if (service?.clearLogsOnStart) {
-      try {
-        await agentManager.agentMutation(effectiveAgentId, "process.clearLogBuffer", { id: input.processId });
-        agentManager.emit("process:log", { agentId: effectiveAgentId, batch: [{ processId: input.processId, __clearLogBuffer: true }] });
-      } catch (err) {
-        console.debug("[process-router] Failed to clear logs before restart for", input.processId + ":", err.message);
-      }
+  }
+  if (target.projectId) {
+    const root = await projectRoot({ id: target.projectId, orgId: target.orgId });
+    if (!root) return void 0;
+    return anchor(root, (target.override ?? "").trim());
+  }
+  return void 0;
+}
+async function resolveConversationCwd(conversationId) {
+  const conv = await conversationStore.get(conversationId);
+  const ref = conv ? await conversationStore.projectRefOf(conv) : null;
+  if (!ref) return resolveAgentCwd({});
+  return resolveAgentCwd({ projectId: ref.id, orgId: ref.orgId });
+}
+
+// ../server/src/trpc/routers/service.ts
+async function resolveEffectiveAgentId(service) {
+  const known = /* @__PURE__ */ new Set([
+    ...agentManager.listAgents().map((a) => a.config.id),
+    ...(await agentStore.list()).map((a) => a.id)
+  ]);
+  if (service.agentId && known.has(service.agentId)) return service.agentId;
+  const projects = await projectStore.list();
+  const project = projects.find((p) => p.serviceIds.includes(service.id));
+  if (project?.activeEnvironmentId) {
+    const activeEnv = await environmentStore.get(project.activeEnvironmentId);
+    if (activeEnv?.agentId && known.has(activeEnv.agentId)) return activeEnv.agentId;
+  }
+  return agentManager.getDefaultAgentId();
+}
+async function resolveServiceVariables(service) {
+  const projects = await projectStore.list();
+  const project = projects.find((p) => p.serviceIds.includes(service.id));
+  let resolvedService = service;
+  const anchored = await resolveWorkspaceCwd({ serviceId: service.id });
+  if (anchored !== (service.cwd ?? "").trim() && isAbsolute3(anchored)) {
+    resolvedService = { ...resolvedService, resolvedCwd: anchored };
+  }
+  try {
+    if (service.parserIds && service.parserIds.length > 0) {
+      const settings = await settingsManager.getSettings();
+      const allParsers = [...nativeParsers, ...settings.logParsers || []];
+      const resolvedParsers = service.parserIds.map((id) => allParsers.find((p) => p.id === id)).filter((p) => p !== void 0);
+      resolvedService = { ...resolvedService, resolvedLogParsers: resolvedParsers };
     }
-    const result = await agentManager.agentMutation(effectiveAgentId, "process.start", { id: input.processId });
-    await auditService.log({ userId: "local", action: "restart", entityType: "process", entityId: input.processId, metadata: { agentId: effectiveAgentId } });
-    return { ...result, agentId: effectiveAgentId };
-  }),
-  /** Get buffered logs for a process from an agent */
-  logs: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes/{agentId}/{processId}/logs", tags: ["processes"], summary: "Get buffered logs for a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).output(z6.any()).query(async ({ input, ctx }) => {
-    requireServiceAction(ctx, input.processId, "logs:read");
-    return agentManager.agentQuery(input.agentId, "process.logs", { id: input.processId });
-  }),
-  /** Clear buffered logs for a process on an agent */
-  clearLogBuffer: protectedProcedure.input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).mutation(async ({ input }) => {
-    await agentManager.agentMutation(input.agentId, "process.clearLogBuffer", { id: input.processId });
-    await auditService.log({ userId: "local", action: "clearLogBuffer", entityType: "process", entityId: input.processId, metadata: { agentId: input.agentId } });
-    return { success: true };
+  } catch (err) {
+    console.error("[service-router] Failed to resolve parsers for service", service.id + ":", err.message);
+  }
+  if (!project || !project.activeEnvironmentId) {
+    return resolvedService;
+  }
+  try {
+    const resolved = await environmentResolver.resolveForService({
+      serviceId: service.id,
+      activeEnvironmentId: project.activeEnvironmentId
+    });
+    const serviceBuiltins = {
+      HOST: env.HOST,
+      HOST_LAN: "0.0.0.0"
+    };
+    const interpolatedEnv = {};
+    for (const [key, value] of Object.entries(resolved.env)) {
+      interpolatedEnv[key] = value.replace(
+        /\{\{service\.([^}]+)\}\}/g,
+        (match, k) => serviceBuiltins[k] !== void 0 ? serviceBuiltins[k] : match
+      );
+    }
+    resolvedService = {
+      ...resolvedService,
+      env: interpolatedEnv,
+      envSecrets: [...resolved.envSecrets]
+    };
+  } catch (err) {
+    console.error("[service-router] Failed to resolve variables for service", service.id + ":", err.message);
+  }
+  return resolvedService;
+}
+var DockerConfigInput = DockerConfigSchema;
+var serviceRouter = router({
+  list: protectedProcedure.meta({ openapi: { method: "GET", path: "/services", tags: ["services"], summary: "List all services", protect: true } }).output(z4.any()).query(async ({ ctx }) => {
+    const all = await serviceStore.list();
+    const allowedIds = getAllowedServiceIds(ctx);
+    const filtered = allowedIds ? all.filter((s) => allowedIds.has(s.id)) : all;
+    return Promise.all(filtered.map(async (s) => ({
+      ...s,
+      effectiveAgentId: await resolveEffectiveAgentId(s)
+    })));
   }),
-  /** Execute a shortcut command on an agent, streaming output into the process log */
-  executeShortcut: protectedProcedure.input(z6.object({
-    agentId: z6.string().max(128),
-    processId: z6.string().max(128),
-    shortcut: ServiceShortcutSchema
-  })).mutation(async ({ input }) => {
-    const service = await serviceStore.get(input.processId);
-    if (service) {
-      try {
-        const resolved = await resolveServiceVariables(service);
-        await agentManager.agentMutation(input.agentId, "process.deploy", resolved);
-      } catch (err) {
-        console.debug("[process-router] Failed to deploy before executeShortcut for", input.processId + ":", err.message);
-      }
+  get: protectedProcedure.meta({ openapi: { method: "GET", path: "/services/{id}", tags: ["services"], summary: "Get a service by ID", protect: true } }).input(z4.object({ id: z4.string().max(128) })).output(z4.any()).query(async ({ input, ctx }) => {
+    requireServiceAction(ctx, input.id, "service:read");
+    const service = await serviceStore.get(input.id);
+    if (!service) {
+      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
     }
-    const result = await agentManager.agentMutation(
-      input.agentId,
-      "process.executeShortcut",
-      { id: input.processId, shortcut: input.shortcut },
-      AGENT_LONG_FETCH_TIMEOUT
-    );
-    await auditService.log({
-      userId: "local",
-      action: "executeShortcut",
-      entityType: "process",
-      entityId: input.processId,
-      metadata: { agentId: input.agentId, shortcutId: input.shortcut.id, shortcutLabel: input.shortcut.label }
-    });
-    return result;
+    return service;
   }),
-  /** Execute an ad-hoc command on an agent, streaming output into the process log */
-  executeAdHocCommand: protectedProcedure.input(z6.object({
-    agentId: z6.string().max(128),
-    processId: z6.string().max(128),
-    command: z6.string().min(1).max(4096),
-    cwd: z6.string().max(4096).optional(),
-    commandId: z6.string().max(128).optional()
-  })).mutation(async ({ input }) => {
-    const service = await serviceStore.get(input.processId);
-    if (service) {
-      try {
-        const resolved = await resolveServiceVariables(service);
-        await agentManager.agentMutation(input.agentId, "process.deploy", resolved);
-      } catch (err) {
-        console.debug("[process-router] Failed to deploy before executeAdHocCommand for", input.processId + ":", err.message);
+  create: protectedProcedure.meta({ openapi: { method: "POST", path: "/services", tags: ["services"], summary: "Create a new service", protect: true } }).output(z4.any()).input(
+    z4.object({
+      agentId: z4.string().max(128).optional(),
+      name: z4.string().min(1).max(200),
+      commands: z4.array(ServiceCommandSchema).max(50).optional(),
+      cwd: z4.string().max(4096).optional(),
+      ports: z4.array(z4.number().int().min(1).max(65535)).max(20).optional(),
+      groups: z4.array(z4.string().max(200)).max(20).optional(),
+      description: z4.string().max(2e3).optional(),
+      docsPath: z4.string().max(4096).optional(),
+      url: z4.string().max(2048).optional(),
+      localUrls: z4.array(z4.object({
+        url: z4.string().max(253),
+        port: z4.number().int().min(1).max(65535)
+      })).max(20).optional(),
+      openapiUrl: z4.string().max(2048).optional(),
+      git: z4.object({ remote: z4.string().max(2048).optional(), home: z4.string().max(2048).optional() }).optional(),
+      meta: z4.record(z4.string().max(256), z4.string().max(2e3)).optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
+      runner: z4.enum(["native", "docker"]).optional().default("native"),
+      dockerConfig: DockerConfigInput.optional(),
+      healthCheck: HealthCheckSchema.optional(),
+      autoRestart: z4.boolean().optional().default(false),
+      restartStrategy: RestartStrategySchema.optional(),
+      maxRestarts: z4.number().int().nonnegative().optional(),
+      restartBackoffMs: z4.number().int().positive().optional().default(1e3),
+      orgId: z4.string().max(128).nullable().optional(),
+      shortcuts: z4.array(ServiceShortcutSchema).max(50).optional(),
+      parserIds: z4.array(z4.string().max(128)).max(50).optional()
+    })
+  ).mutation(async ({ input }) => {
+    if (input.agentId) {
+      const status = agentManager.getStatus(input.agentId);
+      if (!status) {
+        throw new TRPCError4({
+          code: "NOT_FOUND",
+          message: `Agent ${input.agentId} not found`
+        });
       }
     }
-    const result = await agentManager.agentMutation(
-      input.agentId,
-      "process.executeAdHocCommand",
-      {
-        id: input.processId,
-        command: input.command,
-        // An explicit cwd wins; otherwise the service's directory, anchored on
-        // its project rather than on the server's launch directory.
-        cwd: input.cwd ?? await resolveAgentCwd({ serviceId: input.processId }),
-        commandId: input.commandId
-      },
-      AGENT_LONG_FETCH_TIMEOUT
-    );
-    await auditService.log({
-      userId: "local",
-      action: "executeAdHocCommand",
-      entityType: "process",
-      entityId: input.processId,
-      metadata: { agentId: input.agentId, command: input.command }
+    if (input.runner === "docker") {
+      throw new TRPCError4({ code: "BAD_REQUEST", message: 'Docker runner is not yet supported. Use "native" runner.' });
+    }
+    const service = await serviceStore.create({
+      ...input,
+      agentId: input.agentId
     });
-    return result;
-  }),
-  /** Cancel a running shortcut command on an agent */
-  cancelShortcut: protectedProcedure.input(z6.object({
-    agentId: z6.string().max(128),
-    processId: z6.string().max(128),
-    shortcutId: z6.string().max(128)
-  })).mutation(async ({ input }) => {
-    await agentManager.agentMutation(input.agentId, "process.cancelShortcut", { id: input.processId, shortcutId: input.shortcutId });
-    return { success: true };
-  }),
-  /** Cancel a running ad-hoc command on an agent */
-  cancelAdHocCommand: protectedProcedure.input(z6.object({
-    agentId: z6.string().max(128),
-    processId: z6.string().max(128),
-    commandId: z6.string().max(128).optional()
-  })).mutation(async ({ input }) => {
-    await agentManager.agentMutation(input.agentId, "process.cancelAdHocCommand", { id: input.processId, commandId: input.commandId });
-    return { success: true };
-  }),
-  /** Get current metrics for a process from an agent */
-  metrics: protectedProcedure.input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).query(async ({ input }) => {
-    return agentManager.agentQuery(input.agentId, "process.metrics", { id: input.processId });
-  }),
-  /**
-   * Subscribe to real-time log stream for a process.
-   * Forwards batched events from the AgentWSBridge in real-time.
-   * Historical logs are fetched separately via process.logs query.
-   */
-  onLog: protectedProcedure.input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).subscription(async function* ({ input, ctx }) {
-    requireServiceAction(ctx, input.processId, "logs:read");
-    yield* forwardLogBatches(input.agentId, input.processId);
+    await auditService.log({ userId: "local", action: "create", entityType: "service", entityId: service.id, metadata: { name: input.name } });
+    return service;
   }),
-  /**
-   * Subscribe to real-time status changes for processes.
-   * Input is optional — omit agentId/processId for global monitoring (dashboard).
-   * Forwards events from the AgentWSBridge in real-time.
-   */
-  onStatus: protectedProcedure.input(z6.object({
-    agentId: z6.string().max(128).optional(),
-    processId: z6.string().max(128).optional()
-  }).optional()).subscription(async function* ({ input, ctx }) {
-    const allowedIds = getAllowedServiceIds(ctx);
-    if (input?.processId) requireServiceAction(ctx, input.processId, "service:status");
-    try {
-      const agents = agentManager.listAgents();
-      for (const agent of agents.filter((a) => a.status.connected)) {
-        if (input?.agentId && agent.config.id !== input.agentId) continue;
+  update: protectedProcedure.meta({ openapi: { method: "PATCH", path: "/services/{id}", tags: ["services"], summary: "Update a service", protect: true } }).output(z4.any()).input(
+    z4.object({
+      id: z4.string().max(128),
+      agentId: z4.string().max(128).nullable().optional(),
+      // null = clear (inherit from env)
+      name: z4.string().min(1).max(200).optional(),
+      commands: z4.array(ServiceCommandSchema).max(50).optional(),
+      cwd: z4.string().max(4096).nullable().optional(),
+      ports: z4.array(z4.number().int().min(1).max(65535)).max(20).optional(),
+      groups: z4.array(z4.string().max(200)).max(20).optional(),
+      description: z4.string().max(2e3).optional(),
+      docsPath: z4.string().max(4096).optional(),
+      url: z4.string().max(2048).optional(),
+      localUrls: z4.array(z4.object({
+        url: z4.string().max(253),
+        port: z4.number().int().min(1).max(65535)
+      })).max(20).optional(),
+      openapiUrl: z4.string().max(2048).optional(),
+      git: z4.object({ remote: z4.string().max(2048).optional(), home: z4.string().max(2048).optional() }).nullable().optional(),
+      meta: z4.record(z4.string().max(256), z4.string().max(2e3)).nullable().optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
+      runner: z4.enum(["native", "docker"]).optional(),
+      dockerConfig: DockerConfigInput.optional(),
+      healthCheck: HealthCheckSchema.nullable().optional(),
+      autoRestart: z4.boolean().optional(),
+      clearLogsOnStart: z4.boolean().optional(),
+      restartStrategy: RestartStrategySchema.optional(),
+      maxRestarts: z4.number().int().nonnegative().optional(),
+      restartBackoffMs: z4.number().int().positive().optional(),
+      orgId: z4.string().max(128).nullable().optional(),
+      shortcuts: z4.array(ServiceShortcutSchema).max(50).optional(),
+      parserIds: z4.array(z4.string().max(128)).max(50).optional(),
+      logSources: z4.array(LogSourceConfigSchema).max(20).optional()
+    })
+  ).mutation(async ({ input }) => {
+    const existing = await serviceStore.get(input.id);
+    if (!existing) {
+      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
+    }
+    let stoppedForAgentChange = false;
+    if (input.agentId !== void 0 && input.agentId !== existing.agentId && existing.agentId) {
+      const oldAgentStatus = agentManager.getStatus(existing.agentId);
+      if (oldAgentStatus?.connected) {
         try {
-          const processes = await agentManager.agentQuery(agent.config.id, "process.list");
-          for (const proc of processes) {
-            if (input?.processId && proc.id !== input.processId) continue;
-            if (allowedIds && !allowedIds.has(proc.id)) continue;
-            yield { ...proc, agentId: agent.config.id };
+          const processes = await agentManager.agentQuery(existing.agentId, "process.list");
+          const proc = processes.find((p) => p.serviceId === input.id);
+          if (proc && (proc.state === "running" || proc.state === "starting")) {
+            await agentManager.agentMutation(existing.agentId, "process.stop", { id: input.id }, AGENT_STOP_FETCH_TIMEOUT);
+            stoppedForAgentChange = true;
           }
         } catch {
         }
       }
-    } catch {
+      if (input.agentId) {
+        const newAgentStatus = agentManager.getStatus(input.agentId);
+        if (!newAgentStatus) {
+          throw new TRPCError4({
+            code: "NOT_FOUND",
+            message: `Agent ${input.agentId} not found`
+          });
+        }
+      }
     }
-    yield* forwardEvents("process:status", (d) => {
-      if (input?.agentId && d.agentId !== input.agentId) return false;
-      if (input?.processId && d.processId !== input.processId) return false;
-      if (allowedIds && !allowedIds.has(d.processId)) return false;
-      return true;
-    });
+    const service = await serviceStore.update(input);
+    if (!service) {
+      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
+    }
+    if (input.name && input.name !== existing.name) {
+      await environmentStore.renameByReference(input.id, input.name);
+    }
+    if (service.agentId) {
+      const agentStatus = agentManager.getStatus(service.agentId);
+      if (agentStatus?.connected) {
+        try {
+          const resolvedService = await resolveServiceVariables(service);
+          await agentManager.agentMutation(service.agentId, "process.updateConfig", {
+            serviceId: service.id,
+            config: resolvedService
+          });
+        } catch (err) {
+          console.debug("[service-router] Failed to propagate config to agent", service.agentId + ":", err.message);
+        }
+      }
+    }
+    await auditService.log({ userId: "local", action: "update", entityType: "service", entityId: input.id });
+    return { ...service, effectiveAgentId: await resolveEffectiveAgentId(service), stoppedForAgentChange };
   }),
-  /** Subscribe to real-time metrics for a process. */
-  onMetrics: protectedProcedure.input(z6.object({
-    agentId: z6.string().max(128).optional(),
-    processId: z6.string().max(128).optional()
-  }).optional()).subscription(async function* ({ input, ctx }) {
-    const allowedIds = getAllowedServiceIds(ctx);
-    if (input?.processId) requireServiceAction(ctx, input.processId, "service:status");
-    yield* forwardEvents("process:metrics", (d) => {
-      if (input?.agentId && d.agentId !== input.agentId) return false;
-      if (input?.processId && d.processId !== input.processId) return false;
-      if (allowedIds && !allowedIds.has(d.processId)) return false;
-      return true;
-    });
+  delete: protectedProcedure.meta({ openapi: { method: "DELETE", path: "/services/{id}", tags: ["services"], summary: "Delete a service", protect: true } }).input(z4.object({ id: z4.string().max(128) })).output(z4.object({ success: z4.literal(true) })).mutation(async ({ input }) => {
+    const deleted = await serviceStore.delete(input.id);
+    if (!deleted) {
+      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
+    }
+    await auditService.log({ userId: "local", action: "delete", entityType: "service", entityId: input.id });
+    return { success: true };
   }),
-  /** Subscribe to real-time health status changes. */
-  onHealth: protectedProcedure.input(z6.object({
-    agentId: z6.string().max(128).optional(),
-    processId: z6.string().max(128).optional()
-  }).optional()).subscription(async function* ({ input, ctx }) {
-    const allowedIds = getAllowedServiceIds(ctx);
-    if (input?.processId) requireServiceAction(ctx, input.processId, "service:healthcheck");
-    yield* forwardEvents("process:health", (d) => {
-      if (input?.agentId && d.agentId !== input.agentId) return false;
-      if (input?.processId && d.processId !== input.processId) return false;
-      if (allowedIds && !allowedIds.has(d.processId)) return false;
-      return true;
+  checkCwd: protectedProcedure.input(z4.object({ id: z4.string().max(128), checkReachability: z4.boolean().optional() })).query(async ({ input }) => {
+    const service = await serviceStore.get(input.id);
+    if (!service) {
+      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
+    }
+    const effectiveAgentId = await resolveEffectiveAgentId(service);
+    if (!effectiveAgentId) {
+      throw new TRPCError4({ code: "BAD_REQUEST", message: "No agent configured for this service" });
+    }
+    const agentResult = await agentManager.agentQuery(effectiveAgentId, "git.checkCwd", {
+      // Anchored on the project, so the check answers about the directory the
+      // service will actually run in.
+      cwd: await resolveWorkspaceCwd({ serviceId: service.id }),
+      remote: service.git?.remote,
+      checkReachability: input.checkReachability
     });
+    const { exists: exists4, actualRemote, unreachable, resolvedCwd, unresolvedVars } = agentResult;
+    if (unresolvedVars.length > 0) {
+      return { exists: false, canClone: false, unresolvedVars, resolvedCwd, gitMismatch: null };
+    }
+    const canClone = !!service.git?.remote && (!exists4 || actualRemote === null);
+    let gitMismatch = null;
+    if (exists4 && service.git?.remote && !canClone) {
+      if (actualRemote === null) {
+        gitMismatch = { actual: null, configured: service.git.remote };
+      } else if (actualRemote !== service.git.remote) {
+        gitMismatch = { actual: actualRemote, configured: service.git.remote };
+      } else if (unreachable) {
+        gitMismatch = { actual: actualRemote, configured: service.git.remote, unreachable: true };
+      }
+    }
+    return { exists: exists4, canClone, unresolvedVars: [], resolvedCwd, gitMismatch };
+  }),
+  cloneRepository: protectedProcedure.input(z4.object({ id: z4.string().max(128) })).mutation(async ({ input }) => {
+    const service = await serviceStore.get(input.id);
+    if (!service) {
+      throw new TRPCError4({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
+    }
+    if (!service.git?.remote) {
+      throw new TRPCError4({ code: "BAD_REQUEST", message: "Service has no git remote configured" });
+    }
+    const effectiveAgentId = await resolveEffectiveAgentId(service);
+    if (!effectiveAgentId) {
+      throw new TRPCError4({ code: "BAD_REQUEST", message: "No agent configured for this service" });
+    }
+    await agentManager.agentMutation(effectiveAgentId, "git.clone", {
+      remote: service.git.remote,
+      // Clones WRITE: landing this in the launch directory instead of the
+      // project's is how a repository ends up in the wrong place.
+      cwd: await resolveWorkspaceCwd({ serviceId: service.id })
+    }, 5 * 60 * 1e3);
+    return { success: true };
   })
 });
 
-// ../server/src/trpc/routers/audit.ts
-import { z as z7 } from "zod";
-var auditRouter = router({
-  list: protectedProcedure.input(z7.object({
-    action: z7.string().max(50).optional(),
-    entityType: z7.string().max(50).optional(),
-    entityId: z7.string().max(100).optional(),
-    limit: z7.number().int().positive().max(100).default(50),
-    offset: z7.number().int().nonnegative().default(0)
-  }).optional()).query(async ({ input }) => {
-    return auditService.list(input ?? {});
-  })
-});
-
-// ../server/src/trpc/routers/setup.ts
-import { z as z8 } from "zod";
-
-// ../server/src/services/cloud-session-store.ts
-import { readFile as readFile8, writeFile as writeFile8, rename as rename8, mkdir as mkdir8, chmod as chmod7, unlink as unlink2 } from "fs/promises";
-import { dirname as dirname5 } from "path";
-import { randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual2 } from "crypto";
-var FILENAME4 = "cloud-session.json";
-var STATE_TTL_MS = 5 * 60 * 1e3;
-var CloudSessionStore = class {
-  session = null;
-  loaded = false;
-  /** Pending login states (CSRF binding between `start` and the callback). */
-  pending = /* @__PURE__ */ new Map();
-  /**
-   * Encrypted, so it lives beside the key that opens it — usually the machine
-   * root, but a launch directory owning its own key keeps both together.
-   */
-  getFilePath() {
-    return keyedFilePath(FILENAME4);
-  }
-  /** Where older versions kept it — read only, so an older Runeya keeps working. */
-  getLegacyFilePath() {
-    return legacyMachineFilePath(FILENAME4);
-  }
-  /**
-   * Read the machine file, falling back to the launch directory of old.
-   *
-   * The legacy file is left in place: the next save writes the new location,
-   * and a directory still opened by an older Runeya keeps working meanwhile.
-   */
-  async readFromDisk() {
+// ../server/src/trpc/routers/agent.ts
+import { z as z5 } from "zod";
+import { TRPCError as TRPCError5 } from "@trpc/server";
+var SUBSCRIPTION_QUEUE_MAX = LOG_BUFFER_SIZE;
+var agentRouter = router({
+  /** List all registered agents with their connection status */
+  list: protectedProcedure.query(() => {
+    return agentManager.listAgents();
+  }),
+  /** Get a single agent's config and status */
+  get: protectedProcedure.input(z5.object({ id: z5.string().max(128) })).query(({ input }) => {
+    const agent = agentManager.getAgent(input.id);
+    if (!agent) {
+      throw new TRPCError5({ code: "NOT_FOUND", message: `Agent ${input.id} not found` });
+    }
+    return {
+      config: { ...agent.config, passphrase: "***" },
+      status: agent.status
+    };
+  }),
+  /** Test connectivity to an agent given url + passphrase */
+  testConnection: protectedProcedure.input(
+    z5.object({
+      url: z5.string().url().max(2048),
+      passphrase: z5.string().min(1).max(1024).optional(),
+      agentId: z5.string().max(128).optional()
+    })
+  ).mutation(async ({ input }) => {
+    let passphrase = input.passphrase;
+    let targetUrl = input.url;
+    if (!passphrase && input.agentId) {
+      const agent = agentManager.getAgentConfig(input.agentId);
+      if (!agent) {
+        throw new TRPCError5({ code: "NOT_FOUND", message: "Agent not found" });
+      }
+      passphrase = agent.passphrase;
+      targetUrl = agent.url;
+    }
+    if (!passphrase) {
+      throw new TRPCError5({ code: "BAD_REQUEST", message: "Passphrase is required" });
+    }
+    const url = new URL("/api/trpc/health.check", targetUrl);
+    try {
+      const res = await fetch(url.toString(), {
+        headers: { "Authorization": `Bearer ${passphrase}`, "Content-Type": "application/json" },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) {
+        return { success: false, error: `HTTP ${res.status} ${res.statusText}` };
+      }
+      const json = await res.json();
+      if (json.error) {
+        return { success: false, error: json.error.message ?? "Agent returned an error" };
+      }
+      return { success: true, uptime: json.result?.data?.uptime };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error: msg };
+    }
+  }),
+  /** Register a new agent */
+  register: protectedProcedure.input(
+    z5.object({
+      name: z5.string().min(1).max(100),
+      url: z5.string().url().max(2048),
+      passphrase: z5.string().min(1).max(1024),
+      // À quelle organisation rattacher l'agent. Absent = la machine, ce que
+      // font l'agent local et tout client antérieur à ce champ.
+      orgId: z5.string().min(1).max(128).nullable().optional()
+    })
+  ).mutation(async ({ input }) => {
+    const config = await agentManager.register(
+      input.name,
+      input.url,
+      input.passphrase,
+      input.orgId ?? null
+    );
+    return { ...config, passphrase: "***" };
+  }),
+  /** Update an existing agent */
+  update: protectedProcedure.input(
+    z5.object({
+      id: z5.string().max(128),
+      name: z5.string().min(1).max(100).optional(),
+      url: z5.string().url().max(2048).optional(),
+      passphrase: z5.string().min(1).max(1024).optional(),
+      passthroughEnv: z5.array(
+        z5.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256)
+      ).max(100).optional()
+    })
+  ).mutation(async ({ input }) => {
     try {
-      return await readFile8(await this.getFilePath(), "utf-8");
-    } catch {
-      return readFile8(this.getLegacyFilePath(), "utf-8");
+      const { id, ...fields } = input;
+      const config = await agentManager.update(id, fields);
+      return { ...config, passphrase: "***" };
+    } catch (err) {
+      if (err instanceof Error) {
+        if (err.message.includes("not found")) {
+          throw new TRPCError5({ code: "NOT_FOUND", message: err.message });
+        }
+        if (err.message.includes("Cannot modify")) {
+          throw new TRPCError5({ code: "FORBIDDEN", message: err.message });
+        }
+      }
+      throw err;
     }
-  }
-  async load() {
-    if (this.loaded) return;
+  }),
+  /** Get resolved passthrough env values from an agent */
+  getPassthroughEnv: protectedProcedure.input(z5.object({ id: z5.string().max(128) })).query(async ({ input }) => {
     try {
-      const raw = await this.readFromDisk();
-      this.session = JSON.parse(raw);
+      return await agentManager.agentQuery(input.id, "config.getPassthroughEnv");
     } catch {
+      return {};
     }
-    this.loaded = true;
-  }
-  /**
-   * Mint a state value binding a login attempt to this server. Returned to the
-   * cloud page and echoed back on the callback, so a redirect we never
-   * initiated cannot install a token.
-   */
-  createState(returnTo) {
-    this.sweepStates();
-    const state = randomBytes4(32).toString("hex");
-    this.pending.set(state, { expiresAt: Date.now() + STATE_TTL_MS, returnTo });
-    return state;
-  }
-  /**
-   * Consume a state — single use, constant-time compare, TTL enforced. Returns
-   * the URL to send the browser back to, or null when the state is unknown or
-   * expired (i.e. a callback this server never initiated).
-   */
-  consumeState(candidate) {
-    this.sweepStates();
-    for (const [state, entry] of this.pending) {
-      const a = Buffer.from(state);
-      const b = Buffer.from(candidate);
-      if (a.length === b.length && timingSafeEqual2(a, b)) {
-        this.pending.delete(state);
-        return entry.expiresAt > Date.now() ? entry.returnTo : null;
+  }),
+  /** Remove a registered agent */
+  remove: protectedProcedure.input(z5.object({ id: z5.string().max(128) })).mutation(async ({ input }) => {
+    try {
+      const removed = await agentManager.remove(input.id);
+      if (!removed) {
+        throw new TRPCError5({ code: "NOT_FOUND", message: `Agent ${input.id} not found` });
       }
+      return { success: true };
+    } catch (err) {
+      if (err instanceof Error && err.message === "Cannot remove the local agent") {
+        throw new TRPCError5({ code: "FORBIDDEN", message: err.message });
+      }
+      throw err;
     }
-    return null;
-  }
-  sweepStates() {
-    const now = Date.now();
-    for (const [state, entry] of this.pending) {
-      if (entry.expiresAt <= now) this.pending.delete(state);
-    }
-  }
-  async save() {
-    await mkdir8(dirname5(await this.getFilePath()), { recursive: true });
-    const filePath = await this.getFilePath();
-    const tmpPath = filePath + ".tmp";
-    await writeFile8(tmpPath, JSON.stringify(this.session, null, 2), "utf-8");
-    await rename8(tmpPath, filePath);
-    await chmod7(filePath, 384);
-  }
-  /** Store the session token obtained from the one-time-token exchange. */
-  async set(cloudUrl, token) {
-    await this.load();
-    this.session = { cloudUrl, encryptedToken: encryptValue(token) };
-    await this.save();
-  }
-  /** The decrypted session token, or null when not logged in. */
-  async getToken() {
-    await this.load();
-    if (!this.session) return null;
-    try {
-      return decryptValue(this.session.encryptedToken);
-    } catch {
-      return null;
+  }),
+  /** Subscribe to real-time agent status changes */
+  onStatus: protectedProcedure.subscription(async function* () {
+    for (const agent of agentManager.listAgents()) {
+      yield { agentId: agent.config.id, status: agent.status };
     }
-  }
-  /**
-   * The cloud this machine is signed into, or null when not linked.
-   *
-   * Needed to tell "an org I am not a member of" apart from "an org of another
-   * cloud instance entirely" — the ids of two clouds share no namespace, so
-   * comparing them without this would call every foreign-cloud project a
-   * permission problem.
-   */
-  async getCloudUrl() {
-    await this.load();
-    return this.session?.cloudUrl ?? null;
-  }
-  async isLinked() {
-    return await this.getToken() !== null;
-  }
-  /** Forget the session (sign-out). */
-  async clear() {
-    await this.load();
-    this.session = null;
-    this.pending.clear();
+    const queue = [];
+    let resolve7 = null;
+    const handler = (event) => {
+      if (queue.length >= SUBSCRIPTION_QUEUE_MAX) queue.shift();
+      queue.push(event);
+      if (resolve7) {
+        resolve7();
+        resolve7 = null;
+      }
+    };
+    agentManager.on("status", handler);
     try {
-      await unlink2(await this.getFilePath());
-    } catch {
+      while (true) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else {
+          await new Promise((r) => {
+            resolve7 = r;
+          });
+        }
+      }
+    } finally {
+      agentManager.off("status", handler);
     }
-  }
-};
-var cloudSessionStore = new CloudSessionStore();
-
-// ../server/src/services/cloud-api.ts
-var DEFAULT_CLOUD_API_URL = "https://api.runeya.dev";
-var DEFAULT_CLOUD_APP_URL = "https://runeya.dev";
-function getCloudApiUrl() {
-  return (env.CLOUD_URL ?? DEFAULT_CLOUD_API_URL).replace(/\/+$/, "");
-}
-function getCloudAppUrl() {
-  return (env.CLOUD_APP_URL ?? DEFAULT_CLOUD_APP_URL).replace(/\/+$/, "");
-}
-var CloudNotLinkedError = class extends Error {
-  code = "CLOUD_NOT_LINKED";
-  constructor() {
-    super("Not linked to the Runeya cloud.");
-    this.name = "CloudNotLinkedError";
-  }
-};
-async function cloudFetch(path, init = {}) {
-  const token = await cloudSessionStore.getToken();
-  if (!token) throw new CloudNotLinkedError();
-  return fetch(`${getCloudApiUrl()}${path}`, {
-    method: init.method ?? "GET",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      // Le cloud refuse (426) les apps trop anciennes pour son schéma courant.
-      [APP_VERSION_HEADER]: appVersion,
-      ...init.body !== void 0 ? { "Content-Type": "application/json" } : {}
-    },
-    ...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
-    // 15s suits a JSON call; attachment downloads pass a longer budget.
-    signal: AbortSignal.timeout(init.timeoutMs ?? 15e3)
-  });
-}
+  })
+});
 
-// ../server/src/services/conversation-store.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile9, writeFile as writeFile9, rename as rename9, mkdir as mkdir9, chmod as chmod8 } from "fs/promises";
-import { dirname as dirname6, join as join10 } from "path";
-import { EventEmitter as EventEmitter2 } from "events";
-var FILENAME5 = "conversations.private.json";
-async function localProjectId() {
-  const projects = await projectStore.list().catch(() => []);
-  return projects.find((p) => !p.orgId)?.id ?? null;
-}
-var ConversationStore = class {
-  conversations = /* @__PURE__ */ new Map();
-  /** Which vault each conversation was read from, until its project is known. */
-  roots = /* @__PURE__ */ new Map();
-  /**
-   * Les conversations qu'on n'a pas su déchiffrer, par coffre, sous leur forme
-   * de disque.
-   *
-   * Une entrée illisible était simplement ignorée. Tant qu'aucune de ses
-   * voisines ne se chargeait, le fichier n'était jamais réécrit et la donnée
-   * survivait par accident ; dès qu'une seule s'ouvrait, la sauvegarde suivante
-   * réécrivait le fichier avec elle seule — et effaçait les autres. Elles sont
-   * donc gardées ici, telles quelles, et réémises à l'identique.
-   */
-  unreadable = /* @__PURE__ */ new Map();
-  loaded = false;
-  events = new EventEmitter2().setMaxListeners(0);
-  saveQueue = Promise.resolve();
-  snapshotConversation(conv) {
-    return structuredClone(conv);
-  }
-  /**
-   * Encrypted, so it lives beside the key that opens it — usually the machine
-   * root, but a launch directory owning its own key keeps both together.
-   */
-  getFilePath() {
-    return keyedFilePath(FILENAME5);
-  }
-  /** Where older versions kept it — read only, so an older Runeya keeps working. */
-  getLegacyFilePath() {
-    return legacyMachineFilePath(FILENAME5);
-  }
-  /**
-   * Read the machine file, falling back to the launch directory of old.
-   *
-   * The legacy file is left in place: the next save writes the new location,
-   * and a directory still opened by an older Runeya keeps working meanwhile.
-   */
-  async readFromDisk() {
-    try {
-      return await readFile9(await this.getFilePath(), "utf-8");
-    } catch {
-      return readFile9(this.getLegacyFilePath(), "utf-8");
+// ../server/src/trpc/routers/process.ts
+import { z as z6 } from "zod";
+import { TRPCError as TRPCError6 } from "@trpc/server";
+var SUBSCRIPTION_QUEUE_MAX2 = LOG_BUFFER_SIZE;
+async function* forwardEvents(eventName, filter) {
+  const queue = [];
+  let resolve7 = null;
+  const handler = (data) => {
+    if (filter && !filter(data)) return;
+    if (queue.length >= SUBSCRIPTION_QUEUE_MAX2) queue.shift();
+    queue.push(data);
+    if (resolve7) {
+      resolve7();
+      resolve7 = null;
     }
+  };
+  agentManager.on(eventName, handler);
+  try {
+    while (true) {
+      if (queue.length > 0) {
+        yield queue.shift();
+      } else {
+        await new Promise((r) => {
+          resolve7 = r;
+        });
+      }
+    }
+  } finally {
+    agentManager.off(eventName, handler);
   }
-  async ensureDir() {
-    await mkdir9(dirname6(await this.getFilePath()), { recursive: true });
-  }
-  encryptMessages(messages, vault) {
-    return encryptValue(JSON.stringify(messages), vault);
-  }
-  decryptMessages(encrypted, vault) {
-    const json = decryptValue(encrypted, vault);
-    return JSON.parse(json);
+}
+async function* forwardLogBatches(agentId, processId) {
+  const queue = [];
+  let resolve7 = null;
+  const handler = (data) => {
+    if (data.agentId !== agentId) return;
+    const batch = data.batch;
+    if (!Array.isArray(batch)) return;
+    const filtered = batch.filter((log) => log.processId === processId);
+    if (filtered.length === 0) return;
+    if (queue.length >= SUBSCRIPTION_QUEUE_MAX2) queue.shift();
+    queue.push(filtered);
+    if (resolve7) {
+      resolve7();
+      resolve7 = null;
+    }
+  };
+  agentManager.on("process:log", handler);
+  try {
+    while (true) {
+      if (queue.length > 0) {
+        yield queue.shift();
+      } else {
+        await new Promise((r) => {
+          resolve7 = r;
+        });
+      }
+    }
+  } finally {
+    agentManager.off("process:log", handler);
   }
-  /**
-   * Refuser d'écrire dans le coffre d'une organisation sans nommer sa clé.
-   *
-   * `getEncryptionKey(undefined)` rend la clé machine, et c'est le bon défaut
-   * pour le coffre local. Appliqué à un fichier rangé sous `orgs/<org>/`, il
-   * produit un chiffré que ce coffre n'emploie pas — lisible par personne à la
-   * relecture, et impossible à distinguer d'une corruption.
-   *
-   * Le cas a été observé plusieurs fois sans qu'on parvienne à nommer le
-   * chemin fautif : les garde-fous en place traitent le coffre fermé, le
-   * coffre mal résolu et la copie périmée, aucun ne couvrait « coffre non
-   * précisé ». Ces écritures-là n'ont jamais fonctionné — elles échouaient en
-   * silence, ce qui est pire. On les saute désormais en le disant, avec la
-   * pile d'appels qui manquait pour remonter au chemin fautif.
-   */
-  isVaultNamed(root, vault) {
-    const orgId = orgIdOfRoot(root);
-    if (!orgId || vault) return true;
-    console.error(
-      `[conversation-store] \xC9criture ignor\xE9e dans le coffre de l'organisation ${orgId} (${root}) : aucune cl\xE9 d'organisation nomm\xE9e, le contenu serait chiffr\xE9 par la cl\xE9 machine et illisible \xE0 la relecture.
-${new Error("trace").stack}`
+}
+var processRouter = router({
+  /** List all processes across all connected agents */
+  list: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes", tags: ["processes"], summary: "List all processes", protect: true } }).output(z6.any()).query(async () => {
+    const agents = agentManager.listAgents();
+    const results = [];
+    await Promise.allSettled(
+      agents.filter((a) => a.status.connected).map(async (a) => {
+        try {
+          const processes = await agentManager.agentQuery(a.config.id, "process.list");
+          for (const proc of processes) {
+            results.push({ ...proc, agentId: a.config.id });
+          }
+        } catch {
+        }
+      })
     );
-    return false;
-  }
-  toDisk(conv, vault) {
-    return {
-      id: conv.id,
-      projectId: conv.projectId,
-      title: conv.title,
-      encryptedMessages: this.encryptMessages(conv.messages, vault),
-      isCli: conv.isCli,
-      runner: conv.runner,
-      providerId: conv.providerId,
-      codexThreadId: conv.codexThreadId,
-      contextUsage: conv.contextUsage,
-      workflowId: conv.workflowId,
-      workflowType: conv.workflowType,
-      kanbanBoardId: conv.kanbanBoardId,
-      kanbanCardId: conv.kanbanCardId,
-      archived: conv.archived,
-      createdAt: conv.createdAt,
-      updatedAt: conv.updatedAt
-    };
-  }
-  fromDisk(disk, vault) {
-    const workflowType = (disk.workflowType === "scenario" ? "scenario" : void 0) ?? (disk.scenarioId ? "scenario" : void 0);
-    return {
-      id: disk.id,
-      projectId: disk.projectId,
-      title: disk.title,
-      messages: this.decryptMessages(disk.encryptedMessages, vault),
-      isCli: disk.isCli ?? disk.isClaudeCode ?? false,
-      runner: disk.runner,
-      providerId: disk.providerId,
-      codexThreadId: disk.codexThreadId,
-      contextUsage: disk.contextUsage,
-      workflowId: disk.workflowId ?? disk.scenarioId,
-      workflowType,
-      kanbanBoardId: disk.kanbanBoardId,
-      kanbanCardId: disk.kanbanCardId,
-      archived: disk.archived,
-      createdAt: disk.createdAt,
-      updatedAt: disk.updatedAt
-    };
-  }
-  /**
-   * Read every project vault, then the homes older versions used.
-   *
-   * A conversation found in a legacy file is attributed to the local project of
-   * that directory — which is what it was about, back when one directory meant
-   * one project. With no local project to point at, it is left unattributed
-   * rather than filed under a project picked at random.
-   */
-  async load() {
-    if (this.loaded) return;
-    if (!getEncryptionKey()) {
-      return;
+    return results;
+  }),
+  /** Get a single process from a specific agent */
+  get: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes/{agentId}/{id}", tags: ["processes"], summary: "Get a process by agent and ID", protect: true } }).input(z6.object({ agentId: z6.string().max(128), id: z6.string().max(128) })).output(z6.any()).query(async ({ input, ctx }) => {
+    requireServiceAction(ctx, input.id, "service:read");
+    const status = agentManager.getStatus(input.agentId);
+    if (!status) {
+      throw new TRPCError6({ code: "NOT_FOUND", message: `Agent ${input.agentId} not found` });
     }
-    this.loaded = true;
-    this.unreadable.clear();
-    await ensureProjectsLoaded();
-    const vaults = await allVaultRoots();
-    const legacyPaths = [this.getLegacyFilePath(), await keyedFilePath(FILENAME5)];
-    const sources = [
-      ...legacyPaths.map((path) => ({ path, legacy: true })),
-      ...vaults.map((root) => ({ path: join10(root, FILENAME5), legacy: false }))
-    ];
-    for (const { path, legacy } of sources) {
-      let data;
+    const proc = await agentManager.agentQuery(input.agentId, "process.get", { id: input.id });
+    return { ...proc, agentId: input.agentId };
+  }),
+  /** Start a process on an agent.
+   *  Lazy deploy: the agent only learns about a service when it is first started
+   *  (or restarted). This avoids pushing configs for every service at agent boot,
+   *  which would be wasteful when many services are never started.
+   *  The deploy call is idempotent — creates the process if missing, updates config if it exists. */
+  start: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/start", tags: ["processes"], summary: "Start a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128).optional(), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
+    requireServiceAction(ctx, input.processId, "service:start");
+    const service = await serviceStore.get(input.processId);
+    const effectiveAgentId = (service ? await resolveEffectiveAgentId(service) : null) ?? input.agentId ?? null;
+    if (!effectiveAgentId) {
+      throw new TRPCError6({ code: "BAD_REQUEST", message: "No agent assigned to this service. Set an agent on the service or on the active environment." });
+    }
+    if (service) {
+      try {
+        const resolved = await resolveServiceVariables(service);
+        await agentManager.agentMutation(effectiveAgentId, "process.deploy", resolved);
+      } catch (err) {
+        console.debug("[process-router] Failed to deploy before start for", input.processId + ":", err.message);
+      }
+    }
+    if (service?.clearLogsOnStart) {
+      try {
+        await agentManager.agentMutation(effectiveAgentId, "process.clearLogBuffer", { id: input.processId });
+        agentManager.emit("process:log", { agentId: effectiveAgentId, batch: [{ processId: input.processId, __clearLogBuffer: true }] });
+      } catch (err) {
+        console.debug("[process-router] Failed to clear logs before start for", input.processId + ":", err.message);
+      }
+    }
+    let result;
+    try {
+      result = await agentManager.agentMutation(effectiveAgentId, "process.start", { id: input.processId });
+    } catch (err) {
+      const err_ = err;
+      const isFetchError = err_?.cause?.code === "ECONNREFUSED" || err_?.message === "fetch failed" || err_?.name === "TypeError";
+      throw new TRPCError6({
+        code: "INTERNAL_SERVER_ERROR",
+        message: isFetchError ? `Cannot reach agent \u2014 make sure the agent is running` : err_?.message ?? "Failed to start process"
+      });
+    }
+    await auditService.log({ userId: "local", action: "start", entityType: "process", entityId: input.processId, metadata: { agentId: effectiveAgentId } });
+    return { ...result, agentId: effectiveAgentId };
+  }),
+  /** Stop a process on an agent */
+  stop: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/stop", tags: ["processes"], summary: "Stop a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
+    requireServiceAction(ctx, input.processId, "service:stop");
+    const result = await agentManager.agentMutation(input.agentId, "process.stop", { id: input.processId }, AGENT_STOP_FETCH_TIMEOUT);
+    await auditService.log({ userId: "local", action: "stop", entityType: "process", entityId: input.processId, metadata: { agentId: input.agentId } });
+    return { ...result, agentId: input.agentId };
+  }),
+  /** Restart a process on an agent.
+   *  Sends stop → deploy (latest resolved config) → start so that
+   *  config/variable changes take effect. Same lazy deploy pattern as start. */
+  restart: protectedProcedure.meta({ openapi: { method: "POST", path: "/processes/{agentId}/{processId}/restart", tags: ["processes"], summary: "Restart a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128).optional(), processId: z6.string().max(128) })).output(z6.any()).mutation(async ({ input, ctx }) => {
+    requireServiceAction(ctx, input.processId, "service:restart");
+    const service = await serviceStore.get(input.processId);
+    const effectiveAgentId = (service ? await resolveEffectiveAgentId(service) : null) ?? input.agentId ?? null;
+    if (!effectiveAgentId) {
+      throw new TRPCError6({ code: "BAD_REQUEST", message: "No agent assigned to this service. Set an agent on the service or on the active environment." });
+    }
+    try {
+      await agentManager.agentMutation(effectiveAgentId, "process.stop", { id: input.processId }, AGENT_STOP_FETCH_TIMEOUT);
+    } catch (err) {
+      console.debug("[process-router] Stop before restart ignored (process not found on agent?):", err.message);
+    }
+    if (service) {
+      try {
+        const resolved = await resolveServiceVariables(service);
+        await agentManager.agentMutation(effectiveAgentId, "process.deploy", resolved);
+      } catch (err) {
+        console.debug("[process-router] Failed to deploy before restart for", input.processId + ":", err.message);
+      }
+    }
+    if (service?.clearLogsOnStart) {
+      try {
+        await agentManager.agentMutation(effectiveAgentId, "process.clearLogBuffer", { id: input.processId });
+        agentManager.emit("process:log", { agentId: effectiveAgentId, batch: [{ processId: input.processId, __clearLogBuffer: true }] });
+      } catch (err) {
+        console.debug("[process-router] Failed to clear logs before restart for", input.processId + ":", err.message);
+      }
+    }
+    const result = await agentManager.agentMutation(effectiveAgentId, "process.start", { id: input.processId });
+    await auditService.log({ userId: "local", action: "restart", entityType: "process", entityId: input.processId, metadata: { agentId: effectiveAgentId } });
+    return { ...result, agentId: effectiveAgentId };
+  }),
+  /** Get buffered logs for a process from an agent */
+  logs: protectedProcedure.meta({ openapi: { method: "GET", path: "/processes/{agentId}/{processId}/logs", tags: ["processes"], summary: "Get buffered logs for a process", protect: true } }).input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).output(z6.any()).query(async ({ input, ctx }) => {
+    requireServiceAction(ctx, input.processId, "logs:read");
+    return agentManager.agentQuery(input.agentId, "process.logs", { id: input.processId });
+  }),
+  /** Clear buffered logs for a process on an agent */
+  clearLogBuffer: protectedProcedure.input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).mutation(async ({ input }) => {
+    await agentManager.agentMutation(input.agentId, "process.clearLogBuffer", { id: input.processId });
+    await auditService.log({ userId: "local", action: "clearLogBuffer", entityType: "process", entityId: input.processId, metadata: { agentId: input.agentId } });
+    return { success: true };
+  }),
+  /** Execute a shortcut command on an agent, streaming output into the process log */
+  executeShortcut: protectedProcedure.input(z6.object({
+    agentId: z6.string().max(128),
+    processId: z6.string().max(128),
+    shortcut: ServiceShortcutSchema
+  })).mutation(async ({ input }) => {
+    const service = await serviceStore.get(input.processId);
+    if (service) {
       try {
-        data = JSON.parse(await readFile9(path, "utf-8"));
-      } catch {
-        continue;
+        const resolved = await resolveServiceVariables(service);
+        await agentManager.agentMutation(input.agentId, "process.deploy", resolved);
+      } catch (err) {
+        console.debug("[process-router] Failed to deploy before executeShortcut for", input.processId + ":", err.message);
       }
-      const inherited = legacy ? await localProjectId() : null;
-      const root = dirname6(path);
-      await rememberFile(path);
-      for (const item of data) {
-        try {
-          const conv = this.fromDisk(item, vaultIdOfRoot(root));
-          if (!conv.projectId && inherited) conv.projectId = inherited;
-          this.conversations.set(item.id, conv);
-          this.roots.set(item.id, root);
-        } catch {
-          const bucket = this.unreadable.get(root) ?? [];
-          bucket.push(item);
-          this.unreadable.set(root, bucket);
-        }
+    }
+    const result = await agentManager.agentMutation(
+      input.agentId,
+      "process.executeShortcut",
+      { id: input.processId, shortcut: input.shortcut },
+      AGENT_LONG_FETCH_TIMEOUT
+    );
+    await auditService.log({
+      userId: "local",
+      action: "executeShortcut",
+      entityType: "process",
+      entityId: input.processId,
+      metadata: { agentId: input.agentId, shortcutId: input.shortcut.id, shortcutLabel: input.shortcut.label }
+    });
+    return result;
+  }),
+  /** Execute an ad-hoc command on an agent, streaming output into the process log */
+  executeAdHocCommand: protectedProcedure.input(z6.object({
+    agentId: z6.string().max(128),
+    processId: z6.string().max(128),
+    command: z6.string().min(1).max(4096),
+    cwd: z6.string().max(4096).optional(),
+    commandId: z6.string().max(128).optional()
+  })).mutation(async ({ input }) => {
+    const service = await serviceStore.get(input.processId);
+    if (service) {
+      try {
+        const resolved = await resolveServiceVariables(service);
+        await agentManager.agentMutation(input.agentId, "process.deploy", resolved);
+      } catch (err) {
+        console.debug("[process-router] Failed to deploy before executeAdHocCommand for", input.processId + ":", err.message);
       }
     }
-  }
-  /**
-   * Oublier ce qui a été lu, pour tout relire sous la clé courante.
-   *
-   * Appelé après l'adoption d'une clé d'organisation : le disque vient d'être
-   * re-chiffré sous les pieds du store, si bien que sa mémoire décrit un état
-   * qui n'existe plus. La laisser en place n'affichait pas seulement des
-   * comptes périmés — la sauvegarde suivante réécrivait l'ancien chiffré
-   * par-dessus le nouveau, et défaisait l'adoption.
-   */
-  resetCache() {
-    this.conversations.clear();
-    this.roots.clear();
-    this.unreadable.clear();
-    this.loaded = false;
-    this.events.emit("changed", { type: "reloaded" });
-  }
+    const result = await agentManager.agentMutation(
+      input.agentId,
+      "process.executeAdHocCommand",
+      {
+        id: input.processId,
+        command: input.command,
+        // An explicit cwd wins; otherwise the service's directory, anchored on
+        // its project rather than on the server's launch directory.
+        cwd: input.cwd ?? await resolveAgentCwd({ serviceId: input.processId }),
+        commandId: input.commandId
+      },
+      AGENT_LONG_FETCH_TIMEOUT
+    );
+    await auditService.log({
+      userId: "local",
+      action: "executeAdHocCommand",
+      entityType: "process",
+      entityId: input.processId,
+      metadata: { agentId: input.agentId, command: input.command }
+    });
+    return result;
+  }),
+  /** Cancel a running shortcut command on an agent */
+  cancelShortcut: protectedProcedure.input(z6.object({
+    agentId: z6.string().max(128),
+    processId: z6.string().max(128),
+    shortcutId: z6.string().max(128)
+  })).mutation(async ({ input }) => {
+    await agentManager.agentMutation(input.agentId, "process.cancelShortcut", { id: input.processId, shortcutId: input.shortcutId });
+    return { success: true };
+  }),
+  /** Cancel a running ad-hoc command on an agent */
+  cancelAdHocCommand: protectedProcedure.input(z6.object({
+    agentId: z6.string().max(128),
+    processId: z6.string().max(128),
+    commandId: z6.string().max(128).optional()
+  })).mutation(async ({ input }) => {
+    await agentManager.agentMutation(input.agentId, "process.cancelAdHocCommand", { id: input.processId, commandId: input.commandId });
+    return { success: true };
+  }),
+  /** Get current metrics for a process from an agent */
+  metrics: protectedProcedure.input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).query(async ({ input }) => {
+    return agentManager.agentQuery(input.agentId, "process.metrics", { id: input.processId });
+  }),
   /**
-   * Combien de conversations ce coffre garde sans savoir les lire, par
-   * organisation. La machine elle-même est rangée sous `null`.
+   * Subscribe to real-time log stream for a process.
+   * Forwards batched events from the AgentWSBridge in real-time.
+   * Historical logs are fetched separately via process.logs query.
    */
-  async unreadableByVault() {
-    await this.load();
-    const out = /* @__PURE__ */ new Map();
-    for (const [root, items] of this.unreadable) {
-      const vault = vaultIdOfRoot(root) ?? null;
-      out.set(vault, (out.get(vault) ?? 0) + items.length);
-    }
-    return out;
-  }
+  onLog: protectedProcedure.input(z6.object({ agentId: z6.string().max(128), processId: z6.string().max(128) })).subscription(async function* ({ input, ctx }) {
+    requireServiceAction(ctx, input.processId, "logs:read");
+    yield* forwardLogBatches(input.agentId, input.processId);
+  }),
   /**
-   * Write each vault that holds — or held — a conversation.
-   *
-   * A vault emptied by this save is still written, as an empty list: a
-   * conversation that found its project must not survive in the file it was
-   * read from.
+   * Subscribe to real-time status changes for processes.
+   * Input is optional — omit agentId/processId for global monitoring (dashboard).
+   * Forwards events from the AgentWSBridge in real-time.
    */
-  async saveInternal() {
-    if (!getEncryptionKey()) return;
-    const byRoot = /* @__PURE__ */ new Map();
-    for (const root of this.roots.values()) byRoot.set(root, []);
-    for (const conv of this.conversations.values()) {
-      const root = await this.rootFor(conv);
-      this.roots.set(conv.id, root);
-      const bucket = byRoot.get(root) ?? [];
-      const vault = vaultIdOfRoot(root);
-      if (!this.isVaultNamed(root, vault)) continue;
-      bucket.push(this.toDisk(conv, vault));
-      byRoot.set(root, bucket);
-    }
-    for (const [root, items] of this.unreadable) {
-      byRoot.set(root, [...items, ...byRoot.get(root) ?? []]);
-    }
-    const stale = /* @__PURE__ */ new Set();
-    for (const root of byRoot.keys()) {
-      const path = join10(root, FILENAME5);
-      if (wasRead(path) && await hasChangedSinceRead(path)) stale.add(root);
-    }
-    for (const [root, data] of byRoot) {
-      const filePath = join10(root, FILENAME5);
-      if (stale.has(root)) {
-        console.warn(
-          `[conversation-store] ${filePath} a chang\xE9 depuis sa lecture \u2014 \xE9criture ignor\xE9e pour ne pas \xE9craser une r\xE9paration faite en dehors du serveur.`
-        );
-        continue;
+  onStatus: protectedProcedure.input(z6.object({
+    agentId: z6.string().max(128).optional(),
+    processId: z6.string().max(128).optional()
+  }).optional()).subscription(async function* ({ input, ctx }) {
+    const allowedIds = getAllowedServiceIds(ctx);
+    if (input?.processId) requireServiceAction(ctx, input.processId, "service:status");
+    try {
+      const agents = agentManager.listAgents();
+      for (const agent of agents.filter((a) => a.status.connected)) {
+        if (input?.agentId && agent.config.id !== input.agentId) continue;
+        try {
+          const processes = await agentManager.agentQuery(agent.config.id, "process.list");
+          for (const proc of processes) {
+            if (input?.processId && proc.id !== input.processId) continue;
+            if (allowedIds && !allowedIds.has(proc.id)) continue;
+            yield { ...proc, agentId: agent.config.id };
+          }
+        } catch {
+        }
       }
-      await mkdir9(root, { recursive: true });
-      const tmpPath = `${filePath}.tmp`;
-      await writeFile9(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-      await rename9(tmpPath, filePath);
-      await chmod8(filePath, 384);
-      await rememberFile(filePath);
+    } catch {
     }
-  }
+    yield* forwardEvents("process:status", (d) => {
+      if (input?.agentId && d.agentId !== input.agentId) return false;
+      if (input?.processId && d.processId !== input.processId) return false;
+      if (allowedIds && !allowedIds.has(d.processId)) return false;
+      return true;
+    });
+  }),
+  /** Subscribe to real-time metrics for a process. */
+  onMetrics: protectedProcedure.input(z6.object({
+    agentId: z6.string().max(128).optional(),
+    processId: z6.string().max(128).optional()
+  }).optional()).subscription(async function* ({ input, ctx }) {
+    const allowedIds = getAllowedServiceIds(ctx);
+    if (input?.processId) requireServiceAction(ctx, input.processId, "service:status");
+    yield* forwardEvents("process:metrics", (d) => {
+      if (input?.agentId && d.agentId !== input.agentId) return false;
+      if (input?.processId && d.processId !== input.processId) return false;
+      if (allowedIds && !allowedIds.has(d.processId)) return false;
+      return true;
+    });
+  }),
+  /** Subscribe to real-time health status changes. */
+  onHealth: protectedProcedure.input(z6.object({
+    agentId: z6.string().max(128).optional(),
+    processId: z6.string().max(128).optional()
+  }).optional()).subscription(async function* ({ input, ctx }) {
+    const allowedIds = getAllowedServiceIds(ctx);
+    if (input?.processId) requireServiceAction(ctx, input.processId, "service:healthcheck");
+    yield* forwardEvents("process:health", (d) => {
+      if (input?.agentId && d.agentId !== input.agentId) return false;
+      if (input?.processId && d.processId !== input.processId) return false;
+      if (allowedIds && !allowedIds.has(d.processId)) return false;
+      return true;
+    });
+  })
+});
+
+// ../server/src/trpc/routers/audit.ts
+import { z as z7 } from "zod";
+var auditRouter = router({
+  list: protectedProcedure.input(z7.object({
+    action: z7.string().max(50).optional(),
+    entityType: z7.string().max(50).optional(),
+    entityId: z7.string().max(100).optional(),
+    limit: z7.number().int().positive().max(100).default(50),
+    offset: z7.number().int().nonnegative().default(0)
+  }).optional()).query(async ({ input }) => {
+    return auditService.list(input ?? {});
+  })
+});
+
+// ../server/src/trpc/routers/setup.ts
+import { z as z8 } from "zod";
+
+// ../server/src/services/cloud-session-store.ts
+import { readFile as readFile9, writeFile as writeFile9, rename as rename9, mkdir as mkdir9, chmod as chmod8, unlink as unlink2 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+import { randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual2 } from "crypto";
+var FILENAME5 = "cloud-session.json";
+var STATE_TTL_MS = 5 * 60 * 1e3;
+var CloudSessionStore = class {
+  session = null;
+  loaded = false;
+  /** Pending login states (CSRF binding between `start` and the callback). */
+  pending = /* @__PURE__ */ new Map();
   /**
-   * The vault a conversation is written to: its project's.
-   *
-   * One that names no project stays where it was read, falling back to the
-   * key's own directory — never lost for want of an owner.
+   * Encrypted, so it lives beside the key that opens it — usually the machine
+   * root, but a launch directory owning its own key keeps both together.
    */
-  async rootFor(conv) {
-    const known = this.roots.get(conv.id) ?? null;
-    if (conv.projectId) return rootOfProjectAmong(conv.projectId, known);
-    return known ?? dirname6(await keyedFilePath(FILENAME5));
+  getFilePath() {
+    return keyedFilePath(FILENAME5);
   }
-  /**
-   * Le projet d'une conversation, organisation comprise.
-   *
-   * Ce que la conversation ne dit pas d'elle-même : elle ne nomme que l'id.
-   * Le coffre d'où elle vient fournit l'organisation, et c'est ce couple qu'il
-   * faut pour retrouver le répertoire de travail du projet.
-   */
-  async projectRefOf(conv) {
-    if (!conv.projectId) return null;
-    const known = this.roots.get(conv.id) ?? null;
-    const ref = refOfProjectAmong(conv.projectId, known);
-    return { id: ref.id, orgId: ref.orgId ?? null };
+  /** Where older versions kept it — read only, so an older Runeya keeps working. */
+  getLegacyFilePath() {
+    return legacyMachineFilePath(FILENAME5);
   }
   /**
-   * Réécrire chaque coffre, en déplaçant ce qui appartient désormais ailleurs.
+   * Read the machine file, falling back to the launch directory of old.
    *
-   * Appelé quand un projet a changé de coffre : ses conversations sont écrites
-   * dans le nouveau, et le fichier d'où elles viennent est réécrit sans elles.
+   * The legacy file is left in place: the next save writes the new location,
+   * and a directory still opened by an older Runeya keeps working meanwhile.
    */
-  async relocateAll() {
-    await this.load();
-    await this.save();
-  }
-  async save() {
-    const write = this.saveQueue.then(() => this.saveInternal());
-    this.saveQueue = write.catch(() => {
-    });
-    return write;
+  async readFromDisk() {
+    try {
+      return await readFile9(await this.getFilePath(), "utf-8");
+    } catch {
+      return readFile9(this.getLegacyFilePath(), "utf-8");
+    }
   }
-  async list() {
-    await this.load();
-    return Array.from(this.conversations.values()).sort((a, b) => b.updatedAt - a.updatedAt);
+  async load() {
+    if (this.loaded) return;
+    try {
+      const raw = await this.readFromDisk();
+      this.session = JSON.parse(raw);
+    } catch {
+    }
+    this.loaded = true;
   }
   /**
-   * Les conversations d'un projet.
-   *
-   * Celle qui ne nomme aucun projet — écrite avant le champ, ou qu'une
-   * migration n'a pas su attribuer — n'est rendue que dans les projets de son
-   * propre coffre : elle reste atteignable là où elle a été écrite, sans se
-   * déverser dans toutes les organisations de la machine.
+   * Mint a state value binding a login attempt to this server. Returned to the
+   * cloud page and echoed back on the callback, so a redirect we never
+   * initiated cannot install a token.
    */
-  async listForProject(ref) {
-    const belongs = await this.matcherForProject(ref);
-    return (await this.list()).filter(belongs);
+  createState(returnTo) {
+    this.sweepStates();
+    const state = randomBytes4(32).toString("hex");
+    this.pending.set(state, { expiresAt: Date.now() + STATE_TTL_MS, returnTo });
+    return state;
   }
   /**
-   * Le test d'appartenance à un projet, préparé une fois.
-   *
-   * Le flux temps réel en a besoin autant que la liste : une conversation qui
-   * arrive par événement doit passer le même filtre, sans quoi elle se
-   * réinvite dans un projet qui ne l'a jamais demandée.
+   * Consume a state — single use, constant-time compare, TTL enforced. Returns
+   * the URL to send the browser back to, or null when the state is unknown or
+   * expired (i.e. a callback this server never initiated).
    */
-  async matcherForProject(ref) {
-    await this.load();
-    let projectRoot2 = null;
-    try {
-      projectRoot2 = ref.orgId === void 0 ? rootOfProjectAmong(ref.id, null) : rootOfProjectRef({ id: ref.id, orgId: ref.orgId ?? null });
-    } catch {
-      projectRoot2 = null;
+  consumeState(candidate) {
+    this.sweepStates();
+    for (const [state, entry] of this.pending) {
+      const a = Buffer.from(state);
+      const b = Buffer.from(candidate);
+      if (a.length === b.length && timingSafeEqual2(a, b)) {
+        this.pending.delete(state);
+        return entry.expiresAt > Date.now() ? entry.returnTo : null;
+      }
     }
-    return (conv) => {
-      if (conv.projectId) return conv.projectId === ref.id;
-      if (!projectRoot2) return true;
-      return this.roots.get(conv.id) === projectRoot2;
-    };
-  }
-  async get(id) {
-    await this.load();
-    return this.conversations.get(id) ?? null;
+    return null;
   }
-  async create(title, isCli = false, workflowId, workflowType, runner, kanbanBoardId, kanbanCardId, providerId, projectId, orgId) {
-    await this.load();
+  sweepStates() {
     const now = Date.now();
-    const conv = {
-      id: randomUUID3(),
-      projectId,
-      title: title ?? "New conversation",
-      messages: [],
-      isCli,
-      runner,
-      providerId,
-      workflowId,
-      workflowType,
-      kanbanBoardId,
-      kanbanCardId,
-      createdAt: now,
-      updatedAt: now
-    };
-    this.conversations.set(conv.id, conv);
-    if (projectId && orgId !== void 0) {
-      this.roots.set(conv.id, vaultFor({ id: projectId, orgId }).root);
+    for (const [state, entry] of this.pending) {
+      if (entry.expiresAt <= now) this.pending.delete(state);
     }
-    await this.save();
-    this.events.emit("changed", { type: "created", conversation: this.snapshotConversation(conv) });
-    return conv;
   }
-  async update(id, patch, options) {
+  async save() {
+    await mkdir9(dirname6(await this.getFilePath()), { recursive: true });
+    const filePath = await this.getFilePath();
+    const tmpPath = filePath + ".tmp";
+    await writeFile9(tmpPath, JSON.stringify(this.session, null, 2), "utf-8");
+    await rename9(tmpPath, filePath);
+    await chmod8(filePath, 384);
+  }
+  /** Store the session token obtained from the one-time-token exchange. */
+  async set(cloudUrl, token) {
     await this.load();
-    const conv = this.conversations.get(id);
-    if (!conv) return null;
-    if (patch.title !== void 0) conv.title = patch.title;
-    if (patch.messages !== void 0) conv.messages = patch.messages;
-    if (patch.contextUsage !== void 0) conv.contextUsage = patch.contextUsage;
-    if (patch.workflowId !== void 0) conv.workflowId = patch.workflowId;
-    if (patch.archived !== void 0) conv.archived = patch.archived;
-    if (patch.codexThreadId !== void 0) conv.codexThreadId = patch.codexThreadId;
-    if (options?.touch !== false) conv.updatedAt = Date.now();
+    this.session = { cloudUrl, encryptedToken: encryptValue(token) };
     await this.save();
-    if (!options?.silent) {
-      this.events.emit("changed", { type: "updated", conversation: this.snapshotConversation(conv) });
+  }
+  /** The decrypted session token, or null when not logged in. */
+  async getToken() {
+    await this.load();
+    if (!this.session) return null;
+    try {
+      return decryptValue(this.session.encryptedToken);
+    } catch {
+      return null;
     }
-    return conv;
   }
   /**
-   * Synchronously update the last assistant message content in memory, then schedule a save.
-   * Used by activeSessionRegistry.persistNow() to avoid the async get() → .then() race.
+   * The cloud this machine is signed into, or null when not linked.
+   *
+   * Needed to tell "an org I am not a member of" apart from "an org of another
+   * cloud instance entirely" — the ids of two clouds share no namespace, so
+   * comparing them without this would call every foreign-cloud project a
+   * permission problem.
    */
-  updateLastAssistantContent(id, content, parts) {
-    const conv = this.conversations.get(id);
-    if (!conv) return;
-    const lastMsg = conv.messages[conv.messages.length - 1];
-    if (!lastMsg || lastMsg.role !== "assistant") return;
-    lastMsg.content = content;
-    if (parts !== void 0) lastMsg.parts = parts;
-    conv.updatedAt = Date.now();
-    this.save().catch(() => {
-    });
-  }
-  async listByKanbanBoardId(boardId) {
+  async getCloudUrl() {
     await this.load();
-    return Array.from(this.conversations.values()).filter((c) => c.kanbanBoardId === boardId);
+    return this.session?.cloudUrl ?? null;
   }
-  async listByKanbanCardId(cardId) {
-    await this.load();
-    return Array.from(this.conversations.values()).filter((c) => c.kanbanCardId === cardId);
+  async isLinked() {
+    return await this.getToken() !== null;
   }
-  async delete(id) {
+  /** Forget the session (sign-out). */
+  async clear() {
     await this.load();
-    const existed = this.conversations.delete(id);
-    await this.save();
-    if (existed) {
-      this.events.emit("changed", { type: "deleted", id });
+    this.session = null;
+    this.pending.clear();
+    try {
+      await unlink2(await this.getFilePath());
+    } catch {
     }
   }
-  onChanged(handler) {
-    this.events.on("changed", handler);
-  }
-  offChanged(handler) {
-    this.events.off("changed", handler);
+};
+var cloudSessionStore = new CloudSessionStore();
+
+// ../server/src/services/cloud-api.ts
+var DEFAULT_CLOUD_API_URL = "https://api.runeya.dev";
+var DEFAULT_CLOUD_APP_URL = "https://runeya.dev";
+function getCloudApiUrl() {
+  return (env.CLOUD_URL ?? DEFAULT_CLOUD_API_URL).replace(/\/+$/, "");
+}
+function getCloudAppUrl() {
+  return (env.CLOUD_APP_URL ?? DEFAULT_CLOUD_APP_URL).replace(/\/+$/, "");
+}
+var CloudNotLinkedError = class extends Error {
+  code = "CLOUD_NOT_LINKED";
+  constructor() {
+    super("Not linked to the Runeya cloud.");
+    this.name = "CloudNotLinkedError";
   }
 };
-var conversationStore = new ConversationStore();
+async function cloudFetch(path, init = {}) {
+  const token = await cloudSessionStore.getToken();
+  if (!token) throw new CloudNotLinkedError();
+  return fetch(`${getCloudApiUrl()}${path}`, {
+    method: init.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      // Le cloud refuse (426) les apps trop anciennes pour son schéma courant.
+      [APP_VERSION_HEADER]: appVersion,
+      ...init.body !== void 0 ? { "Content-Type": "application/json" } : {}
+    },
+    ...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
+    // 15s suits a JSON call; attachment downloads pass a longer budget.
+    signal: AbortSignal.timeout(init.timeoutMs ?? 15e3)
+  });
+}
 
 // ../server/src/trpc/routers/setup.ts
 var setupRouter = router({
@@ -7965,11 +7973,11 @@ ${apiDocs}` : systemContext;
 
 ${TOKEN_INSTRUCTIONS}`;
   const mcpArgs = mcpConfig && !opts.excludeMcp ? ["--mcp-config", mcpConfig] : [];
+  const modelArgs = model ? ["--model", model] : [];
   const args = [
     ...sessionArg,
     "--dangerously-skip-permissions",
-    "--model",
-    model,
+    ...modelArgs,
     "--append-system-prompt",
     systemPrompt,
     ...mcpArgs,
@@ -8076,6 +8084,15 @@ async function runClaudeViaPty(params) {
           });
         } catch {
         }
+        if (skipTokenInstructions && entry.type === "assistant" && entry.message?.stop_reason === "end_turn") {
+          settle({
+            output: state.assistantText,
+            tokenStatus: "none",
+            tokenMessage: "",
+            actualSessionId: sessionId
+          });
+          return;
+        }
         if (!skipTokenInstructions) {
           const { status, message, branchChoice } = parseEndToken(state.assistantText);
           if (status !== "none") {
@@ -8094,11 +8111,21 @@ async function runClaudeViaPty(params) {
       cli: "claude",
       args,
       env: params.injectedEnv && Object.keys(params.injectedEnv).length > 0 ? params.injectedEnv : void 0,
+      // Le répertoire que l'appelant a résolu — celui du projet de la
+      // conversation. Sans lui, le PTY naissait dans le répertoire de l'agent,
+      // c'est-à-dire là où Runeya a été lancé : une carte kanban du projet A
+      // faisait travailler le CLI dans le code de Runeya.
+      cwd: params.cwd || void 0,
       cols: 120,
       rows: 30,
       sessionId,
       enableMcp: !!params.mcpConfig,
-      mcpApiBaseUrl: params.apiBaseUrl || void 0
+      mcpApiBaseUrl: params.apiBaseUrl || void 0,
+      // Sans lui, l'agent lance le CLI et son serveur MCP sans RUNEYA_API_TOKEN :
+      // toutes les tools répondent « No auth token available », et `$RUNEYA_API_TOKEN`
+      // ne résout à rien dans le shell du CLI. Le jeton est déjà là — la file le
+      // signe elle-même, faute de requête HTTP d'où le tirer.
+      mcpApiToken: params.apiToken || void 0
     }).then(({ spawnId: id }) => {
       spawnId = id;
       if (signal.aborted) {
@@ -8259,6 +8286,7 @@ ${apiDocs}` : systemContext;
 ${TOKEN_INSTRUCTIONS}`;
   const inputArgs = hasImages ? ["--input-format", "stream-json"] : ["-p", prompt];
   const mcpArgs = mcpConfig && !opts?.excludeMcp ? ["--mcp-config", mcpConfig] : [];
+  const modelArgs = model ? ["--model", model] : [];
   const args = [
     ...sessionArg,
     "--output-format",
@@ -8266,8 +8294,7 @@ ${TOKEN_INSTRUCTIONS}`;
     "--verbose",
     "--include-partial-messages",
     "--dangerously-skip-permissions",
-    "--model",
-    model,
+    ...modelArgs,
     ...thinkingArgs,
     "--append-system-prompt",
     systemPrompt,
@@ -9359,7 +9386,10 @@ async function* drainSession(session, signal, isReconnect) {
 }
 async function buildCliSystemContext(conv, jwt) {
   const allServices = await serviceStore.list();
-  const resolvedServices = await Promise.all(allServices.map(resolveServiceVariables));
+  const ref = conv ? await conversationStore.projectRefOf(conv) : null;
+  const project = ref ? await projectStore.get(ref) : null;
+  const ownServices = project ? allServices.filter((svc) => project.serviceIds.includes(svc.id)) : allServices;
+  const resolvedServices = await Promise.all(ownServices.map(resolveServiceVariables));
   let systemContext = generateAdminLlmsTxt(resolvedServices, jwt);
   if (conv?.kanbanBoardId) {
     const kanbanBoard = await kanbanStore.get(conv.kanbanBoardId);
@@ -9529,9 +9559,7 @@ var StoredMessageSchema = z16.object({
   parts: z16.array(MessagePartSchema).max(200).optional()
 });
 async function conversationCwd(conv) {
-  const ref = await conversationStore.projectRefOf(conv);
-  if (!ref) return resolveAgentCwd({});
-  return resolveAgentCwd({ projectId: ref.id, orgId: ref.orgId });
+  return resolveConversationCwd(conv.id);
 }
 var chatRouter = router({
   conversations: router({
@@ -10219,9 +10247,13 @@ ${apiDocs}` : systemContext;
           cli,
           args,
           env: injectedEnv,
-          // An explicit cwd wins; otherwise the service's directory, then the
-          // project's — never the directory the server was launched in.
-          cwd: input.cwd ?? await resolveAgentCwd({
+          // An explicit cwd wins; then le projet de la conversation, s'il y en
+          // a une : c'est elle que ce terminal poursuit, et son projet n'est
+          // pas forcément celui ouvert dans l'onglet — ouvrir le terminal
+          // d'une carte kanban depuis ailleurs lançait le CLI dans le
+          // répertoire de lancement de Runeya. Sinon le service, puis le
+          // projet actif — jamais le répertoire du serveur.
+          cwd: input.cwd ?? (input.sessionId ? await resolveConversationCwd(input.sessionId) : void 0) ?? await resolveAgentCwd({
             serviceId: input.serviceId,
             projectId: input.projectId,
             orgId: input.orgId
@@ -11588,9 +11620,11 @@ async function runNodeCall(conversationId, node, systemContext, userMessage, run
     const result = await state.runner.run({
       agentId: runOverrides?.agentId ?? agentManager.getDefaultAgentId() ?? void 0,
       // Without this the CLI would run wherever the server was launched, whatever
-      // project the scenario belongs to. No project: left unset, so the runner
-      // keeps its own default rather than being sent to this machine's path.
-      cwd: await resolveAgentCwd({ projectId: runOverrides?.projectId, orgId: runOverrides?.orgId }),
+      // project the scenario belongs to. Read from the conversation, so un lancement
+      // sans requête HTTP — la file kanban — est ancré comme les autres. No project:
+      // left unset, so the runner keeps its own default rather than being sent to
+      // this machine's path.
+      cwd: await resolveConversationCwd(conversationId),
       sessionId: state.sessionId,
       prompt: currentPrompt,
       isResume: state.isResume,
@@ -12468,7 +12502,6 @@ var scenarioRouter = router({
         runnerOverride: input.runnerOverride,
         modelOverride: input.modelOverride,
         agentId: input.agentId,
-        projectId: input.projectId,
         orgId: input.orgId
       }, !!input.resume);
       await new Promise((r) => setTimeout(r, 10));
@@ -12917,7 +12950,8 @@ var KanbanQueueService = class extends EventEmitter5 {
       maxConcurrent: this.maxConcurrent
     };
   }
-  add(item) {
+  add(rawItem) {
+    const item = rawItem.scenarioId || rawItem.runner ? rawItem : { ...rawItem, runner: "claude-code" };
     const alreadyQueued = this.items.find((i) => i.boardId === item.boardId && i.cardId === item.cardId);
     if (alreadyQueued) return alreadyQueued;
     const alreadyRunning = this.running.find((r) => r.boardId === item.boardId && r.cardId === item.cardId);
@@ -13049,7 +13083,7 @@ var KanbanQueueService = class extends EventEmitter5 {
   }
   async runWithRunner(runItem, item, cardContent) {
     try {
-      const model = item.model || (item.runner === "codex" ? "" : "claude-opus-4-6");
+      const model = item.model || "";
       const starter = item.runner === "codex" ? startCodexSession : startClaudeCodeSession;
       const jwt = await signJwt();
       const { done } = await starter(runItem.conversationId, cardContent, { model, jwt });
@@ -17555,4 +17589,4 @@ export {
   pullEnv,
   registerInstance
 };
-//# sourceMappingURL=src-WT7HSY3I.js.map
+//# sourceMappingURL=src-6WVQ2FQV.js.map