@runeya/runeya 2.0.124 → 2.0.126

package/{chunk-GKK3ACWB.js → chunk-2EDVDRKV.js}

@@ -31,7 +31,7 @@ import {
   runCompanionNow,
   syncConversationFromClaudeTranscript,
   verifyJwt
-} from "./chunk-H22YLVQE.js";
+} from "./chunk-SG2ACPOE.js";
 import {
   StoreDiskCoordinator,
   agentManager,
@@ -50,10 +50,10 @@ import {
   recordLocalRemoval,
   refsOfProjectId,
   serviceStore
-} from "./chunk-4PN7QBNM.js";
+} from "./chunk-WLZQDWJT.js";
 import {
   settingsManager
-} from "./chunk-N3ZI35SC.js";
+} from "./chunk-K7A3Q62R.js";
 import {
   atomicWriteJsonSecure,
   atomicWriteSecure,
@@ -67,26 +67,33 @@ import {
 import {
   AGENT_STOP_FETCH_TIMEOUT,
   ApiKeysFileSchema,
+  BUILTIN_VARIABLES,
+  BootstrapCommandSchema,
   DockerConfigSchema,
   HealthCheckSchema,
   JSLogParserSchema,
   LogSourceConfigSchema,
+  MASKED_VALUE,
   MissingVariableSchema,
   RestartStrategySchema,
   ScenarioSchema,
   ServiceCommandSchema,
+  ServiceConfigSchema,
   ServiceShortcutSchema,
   ambiguousServiceSlugs,
   crossServiceValues,
+  findUnresolvedReferences,
   interpolateBuiltinsInEnv,
   isSharedWithAi,
+  maskLogSourceSecrets,
   nativeParsers,
+  restoreLogSourceSecrets,
   servicePortValues,
   serviceSlug,
   serviceUrlValues,
   urlHostFor,
   withDeprecatedAliases
-} from "./chunk-T2BV5WZE.js";
+} from "./chunk-TTPL2M74.js";
 import {
   allVaultRoots,
   env,
@@ -101,7 +108,7 @@ import {
 } from "./chunk-ZFELQG4B.js";
 
 // ../server/src/trpc/routers/chat.ts
-import { z as z6 } from "zod";
+import { z as z9 } from "zod";
 import Anthropic2 from "@anthropic-ai/sdk";
 import OpenAI2 from "openai";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -824,7 +831,6 @@ function slotReferenceText(variable) {
 ${slot.value}
 ${slot.post}`;
 }
-var MASKED_VALUE = "***";
 var HIDDEN_VALUES_NOTICE = `Values shown as ${MASKED_VALUE} are secrets their author did not share with AI. The service does receive them: never treat such a key as missing, and never pass ${MASKED_VALUE} as its value.`;
 function filterEnvForAi(resolved, sharedKeys) {
   const secret = new Set(resolved.envSecrets);
@@ -1169,8 +1175,8 @@ var EnvironmentResolver = class {
     return secretKeys;
   }
   interpolatesSecretKey(rawValue, ctxSecretKeys) {
-    const refs = [...rawValue.matchAll(/\{\{environment\.([^}]+)\}\}/g)].map((m) => m[1]);
-    return refs.some((ref) => ctxSecretKeys.has(ref));
+    const refs2 = [...rawValue.matchAll(/\{\{environment\.([^}]+)\}\}/g)].map((m) => m[1]);
+    return refs2.some((ref) => ctxSecretKeys.has(ref));
   }
   /**
    * Build the interpolation context for an environment.
@@ -1374,6 +1380,7 @@ var EnvironmentResolver = class {
 var environmentResolver = new EnvironmentResolver();
 
 // ../../packages/ai-capabilities/src/capabilities.ts
+import { z as z3 } from "zod";
 function toList(raw) {
   if (!raw) return [];
   const text = raw.trim();
@@ -1400,9 +1407,107 @@ function gitTarget(p) {
     ...p.orgId ? { orgId: p.orgId } : {}
   };
 }
+var toBool = (raw) => raw.trim().toLowerCase() === "true";
+var newId = () => globalThis.crypto.randomUUID();
+function listItem(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseTyped(name, schema, raw) {
+  if (raw === void 0) return void 0;
+  let result = raw.trim() === "null" ? schema.safeParse(null) : schema.safeParse(raw);
+  if (!result.success && raw.trim() === "null") result = schema.safeParse(raw);
+  if (!result.success) {
+    const text = raw.trim();
+    const json = listItem(text);
+    if (json !== text) result = schema.safeParse(json);
+    if (!result.success && !/^[[{]/.test(text)) {
+      const list = schema.safeParse(toList(text).map(listItem));
+      if (list.success) result = list;
+    }
+  }
+  if (!result.success) throw new Error(`${name}: ${z3.prettifyError(result.error)}`);
+  return result.data;
+}
+function withIds(items) {
+  return items.map((item) => ({ ...item, id: item.id || newId() }));
+}
+var optionalId = (schema) => schema.extend({ id: z3.string().min(1).max(64).optional() });
+var DockerConfigInput = DockerConfigSchema.extend({
+  bootstrapCommands: z3.array(optionalId(BootstrapCommandSchema)).max(20).default([])
+}).refine((c) => !!c.image !== !!c.dockerfile, {
+  message: 'dockerConfig needs exactly one of "image" (an image to pull) or "dockerfile" (a Dockerfile to build)'
+});
+var SERVICE_FIELDS = [
+  { name: "description", description: "What the service is, in a sentence" },
+  { name: "agentId", description: "The agent that runs it, from list_agents. Omit to inherit from the environment.", clearable: true },
+  { name: "cwd", description: `Working directory, RELATIVE to the project root (e.g. "apps/web", or omit for the root). The project is synced between machines and lives in a different folder on each: Runeya resolves a relative cwd against each machine's own project folder, while an absolute path (/home/you/\u2026) breaks on every other machine. Use an absolute path only for something outside the project, written with ~ or an environment variable ($NAME) rather than a literal home directory.`, clearable: true },
+  { name: "command", description: 'Shortcut for a single command line (e.g. "npm run dev"). Replaces every existing command. Use commands for several.' },
+  { name: "commands", description: 'The processes of the service. They all start AT THE SAME TIME, in parallel, and the service runs while they run \u2014 not one after another. Use several for processes that live side by side (a web server and a worker). Steps that must follow each other (build, then install, then launch) go in ONE command chained with &&. A one-off action the user triggers by hand (build, deploy, read logs) is a shortcut, not a command. Each command runs in the service cwd, or its own "cwd", relative to the project root. No absolute paths of this machine: the service is synced to other machines. Replaces every existing command. "id" is generated when omitted; "shell" runs the line through a shell (default true).', schema: z3.array(optionalId(ServiceCommandSchema)).max(50) },
+  { name: "ports", description: "Ports the service listens on. Declare them: they become {{service.PORT}}, {{service.URL}} and {{services.<slug>.URL}} for the other services, which environment variables should reference instead of repeating the numbers.", schema: ServiceConfigSchema.shape.ports.unwrap().unwrap() },
+  { name: "groups", description: "Groups the service belongs to. Replaces the current ones.", schema: ServiceConfigSchema.shape.groups.unwrap().unwrap() },
+  { name: "url", description: "URL where the service is reached" },
+  { name: "localUrls", description: 'Local domain names routed to a port of the service (e.g. {"url":"api.localhost.dev","port":3000})', schema: ServiceConfigSchema.shape.localUrls.unwrap().unwrap() },
+  { name: "openapiUrl", description: "URL of its OpenAPI document" },
+  { name: "docsPath", description: "Where its markdown docs live, relative to cwd or absolute. Defaults to cwd." },
+  { name: "git", description: 'Its git repository: "remote" URL and "home" page', schema: ServiceConfigSchema.shape.git.unwrap(), clearable: true },
+  { name: "meta", description: "Free key/value metadata (strings)", schema: ServiceConfigSchema.shape.meta.unwrap(), clearable: true },
+  { name: "runner", description: '"native" runs the commands on the machine; "docker" runs the service in a container and then needs dockerConfig', schema: ServiceConfigSchema.shape.runner.unwrap().unwrap() },
+  { name: "dockerConfig", description: 'With runner "docker": the container. Exactly one of "image" (pull) or "dockerfile" (inline Dockerfile, built with "buildContext", "buildArgs", "targetStage"). Ports and volumes use Docker syntax ("8080:80", "./data:/data"); host paths in volumes relative to the service directory, never an absolute path of this machine. "useNativeCommand" runs the service commands inside the container instead of its CMD ("nativeCommandMode": one shared container or one per command). "bootstrapCommands" run once when the container starts. Replaces the whole Docker configuration: read it first with get_service to keep what you do not change.', schema: DockerConfigInput },
+  { name: "healthCheck", description: 'How to tell the service is ready: an HTTP "path" to call, or a "command" that must succeed', schema: HealthCheckSchema, clearable: true },
+  { name: "autoRestart", description: "Restart the service when it crashes", schema: z3.boolean() },
+  { name: "restartStrategy", description: "When to restart it", schema: RestartStrategySchema.unwrap() },
+  { name: "maxRestarts", description: "Give up after this many restarts", schema: ServiceConfigSchema.shape.maxRestarts.unwrap() },
+  { name: "restartBackoffMs", description: "Delay before a restart, in milliseconds", schema: ServiceConfigSchema.shape.restartBackoffMs.unwrap().unwrap() },
+  { name: "clearLogsOnStart", description: "Clear the logs each time the service starts", schema: z3.boolean() },
+  { name: "shortcuts", description: 'One-click actions shown on the service, run on demand and independently of the running commands (build, deploy, migrate, read logs). Same path rules as commands: relative to the project root, never an absolute path of this machine. Replaces the current ones. "id" is generated when omitted.', schema: z3.array(optionalId(ServiceShortcutSchema)).max(50) },
+  { name: "parserIds", description: "Log parsers applied to its output, by id", schema: ServiceConfigSchema.shape.parserIds.unwrap() },
+  { name: "logSources", description: 'Extra log sources beyond the console output (files, databases\u2026). Replaces the current ones. Credentials (mongo connectionString, mysql password) read as "***": send "***" back to keep the stored value, or the real value to change it.', schema: ServiceConfigSchema.shape.logSources.unwrap().unwrap() }
+];
+function serviceParams(clearable2) {
+  return SERVICE_FIELDS.map((f) => {
+    const nullable = clearable2 && f.clearable;
+    const base = f.schema ?? (nullable ? z3.string() : void 0);
+    return {
+      name: f.name,
+      description: nullable ? `${f.description} null clears it.` : f.description,
+      required: false,
+      ...base ? { schema: nullable ? base.nullable() : base } : {}
+    };
+  });
+}
+function serviceFields(p, params) {
+  const out = {};
+  for (const param of params) {
+    if (p[param.name] === void 0 || param.name === "command") continue;
+    out[param.name] = param.schema ? parseTyped(param.name, param.schema, p[param.name]) : p[param.name];
+  }
+  if (p.command !== void 0 && p.commands === void 0) out["commands"] = [{ label: "", command: p.command, shell: true }];
+  if (Array.isArray(out["commands"])) out["commands"] = withIds(out["commands"]);
+  if (Array.isArray(out["shortcuts"])) out["shortcuts"] = withIds(out["shortcuts"]);
+  const docker = out["dockerConfig"];
+  if (docker?.bootstrapCommands) out["dockerConfig"] = { ...docker, bootstrapCommands: withIds(docker.bootstrapCommands) };
+  return out;
+}
+function maskServices(result) {
+  if (Array.isArray(result)) return result.map(maskServices);
+  if (result && typeof result === "object" && Array.isArray(result.logSources)) {
+    const service = result;
+    return { ...service, logSources: maskLogSourceSecrets(service.logSources) };
+  }
+  return result;
+}
+var refs = (scope) => BUILTIN_VARIABLES.filter((b) => b.scope === scope).map((b) => `{{${b.name}}}`).join(", ");
+var BUILTINS_HELP = `Built-in references Runeya fills itself \u2014 filled when the service is deployed, from the service that receives the variable: ${refs("server")}, the numbered {{service.PORT_2}} / {{service.URL_2}}\u2026 for its other ports, and {{services.<slug>.PORT}}, .URL, .BASE_URL, .NAME, .ID for a sibling service of the project (slug = its name in lowercase-dashes). Filled on the machine when the service starts: ${refs("agent")}.`;
+var CREATE_SERVICE_PARAMS = serviceParams(false);
+var UPDATE_SERVICE_PARAMS = serviceParams(true);
 var RUNEYA_CAPABILITIES = [
   {
     name: "list_services",
+    transformOutput: maskServices,
     description: "List services, with the serviceId and agentId to use in other calls. Pass the projectId your context names to stay on the project the user is looking at, or another one from list_projects to look elsewhere. Called with no project, this can answer for every project of every organization on the machine \u2014 far more than the interface shows.",
     route: "service.list",
     method: "GET",
@@ -1688,8 +1793,8 @@ var RUNEYA_CAPABILITIES = [
   },
   // ─── Lecture seule ───────────────────────────────────────────────────────
   //
-  // Tout ce qui se consulte sans rien changer. La création, la mise à jour et
-  // la suppression restent hors MCP : elles s'ajouteront au cas par cas.
+  // Tout ce qui se consulte sans rien changer. Les écritures s'ajoutent au cas
+  // par cas : aujourd'hui les services et leurs variables, plus bas.
   //
   // Volontairement absentes, et à ne pas ajouter sans y regarder à deux fois,
   // parce qu'elles rendent un secret : `environment.list` / `get` / `resolve` /
@@ -1716,6 +1821,7 @@ var RUNEYA_CAPABILITIES = [
   },
   {
     name: "get_service",
+    transformOutput: maskServices,
     description: "Read the full configuration of one service: its commands, ports, groups, runner, log sources and restart policy. list_services gives the ids.",
     route: "service.get",
     method: "GET",
@@ -1726,13 +1832,145 @@ var RUNEYA_CAPABILITIES = [
   },
   {
     name: "get_service_env",
-    description: 'Read the environment variables a service runs with, and the project\'s variable inventory. `env` lists every key the service receives; a value reads "***" when it is a secret whose author did not share it with AI (sharing = ticking "AI read", or injecting it into the agents\' environment, which grants reading too). `envSecrets` says which keys are secret, `hiddenKeys` which ones are masked. A masked key is set on the service: never treat it as missing, never suggest adding it, and never pass "***" as a value \u2014 ask the user for it. `variables` describes every variable of the project \u2014 which environment defines it and its scope, its description, its flags, whether this machine overrides it, and `inService: false` for the ones this service does not receive. Use it to say where a variable must be changed instead of guessing. On an overridden variable, `sharedValue` is what the machine-local override replaces (the team\'s value, masked as "***" when unreadable); no other value appears there.',
+    description: 'Read the environment variables a service runs with, and the project\'s variable inventory. `env` lists every key the service receives; a value reads "***" when it is a secret whose author did not share it with AI (sharing = ticking "AI read", or injecting it into the agents\' environment, which grants reading too). `envSecrets` says which keys are secret, `hiddenKeys` which ones are masked. A masked key is set on the service: never treat it as missing, never suggest adding it, and never pass "***" as a value \u2014 ask the user for it. `variables` describes every variable of the project \u2014 which environment defines it and its scope, its description, its flags, whether this machine overrides it, and `inService: false` for the ones this service does not receive. Use it to say where a variable must be changed instead of guessing. On an overridden variable, `sharedValue` is what the machine-local override replaces (the team\'s value, masked as "***" when unreadable); no other value appears there. This is the resolver: the values are what the service would receive \u2014 inheritance, {{environment.KEY}} references, this machine\'s overrides and server built-ins applied; agent built-ins stay as written until the service starts. Use it to check a variable you just composed. `unresolvedReferences` lists references nothing will fill (a typo, a variable that does not exist): fix them.',
     route: "service.getEnv",
     method: "GET",
     params: [
-      { name: "serviceId", description: "The service ID", required: true }
+      { name: "serviceId", description: "The service ID", required: true },
+      { name: "environmentId", description: "A global environment of the project to resolve in instead of the active one, without activating it (from list_environments). Omit for the active one.", required: false }
     ],
-    buildInput: (p) => ({ id: p.serviceId })
+    buildInput: (p) => ({ id: p.serviceId, ...p.environmentId ? { environmentId: p.environmentId } : {} })
+  },
+  // ─── Écrire un service et ses variables ────────────────────────────────────
+  //
+  // Les variables s'écrivent à l'aveugle (`environment.setVariableBlind`) : une
+  // IA remplace la valeur d'un secret sans la lire, et ne peut ni le rendre
+  // public, ni le partager avec les IA. La règle tient côté serveur, dans la
+  // route ; ces outils ne passent jamais par une route qui renvoie des valeurs
+  // (`upsertVariable`, `removeVariable`, `update` rendent l'environnement entier).
+  {
+    name: "create_service",
+    transformOutput: maskServices,
+    description: "Create a service, native or Docker, in a project: it joins the project and gets its environments in the same call. Pass the projectId your context names. Projects are synced between machines, so write paths relative to the project root and put machine-specific values (a device serial, a local token) in environment variables, referenced as $NAME in commands \u2014 see the cwd, commands and shortcuts parameters. Then set its variables with set_environment_variable.",
+    route: "service.create",
+    method: "POST",
+    params: [
+      { name: "name", description: "The service name", required: true },
+      { name: "projectId", description: "The project it joins: the one your context names, or another from list_projects. Without it, the service belongs to no project.", required: false },
+      { name: "orgId", description: "Its organization. Needed only when the same project id exists in several.", required: false },
+      ...CREATE_SERVICE_PARAMS
+    ],
+    buildInput: (p) => {
+      const fields = serviceFields(p, CREATE_SERVICE_PARAMS);
+      if (fields["runner"] === "docker" && !fields["dockerConfig"]) {
+        throw new Error('dockerConfig: required with runner "docker" \u2014 give an "image" or a "dockerfile"');
+      }
+      return {
+        name: p.name,
+        ...fields,
+        ...p.projectId ? { projectId: p.projectId } : {},
+        ...p.orgId ? { orgId: p.orgId } : {}
+      };
+    }
+  },
+  {
+    name: "add_service_to_project",
+    description: "Add an existing service to a project, and create its environments \u2014 one for each of the project's environments, where its own variables go. Not needed after create_service, which already does it; calling it again changes nothing.",
+    route: "project.addService",
+    method: "POST",
+    params: [
+      { name: "projectId", description: "The project ID, from list_projects", required: true },
+      { name: "serviceId", description: "The service ID", required: true },
+      { name: "orgId", description: "Its organization. Needed only when the same project id exists in several.", required: false }
+    ],
+    buildInput: (p) => ({ projectId: p.projectId, serviceId: p.serviceId, ...p.orgId ? { orgId: p.orgId } : {} })
+  },
+  {
+    name: "update_service",
+    transformOutput: maskServices,
+    description: "Change any part of a service configuration \u2014 commands, ports, health check, restart policy, shortcuts, log sources, whether it runs natively or in Docker (runner, dockerConfig)\u2026 Only the fields you pass change; a list or an object you pass replaces the current one whole. Read the service first with get_service.",
+    route: "service.update",
+    method: "POST",
+    params: [
+      { name: "serviceId", description: "The service ID", required: true },
+      { name: "name", description: "New name", required: false },
+      { name: "orgId", description: "Move the service to this organization vault. Leave unset unless asked.", required: false, schema: z3.string().max(128).nullable() },
+      ...UPDATE_SERVICE_PARAMS
+    ],
+    buildInput: (p) => ({
+      id: p.serviceId,
+      ...p.name ? { name: p.name } : {},
+      ...p.orgId !== void 0 ? { orgId: parseTyped("orgId", z3.string().max(128).nullable(), p.orgId) } : {},
+      ...serviceFields(p, UPDATE_SERVICE_PARAMS)
+    })
+  },
+  {
+    name: "list_environments",
+    description: "List the environments of a project, with no value: each one's id, name and scope (global = shared by the whole project, service = one service's own variables), which global environment is active, which service a service environment belongs to and which global environment activates it, its parents (it inherits their variables), `isolated` when a service environment does not inherit from its global one, and the variables it defines with their flags. Empty environments are listed too \u2014 a service you just created has one per global environment, where its own variables go. Use it to find the environmentId before set_environment_variable.",
+    route: "environment.listForAi",
+    method: "GET",
+    params: [
+      { name: "projectId", description: "The project ID: the one your context names, or another from list_projects", required: true },
+      { name: "orgId", description: "Its organization. Needed only when the same project id exists in several.", required: false }
+    ],
+    buildInput: (p) => ({ projectId: p.projectId, ...p.orgId ? { orgId: p.orgId } : {} })
+  },
+  {
+    name: "resolve_environment",
+    description: "Resolve one environment alone \u2014 its variables with those inherited from its parents and this machine's overrides \u2014 as an AI may read it: secrets not shared with AI read \"***\". Built-in references ({{service.*}}, {{services.*}}, {{agent.*}}\u2026) are NOT filled, since they depend on the service that receives the variable; use get_service_env for a service's final values. `unresolvedReferences` lists references nothing will fill: a misspelled {{environment.KEY}}, or a name that is no built-in.",
+    route: "environment.resolveForAi",
+    method: "GET",
+    params: [
+      { name: "environmentId", description: "The environment, from list_environments", required: true }
+    ],
+    buildInput: (p) => ({ environmentId: p.environmentId })
+  },
+  {
+    name: "set_environment_variable",
+    description: `Create or change an environment variable, by name, in one environment \u2014 global or service, same rules for both. Find the environmentId with list_environments. Where it belongs: a value shared by several services (a database host, an API base URL) goes ONCE in the active global environment; services inherit it. A value only one service needs goes in that service's environment (scope service, activated by the active global one), where it also overrides a global variable of the same name. Never hardcode what Runeya already knows: a service's own port is {{service.PORT}}, its own URL {{service.URL}}, another service's address {{services.<slug>.URL}} \u2014 a copied "3210" or "http://localhost:3211" breaks as soon as a port changes or the project runs on another machine. If the port a variable needs is not declared on its service, declare it there (update_service, ports) instead of writing the number. When a written value contains a port or URL of a project service, the response lists \`suggestions\`: rewrite the value with those references. Compose instead of copying: a value can reference another variable of the resolved environment as {{environment.KEY}} (e.g. "postgres://{{environment.DB_USER}}@{{environment.DB_HOST}}:5432"). ${BUILTINS_HELP} After writing, check the result with get_service_env (a service, optionally in another global environment) or resolve_environment (an environment alone). References are substituted in one pass: a reference to a variable whose own value is only a reference may stay unexpanded, so point at the variable that holds the actual value. $NAME is not a reference here: it only expands inside a shell command. pre and post are concatenated around the value, each resolved separately. You can replace a secret's value without reading it, and create a variable as secret. You cannot make a secret public nor make it readable by AI: that stays the user's decision. Never pass "***" as a value. The response never contains the value.`,
+    route: "environment.setVariableBlind",
+    method: "POST",
+    params: [
+      { name: "environmentId", description: "The environment that holds the variable, from list_environments", required: true },
+      { name: "key", description: "The variable name, e.g. DATABASE_URL", required: true },
+      { name: "value", description: "The new value, possibly with {{environment.KEY}} references. Omit to leave it unchanged.", required: false },
+      { name: "pre", description: 'Text put before the value (e.g. "https://"). Omit to leave it unchanged.', required: false },
+      { name: "post", description: 'Text put after the value (e.g. "/api"). Omit to leave it unchanged.', required: false },
+      { name: "isSecret", description: '"true" to store it as a secret. On an existing public variable, makes it secret.', required: false },
+      { name: "description", description: "What the variable is for, in markdown", required: false }
+    ],
+    buildInput: (p) => ({
+      environmentId: p.environmentId,
+      key: p.key,
+      ...p.value !== void 0 ? { value: p.value } : {},
+      ...p.pre !== void 0 ? { pre: p.pre } : {},
+      ...p.post !== void 0 ? { post: p.post } : {},
+      ...p.isSecret !== void 0 ? { isSecret: toBool(p.isSecret) } : {},
+      ...p.description !== void 0 ? { description: p.description } : {}
+    })
+  },
+  {
+    name: "set_environment_inheritance",
+    description: "Switch whether a service environment inherits the variables of the global environment that activates it (the default), or is isolated from it and receives only its own variables. list_environments shows this as `isolated`. Isolating a service is unusual: it loses every shared variable of the project. Do it only when the user asks, and never to work around a variable \u2014 override it in the service environment instead.",
+    route: "environment.setInheritanceBlind",
+    method: "POST",
+    params: [
+      { name: "environmentId", description: "A service environment (scope service), from list_environments", required: true },
+      { name: "inherit", description: '"true" to inherit from the global environment, "false" to isolate', required: true, schema: z3.boolean() }
+    ],
+    buildInput: (p) => ({ environmentId: p.environmentId, inherit: toBool(p.inherit ?? "true") })
+  },
+  {
+    name: "remove_environment_variable",
+    description: "Delete an environment variable, by name, from one environment. Its value is lost.",
+    route: "environment.removeVariableBlind",
+    method: "POST",
+    params: [
+      { name: "environmentId", description: "The environment that holds the variable", required: true },
+      { name: "key", description: "The variable name", required: true }
+    ],
+    buildInput: (p) => ({ environmentId: p.environmentId, key: p.key }),
+    destructive: true
   },
   {
     name: "get_service_metrics",
@@ -1959,6 +2197,14 @@ var RUNEYA_CAPABILITIES = [
   }
 ];
 
+// ../../packages/ai-capabilities/src/adapters/json-schema.ts
+import { z as z4 } from "zod";
+function paramJsonSchema(param) {
+  if (!param.schema) return { type: "string", description: param.description };
+  const { $schema: _ignored, ...schema } = z4.toJSONSchema(param.schema, { io: "input", unrepresentable: "any" });
+  return { ...schema, description: param.description };
+}
+
 // ../../packages/ai-capabilities/src/adapters/anthropic.ts
 function buildAnthropicTools(capabilities) {
   return capabilities.map((cap) => ({
@@ -1967,7 +2213,7 @@ function buildAnthropicTools(capabilities) {
     input_schema: {
       type: "object",
       properties: Object.fromEntries(
-        cap.params.map((p) => [p.name, { type: "string", description: p.description }])
+        cap.params.map((p) => [p.name, paramJsonSchema(p)])
       ),
       required: cap.params.filter((p) => p.required).map((p) => p.name)
     }
@@ -1984,7 +2230,7 @@ function buildOpenAITools(capabilities) {
       parameters: {
         type: "object",
         properties: Object.fromEntries(
-          cap.params.map((p) => [p.name, { type: "string", description: p.description }])
+          cap.params.map((p) => [p.name, paramJsonSchema(p)])
         ),
         required: cap.params.filter((p) => p.required).map((p) => p.name)
       }
@@ -2011,14 +2257,24 @@ function buildToolSafetyInstruction(capabilities) {
   return lines.join("\n");
 }
 
+// ../../packages/ai-capabilities/src/adapters/mcp.ts
+import { z as z5 } from "zod";
+function toRawParams(input, cap) {
+  const typed = new Set(cap?.params.filter((p) => p.schema).map((p) => p.name));
+  return Object.fromEntries(Object.entries(input).map(([k, v]) => [
+    k,
+    v === null && typed.has(k) ? "null" : v == null ? void 0 : typeof v === "object" ? JSON.stringify(v) : String(v)
+  ]));
+}
+
 // ../../packages/ai-capabilities/src/trpc-caller.ts
-async function callTrpc(baseUrl, route, method, input, authToken) {
+async function callTrpc(baseUrl, route, method, input, authToken, fetchImpl = fetch) {
   const headers = {
     "Content-Type": "application/json",
     "Authorization": `Bearer ${authToken}`
   };
   const url = method === "GET" && input ? `${baseUrl}/api/trpc/${route}?input=${encodeURIComponent(JSON.stringify(input))}` : `${baseUrl}/api/trpc/${route}`;
-  const res = await fetch(url, {
+  const res = await fetchImpl(url, {
     method,
     headers,
     ...method === "POST" ? { body: JSON.stringify(input ?? {}) } : {},
@@ -2029,6 +2285,24 @@ async function callTrpc(baseUrl, route, method, input, authToken) {
   const result = json["result"];
   return result?.["data"] ?? result ?? json;
 }
+async function runCapability(cap, baseUrl, params, authToken, fetchImpl = fetch) {
+  const result = await callTrpc(baseUrl, cap.route, cap.method, cap.buildInput(params), authToken, fetchImpl);
+  return cap.transformOutput ? cap.transformOutput(result) : result;
+}
+
+// ../../packages/ai-capabilities/src/project-anchor.ts
+function applyProjectAnchor(cap, params, anchor2) {
+  if (!anchor2.projectId) return params;
+  const accepts = (name) => cap.params.some((p) => p.name === name);
+  if (!accepts("projectId") || params["projectId"]) return params;
+  return {
+    ...params,
+    projectId: anchor2.projectId,
+    // L'organisation n'accompagne le projet que si la capability la comprend :
+    // ailleurs, ce serait un champ de trop, refusé par le schéma de la route.
+    ...anchor2.orgId && accepts("orgId") && !params["orgId"] ? { orgId: anchor2.orgId } : {}
+  };
+}
 
 // ../server/src/services/llms-txt-generator.ts
 function generateAdminLlmsTxt(services, jwt, project) {
@@ -2215,7 +2489,7 @@ function normalizeToolName(raw) {
   const match = KNOWN_TOOL_NAMES.find((t2) => raw.startsWith(t2));
   return match ?? raw;
 }
-async function executeTool(rawName, input, apiKey, authToken) {
+async function executeTool(rawName, input, apiKey, authToken, anchor2 = {}) {
   const name = normalizeToolName(rawName);
   const cap = RUNEYA_CAPABILITIES.find((c) => c.name === name);
   if (!cap) throw new Error(`Unknown tool: ${name}`);
@@ -2233,18 +2507,13 @@ async function executeTool(rawName, input, apiKey, authToken) {
       throw new Error(`No '${action}' permission for service ${serviceId}`);
     }
   }
-  const params = Object.fromEntries(
-    Object.entries(input).map(([k, v]) => [
-      k,
-      v != null ? typeof v === "object" ? JSON.stringify(v) : String(v) : void 0
-    ])
-  );
+  const params = applyProjectAnchor(cap, toRawParams(input, cap), anchor2);
   const baseUrl = `http://localhost:${env.PORT}`;
-  return callTrpc(baseUrl, cap.route, cap.method, cap.buildInput(params), authToken);
+  return runCapability(cap, baseUrl, params, authToken);
 }
 
 // ../server/src/trpc/routers/service.ts
-import { z as z3 } from "zod";
+import { z as z6 } from "zod";
 import { TRPCError as TRPCError2 } from "@trpc/server";
 
 // ../server/src/services/audit-service.ts
@@ -2538,6 +2807,39 @@ function buildServerBuiltins(input) {
 
 // ../server/src/trpc/routers/service.ts
 import { isAbsolute as isAbsolute2 } from "path";
+
+// ../server/src/services/attach-service.ts
+async function attachServiceToProject(target, serviceId) {
+  const project = await projectStore.addService(target, serviceId);
+  if (!project) return null;
+  const service = await serviceStore.get(serviceId);
+  if (!service) return project;
+  const globalEnvs = await environmentStore.listByScope(target.id, "global", target.orgId);
+  for (const globalEnv of globalEnvs) {
+    if (await environmentStore.findServiceEnvironment(serviceId, globalEnv.id)) continue;
+    const svcEnv = await environmentStore.create({
+      projectId: target.id,
+      name: `${service.name} (${globalEnv.name})`,
+      scope: "service",
+      reference: serviceId,
+      activateOn: globalEnv.id,
+      parentIds: [globalEnv.id],
+      variables: {}
+    }, target.orgId);
+    await projectStore.addEnvironment(target, svcEnv.id);
+  }
+  return project;
+}
+
+// ../server/src/trpc/routers/service.ts
+function withRestoredLogSecrets(incoming, existing) {
+  if (!incoming) return void 0;
+  try {
+    return restoreLogSourceSecrets(incoming, existing);
+  } catch (err) {
+    throw new TRPCError2({ code: "BAD_REQUEST", message: err.message });
+  }
+}
 async function resolveEffectiveAgentId(service) {
   const known = /* @__PURE__ */ new Set([
     ...agentManager.listAgents().map((a) => a.config.id),
@@ -2552,7 +2854,7 @@ async function resolveEffectiveAgentId(service) {
   }
   return agentManager.getDefaultAgentId();
 }
-async function resolveServiceVariables(service) {
+async function resolveServiceVariables(service, opts = {}) {
   const projects = await projectStore.list();
   const project = projects.find((p) => p.serviceIds.includes(service.id));
   let resolvedService = service;
@@ -2571,16 +2873,17 @@ async function resolveServiceVariables(service) {
   } catch (err) {
     console.error("[service-router] Failed to resolve parsers for service", service.id + ":", err.message);
   }
-  if (!project || !project.activeEnvironmentId) {
+  const environmentId = opts.environmentId ?? project?.activeEnvironmentId;
+  if (!project || !environmentId) {
     return resolvedService;
   }
   try {
     const resolved = await environmentResolver.resolveForService({
       serviceId: service.id,
-      activeEnvironmentId: project.activeEnvironmentId
+      activeEnvironmentId: environmentId
     });
     const [environment, agentId, siblings] = await Promise.all([
-      environmentStore.get(project.activeEnvironmentId),
+      environmentStore.get(environmentId),
       resolveEffectiveAgentId(service),
       Promise.all(project.serviceIds.filter((id) => id !== service.id).map((id) => serviceStore.get(id)))
     ]);
@@ -2603,7 +2906,7 @@ async function resolveServiceVariables(service) {
   }
   return resolvedService;
 }
-var DockerConfigInput = DockerConfigSchema;
+var DockerConfigInput2 = DockerConfigSchema;
 var serviceRouter = router({
   /**
    * Sans filtre, la réponse couvre TOUT le poste : `serviceStore.list()` rend
@@ -2620,10 +2923,10 @@ var serviceRouter = router({
    * silencieux ferait croire au filtrage tout en rendant les services des
    * autres organisations.
    */
-  list: protectedProcedure.meta({ openapi: { method: "GET", path: "/services", tags: ["services"], summary: "List services (every project of the machine unless narrowed by project or organization)", protect: true } }).input(z3.object({
-    projectId: z3.string().max(128).optional(),
-    orgId: z3.string().max(128).nullable().optional()
-  }).optional()).output(z3.any()).query(async ({ input, ctx }) => {
+  list: protectedProcedure.meta({ openapi: { method: "GET", path: "/services", tags: ["services"], summary: "List services (every project of the machine unless narrowed by project or organization)", protect: true } }).input(z6.object({
+    projectId: z6.string().max(128).optional(),
+    orgId: z6.string().max(128).nullable().optional()
+  }).optional()).output(z6.any()).query(async ({ input, ctx }) => {
     const all = await serviceStore.list();
     const allowedIds = getAllowedServiceIds(ctx);
     let filtered = allowedIds ? all.filter((s) => allowedIds.has(s.id)) : all;
@@ -2643,7 +2946,7 @@ var serviceRouter = router({
       effectiveAgentId: await resolveEffectiveAgentId(s)
     })));
   }),
-  get: protectedProcedure.meta({ openapi: { method: "GET", path: "/services/{id}", tags: ["services"], summary: "Get a service by ID", protect: true } }).input(z3.object({ id: z3.string().max(128) })).output(z3.any()).query(async ({ input, ctx }) => {
+  get: protectedProcedure.meta({ openapi: { method: "GET", path: "/services/{id}", tags: ["services"], summary: "Get a service by ID", protect: true } }).input(z6.object({ id: z6.string().max(128) })).output(z6.any()).query(async ({ input, ctx }) => {
     requireServiceAction(ctx, input.id, "service:read");
     const service = await serviceStore.get(input.id);
     if (!service) {
@@ -2669,17 +2972,28 @@ var serviceRouter = router({
    * valeurs** — où chacune est définie, ce que ses cases disent, et si ce
    * service la reçoit. Sans lui, un agent lisait l'effet sans la cause.
    */
-  getEnv: protectedProcedure.meta({ openapi: { method: "GET", path: "/services/{id}/env", tags: ["services"], summary: "Get a service's environment variables (unshared secrets masked) plus the project's value-free variable inventory", protect: true } }).input(z3.object({ id: z3.string().max(128) })).output(z3.any()).query(async ({ input, ctx }) => {
+  getEnv: protectedProcedure.meta({ openapi: { method: "GET", path: "/services/{id}/env", tags: ["services"], summary: "Get a service's environment variables (unshared secrets masked) plus the project's value-free variable inventory", protect: true } }).input(z6.object({
+    id: z6.string().max(128),
+    // Un environnement global du projet où résoudre, sans l'activer. Absent : l'actif.
+    environmentId: z6.string().max(128).optional()
+  })).output(z6.any()).query(async ({ input, ctx }) => {
     requireServiceAction(ctx, input.id, "service:read");
     const service = await serviceStore.get(input.id);
     if (!service) {
       throw new TRPCError2({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
     }
-    const resolved = await resolveServiceVariables(service);
     const project = await projectStore.ofService(service.id);
-    const shared = project?.activeEnvironmentId ? await environmentResolver.resolveAiSharedKeysForService({
+    if (input.environmentId) {
+      const target = await environmentStore.get(input.environmentId);
+      if (!target || !project || target.projectId !== project.id || (target.scope ?? "global") !== "global") {
+        throw new TRPCError2({ code: "BAD_REQUEST", message: `Environment ${input.environmentId} is not a global environment of this service's project` });
+      }
+    }
+    const environmentId = input.environmentId ?? project?.activeEnvironmentId ?? null;
+    const resolved = await resolveServiceVariables(service, input.environmentId ? { environmentId: input.environmentId } : {});
+    const shared = environmentId ? await environmentResolver.resolveAiSharedKeysForService({
       serviceId: service.id,
-      activeEnvironmentId: project.activeEnvironmentId
+      activeEnvironmentId: environmentId
     }) : /* @__PURE__ */ new Set();
     const filtered = filterEnvForAi(
       { env: resolved.env ?? {}, envSecrets: resolved.envSecrets ?? [] },
@@ -2688,8 +3002,8 @@ var serviceRouter = router({
     const [environments, overrides, sharedResolved] = project ? await Promise.all([
       environmentStore.getByProjectId(project.id, project.orgId ?? null),
       environmentOverridesStore.getAll(),
-      project.activeEnvironmentId ? environmentResolver.resolveForService(
-        { serviceId: service.id, activeEnvironmentId: project.activeEnvironmentId },
+      environmentId ? environmentResolver.resolveForService(
+        { serviceId: service.id, activeEnvironmentId: environmentId },
         { applyOverrides: false }
       ) : Promise.resolve({ env: {}, envSecrets: [] })
     ]) : [[], {}, { env: {}, envSecrets: [] }];
@@ -2700,38 +3014,47 @@ var serviceRouter = router({
       resolvedSecretKeys: new Set(resolved.envSecrets ?? []),
       maskedKeys: new Set(filtered.hiddenKeys)
     });
-    return { ...filtered, variables };
+    return {
+      ...filtered,
+      environmentId,
+      // Ce qui arrivera tel quel au process. Les valeurs masquées n'y sont pas
+      // inspectées : leurs références diraient la forme du secret.
+      unresolvedReferences: findUnresolvedReferences(resolved.env ?? {}, { serverResolved: true, skipKeys: filtered.hiddenKeys }),
+      variables
+    };
   }),
-  create: protectedProcedure.meta({ openapi: { method: "POST", path: "/services", tags: ["services"], summary: "Create a new service", protect: true } }).output(z3.any()).input(
-    z3.object({
-      agentId: z3.string().max(128).optional(),
-      name: z3.string().min(1).max(200),
-      commands: z3.array(ServiceCommandSchema).max(50).optional(),
-      cwd: z3.string().max(4096).optional(),
-      ports: z3.array(z3.number().int().min(1).max(65535)).max(20).optional(),
-      groups: z3.array(z3.string().max(200)).max(20).optional(),
-      description: z3.string().max(2e3).optional(),
-      docsPath: z3.string().max(4096).optional(),
-      url: z3.string().max(2048).optional(),
-      localUrls: z3.array(z3.object({
-        url: z3.string().max(253),
-        port: z3.number().int().min(1).max(65535)
+  create: protectedProcedure.meta({ openapi: { method: "POST", path: "/services", tags: ["services"], summary: "Create a new service", protect: true } }).output(z6.any()).input(
+    z6.object({
+      agentId: z6.string().max(128).optional(),
+      name: z6.string().min(1).max(200),
+      commands: z6.array(ServiceCommandSchema).max(50).optional(),
+      cwd: z6.string().max(4096).optional(),
+      ports: z6.array(z6.number().int().min(1).max(65535)).max(20).optional(),
+      groups: z6.array(z6.string().max(200)).max(20).optional(),
+      description: z6.string().max(2e3).optional(),
+      docsPath: z6.string().max(4096).optional(),
+      url: z6.string().max(2048).optional(),
+      localUrls: z6.array(z6.object({
+        url: z6.string().max(253),
+        port: z6.number().int().min(1).max(65535)
       })).max(20).optional(),
-      openapiUrl: z3.string().max(2048).optional(),
-      git: z3.object({ remote: z3.string().max(2048).optional(), home: z3.string().max(2048).optional() }).optional(),
-      meta: z3.record(z3.string().max(256), z3.string().max(2e3)).optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
-      runner: z3.enum(["native", "docker"]).optional().default("native"),
-      dockerConfig: DockerConfigInput.optional(),
+      openapiUrl: z6.string().max(2048).optional(),
+      git: z6.object({ remote: z6.string().max(2048).optional(), home: z6.string().max(2048).optional() }).optional(),
+      meta: z6.record(z6.string().max(256), z6.string().max(2e3)).optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
+      runner: z6.enum(["native", "docker"]).optional().default("native"),
+      dockerConfig: DockerConfigInput2.optional(),
       healthCheck: HealthCheckSchema.optional(),
-      autoRestart: z3.boolean().optional().default(false),
+      autoRestart: z6.boolean().optional().default(false),
+      clearLogsOnStart: z6.boolean().optional(),
       restartStrategy: RestartStrategySchema.optional(),
-      maxRestarts: z3.number().int().nonnegative().optional(),
-      restartBackoffMs: z3.number().int().positive().optional().default(1e3),
-      orgId: z3.string().max(128).nullable().optional(),
+      maxRestarts: z6.number().int().nonnegative().optional(),
+      restartBackoffMs: z6.number().int().positive().optional().default(1e3),
+      orgId: z6.string().max(128).nullable().optional(),
+      logSources: z6.array(LogSourceConfigSchema).max(20).optional(),
       // Le projet qui va l'adopter : le service naît dans son coffre.
-      projectId: z3.string().max(128).optional(),
-      shortcuts: z3.array(ServiceShortcutSchema).max(50).optional(),
-      parserIds: z3.array(z3.string().max(128)).max(50).optional()
+      projectId: z6.string().max(128).optional(),
+      shortcuts: z6.array(ServiceShortcutSchema).max(50).optional(),
+      parserIds: z6.array(z6.string().max(128)).max(50).optional()
     })
   ).mutation(async ({ input }) => {
     if (input.agentId) {
@@ -2743,55 +3066,59 @@ var serviceRouter = router({
         });
       }
     }
-    if (input.runner === "docker") {
-      throw new TRPCError2({ code: "BAD_REQUEST", message: 'Docker runner is not yet supported. Use "native" runner.' });
-    }
     const { projectId, ...fields } = input;
+    const logSources = withRestoredLogSecrets(input.logSources, []);
+    const target = projectId ? { id: projectId, ...input.orgId !== void 0 ? { orgId: input.orgId } : {} } : void 0;
+    if (target && !await projectStore.get(target)) {
+      throw new TRPCError2({ code: "NOT_FOUND", message: `Project ${projectId} not found` });
+    }
     const service = await serviceStore.create(
-      { ...fields, agentId: input.agentId },
+      { ...fields, agentId: input.agentId, ...logSources ? { logSources } : {} },
       projectId ? { id: projectId, orgId: input.orgId } : void 0
     );
+    if (target) await attachServiceToProject(target, service.id);
     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(z3.any()).input(
-    z3.object({
-      id: z3.string().max(128),
-      agentId: z3.string().max(128).nullable().optional(),
+  update: protectedProcedure.meta({ openapi: { method: "PATCH", path: "/services/{id}", tags: ["services"], summary: "Update a service", protect: true } }).output(z6.any()).input(
+    z6.object({
+      id: z6.string().max(128),
+      agentId: z6.string().max(128).nullable().optional(),
       // null = clear (inherit from env)
-      name: z3.string().min(1).max(200).optional(),
-      commands: z3.array(ServiceCommandSchema).max(50).optional(),
-      cwd: z3.string().max(4096).nullable().optional(),
-      ports: z3.array(z3.number().int().min(1).max(65535)).max(20).optional(),
-      groups: z3.array(z3.string().max(200)).max(20).optional(),
-      description: z3.string().max(2e3).optional(),
-      docsPath: z3.string().max(4096).optional(),
-      url: z3.string().max(2048).optional(),
-      localUrls: z3.array(z3.object({
-        url: z3.string().max(253),
-        port: z3.number().int().min(1).max(65535)
+      name: z6.string().min(1).max(200).optional(),
+      commands: z6.array(ServiceCommandSchema).max(50).optional(),
+      cwd: z6.string().max(4096).nullable().optional(),
+      ports: z6.array(z6.number().int().min(1).max(65535)).max(20).optional(),
+      groups: z6.array(z6.string().max(200)).max(20).optional(),
+      description: z6.string().max(2e3).optional(),
+      docsPath: z6.string().max(4096).optional(),
+      url: z6.string().max(2048).optional(),
+      localUrls: z6.array(z6.object({
+        url: z6.string().max(253),
+        port: z6.number().int().min(1).max(65535)
       })).max(20).optional(),
-      openapiUrl: z3.string().max(2048).optional(),
-      git: z3.object({ remote: z3.string().max(2048).optional(), home: z3.string().max(2048).optional() }).nullable().optional(),
-      meta: z3.record(z3.string().max(256), z3.string().max(2e3)).nullable().optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
-      runner: z3.enum(["native", "docker"]).optional(),
-      dockerConfig: DockerConfigInput.optional(),
+      openapiUrl: z6.string().max(2048).optional(),
+      git: z6.object({ remote: z6.string().max(2048).optional(), home: z6.string().max(2048).optional() }).nullable().optional(),
+      meta: z6.record(z6.string().max(256), z6.string().max(2e3)).nullable().optional().refine((obj) => !obj || Object.keys(obj).length <= 100, { message: "Too many meta keys (max 100)" }),
+      runner: z6.enum(["native", "docker"]).optional(),
+      dockerConfig: DockerConfigInput2.optional(),
       healthCheck: HealthCheckSchema.nullable().optional(),
-      autoRestart: z3.boolean().optional(),
-      clearLogsOnStart: z3.boolean().optional(),
+      autoRestart: z6.boolean().optional(),
+      clearLogsOnStart: z6.boolean().optional(),
       restartStrategy: RestartStrategySchema.optional(),
-      maxRestarts: z3.number().int().nonnegative().optional(),
-      restartBackoffMs: z3.number().int().positive().optional(),
-      orgId: z3.string().max(128).nullable().optional(),
-      shortcuts: z3.array(ServiceShortcutSchema).max(50).optional(),
-      parserIds: z3.array(z3.string().max(128)).max(50).optional(),
-      logSources: z3.array(LogSourceConfigSchema).max(20).optional()
+      maxRestarts: z6.number().int().nonnegative().optional(),
+      restartBackoffMs: z6.number().int().positive().optional(),
+      orgId: z6.string().max(128).nullable().optional(),
+      shortcuts: z6.array(ServiceShortcutSchema).max(50).optional(),
+      parserIds: z6.array(z6.string().max(128)).max(50).optional(),
+      logSources: z6.array(LogSourceConfigSchema).max(20).optional()
     })
   ).mutation(async ({ input }) => {
     const existing = await serviceStore.get(input.id);
     if (!existing) {
       throw new TRPCError2({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
     }
+    const logSources = withRestoredLogSecrets(input.logSources, existing.logSources ?? []);
     let stoppedForAgentChange = false;
     if (input.agentId !== void 0 && input.agentId !== existing.agentId && existing.agentId) {
       const oldAgentStatus = agentManager.getStatus(existing.agentId);
@@ -2816,7 +3143,7 @@ var serviceRouter = router({
         }
       }
     }
-    const service = await serviceStore.update(input);
+    const service = await serviceStore.update({ ...input, ...logSources ? { logSources } : {} });
     if (!service) {
       throw new TRPCError2({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
     }
@@ -2840,7 +3167,7 @@ var serviceRouter = router({
     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(z3.object({ id: z3.string().max(128) })).output(z3.object({ success: z3.literal(true) })).mutation(async ({ input }) => {
+  delete: protectedProcedure.meta({ openapi: { method: "DELETE", path: "/services/{id}", tags: ["services"], summary: "Delete a service", protect: true } }).input(z6.object({ id: z6.string().max(128) })).output(z6.object({ success: z6.literal(true) })).mutation(async ({ input }) => {
     const deleted = await serviceStore.delete(input.id);
     if (!deleted) {
       throw new TRPCError2({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
@@ -2848,7 +3175,7 @@ var serviceRouter = router({
     await auditService.log({ userId: "local", action: "delete", entityType: "service", entityId: input.id });
     return { success: true };
   }),
-  checkCwd: protectedProcedure.input(z3.object({ id: z3.string().max(128), checkReachability: z3.boolean().optional() })).query(async ({ input }) => {
+  checkCwd: protectedProcedure.input(z6.object({ id: z6.string().max(128), checkReachability: z6.boolean().optional() })).query(async ({ input }) => {
     const service = await serviceStore.get(input.id);
     if (!service) {
       throw new TRPCError2({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
@@ -2881,7 +3208,7 @@ var serviceRouter = router({
     }
     return { exists, canClone, unresolvedVars: [], resolvedCwd, gitMismatch };
   }),
-  cloneRepository: protectedProcedure.input(z3.object({ id: z3.string().max(128) })).mutation(async ({ input }) => {
+  cloneRepository: protectedProcedure.input(z6.object({ id: z6.string().max(128) })).mutation(async ({ input }) => {
     const service = await serviceStore.get(input.id);
     if (!service) {
       throw new TRPCError2({ code: "NOT_FOUND", message: `Service ${input.id} not found` });
@@ -3639,9 +3966,9 @@ async function fetchProviderModels(provider, plaintextKey) {
 async function vaultOfProject(projectId) {
   if (!projectId) return void 0;
   await ensureProjectsLoaded();
-  const refs = refsOfProjectId(projectId);
-  if (refs.length !== 1) return void 0;
-  return refs[0]?.orgId ?? void 0;
+  const refs2 = refsOfProjectId(projectId);
+  if (refs2.length !== 1) return void 0;
+  return refs2[0]?.orgId ?? void 0;
 }
 
 // ../server/src/services/image-storage.service.ts
@@ -3830,7 +4157,7 @@ async function resolveImagesToBase64(images, contextId) {
 }
 
 // ../server/src/trpc/routers/cloud-auth.ts
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 import { hostname } from "os";
 import { basename } from "path";
 import { TRPCError as TRPCError3 } from "@trpc/server";
@@ -4087,12 +4414,12 @@ var cloudSessionStore = new CloudSessionStore();
 import { networkInterfaces } from "os";
 import { readFile as readFile7, writeFile as writeFile4, rename as rename4, mkdir as mkdir6 } from "fs/promises";
 import { join as join7 } from "path";
-import { z as z4 } from "zod";
+import { z as z7 } from "zod";
 var LOOPBACK2 = "127.0.0.1";
 var ANY = "0.0.0.0";
 var NETWORK_FILE = "network.json";
-var NetworkFileSchema = z4.object({
-  instances: z4.record(z4.string(), z4.object({ lanEnabled: z4.boolean().default(false) })).default({})
+var NetworkFileSchema = z7.object({
+  instances: z7.record(z7.string(), z7.object({ lanEnabled: z7.boolean().default(false) })).default({})
 });
 var httpServer = null;
 function instanceKey() {
@@ -4360,15 +4687,15 @@ function isAllowedProxyPath(path) {
   const [pathname] = path.split("?");
   return PROXY_PREFIXES.some((p) => pathname === p || pathname.startsWith(p));
 }
-var ScopeSchema = z5.object({
-  accountId: z5.string().min(1).max(64)
+var ScopeSchema = z8.object({
+  accountId: z8.string().min(1).max(64)
 });
 function scopeOf(input) {
   return { accountId: input.accountId };
 }
 var cloudAuthRouter = router({
   /** Build the cloud authorization URL to open in the browser. */
-  startLogin: protectedProcedure.input(z5.object({ returnTo: z5.string().url().max(2048) })).mutation(async ({ input }) => {
+  startLogin: protectedProcedure.input(z8.object({ returnTo: z8.string().url().max(2048) })).mutation(async ({ input }) => {
     const callback = callbackForReturnTo(input.returnTo);
     if (!callback) {
       throw new TRPCError3({
@@ -4406,7 +4733,7 @@ var cloudAuthRouter = router({
    * `null` quand rien ne rattache cette organisation à un compte de ce poste :
    * l'interface l'affiche comme déconnectée, ce qu'elle est.
    */
-  accountForOrg: protectedProcedure.input(z5.object({ orgId: z5.string().min(1).max(128) })).query(async ({ input }) => ({ accountId: await accountForOrg(input.orgId) })),
+  accountForOrg: protectedProcedure.input(z8.object({ orgId: z8.string().min(1).max(128) })).query(async ({ input }) => ({ accountId: await accountForOrg(input.orgId) })),
   /**
    * Les comptes liés à ce poste, et l'organisation dont chacun répond.
    *
@@ -4462,7 +4789,7 @@ var cloudAuthRouter = router({
    * drops the session, and the local token is dropped here too, so nothing is
    * left holding a dead credential.
    */
-  revokeDevice: protectedProcedure.input(ScopeSchema.extend({ id: z5.string().min(1).max(128) })).mutation(async ({ input }) => {
+  revokeDevice: protectedProcedure.input(ScopeSchema.extend({ id: z8.string().min(1).max(128) })).mutation(async ({ input }) => {
     const { accountId } = input;
     if (!accountId) throw new TRPCError3({ code: "PRECONDITION_FAILED", message: "No cloud account for this scope." });
     const res = await cloudFetch2("/api/auth/device/revoke", {
@@ -4485,17 +4812,17 @@ var cloudAuthRouter = router({
    * the cloud: the web UI asks its own server, which holds the credential.
    */
   proxy: protectedProcedure.input(
-    z5.object({
-      path: z5.string().min(1).max(512),
-      method: z5.enum(["GET", "POST"]).default("GET"),
-      query: z5.record(z5.string().max(128), z5.string().max(2048)).optional(),
-      body: z5.unknown().optional(),
+    z8.object({
+      path: z8.string().min(1).max(512),
+      method: z8.enum(["GET", "POST"]).default("GET"),
+      query: z8.record(z8.string().max(128), z8.string().max(2048)).optional(),
+      body: z8.unknown().optional(),
       // Obligatoire, et seul : c'est la porte par laquelle passent tous les
       // appels cloud de l'interface. La laisser optionnelle est ce qui a
       // permis aux composables partagées de n'envoyer aucune portée pendant
       // trente routes, et au serveur de retomber sur « le compte unique du
       // poste » — muet dès qu'il y en a eu deux.
-      accountId: z5.string().min(1).max(64)
+      accountId: z8.string().min(1).max(64)
     })
   ).mutation(async ({ input }) => {
     if (!isAllowedProxyPath(input.path)) {
@@ -5277,7 +5604,7 @@ function tailTranscript(opts) {
 
 // ../server/src/services/ai-runners/claude-pty-runner.ts
 async function getAgentManager() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-FZFFWISA.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-QLXVQ7OD.js");
   return agentManager2;
 }
 function buildPtyArgs(params, sessionId, opts) {
@@ -5969,7 +6296,7 @@ async function shutdownCodexAppServer() {
   }
 }
 async function getAgentManager2() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-FZFFWISA.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-QLXVQ7OD.js");
   return agentManager2;
 }
 function parseRuneyaCurlCommand(command) {
@@ -6407,22 +6734,22 @@ ${prompt}`;
 };
 
 // ../server/src/trpc/routers/chat.ts
-var MessageSchema = z6.object({
-  role: z6.enum(["user", "assistant"]),
-  content: z6.string().max(1e5)
+var MessageSchema = z9.object({
+  role: z9.enum(["user", "assistant"]),
+  content: z9.string().max(1e5)
 });
-var ImagePartSchema = z6.object({
-  type: z6.literal("image"),
-  imageId: z6.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
-  url: z6.string().max(500),
-  mimeType: z6.string().max(100),
-  altText: z6.string().max(500).optional()
+var ImagePartSchema = z9.object({
+  type: z9.literal("image"),
+  imageId: z9.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  url: z9.string().max(500),
+  mimeType: z9.string().max(100),
+  altText: z9.string().max(500).optional()
 });
-var ImagePartsSchema = z6.array(ImagePartSchema).max(5).optional();
+var ImagePartsSchema = z9.array(ImagePartSchema).max(5).optional();
 var LANGUAGE_INSTRUCTION = "Always respond in the same language the user writes in.";
 async function buildSystemPrompt(apiKey) {
   const allServices = await serviceStore.list();
-  const resolvedServices = await Promise.all(allServices.map(resolveServiceVariables));
+  const resolvedServices = await Promise.all(allServices.map((s) => resolveServiceVariables(s)));
   const context = apiKey ? generateLlmsTxt(apiKey, resolvedServices.filter((s) => apiKey.scopes.services.some((p) => p.serviceId === s.id))) : generateAdminLlmsTxt(resolvedServices);
   const runeya_ai_vars = Object.entries(process.env).filter(([k]) => k.startsWith("RUNEYA_AI_")).map(([k, v]) => `${k}=${v}`).join("\n");
   const envSection = runeya_ai_vars ? `
@@ -6434,7 +6761,7 @@ ${runeya_ai_vars}` : "";
 
 ${context}${envSection}`;
 }
-async function* runAnthropic(client, model, system, initialMessages, apiKey, authToken, signal) {
+async function* runAnthropic(client, model, system, initialMessages, apiKey, authToken, signal, anchor2 = {}) {
   const messages = [...initialMessages];
   const MAX_TOOL_ROUNDS = 10;
   for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
@@ -6491,7 +6818,7 @@ async function* runAnthropic(client, model, system, initialMessages, apiKey, aut
       let result;
       let isError = false;
       try {
-        result = await executeTool(block.name, block.input, apiKey, authToken);
+        result = await executeTool(block.name, block.input, apiKey, authToken, anchor2);
       } catch (err) {
         result = err.message;
         isError = true;
@@ -6508,7 +6835,7 @@ async function* runAnthropic(client, model, system, initialMessages, apiKey, aut
   }
   yield { type: "done", text: "" };
 }
-async function* runOpenAI(client, model, initialMessages, apiKey, authToken, signal) {
+async function* runOpenAI(client, model, initialMessages, apiKey, authToken, signal, anchor2 = {}) {
   const messages = [...initialMessages];
   const MAX_TOOL_ROUNDS = 10;
   for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
@@ -6559,7 +6886,7 @@ async function* runOpenAI(client, model, initialMessages, apiKey, authToken, sig
       let result;
       let isError = false;
       try {
-        result = await executeTool(tc.name, input, apiKey, authToken);
+        result = await executeTool(tc.name, input, apiKey, authToken, anchor2);
       } catch (err) {
         result = err.message;
         isError = true;
@@ -6661,7 +6988,7 @@ async function buildCliSystemContext(conv, jwt) {
   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));
+  const resolvedServices = await Promise.all(ownServices.map((s) => resolveServiceVariables(s)));
   let systemContext = generateAdminLlmsTxt(resolvedServices, jwt, project);
   if (!conv?.isCompanion) systemContext += "\n\n" + companionSystemNote();
   systemContext += await kanbanContextFor(conv);
@@ -6806,24 +7133,24 @@ async function startCodexSession(convId, prompt, opts = {}) {
   });
   return { session, done };
 }
-var MessagePartSchema = z6.discriminatedUnion("type", [
-  z6.object({ type: z6.literal("thinking"), text: z6.string().max(1e5) }),
-  z6.object({ type: z6.literal("text"), text: z6.string().max(1e5) }),
-  z6.object({
-    type: z6.literal("tool"),
+var MessagePartSchema = z9.discriminatedUnion("type", [
+  z9.object({ type: z9.literal("thinking"), text: z9.string().max(1e5) }),
+  z9.object({ type: z9.literal("text"), text: z9.string().max(1e5) }),
+  z9.object({
+    type: z9.literal("tool"),
     id: Id128Schema,
     name: Id128Schema,
-    input: z6.record(z6.string(), z6.unknown()).optional(),
-    rawInput: z6.string().max(1e4).optional(),
-    result: z6.unknown().optional(),
-    isError: z6.boolean().optional(),
-    pending: z6.boolean()
+    input: z9.record(z9.string(), z9.unknown()).optional(),
+    rawInput: z9.string().max(1e4).optional(),
+    result: z9.unknown().optional(),
+    isError: z9.boolean().optional(),
+    pending: z9.boolean()
   })
 ]);
-var StoredMessageSchema = z6.object({
-  role: z6.enum(["user", "assistant"]),
-  content: z6.string().max(1e5),
-  parts: z6.array(MessagePartSchema).max(200).optional()
+var StoredMessageSchema = z9.object({
+  role: z9.enum(["user", "assistant"]),
+  content: z9.string().max(1e5),
+  parts: z9.array(MessagePartSchema).max(200).optional()
 });
 async function conversationCwd(conv) {
   return resolveConversationCwd(conv.id);
@@ -6840,7 +7167,7 @@ var chatRouter = router({
      * et sans le même filtre il y reversait toutes les conversations de la
      * machine, une seconde après un chargement pourtant filtré.
      */
-    onChanged: protectedProcedure.input(z6.object({
+    onChanged: protectedProcedure.input(z9.object({
       projectId: Id128Schema.optional(),
       orgId: Id128Schema.nullable().optional()
     }).optional()).subscription(async function* ({ input }) {
@@ -6888,7 +7215,7 @@ var chatRouter = router({
      * reachable where they were written, without leaking into every other
      * organization's projects.
      */
-    list: protectedProcedure.input(z6.object({
+    list: protectedProcedure.input(z9.object({
       projectId: Id128Schema.optional(),
       orgId: Id128Schema.nullable().optional()
     }).optional()).query(async ({ input }) => {
@@ -6896,24 +7223,24 @@ var chatRouter = router({
       if (!projectId) return conversationStore.list();
       return conversationStore.listForProject({ id: projectId, orgId: input?.orgId });
     }),
-    get: protectedProcedure.input(z6.object({ id: Id128Schema })).query(async ({ input }) => {
+    get: protectedProcedure.input(z9.object({ id: Id128Schema })).query(async ({ input }) => {
       const conv = await conversationStore.get(input.id);
       if (!conv) throw new TRPCError4({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
     }),
-    create: protectedProcedure.input(z6.object({
+    create: protectedProcedure.input(z9.object({
       title: ShortString200Schema.optional(),
-      isCli: z6.boolean().optional(),
-      runner: z6.enum(["claude-code", "codex"]).optional(),
+      isCli: z9.boolean().optional(),
+      runner: z9.enum(["claude-code", "codex"]).optional(),
       providerId: Id128Schema.optional(),
       scenarioId: Id128Schema.optional(),
-      scenarioInput: z6.string().max(1e5).optional(),
+      scenarioInput: z9.string().max(1e5).optional(),
       kanbanBoardId: Id128Schema.optional(),
       kanbanCardId: Id128Schema.optional(),
       // The project the conversation is about: only the caller knows which
       // one it is looking at.
       projectId: Id128Schema.optional(),
-      orgId: z6.string().max(128).nullable().optional()
+      orgId: z9.string().max(128).nullable().optional()
     })).mutation(async ({ input }) => {
       let scenario = null;
       if (input.scenarioId) {
@@ -6947,13 +7274,13 @@ var chatRouter = router({
       }
       return conv;
     }),
-    update: protectedProcedure.input(z6.object({
+    update: protectedProcedure.input(z9.object({
       id: Id128Schema,
       title: ShortString200Schema.optional(),
-      messages: z6.array(StoredMessageSchema).max(500).optional(),
-      contextUsage: z6.object({
-        inputTokens: z6.number().int().nonnegative(),
-        contextWindow: z6.number().int().positive()
+      messages: z9.array(StoredMessageSchema).max(500).optional(),
+      contextUsage: z9.object({
+        inputTokens: z9.number().int().nonnegative(),
+        contextWindow: z9.number().int().positive()
       }).optional()
     })).mutation(async ({ input }) => {
       const conv = await conversationStore.update(input.id, { title: input.title, messages: input.messages, contextUsage: input.contextUsage });
@@ -6967,10 +7294,10 @@ var chatRouter = router({
      * messages, et un réglage qui voyage avec 500 messages se perdrait dans un
      * patch dont ce n'est pas le sujet.
      */
-    setCompanion: protectedProcedure.input(z6.object({
+    setCompanion: protectedProcedure.input(z9.object({
       id: Id128Schema,
-      enabled: z6.boolean(),
-      runner: z6.enum(["claude-code", "codex"]).optional()
+      enabled: z9.boolean(),
+      runner: z9.enum(["claude-code", "codex"]).optional()
     })).mutation(async ({ input }) => {
       const existing = await conversationStore.get(input.id);
       if (!existing) throw new TRPCError4({ code: "NOT_FOUND", message: "Conversation not found" });
@@ -6993,7 +7320,7 @@ var chatRouter = router({
      * compagnon silencieux parce qu'il n'avait rien à dire et un message qui
      * n'a pas pu être transmis se ressemblent parfaitement sans cette trace.
      */
-    companionDelivery: protectedProcedure.input(z6.object({ id: Id128Schema })).query(async ({ input }) => {
+    companionDelivery: protectedProcedure.input(z9.object({ id: Id128Schema })).query(async ({ input }) => {
       const conv = await conversationStore.get(input.id);
       const companionId = conv?.companionConversationId;
       const running = isCompanionThinking(input.id) || (companionId ? activeSessionRegistry.get(companionId)?.status === "running" : false);
@@ -7043,7 +7370,7 @@ var chatRouter = router({
      * route emprunte exactement le chemin de livraison, sans le jugement, et
      * rend PAR OÙ le message est passé.
      */
-    testCompanionBridge: protectedProcedure.input(z6.object({ id: Id128Schema })).mutation(async ({ input }) => {
+    testCompanionBridge: protectedProcedure.input(z9.object({ id: Id128Schema })).mutation(async ({ input }) => {
       const conv = await conversationStore.get(input.id);
       if (!conv) throw new TRPCError4({ code: "NOT_FOUND", message: "Conversation not found" });
       const route = await deliverToMainConversation(
@@ -7064,7 +7391,7 @@ var chatRouter = router({
      * entier, bien plus qu'une requête ne doit rester ouverte. L'interface suit
      * l'avancement par l'état poussé « il relit », déjà en place.
      */
-    runCompanionNow: protectedProcedure.input(z6.object({ id: Id128Schema })).mutation(async ({ input }) => {
+    runCompanionNow: protectedProcedure.input(z9.object({ id: Id128Schema })).mutation(async ({ input }) => {
       const conv = await conversationStore.get(input.id);
       if (!conv) throw new TRPCError4({ code: "NOT_FOUND", message: "Conversation not found" });
       if (conv.isCompanion) {
@@ -7081,7 +7408,7 @@ var chatRouter = router({
       });
       return { started: true };
     }),
-    delete: protectedProcedure.input(z6.object({ id: Id128Schema })).mutation(async ({ input }) => {
+    delete: protectedProcedure.input(z9.object({ id: Id128Schema })).mutation(async ({ input }) => {
       const existing = await conversationStore.get(input.id);
       if (!existing) throw new TRPCError4({ code: "NOT_FOUND", message: "Conversation not found" });
       resetRelaunches(input.id);
@@ -7109,12 +7436,12 @@ var chatRouter = router({
         (err) => console.error("[chat.delete] Image cleanup error:", err)
       );
     }),
-    archive: protectedProcedure.input(z6.object({ id: Id128Schema, archived: z6.boolean() })).mutation(async ({ input }) => {
+    archive: protectedProcedure.input(z9.object({ id: Id128Schema, archived: z9.boolean() })).mutation(async ({ input }) => {
       const conv = await conversationStore.update(input.id, { archived: input.archived });
       if (!conv) throw new TRPCError4({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
     }),
-    pin: protectedProcedure.input(z6.object({ id: Id128Schema, pinned: z6.boolean() })).mutation(async ({ input }) => {
+    pin: protectedProcedure.input(z9.object({ id: Id128Schema, pinned: z9.boolean() })).mutation(async ({ input }) => {
       const conv = await conversationStore.setPinned(input.id, input.pinned);
       if (!conv) throw new TRPCError4({ code: "NOT_FOUND", message: "Conversation not found" });
       return conv;
@@ -7122,16 +7449,16 @@ var chatRouter = router({
     // L'ordre ne vaut que pour les ids donnés : l'écran ne connaît que les
     // conversations du projet courant, et les épinglées des autres projets
     // n'ont pas à bouger parce qu'on a rangé celles-ci.
-    reorderPinned: protectedProcedure.input(z6.object({ ids: z6.array(Id128Schema).max(500) })).mutation(async ({ input }) => {
+    reorderPinned: protectedProcedure.input(z9.object({ ids: z9.array(Id128Schema).max(500) })).mutation(async ({ input }) => {
       await conversationStore.reorderPinned(input.ids);
     })
   }),
-  listModels: protectedProcedure.input(z6.object({
+  listModels: protectedProcedure.input(z9.object({
     providerId: Id128Schema.optional(),
     // Le projet dit de quelle organisation lire les fournisseurs ; absent,
     // ce sont ceux du poste.
     projectId: Id128Schema.optional(),
-    orgId: z6.string().max(128).nullable().optional()
+    orgId: z9.string().max(128).nullable().optional()
   }).optional()).query(async ({ input }) => {
     const active = await getActiveProvider(
       input?.providerId,
@@ -7144,7 +7471,7 @@ var chatRouter = router({
       return [];
     }
   }),
-  checkCliAvailability: protectedProcedure.input(z6.object({ agentId: Id128Schema.optional() }).optional()).query(async ({ input }) => {
+  checkCliAvailability: protectedProcedure.input(z9.object({ agentId: Id128Schema.optional() }).optional()).query(async ({ input }) => {
     if (input?.agentId) {
       try {
         const res = await agentManager.agentQuery(
@@ -7162,12 +7489,12 @@ var chatRouter = router({
     ]);
     return { available: claudeOk, codexAvailable: codexOk };
   }),
-  enhanceScenarioPrompt: protectedProcedure.input(z6.object({
-    text: z6.string().max(1e4),
+  enhanceScenarioPrompt: protectedProcedure.input(z9.object({
+    text: z9.string().max(1e4),
     providerId: Id128Schema.optional(),
-    model: z6.string().max(200).optional(),
+    model: z9.string().max(200).optional(),
     projectId: Id128Schema.optional(),
-    orgId: z6.string().max(128).nullable().optional()
+    orgId: z9.string().max(128).nullable().optional()
   })).mutation(async ({ input }) => {
     const active = await getActiveProvider(
       input.providerId,
@@ -7224,22 +7551,22 @@ Return ONLY the improved text, no explanation, no preamble.`;
     }
   }),
   getStreamingStatus: protectedProcedure.query(() => activeSessionRegistry.listActive()),
-  stopSession: protectedProcedure.input(z6.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
+  stopSession: protectedProcedure.input(z9.object({ conversationId: ConversationIdSchema })).mutation(({ input }) => {
     if (process.env.RUNEYA_DEBUG) console.log("[chat]: stopSession");
     const killed = activeSessionRegistry.kill(input.conversationId);
     if (!killed) throw new TRPCError4({ code: "NOT_FOUND", message: "No active session for this conversation" });
     return { ok: true };
   }),
-  streamViaClaudeCode: protectedProcedure.input(z6.object({
+  streamViaClaudeCode: protectedProcedure.input(z9.object({
     conversationId: ConversationIdSchema,
-    prompt: z6.string().max(1e5),
-    contextNote: z6.string().max(2e5).optional(),
+    prompt: z9.string().max(1e5),
+    contextNote: z9.string().max(2e5).optional(),
     model: ShortString200Schema.optional(),
-    effort: z6.enum(["low", "medium", "high"]).optional(),
-    reconnect: z6.boolean().optional(),
+    effort: z9.enum(["low", "medium", "high"]).optional(),
+    reconnect: z9.boolean().optional(),
     agentId: Id128Schema.optional(),
-    environmentId: z6.string().max(128).optional(),
-    imageIds: z6.array(z6.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
+    environmentId: z9.string().max(128).optional(),
+    imageIds: z9.array(z9.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
     imageParts: ImagePartsSchema
   })).subscription(async function* ({ input, ctx, signal }) {
     if (process.env.RUNEYA_DEBUG) console.log("[chat]: Reconnect");
@@ -7341,15 +7668,15 @@ ${imagePaths.map((p) => `Image: ${p}`).join("\n")}` : cliPrompt;
     if (process.env.RUNEYA_DEBUG) console.log("[chat]: drainSession...");
     yield* drainSession(session, signal, false);
   }),
-  streamViaCodex: protectedProcedure.input(z6.object({
+  streamViaCodex: protectedProcedure.input(z9.object({
     conversationId: ConversationIdSchema,
-    prompt: z6.string().max(1e5),
-    contextNote: z6.string().max(2e5).optional(),
+    prompt: z9.string().max(1e5),
+    contextNote: z9.string().max(2e5).optional(),
     model: ShortString200Schema.optional(),
-    reconnect: z6.boolean().optional(),
+    reconnect: z9.boolean().optional(),
     agentId: Id128Schema.optional(),
-    environmentId: z6.string().max(128).optional(),
-    imageIds: z6.array(z6.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
+    environmentId: z9.string().max(128).optional(),
+    imageIds: z9.array(z9.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
     imageParts: ImagePartsSchema
   })).subscription(async function* ({ input, ctx, signal }) {
     const existingSession = activeSessionRegistry.get(input.conversationId);
@@ -7419,13 +7746,13 @@ ${input.prompt}` : input.prompt;
     });
     yield* drainSession(session, signal, false);
   }),
-  send: protectedProcedure.input(z6.object({
+  send: protectedProcedure.input(z9.object({
     conversationId: ConversationIdSchema,
-    messages: z6.array(MessageSchema).min(0).max(100),
+    messages: z9.array(MessageSchema).min(0).max(100),
     model: ShortString200Schema.optional(),
-    contextNote: z6.string().max(2e5).optional(),
-    reconnect: z6.boolean().optional(),
-    imageIds: z6.array(z6.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
+    contextNote: z9.string().max(2e5).optional(),
+    reconnect: z9.boolean().optional(),
+    imageIds: z9.array(z9.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).max(5).optional(),
     imageParts: ImagePartsSchema
   })).subscription(async function* ({ input, ctx, signal }) {
     const existingSession = activeSessionRegistry.get(input.conversationId);
@@ -7438,6 +7765,7 @@ ${input.prompt}` : input.prompt;
     }
     const conv = await conversationStore.get(input.conversationId);
     const convRef = conv ? await conversationStore.projectRefOf(conv) : null;
+    const anchor2 = { projectId: convRef?.id, orgId: convRef?.orgId ?? void 0 };
     const active = await getActiveProvider(conv?.providerId, convRef?.orgId ?? void 0);
     if (!active) {
       throw new TRPCError4({
@@ -7486,7 +7814,7 @@ ${input.prompt}` : input.prompt;
             }
             return { role: m.role, content: m.content };
           });
-          gen = runAnthropic(client, model, system, msgs, apiKey, authToken, apiSignal);
+          gen = runAnthropic(client, model, system, msgs, apiKey, authToken, apiSignal, anchor2);
         } else if (provider.provider in OPENAI_COMPAT_BASE_URLS) {
           const baseURL = OPENAI_COMPAT_BASE_URLS[provider.provider];
           const client = new OpenAI2({ apiKey: plaintextKey || "ollama", baseURL });
@@ -7505,7 +7833,7 @@ ${input.prompt}` : input.prompt;
               return { role: m.role, content: m.content };
             })
           ];
-          gen = runOpenAI(client, model, msgs, apiKey, authToken, apiSignal);
+          gen = runOpenAI(client, model, msgs, apiKey, authToken, apiSignal, anchor2);
         } else {
           activeSessionRegistry.pushEvent(input.conversationId, { type: "error", message: `Provider "${provider.provider}" is not supported.` });
           activeSessionRegistry.pushEvent(input.conversationId, { type: "done", text: "" });
@@ -7538,25 +7866,25 @@ ${input.prompt}` : input.prompt;
   // ── PTY passthrough (interactive Claude Code session) ────────────────────
   pty: router({
     /** Start a PTY session running `claude --resume <sessionId>` (or fresh). */
-    start: protectedProcedure.input(z6.object({
-      agentId: z6.string().max(128).optional(),
-      sessionId: z6.string().max(128).optional(),
-      runner: z6.enum(["claude-code", "codex"]).default("claude-code"),
-      resume: z6.boolean().default(false),
-      model: z6.string().max(128).optional(),
-      cwd: z6.string().max(4096).optional(),
+    start: protectedProcedure.input(z9.object({
+      agentId: z9.string().max(128).optional(),
+      sessionId: z9.string().max(128).optional(),
+      runner: z9.enum(["claude-code", "codex"]).default("claude-code"),
+      resume: z9.boolean().default(false),
+      model: z9.string().max(128).optional(),
+      cwd: z9.string().max(4096).optional(),
       /** Anchors the session when no explicit cwd is given. */
-      serviceId: z6.string().max(128).optional(),
+      serviceId: z9.string().max(128).optional(),
       projectId: Id128Schema.optional(),
-      orgId: z6.string().max(128).nullable().optional(),
-      cols: z6.number().int().min(1).max(1e3).default(120),
-      rows: z6.number().int().min(1).max(1e3).default(30),
-      enableMcp: z6.boolean().default(false),
-      apiBaseUrl: z6.string().max(512).optional(),
-      environmentId: z6.string().max(128).optional(),
-      attachedContexts: z6.array(z6.object({
-        label: z6.string().max(200),
-        text: z6.string().max(1e6)
+      orgId: z9.string().max(128).nullable().optional(),
+      cols: z9.number().int().min(1).max(1e3).default(120),
+      rows: z9.number().int().min(1).max(1e3).default(30),
+      enableMcp: z9.boolean().default(false),
+      apiBaseUrl: z9.string().max(512).optional(),
+      environmentId: z9.string().max(128).optional(),
+      attachedContexts: z9.array(z9.object({
+        label: z9.string().max(200),
+        text: z9.string().max(1e6)
       })).max(20).optional()
     })).mutation(async ({ input, ctx }) => {
       const t0 = Date.now();
@@ -7714,10 +8042,10 @@ Context:
       return { spawnId: res.spawnId, agentId, reattached: false };
     }),
     /** Subscribe to PTY output stream (raw text with ANSI). */
-    stream: protectedProcedure.input(z6.object({
-      agentId: z6.string().max(128).optional(),
-      spawnId: z6.string().max(128),
-      fromOffset: z6.number().int().min(0).default(0)
+    stream: protectedProcedure.input(z9.object({
+      agentId: z9.string().max(128).optional(),
+      spawnId: z9.string().max(128),
+      fromOffset: z9.number().int().min(0).default(0)
     })).subscription(async function* ({ input, signal }) {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError4({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -7772,10 +8100,10 @@ Context:
       }
     }),
     /** Write input to a PTY session (keystrokes from xterm). */
-    write: protectedProcedure.input(z6.object({
-      agentId: z6.string().max(128).optional(),
-      spawnId: z6.string().max(128),
-      data: z6.string().max(1e6)
+    write: protectedProcedure.input(z9.object({
+      agentId: z9.string().max(128).optional(),
+      spawnId: z9.string().max(128),
+      data: z9.string().max(1e6)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError4({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -7785,11 +8113,11 @@ Context:
       });
     }),
     /** Resize a PTY session. */
-    resize: protectedProcedure.input(z6.object({
-      agentId: z6.string().max(128).optional(),
-      spawnId: z6.string().max(128),
-      cols: z6.number().int().min(1).max(1e3),
-      rows: z6.number().int().min(1).max(1e3)
+    resize: protectedProcedure.input(z9.object({
+      agentId: z9.string().max(128).optional(),
+      spawnId: z9.string().max(128),
+      cols: z9.number().int().min(1).max(1e3),
+      rows: z9.number().int().min(1).max(1e3)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError4({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -7805,11 +8133,11 @@ Context:
      * picks it up. Returns the tmp path and which clipboard method succeeded
      * (null if none — caller should inject `@<path>` instead of Ctrl+V).
      */
-    pasteImage: protectedProcedure.input(z6.object({
-      agentId: z6.string().max(128).optional(),
-      sessionId: z6.string().max(128).optional(),
-      mimeType: z6.string().max(64),
-      base64: z6.string().max(15e6)
+    pasteImage: protectedProcedure.input(z9.object({
+      agentId: z9.string().max(128).optional(),
+      sessionId: z9.string().max(128).optional(),
+      mimeType: z9.string().max(64),
+      base64: z9.string().max(15e6)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError4({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -7827,7 +8155,7 @@ Context:
      * Read the transcript Claude Code stores on disk for a given session.
      * Returns parsed JSONL entries (user / assistant messages, tool uses, etc.).
      */
-    transcript: protectedProcedure.input(z6.object({ sessionId: z6.string().max(128) })).query(async ({ input }) => {
+    transcript: protectedProcedure.input(z9.object({ sessionId: z9.string().max(128) })).query(async ({ input }) => {
       return readClaudeTranscript(input.sessionId);
     }),
     /**
@@ -7835,9 +8163,9 @@ Context:
      * when was the transcript JSONL last touched? Used by the non-PTY view
      * to show a "Claude is thinking…" indicator while output streams.
      */
-    activity: protectedProcedure.input(z6.object({
-      agentId: z6.string().max(128).optional(),
-      sessionId: z6.string().max(128)
+    activity: protectedProcedure.input(z9.object({
+      agentId: z9.string().max(128).optional(),
+      sessionId: z9.string().max(128)
     })).query(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       let running = false;
@@ -7863,7 +8191,7 @@ Context:
      * them on the conversation, so the non-PTY chat view stays in sync.
      * Uses the conversation id as session id (PTY sessions are spawned that way).
      */
-    syncTranscript: protectedProcedure.input(z6.object({ conversationId: ConversationIdSchema })).mutation(async ({ input }) => {
+    syncTranscript: protectedProcedure.input(z9.object({ conversationId: ConversationIdSchema })).mutation(async ({ input }) => {
       const conv = await conversationStore.get(input.conversationId);
       if (!conv) {
         throw new TRPCError4({ code: "NOT_FOUND", message: `Conversation ${input.conversationId} not found` });
@@ -7877,14 +8205,14 @@ Context:
      * with the given sessionId. Used to benchmark the PTY → tRPC → xterm.js
      * pipeline. Open the conversation in PTY mode to attach to it.
      */
-    debugStress: protectedProcedure.input(z6.object({
-      sessionId: z6.string().max(128),
-      agentId: z6.string().max(128).optional(),
-      bytesPerSec: z6.number().int().min(100).max(1e7).default(5e4),
-      chunkSize: z6.number().int().min(1).max(65536).default(256),
-      durationMs: z6.number().int().min(0).max(36e5).default(0),
-      cols: z6.number().int().min(1).max(1e3).default(120),
-      rows: z6.number().int().min(1).max(1e3).default(30)
+    debugStress: protectedProcedure.input(z9.object({
+      sessionId: z9.string().max(128),
+      agentId: z9.string().max(128).optional(),
+      bytesPerSec: z9.number().int().min(100).max(1e7).default(5e4),
+      chunkSize: z9.number().int().min(1).max(65536).default(256),
+      durationMs: z9.number().int().min(0).max(36e5).default(0),
+      cols: z9.number().int().min(1).max(1e3).default(120),
+      rows: z9.number().int().min(1).max(1e3).default(30)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError4({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -7931,9 +8259,9 @@ Context:
       return { spawnId: res.spawnId, agentId, stressSessionId };
     }),
     /** Kill a PTY session. */
-    kill: protectedProcedure.input(z6.object({
-      agentId: z6.string().max(128).optional(),
-      spawnId: z6.string().max(128)
+    kill: protectedProcedure.input(z9.object({
+      agentId: z9.string().max(128).optional(),
+      spawnId: z9.string().max(128)
     })).mutation(async ({ input }) => {
       const agentId = input.agentId ?? agentManager.getDefaultAgentId();
       if (!agentId) throw new TRPCError4({ code: "PRECONDITION_FAILED", message: "No agent available" });
@@ -7965,11 +8293,14 @@ export {
   accountForOrgOrThrow,
   cloudFetch,
   readCloudIdentity,
+  attachServiceToProject,
   environmentOverridesStore,
+  filterEnvForAi,
   environmentResolver,
   auditService,
   isShareable,
   logParserStore,
+  buildServerBuiltins,
   resolveWorkspaceCwd,
   resolveAgentCwd,
   resolveConversationCwd,
@@ -8011,4 +8342,4 @@ export {
   startCliSession,
   chatRouter
 };
-//# sourceMappingURL=chunk-GKK3ACWB.js.map
+//# sourceMappingURL=chunk-2EDVDRKV.js.map