@runeya/runeya 2.0.9 → 2.0.11

package/{dist-PSPHMTZN.js → dist-2H7XZQCV.js}

@@ -34,7 +34,7 @@ import {
   nativeParsers,
   serviceStore,
   traefikManager
-} from "./chunk-BSPKMRKW.js";
+} from "./chunk-6547GLUJ.js";
 import {
   generateKanbanPopulatePrompt,
   generateKanbanSystemPrompt,
@@ -121,27 +121,34 @@ import OpenAI2 from "openai";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 import { fileURLToPath } from "url";
-import { TRPCError as TRPCError10 } from "@trpc/server";
-import { z as z13 } from "zod";
+import { readdir as readdir2, access, readFile as readFile8 } from "fs/promises";
+import { watch } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join10 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 import { readFile as readFile7, writeFile as writeFile7, rename as rename7, mkdir as mkdir8, chmod as chmod6 } from "fs/promises";
 import { join as join9 } from "path";
 import { EventEmitter } from "events";
+import { TRPCError as TRPCError10 } from "@trpc/server";
+import { z as z13 } from "zod";
 import pty from "node-pty";
 import { execSync } from "child_process";
 import pty2 from "node-pty";
-import { mkdir as mkdir10, rm, readFile as readFile9 } from "fs/promises";
-import { join as join10 } from "path";
+import { mkdir as mkdir10, rm, readFile as readFile10 } from "fs/promises";
+import { join as join11 } from "path";
 import { chmod as chmod7, mkdir as mkdir9, rename as rename8, writeFile as writeFile8 } from "fs/promises";
 import { dirname as dirname2, resolve as resolve2, sep } from "path";
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import Anthropic from "@anthropic-ai/sdk";
 import OpenAI from "openai";
 import { randomUUID as randomUUID4 } from "crypto";
-import { mkdir as mkdir11, writeFile as writeFile9, readFile as readFile10, unlink as unlink2, readdir as readdir2 } from "fs/promises";
+import { mkdir as mkdir11, writeFile as writeFile9, readFile as readFile11, unlink as unlink2, readdir as readdir3 } from "fs/promises";
 import { existsSync } from "fs";
-import { join as join11, extname, resolve as resolve3, sep as sep2 } from "path";
+import { join as join12, extname, resolve as resolve3, sep as sep2 } from "path";
 import { spawn as spawn2 } from "child_process";
+import { randomUUID as randomUUID5 } from "crypto";
+import { open } from "fs/promises";
+import { watch as watch2 } from "fs";
 import { spawn as spawn3 } from "child_process";
 import { createInterface } from "readline";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -149,7 +156,7 @@ import { z as z15 } from "zod";
 import { TRPCError as TRPCError11 } from "@trpc/server";
 import Anthropic3 from "@anthropic-ai/sdk";
 import OpenAI3 from "openai";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { TRPCError as TRPCError14 } from "@trpc/server";
 import { z as z16 } from "zod";
 import { TRPCError as TRPCError12 } from "@trpc/server";
@@ -157,46 +164,47 @@ import { TRPCError as TRPCError13 } from "@trpc/server";
 import Anthropic4 from "@anthropic-ai/sdk";
 import OpenAI4 from "openai";
 import { mkdir as mkdir12 } from "fs/promises";
-import { randomUUID as randomUUID5 } from "crypto";
-import { join as join12 } from "path";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
+import { join as join13 } from "path";
+import { randomUUID as randomUUID8 } from "crypto";
 import { TRPCError as TRPCError15 } from "@trpc/server";
 import { z as z17 } from "zod";
 import { z as z18 } from "zod";
 import { TRPCError as TRPCError16 } from "@trpc/server";
 import { z as z19 } from "zod";
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { EventEmitter as EventEmitter3 } from "events";
 import { z as z20 } from "zod";
 import { TRPCError as TRPCError17 } from "@trpc/server";
 import { z as z21 } from "zod";
 import { chmod as chmod8, stat as stat3 } from "fs/promises";
-import { join as join13 } from "path";
-import { writeFile as writeFile10 } from "fs/promises";
 import { join as join14 } from "path";
+import { writeFile as writeFile10 } from "fs/promises";
+import { join as join15 } from "path";
 import { createRequire } from "module";
 import { randomBytes as randomBytes3, createCipheriv, createDecipheriv } from "crypto";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import {
-  readFile as readFile11,
+  readFile as readFile12,
   writeFile as writeFile11,
   rename as rename9,
   mkdir as mkdir13,
-  access,
-  readdir as readdir3
+  access as access2,
+  readdir as readdir4
 } from "fs/promises";
-import { join as join15 } from "path";
-import { randomBytes as randomBytes4, createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2 } from "crypto";
-import { readFile as readFile12, writeFile as writeFile12, chmod as chmod9, stat as stat4, rename as rename10 } from "fs/promises";
 import { join as join16 } from "path";
+import { randomBytes as randomBytes4, createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2 } from "crypto";
+import { readFile as readFile13, writeFile as writeFile12, chmod as chmod9, stat as stat4, rename as rename10 } from "fs/promises";
+import { join as join17 } from "path";
 import { Entry } from "@napi-rs/keyring";
 import { hashRaw as argon2HashRaw } from "@node-rs/argon2";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { stat as stat5 } from "fs/promises";
 import rateLimit from "express-rate-limit";
 import { existsSync as existsSync2, createReadStream } from "fs";
 import { mkdir as mkdir14 } from "fs/promises";
 import multer from "multer";
+import { resolve as resolvePath } from "path";
 import dotenv from "dotenv";
 var jwtSecret = null;
 var jwtSecretGeneratedAt = 0;
@@ -400,11 +408,13 @@ function requireEnvAction(ctx, environmentId, action, serviceId) {
   });
 }
 var startedAt = Date.now();
+var appVersion = process.env["RUNEYA_VERSION"] ?? (true ? "2.0.10" : "dev");
 var healthRouter = router({
-  check: publicProcedure.meta({ openapi: { method: "GET", path: "/health", tags: ["health"], summary: "Health check" } }).output(z.object({ status: z.literal("ok"), uptime: z.number() })).query(() => {
+  check: publicProcedure.meta({ openapi: { method: "GET", path: "/health", tags: ["health"], summary: "Health check" } }).output(z.object({ status: z.literal("ok"), uptime: z.number(), version: z.string() })).query(() => {
     return {
       status: "ok",
-      uptime: Date.now() - startedAt
+      uptime: Date.now() - startedAt,
+      version: appVersion
     };
   })
 });
@@ -571,7 +581,6 @@ var EnvironmentOverridesStore = class {
       const raw = await readFile3(this.getFilePath(), "utf-8");
       const parsed = JSON.parse(raw);
       if (!getEncryptionKey()) {
-        this.loaded = true;
         return;
       }
       this.diskEncryptedSlots = extractEncryptedVariableSlots(
@@ -1868,7 +1877,8 @@ var processRouter = router({
     agentId: z5.string().max(128),
     processId: z5.string().max(128),
     command: z5.string().min(1).max(4096),
-    cwd: z5.string().max(4096).optional()
+    cwd: z5.string().max(4096).optional(),
+    commandId: z5.string().max(128).optional()
   })).mutation(async ({ input }) => {
     const service = await serviceStore.get(input.processId);
     if (service) {
@@ -1882,7 +1892,7 @@ var processRouter = router({
     const result = await agentManager.agentMutation(
       input.agentId,
       "process.executeAdHocCommand",
-      { id: input.processId, command: input.command, cwd: input.cwd },
+      { id: input.processId, command: input.command, cwd: input.cwd, commandId: input.commandId },
       AGENT_LONG_FETCH_TIMEOUT
     );
     await auditService.log({
@@ -1906,9 +1916,10 @@ var processRouter = router({
   /** Cancel a running ad-hoc command on an agent */
   cancelAdHocCommand: protectedProcedure.input(z5.object({
     agentId: z5.string().max(128),
-    processId: z5.string().max(128)
+    processId: z5.string().max(128),
+    commandId: z5.string().max(128).optional()
   })).mutation(async ({ input }) => {
-    await agentManager.agentMutation(input.agentId, "process.cancelAdHocCommand", { id: input.processId });
+    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 */
@@ -2978,200 +2989,6 @@ var apiKeysRouter = router({
     return { path: input.relativePath };
   })
 });
-var Id128Schema = z13.string().max(128);
-var ConversationIdSchema = z13.string().max(128);
-var NameSchema = z13.string().min(1).max(200);
-var ShortString200Schema = z13.string().max(200);
-var DescriptionSchema = z13.string().max(2e3);
-var OptionalProviderIdSchema = Id128Schema.optional();
-function generateAdminLlmsTxt(services, jwt) {
-  const baseUrl = `http://localhost:${env.PORT}`;
-  const trpcBase = `${baseUrl}/api/trpc`;
-  const lines = [];
-  lines.push("# Runeya \u2014 Service Management API");
-  lines.push("");
-  lines.push("> You are operating as an authenticated admin with full access to all services.");
-  lines.push(`> Base URL: ${trpcBase}`);
-  if (jwt) {
-    lines.push("> Authentication: pass `Authorization: Bearer $RUNEYA_API_TOKEN` on all tRPC requests.");
-  }
-  lines.push("");
-  if (services.length === 0) {
-    lines.push("No services configured.");
-    return lines.join("\n");
-  }
-  lines.push("## Services");
-  lines.push("");
-  for (const svc of services) {
-    lines.push(`### ${svc.name}`);
-    lines.push(`- **ID**: \`${svc.id}\``);
-    if (svc.agentId) lines.push(`- **Agent ID**: \`${svc.agentId}\``);
-    if (svc.description) lines.push(`- **Description**: ${svc.description}`);
-    if (svc.cwd) lines.push(`- **Working directory**: \`${svc.cwd}\``);
-    lines.push("- **Permitted actions**: all");
-    lines.push("");
-  }
-  lines.push("## MCP Tools");
-  lines.push("");
-  lines.push("You have access to Runeya MCP tools to manage services. **Always prefer MCP tools** over raw HTTP calls.");
-  lines.push("Available tools: `list_services`, `get_service_status`, `start_service`, `stop_service`, `restart_service`, `get_logs`.");
-  lines.push("");
-  if (jwt) {
-    lines.push("**Important**: Pass the `authToken` parameter with value `$RUNEYA_API_TOKEN` (from environment) on every MCP tool call for authentication.");
-    lines.push("");
-  }
-  lines.push("Use the service IDs and agent IDs listed above when calling these tools.");
-  lines.push("");
-  lines.push("## API Reference (fallback)");
-  lines.push("");
-  lines.push("Only use raw HTTP calls if MCP tools are unavailable.");
-  lines.push("All endpoints use tRPC v11 over HTTP (`Content-Type: application/json`).");
-  lines.push("");
-  lines.push("**tRPC v11 request format:**");
-  lines.push('- **GET queries**: `?input={"id":"abc"}`');
-  lines.push('- **POST mutations**: JSON body `{"agentId":"<agentId>","processId":"<serviceId>"}`');
-  lines.push("");
-  lines.push(`### List services
-\`GET ${trpcBase}/service.list\``);
-  lines.push("");
-  lines.push(`### Get service
-\`GET ${trpcBase}/service.get?input={"agentId":"<agentId>","id":"<serviceId>"}\``);
-  lines.push("");
-  lines.push(`### Read logs
-\`GET ${trpcBase}/process.logs?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
-  lines.push("");
-  lines.push(`### Start service
-\`POST ${trpcBase}/process.start\`
-Body: \`{"agentId":"<agentId>","processId":"<serviceId>"}\``);
-  lines.push("");
-  lines.push(`### Stop service
-\`POST ${trpcBase}/process.stop\`
-Body: \`{"agentId":"<agentId>","processId":"<serviceId>"}\``);
-  lines.push("");
-  lines.push(`### Restart service
-\`POST ${trpcBase}/process.restart\`
-Body: \`{"agentId":"<agentId>","processId":"<serviceId>"}\``);
-  lines.push("");
-  lines.push(`### Get service status
-\`GET ${trpcBase}/process.status?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
-  lines.push("");
-  return lines.join("\n");
-}
-function generateLlmsTxt(apiKey, services) {
-  const { scopes } = apiKey;
-  const baseUrl = `http://localhost:${env.PORT}`;
-  const trpcBase = `${baseUrl}/api/trpc`;
-  const lines = [];
-  lines.push("# Runeya \u2014 Service Management API");
-  lines.push("");
-  lines.push("> This file describes the API surface available for this key.");
-  lines.push(`> Base URL: ${trpcBase}`);
-  lines.push(`> Authentication: pass this key as \`Authorization: Bearer ${apiKey.key}\` on all tRPC requests.`);
-  lines.push("");
-  if (services.length === 0) {
-    lines.push("No services accessible with this key.");
-    return lines.join("\n");
-  }
-  const permByServiceId = new Map(
-    scopes.services.map((p) => [p.serviceId, p])
-  );
-  lines.push("## Services");
-  lines.push("");
-  for (const svc of services) {
-    const perm = permByServiceId.get(svc.id);
-    const actions = perm?.actions ?? [];
-    lines.push(`### ${svc.name}`);
-    lines.push(`- **ID**: \`${svc.id}\``);
-    if (svc.agentId) lines.push(`- **Agent ID**: \`${svc.agentId}\``);
-    if (svc.description) lines.push(`- **Description**: ${svc.description}`);
-    if (svc.cwd) lines.push(`- **Working directory**: \`${svc.cwd}\``);
-    lines.push("- **Permitted actions**:");
-    if (actions.length === 0) {
-      lines.push("  - _(none)_");
-    } else {
-      for (const a of actions) lines.push(`  - \`${a}\``);
-    }
-    const envPerms = perm?.environments ?? [];
-    if (envPerms.length > 0) {
-      lines.push("- **Environment access**:");
-      for (const ep of envPerms) {
-        const envActions = ep.actions.join(", ");
-        const secrets = ep.includeSecrets ? " _(includes secrets)_" : "";
-        lines.push(`  - \`${ep.environmentId}\`: ${envActions}${secrets}`);
-      }
-    }
-    lines.push("");
-  }
-  lines.push("## API Reference");
-  lines.push("");
-  lines.push("All endpoints use tRPC v11 over HTTP (`Content-Type: application/json`).");
-  lines.push("");
-  lines.push("**Important \u2014 tRPC v11 request format:**");
-  lines.push('- **GET queries**: pass input as a plain JSON-encoded string in the `input` query param (no `{"json":...}` wrapper).');
-  lines.push('  Example: `?input={"id":"abc"}`');
-  lines.push('- **POST mutations**: send the input object as a plain JSON body (no `{"json":...}` wrapper).');
-  lines.push('  Example body: `{"agentId":"<agentId>","processId":"<serviceId>"}`');
-  lines.push("- The `agentId` is listed per service above.");
-  lines.push("- The `processId` is the same as the service `ID` listed above.");
-  lines.push("");
-  const allActions = new Set(scopes.services.flatMap((p) => p.actions));
-  const hasEnvRead = scopes.services.some((p) => p.environments.some((e) => e.actions.includes("env:read")));
-  const hasEnvWrite = scopes.services.some((p) => p.environments.some((e) => e.actions.includes("env:write")));
-  if (allActions.has("service:read")) {
-    lines.push("### List services");
-    lines.push(`\`GET ${trpcBase}/service.list\``);
-    lines.push("");
-    lines.push("### Get service");
-    lines.push(`\`GET ${trpcBase}/service.get?input={"agentId":"<agentId>","id":"<serviceId>"}\``);
-    lines.push("");
-  }
-  if (allActions.has("logs:read")) {
-    lines.push("### Read logs");
-    lines.push(`\`GET ${trpcBase}/process.logs?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
-    lines.push("");
-  }
-  if (allActions.has("service:start")) {
-    lines.push("### Start service");
-    lines.push(`\`POST ${trpcBase}/process.start\``);
-    lines.push('Body: `{"agentId":"<agentId>","processId":"<serviceId>"}`');
-    lines.push("");
-  }
-  if (allActions.has("service:stop")) {
-    lines.push("### Stop service");
-    lines.push(`\`POST ${trpcBase}/process.stop\``);
-    lines.push('Body: `{"agentId":"<agentId>","processId":"<serviceId>"}`');
-    lines.push("");
-  }
-  if (allActions.has("service:restart")) {
-    lines.push("### Restart service");
-    lines.push(`\`POST ${trpcBase}/process.restart\``);
-    lines.push('Body: `{"agentId":"<agentId>","processId":"<serviceId>"}`');
-    lines.push("");
-  }
-  if (allActions.has("service:status")) {
-    lines.push("### Get service status");
-    lines.push(`\`GET ${trpcBase}/process.status?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
-    lines.push("");
-  }
-  if (allActions.has("service:healthcheck")) {
-    lines.push("### Get service health");
-    lines.push(`\`GET ${trpcBase}/process.health?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
-    lines.push("");
-  }
-  if (hasEnvRead) {
-    lines.push("### Read environment variables (flat KEY=VALUE \u2014 secrets shown as *****)");
-    lines.push(`\`GET ${trpcBase}/environment.resolveFlat?input={"environmentId":"<environmentId>"}\``);
-    lines.push("Returns a flat `Record<string, string>`. Secret variables you are not authorized to see are shown as `*****`.");
-    lines.push("");
-  }
-  if (hasEnvWrite) {
-    lines.push("### Write environment variable");
-    lines.push(`\`POST ${trpcBase}/environment.upsertVariable\``);
-    lines.push('Body: `{"environmentId":"<environmentId>","key":"<key>","value":"<value>"}`');
-    lines.push("");
-  }
-  return lines.join("\n");
-}
 var RUNEYA_CAPABILITIES = [
   {
     name: "list_services",
@@ -3406,43 +3223,8 @@ async function callTrpc(baseUrl, route, method, input, authToken) {
   const result = json["result"];
   return result?.["data"] ?? result ?? json;
 }
-var CHAT_TOOLS = buildAnthropicTools(RUNEYA_CAPABILITIES);
-var CHAT_TOOLS_OPENAI = buildOpenAITools(RUNEYA_CAPABILITIES);
-var TOOL_SAFETY_INSTRUCTION = buildToolSafetyInstruction(RUNEYA_CAPABILITIES);
-function hasServiceAction(apiKey, serviceId, action) {
-  if (!apiKey) return true;
-  const perm = apiKey.scopes.services.find((p) => p.serviceId === serviceId);
-  return perm?.actions.includes(action) ?? false;
-}
-var KNOWN_TOOL_NAMES = RUNEYA_CAPABILITIES.map((c) => c.name);
-function normalizeToolName(raw) {
-  if (KNOWN_TOOL_NAMES.includes(raw)) return raw;
-  const match = KNOWN_TOOL_NAMES.find((t2) => raw.startsWith(t2));
-  return match ?? raw;
-}
-async function executeTool(rawName, input, apiKey, authToken) {
-  const name = normalizeToolName(rawName);
-  const cap = RUNEYA_CAPABILITIES.find((c) => c.name === name);
-  if (!cap) throw new Error(`Unknown tool: ${name}`);
-  const serviceId = input["serviceId"] ?? input["id"] ?? input["processId"];
-  if (serviceId) {
-    const actionMap = {
-      get_service_status: "service:status",
-      get_logs: "logs:read",
-      start_service: "service:start",
-      stop_service: "service:stop",
-      restart_service: "service:restart"
-    };
-    const action = actionMap[name];
-    if (action && !hasServiceAction(apiKey, serviceId, action)) {
-      throw new Error(`No '${action}' permission for service ${serviceId}`);
-    }
-  }
-  const params = Object.fromEntries(
-    Object.entries(input).map(([k, v]) => [k, v != null ? String(v) : void 0])
-  );
-  const baseUrl = `http://localhost:${env.PORT}`;
-  return callTrpc(baseUrl, cap.route, cap.method, cap.buildInput(params), authToken);
+function buildApiDocs(apiBaseUrl, apiToken) {
+  return buildPromptDocs(apiBaseUrl, apiToken, RUNEYA_CAPABILITIES);
 }
 var FILENAME3 = "conversations.private.json";
 var ConversationStore = class {
@@ -3508,7 +3290,6 @@ var ConversationStore = class {
   async load() {
     if (this.loaded) return;
     if (!getEncryptionKey()) {
-      this.loaded = true;
       return;
     }
     try {
@@ -3580,7 +3361,7 @@ var ConversationStore = class {
     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;
-    conv.updatedAt = Date.now();
+    if (options?.touch !== false) conv.updatedAt = Date.now();
     await this.save();
     if (!options?.silent) {
       this.events.emit("changed", { type: "updated", conversation: this.snapshotConversation(conv) });
@@ -3618,14 +3399,430 @@ var ConversationStore = class {
       this.events.emit("changed", { type: "deleted", id });
     }
   }
-  onChanged(handler) {
-    this.events.on("changed", handler);
+  onChanged(handler) {
+    this.events.on("changed", handler);
+  }
+  offChanged(handler) {
+    this.events.off("changed", handler);
+  }
+};
+var conversationStore = new ConversationStore();
+var PROJECTS_DIR = join10(homedir3(), ".claude", "projects");
+var DEFAULT_TITLES = /* @__PURE__ */ new Set(["", "New conversation", "Nouvelle conversation"]);
+async function findClaudeSessionFile(sessionId) {
+  let entries;
+  try {
+    entries = await readdir2(PROJECTS_DIR);
+  } catch {
+    return null;
+  }
+  const filename = `${sessionId}.jsonl`;
+  for (const dir of entries) {
+    const candidate = join10(PROJECTS_DIR, dir, filename);
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function claudeSessionExists(sessionId) {
+  return await findClaudeSessionFile(sessionId) !== null;
+}
+async function readClaudeTranscript(sessionId) {
+  const path = await findClaudeSessionFile(sessionId);
+  if (!path) return { found: false, path: null, entries: [] };
+  const raw = await readFile8(path, "utf-8");
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return { found: true, path, entries };
+}
+function claudeEntriesToMessages(entries) {
+  const messages = [];
+  const toolPartById = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.type !== "user" && entry.type !== "assistant") continue;
+    const msg = entry.message;
+    if (!msg) continue;
+    const role = msg.role === "user" || msg.role === "assistant" ? msg.role : entry.type;
+    const content = msg.content;
+    const texts = [];
+    const parts = [];
+    let consumedByToolResult = false;
+    if (typeof content === "string") {
+      texts.push(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        if (typeof block === "string") {
+          texts.push(block);
+          continue;
+        }
+        if (!block || typeof block !== "object") continue;
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string") {
+          texts.push(b.text);
+          parts.push({ type: "text", text: b.text });
+        } else if (b.type === "tool_use" && b.id) {
+          const part = {
+            type: "tool",
+            id: b.id,
+            name: b.name ?? "tool",
+            input: b.input,
+            pending: true
+          };
+          parts.push(part);
+          toolPartById.set(b.id, part);
+        } else if (b.type === "tool_result" && b.tool_use_id) {
+          const target = toolPartById.get(b.tool_use_id);
+          if (target) {
+            target.result = b.content;
+            target.isError = b.is_error;
+            target.pending = false;
+          }
+          consumedByToolResult = true;
+        }
+      }
+    }
+    if (role === "user" && consumedByToolResult && texts.length === 0) continue;
+    const last = messages[messages.length - 1];
+    if (last && last.role === role) {
+      const joinedText = [last.content, texts.join("\n").trim()].filter(Boolean).join("\n");
+      last.content = joinedText;
+      if (parts.length > 0) {
+        last.parts = [...last.parts ?? [], ...parts];
+      }
+      continue;
+    }
+    messages.push({
+      role,
+      content: texts.join("\n").trim(),
+      parts: parts.length > 0 ? parts : void 0
+    });
+  }
+  return messages;
+}
+async function syncConversationFromClaudeTranscript(conversationId) {
+  const conv = await conversationStore.get(conversationId);
+  if (!conv) return false;
+  const transcript = await readClaudeTranscript(conversationId);
+  if (!transcript.found) return false;
+  const messages = claudeEntriesToMessages(transcript.entries);
+  const isDefaultTitle = !conv.title || DEFAULT_TITLES.has(conv.title);
+  const sameLength = messages.length === conv.messages.length;
+  const sameLastContent = sameLength && (messages.at(-1)?.content ?? "") === (conv.messages.at(-1)?.content ?? "");
+  if (sameLength && sameLastContent && !isDefaultTitle) {
+    return false;
+  }
+  const patch = { messages };
+  if (isDefaultTitle) {
+    const firstUserMsg = messages.find((m) => m.role === "user" && m.content.trim().length > 0);
+    if (firstUserMsg) {
+      const firstLine = firstUserMsg.content.split("\n")[0].trim();
+      patch.title = firstLine.length > 80 ? firstLine.slice(0, 80) + "\u2026" : firstLine;
+    }
+  }
+  await conversationStore.update(conversationId, patch, { touch: false });
+  return true;
+}
+var lastTranscriptActivity = /* @__PURE__ */ new Map();
+function getLastTranscriptActivity(sessionId) {
+  return lastTranscriptActivity.get(sessionId) ?? null;
+}
+var started = false;
+var watchers = [];
+var pendingResyncs = /* @__PURE__ */ new Map();
+var RESYNC_DEBOUNCE_MS = 250;
+function scheduleResync(sessionId) {
+  const existing = pendingResyncs.get(sessionId);
+  if (existing) clearTimeout(existing);
+  pendingResyncs.set(
+    sessionId,
+    setTimeout(() => {
+      pendingResyncs.delete(sessionId);
+      syncConversationFromClaudeTranscript(sessionId).catch((err) => {
+        console.warn("[claude-transcript-sync] resync failed for", sessionId, err);
+      });
+    }, RESYNC_DEBOUNCE_MS)
+  );
+}
+function handleFsEvent(filename) {
+  if (!filename) return;
+  if (!filename.endsWith(".jsonl")) return;
+  const base = filename.split("/").pop();
+  const sessionId = base.slice(0, -".jsonl".length);
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId)) return;
+  lastTranscriptActivity.set(sessionId, Date.now());
+  scheduleResync(sessionId);
+}
+async function startClaudeTranscriptWatcher() {
+  if (started) return;
+  started = true;
+  let topLevel;
+  try {
+    topLevel = await readdir2(PROJECTS_DIR);
+  } catch {
+    return;
+  }
+  try {
+    const w = watch(PROJECTS_DIR, { recursive: true }, (_event, filename) => {
+      handleFsEvent(filename ? filename.toString() : null);
+    });
+    w.on("error", (err) => console.warn("[claude-transcript-sync] watcher error:", err));
+    watchers.push(w);
+    return;
+  } catch {
+  }
+  for (const dir of topLevel) {
+    try {
+      const w = watch(join10(PROJECTS_DIR, dir), (_event, filename) => {
+        handleFsEvent(filename ? filename.toString() : null);
+      });
+      w.on("error", () => {
+      });
+      watchers.push(w);
+    } catch {
+    }
+  }
+}
+var Id128Schema = z13.string().max(128);
+var ConversationIdSchema = z13.string().max(128);
+var NameSchema = z13.string().min(1).max(200);
+var ShortString200Schema = z13.string().max(200);
+var DescriptionSchema = z13.string().max(2e3);
+var OptionalProviderIdSchema = Id128Schema.optional();
+function generateAdminLlmsTxt(services, jwt) {
+  const baseUrl = `http://localhost:${env.PORT}`;
+  const trpcBase = `${baseUrl}/api/trpc`;
+  const lines = [];
+  lines.push("# Runeya \u2014 Service Management API");
+  lines.push("");
+  lines.push("> You are operating as an authenticated admin with full access to all services.");
+  lines.push(`> Base URL: ${trpcBase}`);
+  if (jwt) {
+    lines.push("> Authentication: pass `Authorization: Bearer $RUNEYA_API_TOKEN` on all tRPC requests.");
+  }
+  lines.push("");
+  if (services.length === 0) {
+    lines.push("No services configured.");
+    return lines.join("\n");
+  }
+  lines.push("## Services");
+  lines.push("");
+  for (const svc of services) {
+    lines.push(`### ${svc.name}`);
+    lines.push(`- **ID**: \`${svc.id}\``);
+    if (svc.agentId) lines.push(`- **Agent ID**: \`${svc.agentId}\``);
+    if (svc.description) lines.push(`- **Description**: ${svc.description}`);
+    if (svc.cwd) lines.push(`- **Working directory**: \`${svc.cwd}\``);
+    lines.push("- **Permitted actions**: all");
+    lines.push("");
+  }
+  lines.push("## MCP Tools");
+  lines.push("");
+  lines.push("You have access to Runeya MCP tools to manage services. **Always prefer MCP tools** over raw HTTP calls.");
+  lines.push("Available tools: `list_services`, `get_service_status`, `start_service`, `stop_service`, `restart_service`, `get_logs`.");
+  lines.push("");
+  if (jwt) {
+    lines.push("**Important**: Pass the `authToken` parameter with value `$RUNEYA_API_TOKEN` (from environment) on every MCP tool call for authentication.");
+    lines.push("");
+  }
+  lines.push("Use the service IDs and agent IDs listed above when calling these tools.");
+  lines.push("");
+  lines.push("## API Reference (fallback)");
+  lines.push("");
+  lines.push("Only use raw HTTP calls if MCP tools are unavailable.");
+  lines.push("All endpoints use tRPC v11 over HTTP (`Content-Type: application/json`).");
+  lines.push("");
+  lines.push("**tRPC v11 request format:**");
+  lines.push('- **GET queries**: `?input={"id":"abc"}`');
+  lines.push('- **POST mutations**: JSON body `{"agentId":"<agentId>","processId":"<serviceId>"}`');
+  lines.push("");
+  lines.push(`### List services
+\`GET ${trpcBase}/service.list\``);
+  lines.push("");
+  lines.push(`### Get service
+\`GET ${trpcBase}/service.get?input={"agentId":"<agentId>","id":"<serviceId>"}\``);
+  lines.push("");
+  lines.push(`### Read logs
+\`GET ${trpcBase}/process.logs?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
+  lines.push("");
+  lines.push(`### Start service
+\`POST ${trpcBase}/process.start\`
+Body: \`{"agentId":"<agentId>","processId":"<serviceId>"}\``);
+  lines.push("");
+  lines.push(`### Stop service
+\`POST ${trpcBase}/process.stop\`
+Body: \`{"agentId":"<agentId>","processId":"<serviceId>"}\``);
+  lines.push("");
+  lines.push(`### Restart service
+\`POST ${trpcBase}/process.restart\`
+Body: \`{"agentId":"<agentId>","processId":"<serviceId>"}\``);
+  lines.push("");
+  lines.push(`### Get service status
+\`GET ${trpcBase}/process.status?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
+  lines.push("");
+  return lines.join("\n");
+}
+function generateLlmsTxt(apiKey, services) {
+  const { scopes } = apiKey;
+  const baseUrl = `http://localhost:${env.PORT}`;
+  const trpcBase = `${baseUrl}/api/trpc`;
+  const lines = [];
+  lines.push("# Runeya \u2014 Service Management API");
+  lines.push("");
+  lines.push("> This file describes the API surface available for this key.");
+  lines.push(`> Base URL: ${trpcBase}`);
+  lines.push(`> Authentication: pass this key as \`Authorization: Bearer ${apiKey.key}\` on all tRPC requests.`);
+  lines.push("");
+  if (services.length === 0) {
+    lines.push("No services accessible with this key.");
+    return lines.join("\n");
+  }
+  const permByServiceId = new Map(
+    scopes.services.map((p) => [p.serviceId, p])
+  );
+  lines.push("## Services");
+  lines.push("");
+  for (const svc of services) {
+    const perm = permByServiceId.get(svc.id);
+    const actions = perm?.actions ?? [];
+    lines.push(`### ${svc.name}`);
+    lines.push(`- **ID**: \`${svc.id}\``);
+    if (svc.agentId) lines.push(`- **Agent ID**: \`${svc.agentId}\``);
+    if (svc.description) lines.push(`- **Description**: ${svc.description}`);
+    if (svc.cwd) lines.push(`- **Working directory**: \`${svc.cwd}\``);
+    lines.push("- **Permitted actions**:");
+    if (actions.length === 0) {
+      lines.push("  - _(none)_");
+    } else {
+      for (const a of actions) lines.push(`  - \`${a}\``);
+    }
+    const envPerms = perm?.environments ?? [];
+    if (envPerms.length > 0) {
+      lines.push("- **Environment access**:");
+      for (const ep of envPerms) {
+        const envActions = ep.actions.join(", ");
+        const secrets = ep.includeSecrets ? " _(includes secrets)_" : "";
+        lines.push(`  - \`${ep.environmentId}\`: ${envActions}${secrets}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("## API Reference");
+  lines.push("");
+  lines.push("All endpoints use tRPC v11 over HTTP (`Content-Type: application/json`).");
+  lines.push("");
+  lines.push("**Important \u2014 tRPC v11 request format:**");
+  lines.push('- **GET queries**: pass input as a plain JSON-encoded string in the `input` query param (no `{"json":...}` wrapper).');
+  lines.push('  Example: `?input={"id":"abc"}`');
+  lines.push('- **POST mutations**: send the input object as a plain JSON body (no `{"json":...}` wrapper).');
+  lines.push('  Example body: `{"agentId":"<agentId>","processId":"<serviceId>"}`');
+  lines.push("- The `agentId` is listed per service above.");
+  lines.push("- The `processId` is the same as the service `ID` listed above.");
+  lines.push("");
+  const allActions = new Set(scopes.services.flatMap((p) => p.actions));
+  const hasEnvRead = scopes.services.some((p) => p.environments.some((e) => e.actions.includes("env:read")));
+  const hasEnvWrite = scopes.services.some((p) => p.environments.some((e) => e.actions.includes("env:write")));
+  if (allActions.has("service:read")) {
+    lines.push("### List services");
+    lines.push(`\`GET ${trpcBase}/service.list\``);
+    lines.push("");
+    lines.push("### Get service");
+    lines.push(`\`GET ${trpcBase}/service.get?input={"agentId":"<agentId>","id":"<serviceId>"}\``);
+    lines.push("");
+  }
+  if (allActions.has("logs:read")) {
+    lines.push("### Read logs");
+    lines.push(`\`GET ${trpcBase}/process.logs?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
+    lines.push("");
+  }
+  if (allActions.has("service:start")) {
+    lines.push("### Start service");
+    lines.push(`\`POST ${trpcBase}/process.start\``);
+    lines.push('Body: `{"agentId":"<agentId>","processId":"<serviceId>"}`');
+    lines.push("");
+  }
+  if (allActions.has("service:stop")) {
+    lines.push("### Stop service");
+    lines.push(`\`POST ${trpcBase}/process.stop\``);
+    lines.push('Body: `{"agentId":"<agentId>","processId":"<serviceId>"}`');
+    lines.push("");
+  }
+  if (allActions.has("service:restart")) {
+    lines.push("### Restart service");
+    lines.push(`\`POST ${trpcBase}/process.restart\``);
+    lines.push('Body: `{"agentId":"<agentId>","processId":"<serviceId>"}`');
+    lines.push("");
+  }
+  if (allActions.has("service:status")) {
+    lines.push("### Get service status");
+    lines.push(`\`GET ${trpcBase}/process.status?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
+    lines.push("");
+  }
+  if (allActions.has("service:healthcheck")) {
+    lines.push("### Get service health");
+    lines.push(`\`GET ${trpcBase}/process.health?input={"agentId":"<agentId>","processId":"<serviceId>"}\``);
+    lines.push("");
+  }
+  if (hasEnvRead) {
+    lines.push("### Read environment variables (flat KEY=VALUE \u2014 secrets shown as *****)");
+    lines.push(`\`GET ${trpcBase}/environment.resolveFlat?input={"environmentId":"<environmentId>"}\``);
+    lines.push("Returns a flat `Record<string, string>`. Secret variables you are not authorized to see are shown as `*****`.");
+    lines.push("");
   }
-  offChanged(handler) {
-    this.events.off("changed", handler);
+  if (hasEnvWrite) {
+    lines.push("### Write environment variable");
+    lines.push(`\`POST ${trpcBase}/environment.upsertVariable\``);
+    lines.push('Body: `{"environmentId":"<environmentId>","key":"<key>","value":"<value>"}`');
+    lines.push("");
   }
-};
-var conversationStore = new ConversationStore();
+  return lines.join("\n");
+}
+var CHAT_TOOLS = buildAnthropicTools(RUNEYA_CAPABILITIES);
+var CHAT_TOOLS_OPENAI = buildOpenAITools(RUNEYA_CAPABILITIES);
+var TOOL_SAFETY_INSTRUCTION = buildToolSafetyInstruction(RUNEYA_CAPABILITIES);
+function hasServiceAction(apiKey, serviceId, action) {
+  if (!apiKey) return true;
+  const perm = apiKey.scopes.services.find((p) => p.serviceId === serviceId);
+  return perm?.actions.includes(action) ?? false;
+}
+var KNOWN_TOOL_NAMES = RUNEYA_CAPABILITIES.map((c) => c.name);
+function normalizeToolName(raw) {
+  if (KNOWN_TOOL_NAMES.includes(raw)) return raw;
+  const match = KNOWN_TOOL_NAMES.find((t2) => raw.startsWith(t2));
+  return match ?? raw;
+}
+async function executeTool(rawName, input, apiKey, authToken) {
+  const name = normalizeToolName(rawName);
+  const cap = RUNEYA_CAPABILITIES.find((c) => c.name === name);
+  if (!cap) throw new Error(`Unknown tool: ${name}`);
+  const serviceId = input["serviceId"] ?? input["id"] ?? input["processId"];
+  if (serviceId) {
+    const actionMap = {
+      get_service_status: "service:status",
+      get_logs: "logs:read",
+      start_service: "service:start",
+      stop_service: "service:stop",
+      restart_service: "service:restart"
+    };
+    const action = actionMap[name];
+    if (action && !hasServiceAction(apiKey, serviceId, action)) {
+      throw new Error(`No '${action}' permission for service ${serviceId}`);
+    }
+  }
+  const params = Object.fromEntries(
+    Object.entries(input).map(([k, v]) => [k, v != null ? String(v) : void 0])
+  );
+  const baseUrl = `http://localhost:${env.PORT}`;
+  return callTrpc(baseUrl, cap.route, cap.method, cap.buildInput(params), authToken);
+}
 var MONTHS = {
   jan: 0,
   feb: 1,
@@ -4337,7 +4534,7 @@ async function atomicWriteJsonSecure(filePath, data, pretty = false) {
 }
 async function readJsonFileSafe(filePath) {
   try {
-    const raw = await readFile8(filePath, "utf-8");
+    const raw = await readFile9(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -4383,8 +4580,8 @@ var ScenarioRunStore = class _ScenarioRunStore {
       "- Use read-only references from linked upstream files as context.",
       ""
     ].join("\n");
-    await atomicWriteSecure(join10(dir, "README.md"), overview);
-    await atomicWriteSecure(join10(dir, "USER_REQUEST.md"), `# User request
+    await atomicWriteSecure(join11(dir, "README.md"), overview);
+    await atomicWriteSecure(join11(dir, "USER_REQUEST.md"), `# User request
 
 ${userInput.trim() || "(empty)"}
 `);
@@ -4410,7 +4607,7 @@ ${userInput.trim() || "(empty)"}
         "- Waiting for assignment.",
         ""
       ].join("\n");
-      await atomicWriteSecure(join10(dir, fileName), content);
+      await atomicWriteSecure(join11(dir, fileName), content);
     }
   }
   async deleteRunDir(conversationId) {
@@ -4420,11 +4617,32 @@ ${userInput.trim() || "(empty)"}
   ensureRunState(conversationId) {
     let runState = this.activeRuns.get(conversationId);
     if (!runState) {
-      runState = { nodeStates: {}, nodeOutputs: {}, waitingInputs: {} };
+      runState = { nodeStates: {}, nodeOutputs: {}, nodeSessionIds: {}, nodeAgentIds: {}, waitingInputs: {} };
       this.activeRuns.set(conversationId, runState);
     }
     return runState;
   }
+  setNodeSession(conversationId, nodeId, sessionId, agentId) {
+    const rs = this.ensureRunState(conversationId);
+    rs.nodeSessionIds[nodeId] = sessionId;
+    rs.nodeAgentIds[nodeId] = agentId;
+  }
+  getNodeSession(conversationId, nodeId) {
+    const rs = this.activeRuns.get(conversationId);
+    const sessionId = rs?.nodeSessionIds[nodeId];
+    const agentId = rs?.nodeAgentIds[nodeId];
+    if (sessionId && agentId) return { sessionId, agentId };
+    return null;
+  }
+  async getNodeSessionPersistent(conversationId, nodeId) {
+    const live = this.getNodeSession(conversationId, nodeId);
+    if (live) return live;
+    const persisted = await this.loadPersistedRunState(conversationId);
+    const sessionId = persisted?.nodeSessionIds?.[nodeId];
+    const agentId = persisted?.nodeAgentIds?.[nodeId];
+    if (sessionId && agentId) return { sessionId, agentId };
+    return null;
+  }
   setNodeState(conversationId, nodeId, state) {
     this.ensureRunState(conversationId).nodeStates[nodeId] = state;
   }
@@ -4453,20 +4671,22 @@ ${userInput.trim() || "(empty)"}
       const data = {
         nodeStates: { ...runState.nodeStates },
         nodeOutputs: { ...runState.nodeOutputs },
+        ...Object.keys(runState.nodeSessionIds).length > 0 ? { nodeSessionIds: { ...runState.nodeSessionIds } } : {},
+        ...Object.keys(runState.nodeAgentIds).length > 0 ? { nodeAgentIds: { ...runState.nodeAgentIds } } : {},
         ...Object.keys(runState.waitingInputs).length > 0 ? { waitingInputs: { ...runState.waitingInputs } } : {}
       };
-      await atomicWriteJsonSecure(join10(dir, "run-state.json"), data);
+      await atomicWriteJsonSecure(join11(dir, "run-state.json"), data);
     } catch {
     }
   }
   async loadPersistedRunState(conversationId) {
     const dir = this.getRunDir(conversationId);
-    return readJsonFileSafe(join10(dir, "run-state.json"));
+    return readJsonFileSafe(join11(dir, "run-state.json"));
   }
   async readUserRequest(conversationId) {
     try {
       const dir = this.getRunDir(conversationId);
-      const content = await readFile9(join10(dir, "USER_REQUEST.md"), "utf-8");
+      const content = await readFile10(join11(dir, "USER_REQUEST.md"), "utf-8");
       return content.replace(/^#\s*User request\s*\n+/, "").trim() || null;
     } catch {
       return null;
@@ -4475,7 +4695,7 @@ ${userInput.trim() || "(empty)"}
   async readReadme(conversationId) {
     try {
       const dir = this.getRunDir(conversationId);
-      return await readFile9(join10(dir, "README.md"), "utf-8");
+      return await readFile10(join11(dir, "README.md"), "utf-8");
     } catch {
       return null;
     }
@@ -4484,14 +4704,14 @@ ${userInput.trim() || "(empty)"}
     const dir = this.getRunDir(conversationId);
     await mkdir10(dir, { recursive: true });
     await atomicWriteJsonSecure(
-      join10(dir, _ScenarioRunStore.SCENARIO_SNAPSHOT_FILE),
+      join11(dir, _ScenarioRunStore.SCENARIO_SNAPSHOT_FILE),
       scenario,
       true
     );
   }
   async loadScenarioSnapshot(conversationId) {
     const dir = this.getRunDir(conversationId);
-    return readJsonFileSafe(join10(dir, _ScenarioRunStore.SCENARIO_SNAPSHOT_FILE));
+    return readJsonFileSafe(join11(dir, _ScenarioRunStore.SCENARIO_SNAPSHOT_FILE));
   }
 };
 var scenarioRunStore = new ScenarioRunStore();
@@ -4566,7 +4786,7 @@ var ImageStorageService = class {
     const imageId = randomUUID4();
     const safeExt = ext.replace(/[^a-z.]/g, "");
     const fileName = `${imageId}${safeExt}`;
-    const filePath = join11(this.dir, fileName);
+    const filePath = join12(this.dir, fileName);
     const resolvedPath = resolve3(filePath);
     const resolvedDir = resolve3(this.dir);
     if (resolvedPath !== resolvedDir && !resolvedPath.startsWith(resolvedDir + sep2)) {
@@ -4580,10 +4800,10 @@ var ImageStorageService = class {
   async getImagePath(imageId) {
     if (!UUID_RE.test(imageId)) return null;
     try {
-      const files = await readdir2(this.dir);
+      const files = await readdir3(this.dir);
       const metaFile = files.find((f) => f.startsWith(imageId) && f.endsWith(".meta.json"));
       if (!metaFile) return null;
-      const raw = JSON.parse(await readFile10(join11(this.dir, metaFile), "utf-8"));
+      const raw = JSON.parse(await readFile11(join12(this.dir, metaFile), "utf-8"));
       if (!existsSync(raw.filePath)) return null;
       return { filePath: raw.filePath, mimeType: raw.mimeType };
     } catch {
@@ -4601,14 +4821,14 @@ var ImageStorageService = class {
   async deleteByContextId(contextId) {
     let files;
     try {
-      files = await readdir2(this.dir);
+      files = await readdir3(this.dir);
     } catch {
       return;
     }
     await Promise.all(
       files.filter((f) => f.endsWith(".meta.json")).map(async (file) => {
         try {
-          const raw = JSON.parse(await readFile10(join11(this.dir, file), "utf-8"));
+          const raw = JSON.parse(await readFile11(join12(this.dir, file), "utf-8"));
           if (raw.contextId === contextId) {
             await unlink2(raw.filePath).catch(() => {
             });
@@ -4623,14 +4843,14 @@ var ImageStorageService = class {
   async readImageAsBase64(imageId) {
     const result = await this.getImagePath(imageId);
     if (!result) return null;
-    const buffer = await readFile10(result.filePath);
+    const buffer = await readFile11(result.filePath);
     return { base64: buffer.toString("base64"), mimeType: result.mimeType };
   }
   async listExpiredImages(ttlMs = IMAGE_TTL_MS) {
     const expired = [];
     let files;
     try {
-      files = await readdir2(this.dir);
+      files = await readdir3(this.dir);
     } catch {
       return [];
     }
@@ -4638,7 +4858,7 @@ var ImageStorageService = class {
     for (const file of files) {
       if (!file.endsWith(".meta.json")) continue;
       try {
-        const raw = JSON.parse(await readFile10(join11(this.dir, file), "utf-8"));
+        const raw = JSON.parse(await readFile11(join12(this.dir, file), "utf-8"));
         if (now - raw.createdAt > ttlMs) expired.push(raw);
       } catch {
       }
@@ -4698,9 +4918,6 @@ async function resolveImagesToBase64(images) {
   );
   return results.filter((r) => r !== null);
 }
-function buildApiDocs(apiBaseUrl, apiToken) {
-  return buildPromptDocs(apiBaseUrl, apiToken, RUNEYA_CAPABILITIES);
-}
 function parseEndToken(output) {
   const tail = output.trimEnd().slice(-2e3);
   const branchMatch = tail.match(/<pass\s+branch="(\d+)"\s*\/>/);
@@ -4732,8 +4949,297 @@ var TOKEN_INSTRUCTIONS = `
 
 Ne jamais omettre ce tag. Il doit \xEAtre la toute derni\xE8re ligne de ta r\xE9ponse.
 `.trim();
+async function waitForFile(sessionId, signal, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (signal.aborted) throw new Error("Aborted");
+    const path = await findClaudeSessionFile(sessionId);
+    if (path) return path;
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  throw new Error(`Transcript file for session ${sessionId} never appeared (timeout ${timeoutMs}ms)`);
+}
+function tailTranscript(opts) {
+  const { sessionId, signal, onEntry, fileAppearTimeoutMs = 3e4 } = opts;
+  let stopped = false;
+  let watcher = null;
+  let fh = null;
+  let offset = 0;
+  let pendingBuf = "";
+  let reading = false;
+  let queuedRead = false;
+  const cleanup = async () => {
+    stopped = true;
+    if (watcher) {
+      try {
+        watcher.close();
+      } catch {
+      }
+      watcher = null;
+    }
+    if (fh) {
+      try {
+        await fh.close();
+      } catch {
+      }
+      fh = null;
+    }
+  };
+  const drainBuffer = () => {
+    let idx;
+    while ((idx = pendingBuf.indexOf("\n")) >= 0) {
+      const line = pendingBuf.slice(0, idx).trim();
+      pendingBuf = pendingBuf.slice(idx + 1);
+      if (!line) continue;
+      try {
+        const entry = JSON.parse(line);
+        onEntry(entry);
+      } catch {
+      }
+    }
+  };
+  const readMore = async () => {
+    if (!fh || stopped) return;
+    if (reading) {
+      queuedRead = true;
+      return;
+    }
+    reading = true;
+    try {
+      while (!stopped) {
+        const st = await fh.stat();
+        if (st.size <= offset) break;
+        const len = st.size - offset;
+        const buf = Buffer.alloc(len);
+        const { bytesRead } = await fh.read(buf, 0, len, offset);
+        if (bytesRead <= 0) break;
+        offset += bytesRead;
+        pendingBuf += buf.slice(0, bytesRead).toString("utf-8");
+        drainBuffer();
+      }
+    } finally {
+      reading = false;
+      if (queuedRead && !stopped) {
+        queuedRead = false;
+        void readMore();
+      }
+    }
+  };
+  const whenDone = (async () => {
+    const onAbort = () => {
+      void cleanup();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      const path = await waitForFile(sessionId, signal, fileAppearTimeoutMs);
+      if (stopped) return;
+      fh = await open(path, "r");
+      await readMore();
+      if (stopped) return;
+      watcher = watch2(path, { persistent: false }, () => {
+        void readMore();
+      });
+      watcher.on("error", () => {
+      });
+      const poll = setInterval(() => {
+        void readMore();
+      }, 500);
+      await new Promise((resolve5) => {
+        const tick = setInterval(() => {
+          if (stopped) {
+            clearInterval(tick);
+            clearInterval(poll);
+            resolve5();
+          }
+        }, 100);
+      });
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+      await cleanup();
+    }
+  })();
+  return {
+    stop: () => {
+      void cleanup();
+    },
+    whenDone
+  };
+}
 async function getAgentManager() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-UP3PJ35X-LO6B3XKF.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-V47DLMYP-26VYXTSG.js");
+  return agentManager2;
+}
+function buildPtyArgs(params, sessionId, opts) {
+  const { isResume, systemContext, apiBaseUrl, apiToken, model, mcpConfig, skipTokenInstructions, prompt } = params;
+  const sessionArg = isResume ? ["--resume", sessionId] : ["--session-id", sessionId];
+  const apiDocs = buildApiDocs(apiBaseUrl, apiToken);
+  const fullSystemContext = apiDocs ? `${systemContext}
+
+${apiDocs}` : systemContext;
+  const systemPrompt = skipTokenInstructions ? fullSystemContext : `${fullSystemContext}
+
+${TOKEN_INSTRUCTIONS}`;
+  const mcpArgs = mcpConfig && !opts.excludeMcp ? ["--mcp-config", mcpConfig] : [];
+  const args = [
+    ...sessionArg,
+    "--dangerously-skip-permissions",
+    "--model",
+    model,
+    "--append-system-prompt",
+    systemPrompt,
+    ...mcpArgs,
+    prompt
+  ];
+  return args;
+}
+function dispatchEntry(entry, state, cbs) {
+  if (entry.type !== "user" && entry.type !== "assistant") return;
+  const msg = entry.message;
+  if (!msg) return;
+  const role = msg.role ?? entry.type;
+  const content = msg.content;
+  if (typeof content === "string") {
+    if (role === "assistant" && content) {
+      state.assistantText += content;
+      cbs.onStatus("");
+      cbs.onDelta(content);
+    }
+    return;
+  }
+  if (!Array.isArray(content)) return;
+  for (const raw of content) {
+    if (!raw || typeof raw !== "object") continue;
+    const block = raw;
+    if (block.type === "text" && typeof block.text === "string" && role === "assistant") {
+      state.assistantText += block.text;
+      cbs.onStatus("");
+      cbs.onDelta(block.text);
+    } else if (block.type === "thinking" && typeof block.thinking === "string") {
+      cbs.onStatus("\u{1F4AD} En r\xE9flexion\u2026");
+      cbs.onThinking?.(block.thinking);
+    } else if (block.type === "tool_use" && block.id) {
+      const name = block.name ?? "tool";
+      state.tools.set(block.id, { id: block.id, name });
+      cbs.onStatus(`\u{1F527} ${name}`);
+      cbs.onToolCall?.(block.id, name, block.input ?? {});
+    } else if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+      const c = block.content;
+      let result = "";
+      if (typeof c === "string") result = c;
+      else if (Array.isArray(c)) {
+        result = c.filter((b) => b["type"] === "text").map((b) => b["text"] ?? "").join("");
+      }
+      cbs.onToolResult?.(block.tool_use_id, result, block.is_error === true);
+    }
+  }
+}
+async function runClaudeViaPty(params) {
+  const { agentId, signal, skipTokenInstructions } = params;
+  if (!agentId) throw new Error("runClaudeViaPty requires an agentId");
+  const sessionId = params.sessionId && params.sessionId.length > 0 ? params.sessionId : randomUUID5();
+  const args = buildPtyArgs(params, sessionId, { excludeMcp: true });
+  const agentMgr = await getAgentManager();
+  const displayArgs = args.map((a) => {
+    if (a === params.prompt) return "<prompt>";
+    if (a.includes(TOKEN_INSTRUCTIONS)) return "<system-context>";
+    return a;
+  });
+  params.onCommand?.(`claude ${displayArgs.join(" ")}`);
+  return new Promise((resolve5, reject) => {
+    let settled = false;
+    let spawnId = null;
+    const state = { assistantText: "", tools: /* @__PURE__ */ new Map() };
+    const innerAbort = new AbortController();
+    const onParentAbort = () => innerAbort.abort();
+    signal.addEventListener("abort", onParentAbort, { once: true });
+    const cleanup = () => {
+      signal.removeEventListener("abort", onParentAbort);
+      innerAbort.abort();
+    };
+    const killSpawn = async () => {
+      if (!spawnId) return;
+      try {
+        await agentMgr.agentMutation(agentId, "ai.kill", { spawnId });
+      } catch {
+      }
+    };
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      void killSpawn();
+      resolve5(result);
+    };
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      void killSpawn();
+      reject(err);
+    };
+    const tail = tailTranscript({
+      sessionId,
+      signal: innerAbort.signal,
+      onEntry: (entry) => {
+        try {
+          dispatchEntry(entry, state, {
+            onDelta: params.onDelta,
+            onStatus: params.onStatus,
+            onThinking: params.onThinking,
+            onToolCall: params.onToolCall,
+            onToolResult: params.onToolResult
+          });
+        } catch {
+        }
+        if (!skipTokenInstructions) {
+          const { status, message, branchChoice } = parseEndToken(state.assistantText);
+          if (status !== "none") {
+            settle({
+              output: state.assistantText,
+              tokenStatus: status,
+              tokenMessage: message,
+              branchChoice,
+              actualSessionId: sessionId
+            });
+          }
+        }
+      }
+    });
+    agentMgr.agentMutation(agentId, "ai.spawnPty", {
+      cli: "claude",
+      args,
+      cols: 120,
+      rows: 30,
+      sessionId,
+      enableMcp: !!params.mcpConfig,
+      mcpApiBaseUrl: params.apiBaseUrl || void 0
+    }).then(({ spawnId: id }) => {
+      spawnId = id;
+      if (signal.aborted) {
+        fail(new Error("Aborted"));
+        return;
+      }
+    }).catch((err) => {
+      fail(new Error(`Failed to spawn claude PTY: ${err.message}`));
+    });
+    signal.addEventListener("abort", () => fail(new Error("Aborted")), { once: true });
+    void tail.whenDone.then(() => {
+      if (settled) return;
+      if (skipTokenInstructions) {
+        settle({
+          output: state.assistantText,
+          tokenStatus: "none",
+          tokenMessage: "",
+          actualSessionId: sessionId
+        });
+      } else {
+        fail(new Error("Claude PTY ended before producing an end token"));
+      }
+    });
+  });
+}
+async function getAgentManager2() {
+  const { agentManager: agentManager2 } = await import("./agent-manager-V47DLMYP-26VYXTSG.js");
   return agentManager2;
 }
 function createClaudeStreamState() {
@@ -4957,6 +5463,10 @@ function processClaudeStdoutLines(lines, streamState, params, ctx) {
 }
 var ClaudeCodeRunner = class {
   run(params) {
+    const ptyEnabled = params.usePty ?? process.env["RUNEYA_CLAUDE_PTY"] === "1";
+    if (ptyEnabled && params.agentId && !(params.images && params.images.length > 0)) {
+      return runClaudeViaPty(params);
+    }
     if (params.agentId) {
       return this.runViaAgent(params);
     }
@@ -4966,7 +5476,7 @@ var ClaudeCodeRunner = class {
   async runViaAgent(params) {
     const { agentId, signal, skipTokenInstructions } = params;
     const { args, env: env2, stdinData, sessionArg } = buildClaudeSpawnConfig(params, { excludeMcp: true });
-    const agentMgr = await getAgentManager();
+    const agentMgr = await getAgentManager2();
     const totalArgSize = args.reduce((s, a) => s + a.length + 1, 0);
     console.log(`[claude-code-runner] [agent:${agentId}] arg size: ${totalArgSize} bytes, session: ${sessionArg.join(" ")}, images: ${params.images?.length ?? 0}`);
     const displayArgs = args.map((a) => {
@@ -5301,8 +5811,8 @@ async function shutdownCodexAppServer() {
     await client.shutdown();
   }
 }
-async function getAgentManager2() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-UP3PJ35X-LO6B3XKF.js");
+async function getAgentManager3() {
+  const { agentManager: agentManager2 } = await import("./agent-manager-V47DLMYP-26VYXTSG.js");
   return agentManager2;
 }
 function parseRuneyaCurlCommand(command) {
@@ -5371,7 +5881,7 @@ var CodexRunner = class {
   // ── Run via agent (app-server JSON-RPC via agent tRPC routes) ───────────
   async runViaAgent(params) {
     const { agentId, prompt, systemContext, signal, model, effort, isResume, images, skipTokenInstructions, apiBaseUrl, apiToken } = params;
-    const agentMgr = await getAgentManager2();
+    const agentMgr = await getAgentManager3();
     if (isResume && params.sessionId && !this.lastThreadId) {
       this.lastThreadId = params.sessionId;
     }
@@ -6634,6 +7144,325 @@ ${input.prompt}` : input.prompt;
     };
     runStream();
     yield* drainSession(session, signal, false);
+  }),
+  // ── PTY passthrough (interactive Claude Code session) ────────────────────
+  pty: router({
+    /** Start a PTY session running `claude --resume <sessionId>` (or fresh). */
+    start: protectedProcedure.input(z14.object({
+      agentId: z14.string().max(128).optional(),
+      sessionId: z14.string().max(128).optional(),
+      resume: z14.boolean().default(false),
+      model: z14.string().max(128).optional(),
+      cwd: z14.string().max(4096).optional(),
+      cols: z14.number().int().min(1).max(1e3).default(120),
+      rows: z14.number().int().min(1).max(1e3).default(30),
+      enableMcp: z14.boolean().default(false),
+      apiBaseUrl: z14.string().max(512).optional(),
+      attachedContexts: z14.array(z14.object({
+        label: z14.string().max(200),
+        text: z14.string().max(1e6)
+      })).max(20).optional()
+    })).mutation(async ({ input, ctx }) => {
+      const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      if (input.sessionId) {
+        try {
+          const existing = await agentManager.agentQuery(
+            agentId,
+            "ai.findPtyBySession",
+            { sessionId: input.sessionId }
+          );
+          if (existing && existing.status === "running") {
+            await agentManager.agentMutation(agentId, "ai.resizePty", {
+              spawnId: existing.spawnId,
+              cols: input.cols,
+              rows: input.rows
+            }).catch(() => {
+            });
+            return { spawnId: existing.spawnId, agentId, reattached: true };
+          }
+        } catch {
+        }
+      }
+      const args = [];
+      if (input.sessionId) {
+        const sessionExists = await claudeSessionExists(input.sessionId);
+        if (input.resume || sessionExists) {
+          args.push("--resume", input.sessionId);
+        } else {
+          args.push("--session-id", input.sessionId);
+        }
+      }
+      if (input.model) args.push("--model", input.model);
+      args.push("--dangerously-skip-permissions");
+      const jwt = ctx.authorization?.startsWith("Bearer ") ? ctx.authorization.slice(7) : void 0;
+      if (input.sessionId) {
+        try {
+          const conv = await conversationStore.get(input.sessionId);
+          if (conv) {
+            const systemContext = await buildCliSystemContext(conv, jwt);
+            const apiBase = input.apiBaseUrl ?? `http://localhost:${env.PORT}`;
+            const apiDocs = buildApiDocs(apiBase, jwt ?? "");
+            const fullSystemPrompt = apiDocs ? `${systemContext}
+
+${apiDocs}` : systemContext;
+            if (fullSystemPrompt.trim().length > 0) {
+              args.push("--append-system-prompt", fullSystemPrompt);
+            }
+          }
+        } catch (err) {
+          console.warn("[chat.pty.start] buildCliSystemContext failed:", err.message);
+        }
+      }
+      const res = await agentManager.agentMutation(
+        agentId,
+        "ai.spawnPty",
+        {
+          cli: "claude",
+          args,
+          cwd: input.cwd,
+          cols: input.cols,
+          rows: input.rows,
+          sessionId: input.sessionId,
+          enableMcp: input.enableMcp,
+          mcpApiBaseUrl: input.apiBaseUrl ?? `http://localhost:${env.PORT}`,
+          mcpApiToken: jwt
+        }
+      );
+      const contexts = input.attachedContexts ?? [];
+      if (contexts.length > 0) {
+        const body = contexts.map((c) => `### ${c.label}
+${c.text}`).join("\n\n");
+        const injection = `\x1B[200~---------
+Context:
+\x1B[201~\x1B[200~${body}\x1B[201~\x1B[200~
+---------
+\x1B[201~`;
+        setTimeout(() => {
+          agentManager.agentMutation(agentId, "ai.writePty", { spawnId: res.spawnId, data: injection }).catch((err) => {
+            console.warn("[chat.pty.start] deferred context writePty failed:", err.message);
+          });
+        }, 500);
+      }
+      return { spawnId: res.spawnId, agentId, reattached: false };
+    }),
+    /** Subscribe to PTY output stream (raw text with ANSI). */
+    stream: protectedProcedure.input(z14.object({
+      agentId: z14.string().max(128).optional(),
+      spawnId: z14.string().max(128),
+      fromOffset: z14.number().int().min(0).default(0)
+    })).subscription(async function* ({ input, signal }) {
+      const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      const queue = [];
+      let resolve5 = null;
+      let stopped = false;
+      const unsub = agentManager.agentSubscribe(
+        agentId,
+        "ai.stream",
+        { spawnId: input.spawnId, fromOffset: input.fromOffset },
+        (data) => {
+          queue.push(data);
+          if (resolve5) {
+            resolve5();
+            resolve5 = null;
+          }
+        },
+        () => {
+          stopped = true;
+          if (resolve5) {
+            resolve5();
+            resolve5 = null;
+          }
+        }
+      );
+      try {
+        while (!signal?.aborted && !stopped) {
+          while (queue.length > 0) {
+            const item = queue.shift();
+            yield item;
+            if (item.chunk.type === "exit") {
+              stopped = true;
+              break;
+            }
+          }
+          if (stopped) break;
+          await new Promise((r) => {
+            resolve5 = r;
+          });
+        }
+      } finally {
+        unsub();
+      }
+    }),
+    /** Write input to a PTY session (keystrokes from xterm). */
+    write: protectedProcedure.input(z14.object({
+      agentId: z14.string().max(128).optional(),
+      spawnId: z14.string().max(128),
+      data: z14.string().max(1e6)
+    })).mutation(async ({ input }) => {
+      const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      return agentManager.agentMutation(agentId, "ai.writePty", {
+        spawnId: input.spawnId,
+        data: input.data
+      });
+    }),
+    /** Resize a PTY session. */
+    resize: protectedProcedure.input(z14.object({
+      agentId: z14.string().max(128).optional(),
+      spawnId: z14.string().max(128),
+      cols: z14.number().int().min(1).max(1e3),
+      rows: z14.number().int().min(1).max(1e3)
+    })).mutation(async ({ input }) => {
+      const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      return agentManager.agentMutation(agentId, "ai.resizePty", {
+        spawnId: input.spawnId,
+        cols: input.cols,
+        rows: input.rows
+      });
+    }),
+    /**
+     * Upload a pasted image to the agent. The agent saves it to a tmp file and
+     * tries to populate its system clipboard so Claude's native paste detection
+     * picks it up. Returns the tmp path and which clipboard method succeeded
+     * (null if none — caller should inject `@<path>` instead of Ctrl+V).
+     */
+    pasteImage: protectedProcedure.input(z14.object({
+      agentId: z14.string().max(128).optional(),
+      sessionId: z14.string().max(128).optional(),
+      mimeType: z14.string().max(64),
+      base64: z14.string().max(15e6)
+    })).mutation(async ({ input }) => {
+      const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      const res = await agentManager.agentMutation(agentId, "ai.pasteImage", {
+        sessionId: input.sessionId,
+        mimeType: input.mimeType,
+        base64: input.base64
+      });
+      if (!res.clipboardMethod) {
+        console.warn("[chat.pty.pasteImage] clipboard spoof failed, using @path fallback:", res.clipboardError);
+      }
+      return res;
+    }),
+    /**
+     * Read the transcript Claude Code stores on disk for a given session.
+     * Returns parsed JSONL entries (user / assistant messages, tool uses, etc.).
+     */
+    transcript: protectedProcedure.input(z14.object({ sessionId: z14.string().max(128) })).query(async ({ input }) => {
+      return readClaudeTranscript(input.sessionId);
+    }),
+    /**
+     * Lightweight liveness probe: is a PTY running for this session, and
+     * when was the transcript JSONL last touched? Used by the non-PTY view
+     * to show a "Claude is thinking…" indicator while output streams.
+     */
+    activity: protectedProcedure.input(z14.object({
+      agentId: z14.string().max(128).optional(),
+      sessionId: z14.string().max(128)
+    })).query(async ({ input }) => {
+      const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+      let running = false;
+      let lastChunkAt = null;
+      if (agentId) {
+        try {
+          const existing = await agentManager.agentQuery(
+            agentId,
+            "ai.findPtyBySession",
+            { sessionId: input.sessionId }
+          );
+          running = existing?.status === "running";
+          lastChunkAt = existing?.lastChunkAt ?? null;
+        } catch {
+        }
+      }
+      const transcriptActivityAt = getLastTranscriptActivity(input.sessionId);
+      const lastActivityAt = lastChunkAt && transcriptActivityAt ? Math.max(lastChunkAt, transcriptActivityAt) : lastChunkAt ?? transcriptActivityAt;
+      return { running, lastActivityAt };
+    }),
+    /**
+     * Convert the on-disk Claude transcript into Runeya Message[] and persist
+     * them on the conversation, so the non-PTY chat view stays in sync.
+     * Uses the conversation id as session id (PTY sessions are spawned that way).
+     */
+    syncTranscript: protectedProcedure.input(z14.object({ conversationId: ConversationIdSchema })).mutation(async ({ input }) => {
+      const conv = await conversationStore.get(input.conversationId);
+      if (!conv) {
+        throw new TRPCError10({ code: "NOT_FOUND", message: `Conversation ${input.conversationId} not found` });
+      }
+      const synced = await syncConversationFromClaudeTranscript(conv.id);
+      const after = await conversationStore.get(conv.id);
+      return { synced, messageCount: after?.messages.length ?? 0 };
+    }),
+    /**
+     * Debug-only: spawn a PTY that emits random data at a chosen rate, tagged
+     * with the given sessionId. Used to benchmark the PTY → tRPC → xterm.js
+     * pipeline. Open the conversation in PTY mode to attach to it.
+     */
+    debugStress: protectedProcedure.input(z14.object({
+      sessionId: z14.string().max(128),
+      agentId: z14.string().max(128).optional(),
+      bytesPerSec: z14.number().int().min(100).max(1e7).default(5e4),
+      chunkSize: z14.number().int().min(1).max(65536).default(256),
+      durationMs: z14.number().int().min(0).max(36e5).default(0),
+      cols: z14.number().int().min(1).max(1e3).default(120),
+      rows: z14.number().int().min(1).max(1e3).default(30)
+    })).mutation(async ({ input }) => {
+      const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      const stressSessionId = `${input.sessionId}-stress-${Date.now().toString(36)}`;
+      const { existsSync: existsSync3 } = await import("fs");
+      const candidates = [
+        new URL("../../../../scripts/pty-stress-gen.mjs", import.meta.url),
+        new URL("../../../../../scripts/pty-stress-gen.mjs", import.meta.url),
+        new URL("../../../scripts/pty-stress-gen.mjs", import.meta.url)
+      ];
+      let scriptPath = null;
+      for (const c of candidates) {
+        const p = fileURLToPath(c);
+        if (existsSync3(p)) {
+          scriptPath = p;
+          break;
+        }
+      }
+      if (!scriptPath) {
+        throw new TRPCError10({
+          code: "INTERNAL_SERVER_ERROR",
+          message: `pty-stress-gen.mjs not found near ${fileURLToPath(import.meta.url)}`
+        });
+      }
+      const res = await agentManager.agentMutation(
+        agentId,
+        "ai.spawnPty",
+        {
+          cli: "node",
+          args: [scriptPath],
+          cwd: process.cwd(),
+          cols: input.cols,
+          rows: input.rows,
+          sessionId: stressSessionId,
+          env: {
+            BYTES_PER_SEC: String(input.bytesPerSec),
+            CHUNK_SIZE: String(input.chunkSize),
+            DURATION_MS: String(input.durationMs)
+          }
+        }
+      );
+      return { spawnId: res.spawnId, agentId, stressSessionId };
+    }),
+    /** Kill a PTY session. */
+    kill: protectedProcedure.input(z14.object({
+      agentId: z14.string().max(128).optional(),
+      spawnId: z14.string().max(128)
+    })).mutation(async ({ input }) => {
+      const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+      if (!agentId) throw new TRPCError10({ code: "PRECONDITION_FAILED", message: "No agent available" });
+      return agentManager.agentMutation(agentId, "ai.kill", {
+        spawnId: input.spawnId
+      });
+    })
   })
 });
 var SERVICE_ID_SCHEMA = z15.string().max(128);
@@ -7266,7 +8095,7 @@ function applyHireDirectivesFromOutput(manager, scenario, output) {
   }
   const hired = [];
   for (const payload of hireDirectives) {
-    const id = `hire-${randomUUID5().slice(0, 8)}`;
+    const id = `hire-${randomUUID6().slice(0, 8)}`;
     const position = computeHirePosition(manager, scenario.nodes);
     ensureGroupCanContainNode(scenario, manager.groupId ?? null, position);
     const node = {
@@ -7630,6 +8459,9 @@ async function runNodeCall(conversationId, node, systemContext, userMessage, run
       model,
       effort: "normal",
       signal,
+      // Scenarios default to interactive PTY to stay on subscription pricing.
+      // Override with RUNEYA_CLAUDE_PTY=0 to fall back to headless `-p` mode.
+      usePty: aiCli === "claude-code" && process.env["RUNEYA_CLAUDE_PTY"] !== "0",
       onDelta: (text) => {
         accumulated += text;
         onDelta(text);
@@ -7644,6 +8476,11 @@ async function runNodeCall(conversationId, node, systemContext, userMessage, run
     flushPersist();
     if (result.actualSessionId) state.sessionId = result.actualSessionId;
     state.isResume = true;
+    const agentForNode = runOverrides?.agentId ?? agentManager.getDefaultAgentId() ?? null;
+    if (state.sessionId && agentForNode) {
+      scenarioRunStore.setNodeSession(conversationId, node.id, state.sessionId, agentForNode);
+      void scenarioRunStore.persistRunState(conversationId);
+    }
     if (result.tokenStatus === "ask_user") {
       publish2({ type: "node_duration", nodeId: node.id, durationMs: Date.now() - turnStart });
       scenarioRunStore.setNodeState(conversationId, node.id, "waiting_input");
@@ -7694,7 +8531,7 @@ async function appendNodeOutput(conversationId, node, output) {
   if (!dir) return;
   const slug = node.label.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 60) || "member";
   const safeId = node.id.replace(/[^a-z0-9_-]/gi, "-").slice(0, 80);
-  const filePath = join12(dir, `${slug}_${safeId}.md`);
+  const filePath = join13(dir, `${slug}_${safeId}.md`);
   const content = `## Output
 
 ${output}
@@ -7709,7 +8546,7 @@ async function appendToReadme(conversationId, bus, text) {
   try {
     await mkdir12(dir, { recursive: true });
     const { appendFile: appendFile2 } = await import("fs/promises");
-    await appendFile2(join12(dir, "README.md"), line, "utf-8");
+    await appendFile2(join13(dir, "README.md"), line, "utf-8");
   } catch {
   }
   publishToBus(bus, { type: "readme_append", text: line });
@@ -7729,7 +8566,7 @@ async function writeFinalMd(conversationId, bus, userRequest, content) {
 
 ${content}
 `;
-  const filePath = join12(dir, "FINAL.md");
+  const filePath = join13(dir, "FINAL.md");
   await atomicWriteSecure(filePath, fullContent);
   await appendToReadme(
     conversationId,
@@ -8352,6 +9189,8 @@ ${out}`;
         ).catch(() => {
         });
       }
+      await scenarioRunStore.persistRunState(conversationId).catch(() => {
+      });
       publishToBus(bus, null);
       activeAbortControllers.delete(conversationId);
     }
@@ -8408,7 +9247,7 @@ var scenarioRouter = router({
   })).mutation(({ input }) => {
     const now = Date.now();
     return createOrBadRequest(() => scenarioStore.create({
-      id: randomUUID6(),
+      id: randomUUID7(),
       name: input.name,
       icon: input.icon,
       description: input.description,
@@ -8529,6 +9368,17 @@ var scenarioRouter = router({
       }
     }
   }),
+  /**
+   * Returns the Claude Code session-id + agent-id for a node, so the UI can
+   * open a debug PTY with `claude --resume <sessionId>` on the right agent.
+   * Falls back to the persisted run-state for past nodes.
+   */
+  getNodeSession: protectedProcedure.input(z16.object({
+    conversationId: ConversationIdSchema,
+    nodeId: Id128Schema
+  })).query(async ({ input }) => {
+    return await scenarioRunStore.getNodeSessionPersistent(input.conversationId, input.nodeId);
+  }),
   listPresets: protectedProcedure.query(() => listPresets()),
   getPreset: protectedProcedure.input(z16.object({ id: Id128Schema })).query(({ input }) => {
     const preset = getPreset(input.id);
@@ -8596,7 +9446,7 @@ var debugRouter = router({
     intervalMs: z17.number().int().min(100).max(5e3).optional(),
     maxTicks: z17.number().int().min(1).max(1e4).optional()
   }).optional()).mutation(({ input }) => {
-    const jobId = randomUUID7();
+    const jobId = randomUUID8();
     const intervalMs = input?.intervalMs ?? 400;
     const maxTicks = input?.maxTicks ?? 500;
     const job = {
@@ -8782,7 +9632,7 @@ var KanbanQueueService = class extends EventEmitter3 {
       return { id: alreadyRunning.id, addedAt: alreadyRunning.startedAt, ...item };
     }
     const queueItem = {
-      id: randomUUID8(),
+      id: randomUUID9(),
       ...item,
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -9170,7 +10020,7 @@ var SENSITIVE_FILES = [
 var SECURE_MODE = 384;
 async function ensureFilePermissions() {
   for (const filename of SENSITIVE_FILES) {
-    const filepath = join13(env.DATA_DIR, filename);
+    const filepath = join14(env.DATA_DIR, filename);
     try {
       const stats = await stat3(filepath);
       const mode = stats.mode & 511;
@@ -9218,7 +10068,7 @@ conversations.private.json
 *.log.*
 `;
 async function ensureDataGitignore(dataDir) {
-  const gitignorePath = join14(dataDir, ".gitignore");
+  const gitignorePath = join15(dataDir, ".gitignore");
   await writeFile10(gitignorePath, GITIGNORE_CONTENT, "utf-8");
 }
 var _require = createRequire(import.meta.url);
@@ -9327,7 +10177,7 @@ async function getSodium() {
   return _sodium;
 }
 async function decryptLegacyFile(filePath, key, sodium) {
-  const raw = (await readFile11(filePath, "utf-8")).trim();
+  const raw = (await readFile12(filePath, "utf-8")).trim();
   if (!raw || raw === "[]" || raw === "{}") {
     try {
       return JSON.parse(raw);
@@ -9353,29 +10203,29 @@ async function atomicWrite(path, data) {
 async function runLegacyMigration(dataDir) {
   const { resolve: resolve5 } = await import("path");
   const abCwd = resolve5(process.cwd());
-  const legacyRoot = join15(abCwd, env.DATA_DIR);
-  const legacyKeyPath = join15(legacyRoot, "dbs", "encryption-key.json");
+  const legacyRoot = join16(abCwd, env.DATA_DIR);
+  const legacyKeyPath = join16(legacyRoot, "dbs", "encryption-key.json");
   try {
-    await access(legacyKeyPath);
+    await access2(legacyKeyPath);
   } catch {
     return false;
   }
   console.log("[legacy-migration] Legacy Runeya data detected, starting migration\u2026");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
-  const legacyTmp = join15(abCwd, ".runeya-tmp");
+  const legacyTmp = join16(abCwd, ".runeya-tmp");
   await rename9(legacyRoot, legacyTmp);
   await mkdir13(dataDir, { recursive: true });
-  const legacyOld = join15(dataDir, `backup-${timestamp}`);
+  const legacyOld = join16(dataDir, `backup-${timestamp}`);
   await rename9(legacyTmp, legacyOld);
   console.log(`[legacy-migration] Legacy data backed up to ${legacyOld}`);
-  const keyJson = JSON.parse(await readFile11(join15(legacyOld, "dbs", "encryption-key.json"), "utf-8"));
+  const keyJson = JSON.parse(await readFile12(join16(legacyOld, "dbs", "encryption-key.json"), "utf-8"));
   const sodium = await getSodium();
   const sodiumKey = sodium.from_base64(keyJson.encryptionKey);
   const keyBuffer = Buffer.from(sodiumKey);
   const runyeaKeyHex = keyBuffer.toString("hex");
   await setEncryptionKey(runyeaKeyHex);
   console.log("[legacy-migration] Encryption key loaded in memory (temporary)");
-  const dbsDir = join15(legacyOld, "dbs");
+  const dbsDir = join16(legacyOld, "dbs");
   async function readEncrypted(filePath) {
     try {
       return await decryptLegacyFile(filePath, sodiumKey, sodium);
@@ -9384,29 +10234,29 @@ async function runLegacyMigration(dataDir) {
       return null;
     }
   }
-  const envsDir = join15(dbsDir, "envs");
-  const envFiles = (await readdir3(envsDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
+  const envsDir = join16(dbsDir, "envs");
+  const envFiles = (await readdir4(envsDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyEnvs = {};
   for (const file of envFiles) {
     const name = file.replace(".encrypted.json", "");
-    legacyEnvs[name] = await readEncrypted(join15(envsDir, file));
+    legacyEnvs[name] = await readEncrypted(join16(envsDir, file));
   }
-  const servicesDir = join15(dbsDir, "services");
-  const serviceFiles = (await readdir3(servicesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
+  const servicesDir = join16(dbsDir, "services");
+  const serviceFiles = (await readdir4(servicesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyServices = {};
   for (const file of serviceFiles) {
     const name = file.replace(".encrypted.json", "");
     if (!name) continue;
-    const data = await readEncrypted(join15(servicesDir, file));
+    const data = await readEncrypted(join16(servicesDir, file));
     if (data?.label) legacyServices[name] = data;
   }
-  const overridesDir = join15(dbsDir, "overrides");
-  const overrideFiles = (await readdir3(overridesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
+  const overridesDir = join16(dbsDir, "overrides");
+  const overrideFiles = (await readdir4(overridesDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyServiceOverrides = {};
   const legacyEnvOverrides = {};
   for (const file of overrideFiles) {
     const baseName = file.replace(".encrypted.json", "");
-    const data = await readEncrypted(join15(overridesDir, file));
+    const data = await readEncrypted(join16(overridesDir, file));
     if (!data) continue;
     if (baseName.endsWith("-envs")) {
       legacyServiceOverrides[baseName.slice(0, -5)] = data;
@@ -9414,18 +10264,18 @@ async function runLegacyMigration(dataDir) {
       legacyEnvOverrides[baseName.slice(0, -12)] = data;
     }
   }
-  const parsersDir = join15(dbsDir, "parsers");
-  const parserFiles = (await readdir3(parsersDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
+  const parsersDir = join16(dbsDir, "parsers");
+  const parserFiles = (await readdir4(parsersDir).catch(() => [])).filter((f) => f.endsWith(".encrypted.json"));
   const legacyParsers = [];
   for (const file of parserFiles) {
-    const data = await readEncrypted(join15(parsersDir, file));
+    const data = await readEncrypted(join16(parsersDir, file));
     if (data?.id) legacyParsers.push(data);
   }
-  const projectMonoId = randomUUID9();
+  const projectMonoId = randomUUID10();
   const envIdMap = {};
   const labelToKey = {};
   for (const [name, legacyEnv] of Object.entries(legacyEnvs)) {
-    envIdMap[name] = randomUUID9();
+    envIdMap[name] = randomUUID10();
     if (legacyEnv?.label) labelToKey[legacyEnv.label] = name;
   }
   const runeEnvs = [];
@@ -9450,7 +10300,7 @@ async function runLegacyMigration(dataDir) {
         if (hasInvalidInterpolation(value)) continue;
         const cleaned = cleanVarKey(key);
         if (inheritedVars[cleaned] === value) continue;
-        const varId = randomUUID9();
+        const varId = randomUUID10();
         variables[varId] = makeVariable(cleaned, value);
         varIdLookup.set(`${envIdMap[name]}:${cleaned}`, varId);
       }
@@ -9471,7 +10321,7 @@ async function runLegacyMigration(dataDir) {
   const serviceIdMap = {};
   const runeServices = [];
   for (const [name, legacy] of Object.entries(legacyServices)) {
-    const id = randomUUID9();
+    const id = randomUUID10();
     serviceIdMap[name] = id;
     const rootPath = legacy.rootPath || "";
     const rootPathCwd = rootPath && rootPath !== "." ? rootPath : "";
@@ -9480,7 +10330,7 @@ async function runLegacyMigration(dataDir) {
       const parts = [cmd.spawnCmd, ...cmd.spawnArgs || []].filter(Boolean);
       if (!parts.length) continue;
       commands.push({
-        id: cmd.id || randomUUID9(),
+        id: cmd.id || randomUUID10(),
         label: "Launch",
         command: parts.join(" "),
         cwd: cmd.spawnOptions?.cwd || "",
@@ -9541,7 +10391,7 @@ async function runLegacyMigration(dataDir) {
       const legacyBootstrapCmds = container.bootstrap?.commands || [];
       if (legacyBootstrapCmds.length > 0) {
         dockerConfig.bootstrapCommands = legacyBootstrapCmds.filter((bs) => bs.cmd || bs.entrypoint).map((bs, idx) => ({
-          id: bs.id || randomUUID9(),
+          id: bs.id || randomUUID10(),
           label: bs.label || `Bootstrap ${idx + 1}`,
           command: bs.cmd || "",
           ...bs.entrypoint ? { entrypoint: bs.entrypoint } : {},
@@ -9589,7 +10439,7 @@ async function runLegacyMigration(dataDir) {
       cwd: serviceCwd,
       runner: dockerConfig ? "docker" : "native",
       shortcuts: (legacy.shortcuts || []).filter((s) => s.spawnCmd || s.label).map((s) => ({
-        id: s.id || randomUUID9(),
+        id: s.id || randomUUID10(),
         label: s.label || s.spawnCmd || "",
         command: [s.spawnCmd, ...s.spawnArgs || []].filter(Boolean).join(" "),
         ...s.spawnOptions?.cwd ? { cwd: s.spawnOptions.cwd } : {}
@@ -9629,7 +10479,7 @@ async function runLegacyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID9(),
+          id: randomUUID10(),
           projectId: projectMonoId,
           name: `${service?.name || name} (${globalEnv.name})`,
           scope: "service",
@@ -9653,7 +10503,7 @@ async function runLegacyMigration(dataDir) {
         const varPost = typeof varData === "object" ? String(varData.suffix ?? "") : "";
         if (!varKey || existingKeys.has(cleanVarKey(varKey))) continue;
         const cleaned = cleanVarKey(varKey);
-        const varId = randomUUID9();
+        const varId = randomUUID10();
         svcScopedEnv.variables[varId] = makeVariable(cleaned, varValue, varPre, varPost);
         existingKeys.add(cleaned);
       }
@@ -9673,7 +10523,7 @@ async function runLegacyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID9(),
+          id: randomUUID10(),
           projectId: projectMonoId,
           name: `${service?.name || serviceName} (${globalEnv.name})`,
           scope: "service",
@@ -9694,7 +10544,7 @@ async function runLegacyMigration(dataDir) {
         const baseEntry = Object.entries(svcScopedEnv.variables).find(([, v]) => v.key === cleaned);
         let varId = baseEntry?.[0];
         if (!varId) {
-          varId = randomUUID9();
+          varId = randomUUID10();
           svcScopedEnv.variables[varId] = {
             key: cleaned,
             value: { value: "", pre: "", post: "", isSecret: false }
@@ -9724,13 +10574,13 @@ async function runLegacyMigration(dataDir) {
             flatOverrides[varId] = makeVariable(cleaned, value);
           }
         } else {
-          flatOverrides[randomUUID9()] = makeVariable(cleaned, value);
+          flatOverrides[randomUUID10()] = makeVariable(cleaned, value);
         }
       } else {
         const cleaned = cleanVarKey(key);
         const existingVarId = Object.entries(env2.variables).find(([, v]) => v.key === cleaned)?.[0];
         if (!existingVarId) {
-          const varId = randomUUID9();
+          const varId = randomUUID10();
           env2.variables[varId] = makeVariable(cleaned, value);
           varIdLookup.set(`${envId}:${cleaned}`, varId);
         }
@@ -9759,7 +10609,7 @@ async function runLegacyMigration(dataDir) {
   }
   let existingSettings = {};
   try {
-    existingSettings = JSON.parse(await readFile11(join15(dataDir, "settings.json"), "utf-8"));
+    existingSettings = JSON.parse(await readFile12(join16(dataDir, "settings.json"), "utf-8"));
   } catch {
   }
   const migratedParsers = legacyParsers.map((p) => ({
@@ -9780,11 +10630,11 @@ ${p.transform ?? ""}`,
       ...migratedParsers
     ]
   };
-  await atomicWrite(join15(dataDir, "projects.json"), runeProjects);
-  await atomicWrite(join15(dataDir, "services.json"), runeServices);
-  await atomicWrite(join15(dataDir, "environments.json"), runeEnvs);
-  await atomicWrite(join15(dataDir, "environment-overrides.json"), flatOverrides);
-  await atomicWrite(join15(dataDir, "settings.json"), newSettings);
+  await atomicWrite(join16(dataDir, "projects.json"), runeProjects);
+  await atomicWrite(join16(dataDir, "services.json"), runeServices);
+  await atomicWrite(join16(dataDir, "environments.json"), runeEnvs);
+  await atomicWrite(join16(dataDir, "environment-overrides.json"), flatOverrides);
+  await atomicWrite(join16(dataDir, "settings.json"), newSettings);
   const svcEnvCount = runeEnvs.filter((e) => e.scope === "service").length;
   console.log(`[legacy-migration] Written: ${runeProjects.length} projects, ${runeServices.length} services, ${runeEnvs.length} environments (${svcEnvCount} service-scoped)`);
   console.log(`[legacy-migration] Overrides: ${Object.keys(flatOverrides).length}, custom parsers: ${migratedParsers.length} (all disabled \u2014 rewrite required)`);
@@ -9795,12 +10645,12 @@ ${p.transform ?? ""}`,
 }
 async function findLegacyKeyInBackup(dataDir) {
   try {
-    const entries = await readdir3(dataDir);
+    const entries = await readdir4(dataDir);
     const backupDirs = entries.filter((e) => e.startsWith("backup-")).sort().reverse();
     for (const dir of backupDirs) {
-      const keyJsonPath = join15(dataDir, dir, "dbs", "encryption-key.json");
+      const keyJsonPath = join16(dataDir, dir, "dbs", "encryption-key.json");
       try {
-        const raw = await readFile11(keyJsonPath, "utf-8");
+        const raw = await readFile12(keyJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!parsed.encryptionKey) continue;
         const sodium = await getSodium();
@@ -9822,14 +10672,14 @@ async function runOverrideOnlyMigration(dataDir) {
   const abDataDir = resolve5(dataDir);
   const abCwd = resolve5(process.cwd());
   const candidateDirs = [
-    join15(abCwd, ".runeya", "dbs", "overrides"),
-    join15(abDataDir, "dbs", "overrides")
+    join16(abCwd, ".runeya", "dbs", "overrides"),
+    join16(abDataDir, "dbs", "overrides")
   ];
   let overridesDir = null;
   let overrideFiles = [];
   for (const dir of candidateDirs) {
     try {
-      const files = (await readdir3(dir)).filter((f) => f.endsWith(".encrypted.json"));
+      const files = (await readdir4(dir)).filter((f) => f.endsWith(".encrypted.json"));
       if (files.length > 0) {
         overridesDir = dir;
         overrideFiles = files;
@@ -9839,9 +10689,9 @@ async function runOverrideOnlyMigration(dataDir) {
     }
   }
   if (!overridesDir || overrideFiles.length === 0) return false;
-  const legacyKeyPath = join15(overridesDir, "..", "encryption-key.json");
+  const legacyKeyPath = join16(overridesDir, "..", "encryption-key.json");
   try {
-    await access(legacyKeyPath);
+    await access2(legacyKeyPath);
     return false;
   } catch {
   }
@@ -9857,7 +10707,7 @@ async function runOverrideOnlyMigration(dataDir) {
   const envNameToId = {};
   let envsRaw;
   try {
-    envsRaw = JSON.parse(await readFile11(join15(abDataDir, "environments.json"), "utf-8"));
+    envsRaw = JSON.parse(await readFile12(join16(abDataDir, "environments.json"), "utf-8"));
     for (const _env of envsRaw) {
       const env2 = _env;
       if (env2["name"] && env2["id"]) {
@@ -9876,7 +10726,7 @@ async function runOverrideOnlyMigration(dataDir) {
   let servicesRaw = [];
   const serviceNameToId = {};
   try {
-    servicesRaw = JSON.parse(await readFile11(join15(abDataDir, "services.json"), "utf-8"));
+    servicesRaw = JSON.parse(await readFile12(join16(abDataDir, "services.json"), "utf-8"));
     for (const _svc of servicesRaw) {
       const svc = _svc;
       if (svc["name"] && svc["id"]) serviceNameToId[svc["name"]] = svc["id"];
@@ -9893,7 +10743,7 @@ async function runOverrideOnlyMigration(dataDir) {
     const envName = baseName.slice(0, -"-environment".length);
     let data;
     try {
-      data = await decryptLegacyFile(join15(overridesDir, file), sodiumKey, sodium);
+      data = await decryptLegacyFile(join16(overridesDir, file), sodiumKey, sodium);
     } catch (err) {
       console.warn(`[override-migration] Failed to decrypt ${file}: ${err.message}`);
       continue;
@@ -9915,12 +10765,12 @@ async function runOverrideOnlyMigration(dataDir) {
         if (isSameAsBase(value, baseVar)) continue;
         flatOverrides[varId] = makeVariable(cleaned, value);
       } else {
-        flatOverrides[randomUUID9()] = makeVariable(cleaned, value);
+        flatOverrides[randomUUID10()] = makeVariable(cleaned, value);
       }
     }
   }
   if (Object.keys(flatOverrides).length > 0) {
-    await atomicWrite(join15(abDataDir, "environment-overrides.json"), flatOverrides);
+    await atomicWrite(join16(abDataDir, "environment-overrides.json"), flatOverrides);
     console.log(`[override-migration] Written ${Object.keys(flatOverrides).length} override(s) to environment-overrides.json`);
   }
   let envsModified = false;
@@ -9930,7 +10780,7 @@ async function runOverrideOnlyMigration(dataDir) {
     const serviceName = baseName.slice(0, -"-envs".length);
     let data;
     try {
-      data = await decryptLegacyFile(join15(overridesDir, file), sodiumKey, sodium);
+      data = await decryptLegacyFile(join16(overridesDir, file), sodiumKey, sodium);
     } catch (err) {
       console.warn(`[override-migration] Failed to decrypt ${file}: ${err.message}`);
       continue;
@@ -9952,7 +10802,7 @@ async function runOverrideOnlyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID9(),
+          id: randomUUID10(),
           projectId: globalEnv["projectId"],
           name: `${service?.["name"] || serviceName} (${globalEnv["name"]})`,
           scope: "service",
@@ -9974,7 +10824,7 @@ async function runOverrideOnlyMigration(dataDir) {
         const baseEntry = Object.entries(svcScopedEnv["variables"]).find(([, v]) => v.key === cleaned);
         let varId = baseEntry?.[0];
         if (!varId) {
-          varId = randomUUID9();
+          varId = randomUUID10();
           svcScopedEnv["variables"][varId] = {
             key: cleaned,
             value: { value: "", pre: "", post: "", isSecret: false }
@@ -9989,7 +10839,7 @@ async function runOverrideOnlyMigration(dataDir) {
     }
   }
   if (envsModified) {
-    await atomicWrite(join15(abDataDir, "environments.json"), envsRaw);
+    await atomicWrite(join16(abDataDir, "environments.json"), envsRaw);
     console.log("[override-migration] Merged service overrides into environments.json");
   }
   const migratedDir = overridesDir.replace(/overrides$/, "overrides-migrated");
@@ -10013,7 +10863,7 @@ var ARGON2_OPTIONS = { memoryCost: 65536, timeCost: 3, parallelism: 4, outputLen
 async function readKeyFile(filePath) {
   const s = await stat4(filePath);
   if (s.size > MAX_KEY_FILE_SIZE) throw new Error(`Fichier suspect : ${filePath} (${s.size} octets)`);
-  return readFile12(filePath);
+  return readFile13(filePath);
 }
 function aesEncrypt(key, plaintext) {
   const iv = randomBytes4(12);
@@ -10032,7 +10882,7 @@ function aesDecrypt(key, data) {
 }
 async function getPepperFromFile(dataDir) {
   try {
-    const raw = await readKeyFile(join16(dataDir, PEPPER_FILENAME));
+    const raw = await readKeyFile(join17(dataDir, PEPPER_FILENAME));
     const hex = raw.toString("utf-8").trim();
     if (/^[0-9a-f]{64}$/i.test(hex)) return Buffer.from(hex, "hex");
   } catch {
@@ -10040,7 +10890,7 @@ async function getPepperFromFile(dataDir) {
   return null;
 }
 async function writePepperToFile(dataDir, pepper) {
-  const filePath = join16(dataDir, PEPPER_FILENAME);
+  const filePath = join17(dataDir, PEPPER_FILENAME);
   const tmpPath = filePath + ".tmp";
   await writeFile12(tmpPath, pepper.toString("hex"), "utf-8");
   await chmod9(tmpPath, 384);
@@ -10091,14 +10941,14 @@ async function writeEncryptedKey(dataDir, masterPassword, encryptionKey) {
   const payload = aesEncrypt(derivedKey, encryptionKey);
   const fileContent = Buffer.concat([salt, payload]);
   const encoded = fileContent.toString("base64");
-  const filePath = join16(dataDir, ENCRYPTED_KEY_FILENAME);
+  const filePath = join17(dataDir, ENCRYPTED_KEY_FILENAME);
   const tmpPath = filePath + ".tmp";
   await writeFile12(tmpPath, encoded, "utf-8");
   await chmod9(tmpPath, 384);
   await rename10(tmpPath, filePath);
 }
 async function readEncryptedKey(dataDir, masterPassword) {
-  const filePath = join16(dataDir, ENCRYPTED_KEY_FILENAME);
+  const filePath = join17(dataDir, ENCRYPTED_KEY_FILENAME);
   const raw = await readKeyFile(filePath);
   const fileContent = Buffer.from(raw.toString("utf-8").trim(), "base64");
   const salt = fileContent.subarray(0, 16);
@@ -10118,13 +10968,13 @@ async function getPepperFromKeychain(dataDir) {
 }
 async function writeVerifyFile(dataDir, encryptionKey) {
   const payload = aesEncrypt(encryptionKey, Buffer.from(CANARY_PLAINTEXT, "utf-8"));
-  const filePath = join16(dataDir, VERIFY_FILENAME);
+  const filePath = join17(dataDir, VERIFY_FILENAME);
   const tmpPath = filePath + ".tmp";
   await writeFile12(tmpPath, payload.toString("base64"), "utf-8");
   await rename10(tmpPath, filePath);
 }
 async function verifyEncryptionKey(dataDir, encryptionKey) {
-  const filePath = join16(dataDir, VERIFY_FILENAME);
+  const filePath = join17(dataDir, VERIFY_FILENAME);
   const raw = await readKeyFile(filePath);
   const payload = Buffer.from(raw.toString("utf-8").trim(), "base64");
   const plaintext = aesDecrypt(encryptionKey, payload);
@@ -10134,7 +10984,7 @@ async function verifyEncryptionKey(dataDir, encryptionKey) {
 }
 async function hasVerifyFile(dataDir) {
   try {
-    await stat4(join16(dataDir, VERIFY_FILENAME));
+    await stat4(join17(dataDir, VERIFY_FILENAME));
     return true;
   } catch {
     return false;
@@ -10142,7 +10992,7 @@ async function hasVerifyFile(dataDir) {
 }
 async function hasEncryptedKeyFile(dataDir) {
   try {
-    await stat4(join16(dataDir, ENCRYPTED_KEY_FILENAME));
+    await stat4(join17(dataDir, ENCRYPTED_KEY_FILENAME));
     return true;
   } catch {
     return false;
@@ -10156,17 +11006,17 @@ async function getServerState() {
   let hasVerify = false;
   let hasData = false;
   try {
-    await stat5(join17(dataDir, ENCRYPTED_KEY_FILENAME2));
+    await stat5(join18(dataDir, ENCRYPTED_KEY_FILENAME2));
     hasEncFile = true;
   } catch {
   }
   try {
-    await stat5(join17(dataDir, VERIFY_FILENAME2));
+    await stat5(join18(dataDir, VERIFY_FILENAME2));
     hasVerify = true;
   } catch {
   }
   try {
-    await stat5(join17(dataDir, "projects.json"));
+    await stat5(join18(dataDir, "projects.json"));
     hasData = true;
   } catch {
   }
@@ -10609,6 +11459,9 @@ async function createLocalServer() {
     }
     await agentManager.init();
     await agentSpawner.spawnLocalAgent();
+    startClaudeTranscriptWatcher().catch((err) => {
+      console.warn("[server] Failed to start Claude transcript watcher:", err);
+    });
   }
   if (hasEncryptionKey()) {
     await runPostUnlock();
@@ -10742,20 +11595,39 @@ async function createLocalServer() {
       res.status(500).send("Internal server error");
     }
   });
-  app.get("/api/docs", (_req, res) => {
+  app.get("/api/docs", (req, res) => {
+    const dark = req.query["dark"] === "1";
     res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.setHeader("Cache-Control", "no-store");
     res.send(`<!doctype html>
-<html>
+<html lang="en">
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>Runeya API Docs</title>
-  <style>body { margin: 0; }</style>
+  <meta name="description" content="Runeya service management API reference" />
+  <style>
+    body { margin: 0; }
+  </style>
 </head>
 <body>
   <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
   <script>
-    Scalar.createApiReference(document.body, { url: '/api/openapi.json' });
+    Scalar.createApiReference(document.body, {
+      url: '/api/openapi.json',
+      darkMode: ${dark},
+      layout: 'modern',
+      defaultHttpClient: { targetKey: 'shell', clientKey: 'curl' },
+      defaultOpenAllTags: false,
+      persistAuth: true,
+      agent: { disabled: true },
+      metaData: {
+        title: 'Runeya API Docs',
+        description: 'Runeya service management API reference',
+        ogTitle: 'Runeya API Docs',
+        ogDescription: 'Runeya service management API reference',
+      },
+    });
   </script>
 </body>
 </html>`);
@@ -10997,6 +11869,11 @@ async function pullEnv(opts) {
   return Object.entries(env2).map(([key, value]) => `${key}=${value}`).join("\n");
 }
 dotenv.config({ quiet: true });
+if (process.env["DATA_DIR"]) {
+  const resolved = resolvePath(process.env["DATA_DIR"], "..");
+  process.chdir(resolved);
+  console.log(`[server] Working directory: ${resolved} (from DATA_DIR)`);
+}
 function listenWithRetry(server, port, host, wss, maxRetries = 20, delay = 500) {
   return new Promise((resolve5, reject) => {
     let attempts = 0;
@@ -11066,4 +11943,4 @@ export {
   createLocalServer,
   pullEnv
 };
-//# sourceMappingURL=dist-PSPHMTZN.js.map
+//# sourceMappingURL=dist-2H7XZQCV.js.map