@openscout/scout 0.2.57 → 0.2.60

package/dist/scout-control-plane-web.mjs

@@ -5703,6 +5703,20 @@ var init_support_paths = () => {};
 import { existsSync as existsSync4, statSync as statSync2 } from "fs";
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname3, join as join5 } from "path";
+function buildHarnessResumeCommand(entry, sessionId, cwd) {
+  if (!entry.resume)
+    return null;
+  const parts = [entry.resume.command, entry.resume.sessionFlag, sessionId];
+  if (cwd && entry.resume.cwdFlag) {
+    parts.push(entry.resume.cwdFlag, cwd);
+  }
+  return parts.join(" ");
+}
+function findHarnessEntry(harness) {
+  if (!harness)
+    return null;
+  return BUILT_IN_HARNESS_CATALOG.find((e) => e.harness === harness || e.name === harness) ?? null;
+}
 async function writeHarnessCatalogOverrides(overrides, overridePath = resolveOpenScoutSupportPaths().harnessCatalogPath) {
   await mkdir2(dirname3(overridePath), { recursive: true });
   const payload = {
@@ -5761,6 +5775,11 @@ var init_harness_catalog = __esm(() => {
         loginCommand: "claude login",
         notReadyMessage: "Claude is installed but not authenticated yet."
       },
+      resume: {
+        command: "claude",
+        sessionFlag: "--resume",
+        cwdFlag: "--cwd"
+      },
       capabilities: ["chat", "invoke", "deliver", "summarize", "review"]
     },
     {
@@ -5792,6 +5811,11 @@ var init_harness_catalog = __esm(() => {
         loginCommand: "codex login",
         notReadyMessage: "Codex is installed but not authenticated yet."
       },
+      resume: {
+        command: "codex",
+        sessionFlag: "--thread",
+        cwdFlag: "--cwd"
+      },
       capabilities: ["chat", "invoke", "deliver", "review", "execute"]
     }
   ];
@@ -8056,7 +8080,8 @@ function buildManagedAgentShellExports(options) {
 // packages/runtime/src/claude-stream-json.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn3 } from "child_process";
-import { appendFile as appendFile2, mkdir as mkdir4, readFile as readFile5, rm as rm3, writeFile as writeFile4 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
 import { join as join13 } from "path";
 function resolveClaudeStreamJsonOutput(result, fallbackParts) {
   const trimmedResult = result?.trim();
@@ -8092,6 +8117,53 @@ function parseJsonObject(value) {
     return {};
   }
 }
+function readSessionCatalogSync(runtimeDirectory) {
+  const catalogPath = join13(runtimeDirectory, SESSION_CATALOG_FILENAME);
+  try {
+    if (!existsSync9(catalogPath)) {
+      const legacyPath = join13(runtimeDirectory, "claude-session-id.txt");
+      if (existsSync9(legacyPath)) {
+        const legacyId = readFileSync5(legacyPath, "utf8").trim();
+        if (legacyId) {
+          return {
+            activeSessionId: legacyId,
+            sessions: [{ id: legacyId, startedAt: Date.now(), cwd: "" }]
+          };
+        }
+      }
+      return { activeSessionId: null, sessions: [] };
+    }
+    const raw2 = readFileSync5(catalogPath, "utf8").trim();
+    if (!raw2)
+      return { activeSessionId: null, sessions: [] };
+    const parsed = JSON.parse(raw2);
+    return {
+      activeSessionId: parsed.activeSessionId ?? null,
+      sessions: Array.isArray(parsed.sessions) ? parsed.sessions : []
+    };
+  } catch {
+    return { activeSessionId: null, sessions: [] };
+  }
+}
+async function readSessionCatalog(runtimeDirectory) {
+  return readSessionCatalogSync(runtimeDirectory);
+}
+async function writeSessionCatalog(runtimeDirectory, catalog) {
+  const catalogPath = join13(runtimeDirectory, SESSION_CATALOG_FILENAME);
+  await writeFile4(catalogPath, JSON.stringify(catalog, null, 2) + `
+`);
+}
+function catalogRecordSession(catalog, sessionId, cwd) {
+  const now = Date.now();
+  const sessions = catalog.sessions.map((s) => s.id === catalog.activeSessionId && !s.endedAt ? { ...s, endedAt: now } : s);
+  if (!sessions.some((s) => s.id === sessionId)) {
+    sessions.push({ id: sessionId, startedAt: now, cwd });
+  }
+  while (sessions.length > SESSION_CATALOG_MAX_ENTRIES) {
+    sessions.shift();
+  }
+  return { activeSessionId: sessionId, sessions };
+}
 function appendActionOutput(blockState, output) {
   if (!blockState || blockState.block.type !== "action" || !output) {
     return;
@@ -8495,7 +8567,7 @@ function buildClaudeStreamJsonSessionSnapshot(raw2, options, targetClaudeSession
 
 class ClaudeStreamJsonSession {
   options;
-  sessionStatePath;
+  catalogDirectory;
   stdoutLogPath;
   stderrLogPath;
   process = null;
@@ -8506,7 +8578,7 @@ class ClaudeStreamJsonSession {
   lastConfigSignature;
   constructor(options) {
     this.options = options;
-    this.sessionStatePath = join13(options.runtimeDirectory, "claude-session-id.txt");
+    this.catalogDirectory = options.runtimeDirectory;
     this.stdoutLogPath = join13(options.logsDirectory, "stdout.log");
     this.stderrLogPath = join13(options.logsDirectory, "stderr.log");
     this.lastConfigSignature = this.configSignature(options);
@@ -8612,7 +8684,9 @@ class ClaudeStreamJsonSession {
     }
     if (options.resetSession) {
       this.claudeSessionId = null;
-      await rm3(this.sessionStatePath, { force: true });
+      const catalog = await readSessionCatalog(this.catalogDirectory);
+      catalog.activeSessionId = null;
+      await writeSessionCatalog(this.catalogDirectory, catalog);
     }
   }
   configSignature(options) {
@@ -8641,7 +8715,8 @@ class ClaudeStreamJsonSession {
     await mkdir4(this.options.runtimeDirectory, { recursive: true });
     await mkdir4(this.options.logsDirectory, { recursive: true });
     await writeFile4(join13(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
-    this.claudeSessionId = await readOptionalFile2(this.sessionStatePath);
+    const catalog = await readSessionCatalog(this.catalogDirectory);
+    this.claudeSessionId = catalog.activeSessionId;
     const args = [
       "--verbose",
       "--print",
@@ -8720,8 +8795,11 @@ class ClaudeStreamJsonSession {
       const nextSessionId = event.session_id ?? event.sessionId ?? null;
       if (nextSessionId && nextSessionId !== this.claudeSessionId) {
         this.claudeSessionId = nextSessionId;
-        writeFile4(this.sessionStatePath, `${nextSessionId}
-`);
+        (async () => {
+          const catalog = await readSessionCatalog(this.catalogDirectory);
+          const updated = catalogRecordSession(catalog, nextSessionId, this.options.cwd);
+          await writeSessionCatalog(this.catalogDirectory, updated);
+        })();
       }
       return;
     }
@@ -8794,37 +8872,137 @@ async function answerClaudeStreamJsonQuestion(options, input) {
 }
 async function getClaudeStreamJsonAgentSnapshot(options) {
   const stdoutLogPath = join13(options.logsDirectory, "stdout.log");
-  const sessionStatePath = join13(options.runtimeDirectory, "claude-session-id.txt");
-  const [rawLog, persistedSessionId] = await Promise.all([
+  const [rawLog, catalog] = await Promise.all([
     readOptionalFile2(stdoutLogPath),
-    readOptionalFile2(sessionStatePath)
+    readSessionCatalog(options.runtimeDirectory)
   ]);
   if (!rawLog) {
     return null;
   }
-  return buildClaudeStreamJsonSessionSnapshot(rawLog, options, persistedSessionId);
+  return buildClaudeStreamJsonSessionSnapshot(rawLog, options, catalog.activeSessionId);
 }
 async function shutdownClaudeStreamJsonAgent(options, shutdownOptions = {}) {
   const key = sessionKey(options);
   const session = sessions.get(key);
   if (!session) {
     if (shutdownOptions.resetSession) {
-      await rm3(join13(options.runtimeDirectory, "claude-session-id.txt"), { force: true });
+      const catalog = await readSessionCatalog(options.runtimeDirectory);
+      catalog.activeSessionId = null;
+      await writeSessionCatalog(options.runtimeDirectory, catalog);
     }
     return;
   }
   sessions.delete(key);
   await session.shutdown(shutdownOptions);
 }
-var sessions;
+var SESSION_CATALOG_FILENAME = "session-catalog.json", SESSION_CATALOG_MAX_ENTRIES = 64, sessions;
 var init_claude_stream_json = __esm(() => {
   sessions = new Map;
 });
 
 // packages/runtime/src/codex-app-server.ts
 import { spawn as spawn4 } from "child_process";
-import { access as access3, appendFile as appendFile3, constants as constants4, mkdir as mkdir5, readFile as readFile6, rm as rm4, writeFile as writeFile5 } from "fs/promises";
+import { constants as constants4 } from "fs";
+import { access as access3, appendFile as appendFile3, mkdir as mkdir5, readFile as readFile6, rm as rm4, writeFile as writeFile5 } from "fs/promises";
 import { delimiter as delimiter3, join as join14 } from "path";
+function normalizeCodexModelValue(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function encodeCodexModelConfig(model) {
+  return `model=${JSON.stringify(model)}`;
+}
+function parseCodexModelConfig(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const separatorIndex = trimmed.indexOf("=");
+  if (separatorIndex <= 0) {
+    return null;
+  }
+  const key = trimmed.slice(0, separatorIndex).trim();
+  if (key !== "model") {
+    return null;
+  }
+  const rawValue = trimmed.slice(separatorIndex + 1).trim();
+  if (!rawValue) {
+    return null;
+  }
+  if (rawValue.startsWith('"') && rawValue.endsWith('"') || rawValue.startsWith("'") && rawValue.endsWith("'")) {
+    return rawValue.slice(1, -1) || null;
+  }
+  return rawValue;
+}
+function normalizeCodexAppServerLaunchArgs(launchArgs) {
+  const args = Array.isArray(launchArgs) ? launchArgs.map((entry) => String(entry).trim()).filter(Boolean) : [];
+  const normalized = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index] ?? "";
+    if (current === "--model" || current === "-m") {
+      const model = normalizeCodexModelValue(args[index + 1]);
+      if (model) {
+        normalized.push("-c", encodeCodexModelConfig(model));
+        index += 1;
+        continue;
+      }
+      normalized.push(current);
+      continue;
+    }
+    if (current.startsWith("--model=")) {
+      const model = normalizeCodexModelValue(current.slice("--model=".length));
+      if (model) {
+        normalized.push("-c", encodeCodexModelConfig(model));
+        continue;
+      }
+    }
+    if (current.startsWith("-m=")) {
+      const model = normalizeCodexModelValue(current.slice(3));
+      if (model) {
+        normalized.push("-c", encodeCodexModelConfig(model));
+        continue;
+      }
+    }
+    if (current === "-c" || current === "--config") {
+      const next = args[index + 1];
+      if (typeof next === "string") {
+        const model = parseCodexModelConfig(next);
+        normalized.push(current === "--config" ? "--config" : "-c", model ? encodeCodexModelConfig(model) : next);
+        index += 1;
+        continue;
+      }
+    }
+    if (current.startsWith("--config=")) {
+      const value = current.slice("--config=".length);
+      const model = parseCodexModelConfig(value);
+      normalized.push(model ? `--config=${encodeCodexModelConfig(model)}` : current);
+      continue;
+    }
+    normalized.push(current);
+  }
+  return normalized;
+}
+function readCodexAppServerModelFromLaunchArgs(launchArgs) {
+  const normalized = normalizeCodexAppServerLaunchArgs(launchArgs);
+  for (let index = 0;index < normalized.length; index += 1) {
+    const current = normalized[index] ?? "";
+    if (current === "-c" || current === "--config") {
+      const model = parseCodexModelConfig(normalized[index + 1]);
+      if (model) {
+        return model;
+      }
+      index += 1;
+      continue;
+    }
+    if (current.startsWith("--config=")) {
+      const model = parseCodexModelConfig(current.slice("--config=".length));
+      if (model) {
+        return model;
+      }
+    }
+  }
+  return null;
+}
 function isCodexThreadGlobalMessage(message) {
   const result = message.result;
   const thread = result?.thread;
@@ -9627,6 +9805,13 @@ function isMissingCodexRolloutError2(error) {
   const message = errorMessage3(error).toLowerCase();
   return message.includes("no rollout found for thread id");
 }
+function resolveCodexCompletionGraceMs() {
+  const parsed = Number.parseInt(process.env.OPENSCOUT_CODEX_COMPLETION_GRACE_MS ?? "", 10);
+  if (Number.isFinite(parsed) && parsed >= 0) {
+    return parsed;
+  }
+  return 60000;
+}
 
 class CodexAppServerSession {
   options;
@@ -9816,7 +10001,7 @@ class CodexAppServerSession {
       systemPrompt: options.systemPrompt,
       threadId: options.threadId ?? null,
       requireExistingThread: options.requireExistingThread === true,
-      launchArgs: Array.isArray(options.launchArgs) ? options.launchArgs : []
+      launchArgs: normalizeCodexAppServerLaunchArgs(options.launchArgs)
     });
   }
   async ensureStarted() {
@@ -9838,6 +10023,7 @@ class CodexAppServerSession {
     await mkdir5(this.options.logsDirectory, { recursive: true });
     await writeFile5(join14(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
     const codexExecutable = await resolveCodexExecutable2();
+    const launchArgs = normalizeCodexAppServerLaunchArgs(this.options.launchArgs);
     const env = buildManagedAgentEnvironment({
       agentName: this.options.agentName,
       currentDirectory: this.options.cwd,
@@ -9848,7 +10034,8 @@ class CodexAppServerSession {
       ...buildScoutMcpCodexLaunchArgs({
         currentDirectory: this.options.cwd,
         env
-      })
+      }),
+      ...launchArgs
     ], {
       cwd: this.options.cwd,
       env,
@@ -9946,6 +10133,8 @@ class CodexAppServerSession {
       turnId: "",
       startedAt: Date.now(),
       timer: null,
+      graceTimer: null,
+      timedOutAt: null,
       messageOrder: [],
       messageByItemId: new Map,
       resolve: resolve5,
@@ -9953,20 +10142,43 @@ class CodexAppServerSession {
       watchers: []
     };
     turn.timer = setTimeout(() => {
-      this.interrupt().catch(() => {
-        return;
-      });
-      if (this.activeTurn === turn) {
-        this.activeTurn = null;
-      }
-      for (const watcher of this.drainTurnWatchers(turn)) {
-        watcher.reject(new Error(`Timed out after ${timeoutMs}ms waiting for ${this.options.agentName}.`));
-      }
-      reject(new Error(`Timed out after ${timeoutMs}ms waiting for ${this.options.agentName}.`));
+      this.scheduleTurnTimeout(turn, timeoutMs);
     }, timeoutMs);
     this.activeTurn = turn;
     return turn;
   }
+  buildTurnTimeoutError(timeoutMs) {
+    return new Error(`Timed out after ${timeoutMs}ms waiting for ${this.options.agentName}.`);
+  }
+  scheduleTurnTimeout(turn, timeoutMs) {
+    if (turn.timedOutAt !== null) {
+      return;
+    }
+    turn.timedOutAt = Date.now();
+    this.interrupt().catch(() => {
+      return;
+    });
+    const graceMs = resolveCodexCompletionGraceMs();
+    if (graceMs <= 0) {
+      this.rejectTimedOutTurn(turn, timeoutMs);
+      return;
+    }
+    turn.graceTimer = setTimeout(() => {
+      this.rejectTimedOutTurn(turn, timeoutMs);
+    }, graceMs);
+  }
+  rejectTimedOutTurn(turn, timeoutMs) {
+    if (this.activeTurn !== turn) {
+      this.clearActiveTurn(turn);
+      return;
+    }
+    this.clearActiveTurn(turn);
+    const error = this.buildTurnTimeoutError(timeoutMs);
+    for (const watcher of this.drainTurnWatchers(turn)) {
+      watcher.reject(error);
+    }
+    turn.reject(error);
+  }
   addTurnWatcher(turn, resolve5, reject, timeoutMs) {
     const watcher = {
       resolve: resolve5,
@@ -10000,6 +10212,9 @@ class CodexAppServerSession {
     if (turn.timer) {
       clearTimeout(turn.timer);
     }
+    if (turn.graceTimer) {
+      clearTimeout(turn.graceTimer);
+    }
     if (this.activeTurn === turn) {
       this.activeTurn = null;
     }
@@ -10435,7 +10650,7 @@ function buildInvocationCollaborationContextPrompt(invocation) {
 
 // packages/runtime/src/broker-service.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir11 } from "os";
 import { basename as basename4, dirname as dirname10, join as join15, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
@@ -10474,7 +10689,7 @@ function runtimePackageDir() {
   return resolve5(moduleDir, "..");
 }
 function isInstalledRuntimePackageDir(candidate) {
-  return existsSync9(join15(candidate, "package.json")) && existsSync9(join15(candidate, "bin", "openscout-runtime.mjs"));
+  return existsSync10(join15(candidate, "package.json")) && existsSync10(join15(candidate, "bin", "openscout-runtime.mjs"));
 }
 function findGlobalRuntimeDir() {
   const candidates = [
@@ -10505,7 +10720,7 @@ function findWorkspaceRuntimeDir(startDir) {
   let current = resolve5(startDir);
   while (true) {
     const candidate = join15(current, "packages", "runtime");
-    if (existsSync9(join15(candidate, "package.json")) && existsSync9(join15(candidate, "src"))) {
+    if (existsSync10(join15(candidate, "package.json")) && existsSync10(join15(candidate, "src"))) {
       return candidate;
     }
     const parent = dirname10(current);
@@ -10519,18 +10734,18 @@ function resolveBunExecutable2() {
   if (explicit && explicit.trim().length > 0) {
     return explicit;
   }
-  if (basename4(process.execPath).startsWith("bun") && existsSync9(process.execPath)) {
+  if (basename4(process.execPath).startsWith("bun") && existsSync10(process.execPath)) {
     return process.execPath;
   }
   const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
   for (const entry of pathEntries) {
     const candidate = join15(entry, "bun");
-    if (existsSync9(candidate)) {
+    if (existsSync10(candidate)) {
       return candidate;
     }
   }
   const homeBun = join15(homedir11(), ".bun", "bin", "bun");
-  if (existsSync9(homeBun)) {
+  if (existsSync10(homeBun)) {
     return homeBun;
   }
   return "bun";
@@ -10720,10 +10935,10 @@ function launchctlPath() {
   return "/bin/launchctl";
 }
 function readLogLines(path) {
-  if (!existsSync9(path)) {
+  if (!existsSync10(path)) {
     return [];
   }
-  return readFileSync5(path, "utf8").split(`
+  return readFileSync6(path, "utf8").split(`
 `).map((line) => line.trim()).filter(Boolean);
 }
 function isPackageScriptBanner(line) {
@@ -10820,7 +11035,7 @@ async function brokerServiceStatus(config = resolveBrokerServiceConfig()) {
   ensureServiceDirectories(config);
   const launchctl = inspectLaunchctl(config);
   const health = await fetchHealthSnapshot(config);
-  const installed = existsSync9(config.launchAgentPath);
+  const installed = existsSync10(config.launchAgentPath);
   const lastLogLine = health.reachable ? readLastLogLine([config.stdoutLogPath, config.stderrLogPath]) : readLastLogLine([config.stderrLogPath, config.stdoutLogPath]);
   return {
     label: config.label,
@@ -10882,7 +11097,7 @@ async function restartBrokerService(config = resolveBrokerServiceConfig()) {
 }
 async function uninstallBrokerService(config = resolveBrokerServiceConfig()) {
   await stopBrokerService(config);
-  if (existsSync9(config.launchAgentPath)) {
+  if (existsSync10(config.launchAgentPath)) {
     rmSync2(config.launchAgentPath, { force: true });
   }
   return brokerServiceStatus(config);
@@ -10975,6 +11190,7 @@ __export(exports_local_agents, {
   resolveLocalAgentIdentity: () => resolveLocalAgentIdentity,
   resolveLocalAgentByName: () => resolveLocalAgentByName,
   renderLocalAgentSystemPromptTemplate: () => renderLocalAgentSystemPromptTemplate,
+  normalizeLocalAgentSystemPrompt: () => normalizeLocalAgentSystemPrompt,
   loadRegisteredLocalAgentBindings: () => loadRegisteredLocalAgentBindings,
   listLocalAgents: () => listLocalAgents,
   isLocalAgentSessionAlive: () => isLocalAgentSessionAlive,
@@ -10998,7 +11214,7 @@ __export(exports_local_agents, {
 });
 import { randomUUID as randomUUID2 } from "crypto";
 import { execFileSync as execFileSync2, execSync } from "child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
 import { mkdir as mkdir6, rm as rm5, stat as stat4, writeFile as writeFile6 } from "fs/promises";
 import { basename as basename5, dirname as dirname11, join as join16, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
@@ -11011,10 +11227,10 @@ function resolveProjectsRoot(projectPath) {
   }
   try {
     const supportPaths = resolveOpenScoutSupportPaths();
-    if (!existsSync10(supportPaths.settingsPath)) {
+    if (!existsSync11(supportPaths.settingsPath)) {
       return dirname11(projectPath);
     }
-    const raw2 = JSON.parse(readFileSync6(supportPaths.settingsPath, "utf8"));
+    const raw2 = JSON.parse(readFileSync7(supportPaths.settingsPath, "utf8"));
     const workspaceRoot = raw2.discovery?.workspaceRoots?.find((entry) => typeof entry === "string" && entry.trim().length > 0);
     return workspaceRoot ? resolve6(workspaceRoot) : dirname11(projectPath);
   } catch {
@@ -11030,8 +11246,14 @@ function nowSeconds2() {
 function normalizeBrokerTimestamp(value) {
   return value > 10000000000 ? Math.floor(value / 1000) : value;
 }
+function scoutCliPath() {
+  return join16(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
+}
+function legacyNodeBrokerRelayCommand() {
+  return `node ${JSON.stringify(scoutCliPath())}`;
+}
 function brokerRelayCommand() {
-  return `node ${JSON.stringify(join16(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs"))}`;
+  return `bun ${JSON.stringify(scoutCliPath())}`;
 }
 function sleep3(ms) {
   return new Promise((resolve7) => setTimeout(resolve7, ms));
@@ -11053,7 +11275,7 @@ function resolveScoutSkillPath() {
     join16(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
   ];
   for (const path of candidatePaths) {
-    if (existsSync10(path)) {
+    if (existsSync11(path)) {
       return path;
     }
   }
@@ -11249,7 +11471,7 @@ function buildLegacyBrokerBackedRelayPrompt(agentId, projectName, projectPath, r
 function legacyLocalAgentSystemPromptCandidates(agentId, projectName, projectPath) {
   const relayHub = resolveRelayHub();
   const brokerUrl = resolveBrokerUrl();
-  const relayCommandBases = ["openscout relay", brokerRelayCommand()];
+  const relayCommandBases = ["openscout relay", brokerRelayCommand(), legacyNodeBrokerRelayCommand()];
   const projectPathCandidates = projectPath.endsWith("/") ? [projectPath, projectPath.slice(0, -1)] : [projectPath, `${projectPath}/`];
   const candidates = new Set;
   for (const pathCandidate of projectPathCandidates) {
@@ -11260,12 +11482,28 @@ function legacyLocalAgentSystemPromptCandidates(agentId, projectName, projectPat
   }
   return Array.from(candidates);
 }
+function generatedLocalAgentSystemPromptCandidates(agentId, projectName, projectPath) {
+  const baseContext = buildLocalAgentTemplateContext(agentId, projectName, projectPath);
+  const relayCommands = [brokerRelayCommand(), legacyNodeBrokerRelayCommand()];
+  const transportModes = [undefined, "codex_app_server", "claude_stream_json"];
+  const candidates = new Set;
+  for (const relayCommand of relayCommands) {
+    const context = {
+      ...baseContext,
+      relayCommand
+    };
+    for (const transport of transportModes) {
+      candidates.add(renderLocalAgentSystemPromptTemplate(buildLocalAgentSystemPromptTemplate(), context, transport ? { transport } : {}));
+    }
+  }
+  return Array.from(candidates);
+}
 function normalizeLocalAgentSystemPrompt(agentId, projectName, projectPath, systemPrompt) {
   const trimmed = systemPrompt?.trim();
   if (!trimmed) {
     return;
   }
-  if (legacyLocalAgentSystemPromptCandidates(agentId, projectName, projectPath).includes(trimmed)) {
+  if (legacyLocalAgentSystemPromptCandidates(agentId, projectName, projectPath).includes(trimmed) || generatedLocalAgentSystemPromptCandidates(agentId, projectName, projectPath).includes(trimmed)) {
     return;
   }
   return trimmed;
@@ -11352,6 +11590,128 @@ function normalizeLocalAgentCapabilities(value) {
 function normalizeLocalAgentLaunchArgs(value) {
   return Array.isArray(value) ? value.map((entry) => String(entry).trim()).filter(Boolean) : [];
 }
+function normalizeRequestedModel(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+function readClaudeLaunchModel(launchArgs) {
+  for (let index = 0;index < launchArgs.length; index += 1) {
+    const current = launchArgs[index] ?? "";
+    if (current === "--model") {
+      const next = launchArgs[index + 1]?.trim();
+      return next || undefined;
+    }
+    if (current.startsWith("--model=")) {
+      const next = current.slice("--model=".length).trim();
+      return next || undefined;
+    }
+  }
+  return;
+}
+function normalizeLaunchArgsForHarness(harness, value) {
+  const normalized = normalizeLocalAgentLaunchArgs(value);
+  if (harness === "codex") {
+    return normalizeCodexAppServerLaunchArgs(normalized);
+  }
+  return normalized;
+}
+function readLaunchModelForHarness(harness, launchArgs) {
+  if (harness === "codex") {
+    return readCodexAppServerModelFromLaunchArgs(launchArgs) ?? undefined;
+  }
+  if (harness === "claude") {
+    return readClaudeLaunchModel(launchArgs ?? []);
+  }
+  return;
+}
+function stripLaunchModelForHarness(harness, launchArgs) {
+  if (harness === "codex") {
+    const next = [];
+    const normalized = normalizeCodexAppServerLaunchArgs(launchArgs);
+    for (let index = 0;index < normalized.length; index += 1) {
+      const current = normalized[index] ?? "";
+      if (current === "-c" || current === "--config") {
+        const value = normalized[index + 1];
+        if (readCodexAppServerModelFromLaunchArgs(value ? [current, value] : [current])) {
+          index += 1;
+          continue;
+        }
+        next.push(current);
+        if (value) {
+          next.push(value);
+          index += 1;
+        }
+        continue;
+      }
+      if (current.startsWith("--config=")) {
+        if (readCodexAppServerModelFromLaunchArgs([current])) {
+          continue;
+        }
+      }
+      next.push(current);
+    }
+    return next;
+  }
+  if (harness === "claude") {
+    const next = [];
+    const normalized = normalizeLocalAgentLaunchArgs(launchArgs);
+    for (let index = 0;index < normalized.length; index += 1) {
+      const current = normalized[index] ?? "";
+      if (current === "--model") {
+        index += 1;
+        continue;
+      }
+      if (current.startsWith("--model=")) {
+        continue;
+      }
+      next.push(current);
+    }
+    return next;
+  }
+  return normalizeLocalAgentLaunchArgs(launchArgs);
+}
+function buildLaunchArgsForRequestedModel(harness, model) {
+  if (harness === "codex") {
+    return normalizeCodexAppServerLaunchArgs(["--model", model]);
+  }
+  if (harness === "claude") {
+    return ["--model", model];
+  }
+  return [];
+}
+function applyRequestedModelToLaunchArgs(harness, launchArgs, model) {
+  const normalized = normalizeLaunchArgsForHarness(harness, launchArgs);
+  const requestedModel = normalizeRequestedModel(model);
+  if (!requestedModel) {
+    return normalized;
+  }
+  return [
+    ...stripLaunchModelForHarness(harness, normalized),
+    ...buildLaunchArgsForRequestedModel(harness, requestedModel)
+  ];
+}
+function defaultHarnessForOverride(override, fallback = "claude") {
+  return normalizeManagedHarness2(override.defaultHarness ?? override.runtime?.harness, fallback);
+}
+function launchArgsForOverrideHarness(override, harness) {
+  const profileLaunchArgs = override.harnessProfiles?.[harness]?.launchArgs;
+  if (profileLaunchArgs) {
+    return normalizeLaunchArgsForHarness(harness, profileLaunchArgs);
+  }
+  if (harness === defaultHarnessForOverride(override, harness)) {
+    return normalizeLaunchArgsForHarness(harness, override.launchArgs);
+  }
+  return [];
+}
+function overrideHarnessProfile(override, harness) {
+  const profile = override.harnessProfiles?.[harness];
+  return {
+    cwd: normalizeProjectPath(profile?.cwd || override.runtime?.cwd || override.projectRoot || process.cwd()),
+    transport: normalizeLocalAgentTransport(profile?.transport ?? override.runtime?.transport, harness),
+    sessionId: normalizeTmuxSessionName2(profile?.sessionId, `${override.agentId}-${harness}`),
+    launchArgs: launchArgsForOverrideHarness(override, harness)
+  };
+}
 function normalizeManagedHarness2(value, fallback) {
   return value === "codex" ? "codex" : value === "claude" ? "claude" : fallback;
 }
@@ -11367,7 +11727,7 @@ function normalizeLocalHarnessProfiles(agentId, record) {
       cwd: normalizeProjectPath(profile.cwd || record.cwd || process.cwd()),
       transport: normalizeLocalAgentTransport(profile.transport, harness),
       sessionId: normalizeTmuxSessionName2(profile.sessionId, `${agentId}-${harness}`),
-      launchArgs: normalizeLocalAgentLaunchArgs(profile.launchArgs)
+      launchArgs: normalizeLaunchArgsForHarness(harness, profile.launchArgs)
     };
   }
   const runtimeHarness = normalizeManagedHarness2(record.harness, defaultHarness);
@@ -11376,7 +11736,7 @@ function normalizeLocalHarnessProfiles(agentId, record) {
       cwd: normalizeProjectPath(record.cwd || process.cwd()),
       transport: normalizeLocalAgentTransport(record.transport, runtimeHarness),
       sessionId: normalizeTmuxSessionName2(record.tmuxSession, `${agentId}-${runtimeHarness}`),
-      launchArgs: normalizeLocalAgentLaunchArgs(record.launchArgs)
+      launchArgs: normalizeLaunchArgsForHarness(runtimeHarness, record.launchArgs)
     };
   }
   if (!nextProfiles[defaultHarness]) {
@@ -11384,7 +11744,7 @@ function normalizeLocalHarnessProfiles(agentId, record) {
       cwd: normalizeProjectPath(record.cwd || process.cwd()),
       transport: normalizeLocalAgentTransport(record.transport, defaultHarness),
       sessionId: normalizeTmuxSessionName2(record.tmuxSession, `${agentId}-${defaultHarness}`),
-      launchArgs: normalizeLocalAgentLaunchArgs(record.launchArgs)
+      launchArgs: normalizeLaunchArgsForHarness(defaultHarness, record.launchArgs)
     };
   }
   for (const harness of ["claude", "codex"]) {
@@ -11396,7 +11756,7 @@ function normalizeLocalHarnessProfiles(agentId, record) {
       cwd: normalizeProjectPath(profile.cwd || record.cwd || process.cwd()),
       transport: normalizeLocalAgentTransport(profile.transport, harness),
       sessionId: normalizeTmuxSessionName2(profile.sessionId, `${agentId}-${harness}`),
-      launchArgs: normalizeLocalAgentLaunchArgs(profile.launchArgs)
+      launchArgs: normalizeLaunchArgsForHarness(harness, profile.launchArgs)
     };
   }
   return nextProfiles;
@@ -11420,14 +11780,14 @@ function recordForHarness(record, harnessOverride) {
       tmuxSession: fallbackSessionId,
       cwd: fallbackCwd,
       transport: fallbackTransport,
-      launchArgs: normalizeLocalAgentLaunchArgs(normalized.launchArgs),
+      launchArgs: normalizeLaunchArgsForHarness(selectedHarness, normalized.launchArgs),
       harnessProfiles: {
         ...normalized.harnessProfiles,
         [selectedHarness]: {
           cwd: fallbackCwd,
           transport: fallbackTransport,
           sessionId: fallbackSessionId,
-          launchArgs: normalizeLocalAgentLaunchArgs(normalized.launchArgs)
+          launchArgs: normalizeLaunchArgsForHarness(selectedHarness, normalized.launchArgs)
         }
       }
     };
@@ -11469,7 +11829,7 @@ function normalizeLocalAgentRecord(agentId, record) {
     harnessProfiles,
     transport: activeProfile?.transport ?? normalizeLocalAgentTransport(record.transport, harness),
     capabilities: normalizeLocalAgentCapabilities(record.capabilities),
-    launchArgs: activeProfile?.launchArgs ?? normalizeLocalAgentLaunchArgs(record.launchArgs)
+    launchArgs: activeProfile?.launchArgs ?? normalizeLaunchArgsForHarness(harness, record.launchArgs)
   };
 }
 function localAgentStatusFromRecord(agentId, record, source) {
@@ -11538,7 +11898,7 @@ function relayAgentOverrideFromLocalAgentRecord(agentId, record, existing) {
     source: existing?.source && existing.source !== "inferred" ? existing.source : "manual",
     startedAt: normalizedRecord.startedAt,
     systemPrompt: normalizedRecord.systemPrompt,
-    launchArgs: normalizeLocalAgentLaunchArgs(normalizedRecord.launchArgs),
+    launchArgs: normalizeLaunchArgsForHarness(normalizeLocalAgentHarness(normalizedRecord.harness), normalizedRecord.launchArgs),
     capabilities: normalizeLocalAgentCapabilities(normalizedRecord.capabilities),
     defaultHarness: normalizeManagedHarness2(normalizedRecord.defaultHarness, "claude"),
     harnessProfiles: normalizedRecord.harnessProfiles,
@@ -11563,7 +11923,7 @@ function buildLocalAgentConfigState(agentId, record) {
       sessionId: record.tmuxSession,
       wakePolicy: "on_demand"
     },
-    launchArgs: normalizeLocalAgentLaunchArgs(record.launchArgs),
+    launchArgs: normalizeLaunchArgsForHarness(normalizeLocalAgentHarness(record.harness), record.launchArgs),
     capabilities: normalizeLocalAgentCapabilities(record.capabilities),
     applyMode: "restart",
     templateHint: LOCAL_AGENT_SYSTEM_PROMPT_TEMPLATE_HINT
@@ -11617,11 +11977,13 @@ async function getLocalAgentEndpointSessionSnapshot(endpoint) {
 async function ensureLocalSessionEndpointOnline(endpoint) {
   if (endpoint.transport === "codex_app_server") {
     await ensureCodexAppServerAgentOnline(buildCodexEndpointSessionOptions(endpoint));
-    return;
+    return {};
   }
   if (endpoint.transport === "claude_stream_json") {
-    await ensureClaudeStreamJsonAgentOnline(buildClaudeEndpointSessionOptions(endpoint));
+    const result = await ensureClaudeStreamJsonAgentOnline(buildClaudeEndpointSessionOptions(endpoint));
+    return { externalSessionId: result.sessionId };
   }
+  return {};
 }
 async function shutdownLocalSessionEndpoint(endpoint) {
   if (endpoint.transport === "codex_app_server") {
@@ -11687,7 +12049,7 @@ function buildCodexAgentSessionOptions(agentName, record, systemPrompt) {
     systemPrompt: systemPrompt ?? buildLocalAgentSystemPrompt(agentName, record.project, record.cwd, { transport: "codex_app_server" }),
     runtimeDirectory: relayAgentRuntimeDirectory(agentName),
     logsDirectory: relayAgentLogsDirectory(agentName),
-    launchArgs: normalizeLocalAgentLaunchArgs(record.launchArgs)
+    launchArgs: normalizeLaunchArgsForHarness("codex", record.launchArgs)
   };
 }
 function buildClaudeAgentSessionOptions(agentName, record, systemPrompt) {
@@ -11698,7 +12060,7 @@ function buildClaudeAgentSessionOptions(agentName, record, systemPrompt) {
     systemPrompt: systemPrompt ?? buildLocalAgentSystemPrompt(agentName, record.project, record.cwd, { transport: "claude_stream_json" }),
     runtimeDirectory: relayAgentRuntimeDirectory(agentName),
     logsDirectory: relayAgentLogsDirectory(agentName),
-    launchArgs: normalizeLocalAgentLaunchArgs(record.launchArgs)
+    launchArgs: normalizeLaunchArgsForHarness("claude", record.launchArgs)
   };
 }
 function endpointMetadataString(endpoint, key) {
@@ -11903,7 +12265,7 @@ function buildLocalAgentBootstrapPrompt(_harness, _systemPrompt, initialMessage)
   return initialMessage;
 }
 function buildLocalAgentLaunchCommand(agentName, record, projectPath, promptFile, workerScript) {
-  const extraArgs = shellQuoteArguments(normalizeLocalAgentLaunchArgs(record.launchArgs));
+  const extraArgs = shellQuoteArguments(normalizeLaunchArgsForHarness(normalizeLocalAgentHarness(record.harness), record.launchArgs));
   if (normalizeLocalAgentHarness(record.harness) === "codex") {
     return `exec bash ${JSON.stringify(workerScript ?? join16(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
   }
@@ -12059,7 +12421,7 @@ async function ensureLocalAgentOnline(agentName, record) {
     await new Promise((resolve7) => setTimeout(resolve7, 100));
   }
   if (!isLocalAgentSessionAlive(normalizedRecord.tmuxSession)) {
-    const stderrTail = existsSync10(stderrLogFile) ? readFileSync6(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
+    const stderrTail = existsSync11(stderrLogFile) ? readFileSync7(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
 `).trim() : "";
     throw new Error(stderrTail ? `Relay agent ${agentName} failed to stay online:
 ${stderrTail}` : `Relay agent ${agentName} failed to stay online.`);
@@ -12275,6 +12637,7 @@ async function startLocalAgent(input) {
     const effectiveHarness = normalizeManagedHarness2(preferredHarness ?? configDefaultHarness, "claude");
     const transport = normalizeLocalAgentTransport(undefined, effectiveHarness);
     const sessionId = normalizeTmuxSessionName2(undefined, `${instance.id}-${effectiveHarness}`);
+    const launchArgs = applyRequestedModelToLaunchArgs(effectiveHarness, [], input.model);
     const existingForInstance = overrides[instance.id];
     if (existingForInstance && normalizeProjectPath(existingForInstance.projectRoot) !== projectRoot) {
       throw new Error(`Another agent is already registered as ${instance.id} at ${existingForInstance.projectRoot}. ` + `Two clones of the same project on the same branch cannot both register here; ` + `rename one of the checkouts or switch its branch before running scout up.`);
@@ -12288,13 +12651,14 @@ async function startLocalAgent(input) {
       projectConfigPath: coldProjectConfigPath,
       source: "manual",
       startedAt: nowSeconds2(),
+      launchArgs,
       defaultHarness: effectiveHarness,
       harnessProfiles: {
         [effectiveHarness]: {
           cwd: effectiveCwd ?? projectRoot,
           transport,
           sessionId,
-          launchArgs: []
+          launchArgs
         }
       },
       runtime: {
@@ -12315,6 +12679,9 @@ async function startLocalAgent(input) {
       throw new Error(`Another agent is already registered as ${instance.id} at ${existingForInstance.projectRoot}. ` + `Two clones of the same project on the same branch cannot both register here; ` + `rename one of the checkouts or switch its branch before running scout up.`);
     }
     const resolvedHarness = preferredHarness ?? matchingOverride.runtime?.harness;
+    const nextHarness = normalizeManagedHarness2(resolvedHarness, "claude");
+    const nextDefaultHarness = preferredHarness ? normalizeManagedHarness2(preferredHarness, "claude") : defaultHarnessForOverride(matchingOverride, "claude");
+    const nextLaunchArgs = applyRequestedModelToLaunchArgs(nextHarness, launchArgsForOverrideHarness(matchingOverride, nextHarness), input.model);
     overrides[instance.id] = {
       agentId: instance.id,
       definitionId: requestedDefinitionId,
@@ -12325,10 +12692,16 @@ async function startLocalAgent(input) {
       source: "manual",
       startedAt: matchingOverride.startedAt ?? nowSeconds2(),
       systemPrompt: matchingOverride.systemPrompt,
-      launchArgs: matchingOverride.launchArgs,
+      launchArgs: nextHarness === nextDefaultHarness ? nextLaunchArgs : matchingOverride.launchArgs,
       capabilities: matchingOverride.capabilities,
-      defaultHarness: normalizeManagedHarness2(preferredHarness ?? matchingOverride.defaultHarness, "claude"),
-      harnessProfiles: matchingOverride.harnessProfiles,
+      defaultHarness: nextDefaultHarness,
+      harnessProfiles: {
+        ...matchingOverride.harnessProfiles ?? {},
+        [nextHarness]: {
+          ...overrideHarnessProfile(matchingOverride, nextHarness),
+          launchArgs: nextLaunchArgs
+        }
+      },
       runtime: {
         cwd: effectiveCwd ?? matchingOverride.runtime?.cwd ?? matchingProjectRoot,
         harness: resolvedHarness,
@@ -12340,6 +12713,22 @@ async function startLocalAgent(input) {
     await writeRelayAgentOverrides(overrides);
     targetAgentId = instance.id;
   } else {
+    if (input.model) {
+      const existingHarness = normalizeManagedHarness2(preferredHarness ?? matchingOverride.defaultHarness ?? matchingOverride.runtime?.harness, "claude");
+      const nextLaunchArgs = applyRequestedModelToLaunchArgs(existingHarness, launchArgsForOverrideHarness(matchingOverride, existingHarness), input.model);
+      overrides[matchingAgentId] = {
+        ...matchingOverride,
+        launchArgs: existingHarness === defaultHarnessForOverride(matchingOverride, existingHarness) ? nextLaunchArgs : matchingOverride.launchArgs,
+        harnessProfiles: {
+          ...matchingOverride.harnessProfiles ?? {},
+          [existingHarness]: {
+            ...overrideHarnessProfile(matchingOverride, existingHarness),
+            launchArgs: nextLaunchArgs
+          }
+        }
+      };
+      await writeRelayAgentOverrides(overrides);
+    }
     targetAgentId = matchingAgentId;
   }
   await ensureLocalAgentBindingOnline(targetAgentId, process.env.OPENSCOUT_NODE_ID ?? "local", {
@@ -12427,13 +12816,38 @@ async function restartAllLocalAgents(options = {}) {
   }));
   return restarted.filter((agent) => Boolean(agent));
 }
+function readPersistedClaudeSessionId(agentName) {
+  try {
+    const runtimeDir = relayAgentRuntimeDirectory(agentName);
+    const catalogPath = join16(runtimeDir, "session-catalog.json");
+    if (existsSync11(catalogPath)) {
+      const raw2 = readFileSync7(catalogPath, "utf8").trim();
+      if (raw2) {
+        const catalog = JSON.parse(raw2);
+        if (typeof catalog.activeSessionId === "string" && catalog.activeSessionId.trim()) {
+          return catalog.activeSessionId.trim();
+        }
+      }
+    }
+    const legacyPath = join16(runtimeDir, "claude-session-id.txt");
+    if (existsSync11(legacyPath)) {
+      const value = readFileSync7(legacyPath, "utf8").trim();
+      return value || null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
   const normalizedRecord = normalizeLocalAgentRecord(agentId, record);
+  const configuredModel = readLaunchModelForHarness(normalizeLocalAgentHarness(normalizedRecord.harness), normalizedRecord.launchArgs);
   const definitionId = normalizedRecord.definitionId ?? agentId;
   const displayName = titleCaseLocalAgentName(definitionId);
   const projectRoot = normalizedRecord.projectRoot ?? normalizedRecord.cwd;
   const instance = buildRelayAgentInstance(definitionId, projectRoot);
   const actorId = instance.id;
+  const externalSessionId = normalizedRecord.transport === "claude_stream_json" ? readPersistedClaudeSessionId(definitionId) : null;
   return {
     actor: {
       id: actorId,
@@ -12452,7 +12866,8 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         defaultSelector: instance.defaultSelector,
         nodeQualifier: instance.nodeQualifier,
         workspaceQualifier: instance.workspaceQualifier,
-        branch: instance.branch
+        branch: instance.branch,
+        ...configuredModel ? { model: configuredModel } : {}
       }
     },
     agent: {
@@ -12479,7 +12894,8 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         defaultSelector: instance.defaultSelector,
         nodeQualifier: instance.nodeQualifier,
         workspaceQualifier: instance.workspaceQualifier,
-        branch: instance.branch
+        branch: instance.branch,
+        ...configuredModel ? { model: configuredModel } : {}
       },
       agentClass: "general",
       capabilities: normalizeLocalAgentCapabilities(normalizedRecord.capabilities),
@@ -12511,7 +12927,9 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         selector: instance.selector,
         nodeQualifier: instance.nodeQualifier,
         workspaceQualifier: instance.workspaceQualifier,
-        branch: instance.branch
+        branch: instance.branch,
+        ...configuredModel ? { model: configuredModel } : {},
+        ...externalSessionId ? { externalSessionId } : {}
       }
     }
   };
@@ -12711,12 +13129,12 @@ var init_local_agents = __esm(async () => {
 });
 
 // packages/web/server/index.ts
-import { existsSync as existsSync14 } from "fs";
-import { dirname as dirname13, join as join21, resolve as resolve10 } from "path";
-import { fileURLToPath as fileURLToPath8 } from "url";
+import { existsSync as existsSync15 } from "fs";
+import { dirname as dirname14, join as join20, resolve as resolve11 } from "path";
+import { fileURLToPath as fileURLToPath9 } from "url";
 
 // packages/web/server/create-openscout-web-server.ts
-import { existsSync as existsSync12, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync13, rmSync as rmSync3 } from "fs";
 import { dirname as dirname12, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
@@ -15487,19 +15905,15 @@ function resolveDbPath() {
   return join12(controlHome, "control-plane.sqlite");
 }
 var _db = null;
-var _dbOpenedAt = 0;
-var DB_REOPEN_MS = 2000;
+var DB_BUSY_TIMEOUT_MS = 250;
+function configureReadonlyDb(db) {
+  db.exec(`PRAGMA busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
+  db.exec("PRAGMA query_only = ON");
+}
 function db() {
-  const now = Date.now();
-  if (_db && now - _dbOpenedAt > DB_REOPEN_MS) {
-    _db.close();
-    _db = null;
-  }
   if (!_db) {
     _db = new Database(resolveDbPath(), { readonly: true });
-    _db.exec("PRAGMA busy_timeout = 5000");
-    _db.exec("PRAGMA journal_mode = WAL");
-    _dbOpenedAt = now;
+    configureReadonlyDb(_db);
   }
   return _db;
 }
@@ -15536,7 +15950,7 @@ function resolveHarnessSessionId(transport, endpointSessionId, metadata) {
     return metadataString(metadata, "threadId") ?? endpointSessionId;
   }
   if (transport === "claude_stream_json") {
-    return endpointSessionId ?? metadataString(metadata, "externalSessionId");
+    return metadataString(metadata, "externalSessionId") ?? endpointSessionId;
   }
   return null;
 }
@@ -15620,6 +16034,12 @@ function transientBrokerWorkingStatusPredicate(alias) {
     AND ${alias}.body LIKE '% is working.'
   )`;
 }
+function staleFlightActivityPredicate(alias) {
+  return `NOT (
+    ${alias}.kind = 'flight_updated'
+    AND COALESCE(${alias}.summary, '') LIKE 'Stale running flight reconciled:%'
+  )`;
+}
 function workPhaseFromFlightState(state) {
   switch (state) {
     case "queued":
@@ -15783,10 +16203,7 @@ function queryActivity(limit = 60) {
        FROM activity_items ai
        LEFT JOIN actors ac ON ac.id = ai.actor_id
        WHERE ai.kind != 'ask_replied'
-         AND NOT (
-           ai.kind = 'flight_updated'
-           AND COALESCE(ai.summary, '') LIKE 'Stale running flight reconciled:%'
-         )
+         AND ${staleFlightActivityPredicate("ai")}
        ORDER BY ai.ts DESC
        LIMIT ?`).all(limit);
   const items = rows.map((r) => ({
@@ -16512,6 +16929,7 @@ function queryFleetActivity(opts) {
     filters.push("ai.conversation_id = ?");
     params.push(opts.conversationId);
   }
+  const scopedFilters = sqlJoinClauses(filters, "OR");
   const sql = `SELECT
     ai.id,
     ai.kind,
@@ -16530,7 +16948,10 @@ function queryFleetActivity(opts) {
     ai.session_id
   FROM activity_items ai
   LEFT JOIN actors ac ON ac.id = ai.actor_id
-  ${sqlWhereClause(filters, "OR")}
+  ${sqlWhereClause([
+    staleFlightActivityPredicate("ai"),
+    scopedFilters ? `(${scopedFilters})` : null
+  ])}
   ORDER BY ai.ts DESC
   LIMIT ?`;
   const rows = db().prepare(sql).all(...params, opts?.limit ?? 80);
@@ -16613,6 +17034,10 @@ function queryFleetAskRows(requesterIds, limit) {
      )
      LEFT JOIN collaboration_records cr ON cr.id = inv.collaboration_record_id
      WHERE inv.requester_id IN (${requesterClause})
+       AND NOT (
+         COALESCE(f.state, '') = 'failed'
+         AND COALESCE(f.error, '') LIKE 'Stale running flight reconciled:%'
+       )
      ORDER BY COALESCE(f.completed_at, f.started_at, inv.created_at) DESC
      LIMIT ?`).all(...requesterIds, limit);
 }
@@ -16714,125 +17139,67 @@ function queryFleet(opts) {
     activity
   };
 }
-var WINDOW_TIERS = [
-  { ms: 30 * 60000, label: "30m" },
-  { ms: 60 * 60000, label: "1h" },
-  { ms: 6 * 60 * 60000, label: "6h" },
-  { ms: 24 * 60 * 60000, label: "24h" },
-  { ms: 7 * 24 * 60 * 60000, label: "7d" }
-];
-var MIN_FILLED_BUCKETS = 3;
-var _sealedCounts = new Map;
-var _cachedTier = null;
-function queryHeartrate(numBuckets = 48) {
-  const nowMs = Date.now();
-  let chosenTier = WINDOW_TIERS[WINDOW_TIERS.length - 1];
-  for (const tier of WINDOW_TIERS) {
-    const bucketMs2 = tier.ms / numBuckets;
-    const currentBucketStart2 = Math.floor(nowMs / bucketMs2) * bucketMs2;
-    const alignedStart2 = currentBucketStart2 - (numBuckets - 1) * bucketMs2;
-    if (_cachedTier === tier.label) {
-      let sealedHits = 0;
-      let filledSealed = 0;
-      for (let i = 0;i < numBuckets - 1; i++) {
-        const key = String(alignedStart2 + i * bucketMs2);
-        if (_sealedCounts.has(key)) {
-          sealedHits++;
-          if (_sealedCounts.get(key) > 0)
-            filledSealed++;
-        }
-      }
-      if (sealedHits === numBuckets - 1 && filledSealed >= MIN_FILLED_BUCKETS) {
-        chosenTier = tier;
-        break;
-      }
-    }
-    const rows2 = db().prepare(`SELECT ts FROM activity_items WHERE ts >= ? ORDER BY ts ASC`).all(alignedStart2);
-    const counts2 = new Array(numBuckets).fill(0);
-    for (const row of rows2) {
-      const ms = row.ts < 1000000000000 ? row.ts * 1000 : row.ts;
-      if (ms < alignedStart2)
+var HEARTRATE_WINDOW_MS = 7 * 24 * 60 * 60000;
+var DEFAULT_HEARTRATE_BUCKETS = 56;
+var SQLITE_MILLISECONDS_THRESHOLD = 1000000000000;
+function normalizeActivityTimestampMs(ts) {
+  return ts < SQLITE_MILLISECONDS_THRESHOLD ? ts * 1000 : ts;
+}
+function smoothHeartrateCounts(counts) {
+  const energy = counts.map((count) => Math.sqrt(count));
+  const weights = [0.56, 0.28, 0.11, 0.05];
+  return energy.map((_, index) => {
+    let total = 0;
+    let weightTotal = 0;
+    for (let offset = -3;offset <= 3; offset++) {
+      const nextIndex = index + offset;
+      if (nextIndex < 0 || nextIndex >= energy.length)
         continue;
-      const idx = Math.min(numBuckets - 1, Math.floor((ms - alignedStart2) / bucketMs2));
-      if (idx >= 0)
-        counts2[idx]++;
-    }
-    const filled = counts2.filter((c) => c > 0).length;
-    if (filled >= MIN_FILLED_BUCKETS) {
-      if (_cachedTier !== tier.label) {
-        _sealedCounts.clear();
-        _cachedTier = tier.label;
-      }
-      for (let i = 0;i < numBuckets - 1; i++) {
-        _sealedCounts.set(String(alignedStart2 + i * bucketMs2), counts2[i]);
-      }
-      const peak2 = Math.max(1, ...counts2);
-      return {
-        windowLabel: tier.label,
-        buckets: counts2.map((count, i) => ({
-          ts: Math.round(alignedStart2 + i * bucketMs2),
-          count,
-          value: count / peak2
-        }))
-      };
+      const weight = weights[Math.abs(offset)] ?? 0;
+      total += energy[nextIndex] * weight;
+      weightTotal += weight;
     }
+    return weightTotal > 0 ? total / weightTotal : 0;
+  });
+}
+function formatHeartrateBucketLabel(bucketMs) {
+  const minutes = Math.round(bucketMs / 60000);
+  if (minutes % (24 * 60) === 0) {
+    return `${minutes / (24 * 60)}d buckets`;
+  }
+  if (minutes % 60 === 0) {
+    return `${minutes / 60}h buckets`;
   }
-  const bucketMs = chosenTier.ms / numBuckets;
+  return `${minutes}m buckets`;
+}
+function queryHeartrate(numBuckets = DEFAULT_HEARTRATE_BUCKETS, nowMs = Date.now()) {
+  const bucketMs = HEARTRATE_WINDOW_MS / numBuckets;
   const currentBucketStart = Math.floor(nowMs / bucketMs) * bucketMs;
   const alignedStart = currentBucketStart - (numBuckets - 1) * bucketMs;
-  if (_cachedTier === chosenTier.label) {
-    const counts2 = new Array(numBuckets).fill(0);
-    let allSealed = true;
-    for (let i = 0;i < numBuckets - 1; i++) {
-      const key = String(alignedStart + i * bucketMs);
-      if (_sealedCounts.has(key)) {
-        counts2[i] = _sealedCounts.get(key);
-      } else {
-        allSealed = false;
-        break;
-      }
-    }
-    if (allSealed) {
-      const liveStart = alignedStart + (numBuckets - 1) * bucketMs;
-      const row = db().prepare(`SELECT COUNT(*) AS c FROM activity_items WHERE ts >= ?`).get(liveStart);
-      counts2[numBuckets - 1] = row.c;
-      const peak2 = Math.max(1, ...counts2);
-      return {
-        windowLabel: chosenTier.label,
-        buckets: counts2.map((count, i) => ({
-          ts: Math.round(alignedStart + i * bucketMs),
-          count,
-          value: count / peak2
-        }))
-      };
-    }
-  }
-  _sealedCounts.clear();
-  _cachedTier = chosenTier.label;
-  const rows = db().prepare(`SELECT ts FROM activity_items WHERE ts >= ? ORDER BY ts ASC`).all(alignedStart);
+  const alignedStartSeconds = Math.floor(alignedStart / 1000);
+  const rows = db().prepare(`SELECT ts
+       FROM activity_items
+       WHERE ts >= ?1
+          OR (ts < ?2 AND ts >= ?3)
+       ORDER BY ts ASC`).all(alignedStart, SQLITE_MILLISECONDS_THRESHOLD, alignedStartSeconds);
   const counts = new Array(numBuckets).fill(0);
   for (const row of rows) {
-    const ms = row.ts < 1000000000000 ? row.ts * 1000 : row.ts;
-    if (ms < alignedStart)
+    const ms = normalizeActivityTimestampMs(row.ts);
+    if (ms < alignedStart || ms > nowMs)
       continue;
     const idx = Math.min(numBuckets - 1, Math.floor((ms - alignedStart) / bucketMs));
     if (idx >= 0)
       counts[idx]++;
   }
-  for (let i = 0;i < numBuckets - 1; i++) {
-    _sealedCounts.set(String(alignedStart + i * bucketMs), counts[i]);
-  }
-  for (const key of _sealedCounts.keys()) {
-    if (Number(key) < alignedStart)
-      _sealedCounts.delete(key);
-  }
-  const peak = Math.max(1, ...counts);
+  const smoothed = smoothHeartrateCounts(counts);
+  const peak = Math.max(1, ...smoothed);
   return {
-    windowLabel: chosenTier.label,
+    windowLabel: "trailing 7d",
+    bucketLabel: formatHeartrateBucketLabel(bucketMs),
     buckets: counts.map((count, i) => ({
       ts: Math.round(alignedStart + i * bucketMs),
       count,
-      value: count / peak
+      value: smoothed[i] / peak
     }))
   };
 }
@@ -17761,7 +18128,7 @@ function whoEntryState(endpoints, registrationKind) {
 
 // packages/web/server/core/observe/service.ts
 init_src();
-import { existsSync as existsSync11, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
 import { homedir as homedir12 } from "os";
 import { join as join18, resolve as resolve8 } from "path";
 
@@ -19749,6 +20116,9 @@ function parseSelf(status) {
     magicDnsSuffix: status.CurrentTailnet?.MagicDNSSuffix
   };
 }
+function isBackendRunning(status) {
+  return (status.BackendState ?? "").trim().toLowerCase() === "running";
+}
 async function readStatusJsonFromFile(filePath) {
   const raw2 = await readFile7(filePath, "utf8");
   return parseStatusJson(raw2);
@@ -19766,19 +20136,25 @@ async function readStatusJson() {
     return null;
   }
 }
-async function readTailscalePeers() {
-  const status = await readStatusJson();
-  if (!status) {
-    return [];
+async function readTailscaleSelf() {
+  const summary = await readTailscaleStatusSummary();
+  if (!summary) {
+    return null;
   }
-  return parsePeers(status);
+  return summary.self;
 }
-async function readTailscaleSelf() {
+async function readTailscaleStatusSummary() {
   const status = await readStatusJson();
   if (!status) {
     return null;
   }
-  return parseSelf(status);
+  return {
+    backendState: status.BackendState ?? null,
+    running: isBackendRunning(status),
+    health: status.Health ?? [],
+    peers: parsePeers(status),
+    self: parseSelf(status)
+  };
 }
 
 // packages/runtime/src/index.ts
@@ -20075,11 +20451,37 @@ function encodeClaudeProjectsSlug2(absolutePath) {
 }
 function resolveClaudeHistoryPath(cwd, sessionId) {
   const normalizedCwd = expandHome(cwd)?.trim();
+  if (!normalizedCwd) {
+    return null;
+  }
+  const projectDir = join18(homedir12(), ".claude", "projects", encodeClaudeProjectsSlug2(normalizedCwd));
   const normalizedSessionId = sessionId?.trim().replace(/\.jsonl$/u, "") || "";
-  if (!normalizedCwd || !normalizedSessionId) {
+  if (normalizedSessionId) {
+    const exactPath = join18(projectDir, `${normalizedSessionId}.jsonl`);
+    if (existsSync12(exactPath)) {
+      return exactPath;
+    }
+  }
+  return findMostRecentJsonl(projectDir);
+}
+function findMostRecentJsonl(dir) {
+  if (!existsSync12(dir))
+    return null;
+  try {
+    let best = null;
+    for (const entry of readdirSync2(dir)) {
+      if (!entry.endsWith(".jsonl"))
+        continue;
+      const full = join18(dir, entry);
+      const st = statSync4(full);
+      if (!best || st.mtimeMs > best.mtime) {
+        best = { path: full, mtime: st.mtimeMs };
+      }
+    }
+    return best?.path ?? null;
+  } catch {
     return null;
   }
-  return join18(homedir12(), ".claude", "projects", encodeClaudeProjectsSlug2(normalizedCwd), `${normalizedSessionId}.jsonl`);
 }
 function historyAdapterAlias(value) {
   const normalized = value?.trim().toLowerCase();
@@ -20143,7 +20545,7 @@ function readHistorySnapshot(candidate) {
   if (!supportsHistorySessionSnapshotForPath(candidate.path, candidate.adapterType)) {
     return null;
   }
-  if (!existsSync11(candidate.path)) {
+  if (!existsSync12(candidate.path)) {
     return null;
   }
   const stat5 = statSync4(candidate.path);
@@ -20157,7 +20559,7 @@ function readHistorySnapshot(candidate) {
   }
   const replay = createHistorySessionSnapshot({
     path: candidate.path,
-    content: readFileSync7(candidate.path, "utf8"),
+    content: readFileSync8(candidate.path, "utf8"),
     adapterType: candidate.adapterType,
     baseTimestampMs: stat5.mtimeMs
   });
@@ -20659,6 +21061,9 @@ async function loadAgentObservePayload(agentId) {
 
 // packages/web/server/core/mesh/service.ts
 await init_broker_service();
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
 function normalizeHost(host) {
   return host.trim().replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
 }
@@ -20689,9 +21094,13 @@ function stripTrailingDot(value) {
   return trimmed.replace(/\.$/, "");
 }
 async function readTailscaleStatus() {
-  const peers = await readTailscalePeers();
+  const summary = await readTailscaleStatusSummary();
+  const peers = summary?.peers ?? [];
   return {
-    available: peers.length > 0,
+    available: summary !== null,
+    running: summary?.running ?? false,
+    backendState: summary?.backendState ?? null,
+    health: summary?.health ?? [],
     peers,
     onlineCount: peers.filter((p) => p.online).length
   };
@@ -20712,6 +21121,16 @@ function computeIssues(health, localNode, nodes, tailscale2) {
     });
     return issues;
   }
+  if (tailscale2.available && !tailscale2.running) {
+    issues.push({
+      code: "tailscale_stopped",
+      severity: "warning",
+      title: "Tailscale is stopped",
+      summary: "This machine can still show cached Tailnet peers, but the local Tailscale backend is not running, so the broker cannot reach them.",
+      action: "Start Tailscale on this machine, then refresh mesh discovery.",
+      actionCommand: null
+    });
+  }
   if (localNode?.advertiseScope === "local") {
     issues.push({
       code: "local_only",
@@ -20879,6 +21298,24 @@ async function announceMeshVisibility() {
   } catch {}
   return loadMeshStatus();
 }
+async function openTailscaleApp() {
+  if (process.platform !== "darwin") {
+    throw new Error("Opening Tailscale from Scout is only supported on macOS right now.");
+  }
+  try {
+    await execFileAsync2("open", ["-a", "Tailscale"]);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Scout could not open Tailscale.app on this machine. ${detail}`);
+  }
+}
+async function controlTailscale(action) {
+  if (action === "open_app") {
+    await openTailscaleApp();
+    return loadMeshStatus();
+  }
+  throw new Error(`Unsupported Tailscale action: ${action}`);
+}
 
 // packages/web/server/runtime-summary.ts
 async function loadOpenScoutWebShellState() {
@@ -20915,6 +21352,9 @@ async function loadOpenScoutWebShellState() {
 
 // packages/web/server/create-openscout-web-server.ts
 init_setup();
+init_support_paths();
+init_claude_stream_json();
+init_harness_catalog();
 function parseOptionalPositiveInt(value, fallback) {
   if (typeof value !== "string" || value.trim().length === 0) {
     return fallback;
@@ -20958,10 +21398,10 @@ function resolveConversationRouting(conversationId) {
   return { directAgentId, senderId };
 }
 function resolveBundledStaticClientRoot(moduleUrl = import.meta.url) {
-  return resolve9(dirname12(fileURLToPath7(moduleUrl)), "client");
+  return resolve9(dirname12(fileURLToPath7(moduleUrl.toString())), "client");
 }
 function resolveSourceStaticClientRoot(moduleUrl = import.meta.url) {
-  return resolve9(dirname12(fileURLToPath7(moduleUrl)), "../dist/client");
+  return resolve9(dirname12(fileURLToPath7(moduleUrl.toString())), "../dist/client");
 }
 function resolveStaticRoot(staticRoot) {
   const configured = staticRoot?.trim();
@@ -20969,7 +21409,7 @@ function resolveStaticRoot(staticRoot) {
     return configured;
   }
   const bundled = resolveBundledStaticClientRoot(import.meta.url);
-  if (existsSync12(resolve9(bundled, "index.html"))) {
+  if (existsSync13(resolve9(bundled, "index.html"))) {
     return bundled;
   }
   return resolveSourceStaticClientRoot(import.meta.url);
@@ -21015,6 +21455,20 @@ async function createOpenScoutWebServer(options) {
     const payload = await loadAgentObservePayload(c.req.param("id"));
     return payload ? c.json(payload) : c.json({ error: "not found" }, 404);
   });
+  app.get("/api/agents/:id/session-catalog", (c) => {
+    const agentId = c.req.param("id");
+    const agents = queryAgents();
+    const agent = agents.find((a) => a.id === agentId);
+    if (!agent)
+      return c.json({ error: "agent not found" }, 404);
+    const runtimeDir = relayAgentRuntimeDirectory(agent.id);
+    const catalog = readSessionCatalogSync(runtimeDir);
+    const cwd = agent.cwd ?? agent.projectRoot ?? ".";
+    const sessionId = catalog.activeSessionId;
+    const harnessEntry = findHarnessEntry(agent.harness);
+    const resumeCommand = sessionId && harnessEntry ? buildHarnessResumeCommand(harnessEntry, sessionId, cwd) : null;
+    return c.json({ ...catalog, agentId, harness: agent.harness, resumeCommand });
+  });
   app.get("/api/activity", (c) => c.json(queryActivity()));
   app.get("/api/heartrate", (c) => c.json(queryHeartrate()));
   app.get("/api/fleet", (c) => c.json(queryFleet({
@@ -21075,6 +21529,15 @@ async function createOpenScoutWebServer(options) {
       return c.json({ error: message }, 500);
     }
   });
+  app.post("/api/mesh/tailscale", async (c) => {
+    try {
+      const { action } = await c.req.json();
+      return c.json(await controlTailscale(action));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
   app.get("/api/user", (c) => {
     const config = loadUserConfig();
     return c.json({
@@ -21215,6 +21678,21 @@ async function createOpenScoutWebServer(options) {
       quietHours: config.quietHours ?? "22:00 \u2013 07:00"
     });
   });
+  app.post("/api/terminal/run", async (c) => {
+    const body = await c.req.json();
+    if (!body.command)
+      return c.json({ error: "missing command" }, 400);
+    if (!options.runTerminalCommand) {
+      return c.json({ error: "terminal relay is unavailable" }, 503);
+    }
+    try {
+      await options.runTerminalCommand(body.command);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "failed to queue command";
+      return c.json({ error: message }, 503);
+    }
+    return c.json({ ok: true });
+  });
   app.post("/api/agents/:agentId/interrupt", async (c) => {
     const agentId = c.req.param("agentId");
     const { interruptLocalAgent: interruptLocalAgent2 } = await init_local_agents().then(() => exports_local_agents);
@@ -21308,387 +21786,252 @@ async function createOpenScoutWebServer(options) {
   return { app, warmupCaches };
 }
 
-// ../hudson/packages/hudson-relay/src/relay/session.ts
-import { createRequire } from "module";
-import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join19, dirname as pathDirname } from "path";
-var require2 = createRequire(import.meta.url);
-var pty = require2("node-pty");
-var DEFAULT_ORPHAN_TTL_MS = 30 * 60 * 1000;
-var MAX_BUFFER_SIZE = 512 * 1024;
-var sessions3 = new Map;
-function generateId() {
-  return Math.random().toString(36).slice(2, 10);
-}
-function send(ws, data) {
-  if (ws.readyState === 1) {
-    ws.send(JSON.stringify(data));
-  }
-}
-function resolveCwd(raw2) {
-  const home = process.env.HOME || "/tmp";
-  const expanded = (raw2 || home).replace(/^~/, home);
-  if (existsSync13(expanded))
-    return expanded;
-  try {
-    mkdirSync6(expanded, { recursive: true });
-    console.log(`[relay] Created missing cwd: ${expanded}`);
-    return expanded;
-  } catch {
-    console.warn(`[relay] Could not create cwd ${expanded}, falling back to ${home}`);
-    return home;
-  }
-}
-function findBin(name, envOverride) {
-  if (envOverride && process.env[envOverride])
-    return process.env[envOverride];
-  try {
-    return execSync2(`which ${name}`, { encoding: "utf8" }).trim() || null;
-  } catch {
-    return null;
-  }
-}
-function findClaudeBin() {
-  return findBin("claude", "CLAUDE_BIN");
-}
-function findPiBin() {
-  return findBin("pi", "PI_BIN");
-}
-function tmuxSessionExists2(name) {
-  try {
-    execSync2(`tmux has-session -t ${name} 2>/dev/null`, { encoding: "utf8" });
-    return true;
-  } catch {
-    return false;
+// packages/web/server/relay.ts
+import { mkdir as mkdir7 } from "fs/promises";
+import { join as join19 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+var UPLOAD_DIR = "/tmp/scout-uploads";
+async function handleRelayUpload(req) {
+  const { name, data } = await req.json();
+  if (!name || !data) {
+    return Response.json({ error: "Missing name or data" }, { status: 400 });
   }
+  await mkdir7(UPLOAD_DIR, { recursive: true });
+  const filename = `${randomUUID3()}-${name}`;
+  const filepath = join19(UPLOAD_DIR, filename);
+  await Bun.write(filepath, Buffer.from(data, "base64"));
+  return Response.json({ path: filepath });
 }
-function bootstrapFiles(cwd, files, sessionId) {
-  for (const [relPath, content] of Object.entries(files)) {
-    const absPath = join19(cwd, relPath);
-    if (!existsSync13(absPath)) {
-      try {
-        const dir = pathDirname(absPath);
-        if (!existsSync13(dir))
-          mkdirSync6(dir, { recursive: true });
-        writeFileSync6(absPath, content, "utf-8");
-        console.log(`[relay] Session ${sessionId}: bootstrapped ${relPath}`);
-      } catch (err) {
-        console.warn(`[relay] Session ${sessionId}: failed to bootstrap ${relPath}:`, err);
-      }
-    }
+function flushPending(ws) {
+  const upstream = ws.data.upstream;
+  if (!upstream || upstream.readyState !== WebSocket.OPEN) {
+    return;
   }
-}
-function spawnTmuxSession(tmuxName, cols, rows, cwd, claudeBin, claudeArgs, env) {
-  const exists = tmuxSessionExists2(tmuxName);
-  if (!exists) {
-    const shellCmd = [claudeBin, ...claudeArgs].map((a) => a.includes(" ") ? `'${a}'` : a).join(" ");
-    execSync2(`tmux new-session -d -s ${tmuxName} -x ${cols} -y ${rows} -c '${cwd}' '${shellCmd}'`, { env });
-    console.log(`[relay] Created tmux session: ${tmuxName}`);
-  } else {
-    try {
-      execSync2(`tmux resize-window -t ${tmuxName} -x ${cols} -y ${rows} 2>/dev/null`);
-    } catch {}
-    console.log(`[relay] Attaching to existing tmux session: ${tmuxName}`);
+  for (const payload of ws.data.pending) {
+    upstream.send(payload);
   }
-  return pty.spawn("tmux", ["attach", "-t", tmuxName], {
-    name: "xterm-256color",
-    cols,
-    rows,
-    cwd,
-    env
-  });
+  ws.data.pending.length = 0;
 }
-function createSession(ws, msg) {
-  const id = generateId();
-  const cols = Math.max(msg.cols || 80, 20);
-  const rows = Math.max(msg.rows || 24, 4);
-  const backend = msg.backend || "pty";
-  const tmuxName = msg.tmuxSession || `hudson-${id}`;
-  const agent = msg.agent || "claude";
-  let agentBin;
-  if (agent === "pi") {
-    agentBin = findPiBin();
-    if (!agentBin) {
-      const reason = "pi CLI not found. Install it with: npm install -g @mariozechner/pi-coding-agent";
-      console.error(`[relay] Session ${id} failed: ${reason}`);
-      send(ws, { type: "session:error", error: reason });
-      return null;
-    }
-  } else {
-    agentBin = findClaudeBin();
-    if (!agentBin) {
-      const reason = "Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code";
-      console.error(`[relay] Session ${id} failed: ${reason}`);
-      send(ws, { type: "session:error", error: reason });
-      return null;
-    }
-  }
-  if (!existsSync13(agentBin)) {
-    const reason = `${agent} binary not found at ${agentBin}`;
-    console.error(`[relay] Session ${id} failed: ${reason}`);
-    send(ws, { type: "session:error", error: reason });
-    return null;
+function forwardToClient(ws, data) {
+  if (ws.readyState !== WebSocket.OPEN) {
+    return;
   }
-  if (backend === "tmux" && !findBin("tmux")) {
-    const reason = "tmux not found. Install it with: brew install tmux";
-    console.error(`[relay] Session ${id} failed: ${reason}`);
-    send(ws, { type: "session:error", error: reason });
-    return null;
+  if (typeof data === "string") {
+    ws.send(data);
+    return;
   }
-  const cwd = resolveCwd(msg.cwd);
-  if (msg.workspaceFiles) {
-    bootstrapFiles(cwd, msg.workspaceFiles, id);
-  }
-  let agentArgs;
-  if (agent === "pi") {
-    agentArgs = ["--verbose"];
-    if (msg.provider)
-      agentArgs.push("--provider", msg.provider);
-    if (msg.model)
-      agentArgs.push("--model", msg.model);
-    if (msg.systemPrompt)
-      agentArgs.push("--system-prompt", msg.systemPrompt);
-  } else {
-    agentArgs = ["--verbose"];
-    if (msg.systemPrompt)
-      agentArgs.push("--system-prompt", msg.systemPrompt);
+  if (data instanceof Blob) {
+    data.arrayBuffer().then((buffer) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(buffer);
+      }
+    }).catch(() => {});
+    return;
   }
-  const env = { ...process.env, TERM: "xterm-256color", FORCE_COLOR: "1" };
-  delete env.CLAUDECODE;
-  let ptyProcess;
-  try {
-    if (backend === "tmux") {
-      console.log(`[relay] Session ${id}: tmux backend (session: ${tmuxName}) in ${cwd} [agent: ${agent}]`);
-      ptyProcess = spawnTmuxSession(tmuxName, cols, rows, cwd, agentBin, agentArgs, env);
-    } else {
-      console.log(`[relay] Session ${id}: pty backend, spawning ${agentBin} in ${cwd} [agent: ${agent}]`);
-      ptyProcess = pty.spawn(agentBin, agentArgs, {
-        name: "xterm-256color",
-        cols,
-        rows,
-        cwd,
-        env
-      });
+  ws.send(data);
+}
+function createRelayWebSocketProxy(targetUrl) {
+  return {
+    open(ws) {
+      ws.data.pending = [];
+      const upstream = new WebSocket(targetUrl);
+      upstream.binaryType = "arraybuffer";
+      ws.data.upstream = upstream;
+      upstream.onopen = () => {
+        flushPending(ws);
+      };
+      upstream.onmessage = (event) => {
+        forwardToClient(ws, event.data);
+      };
+      upstream.onerror = () => {
+        if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+          ws.close();
+        }
+      };
+      upstream.onclose = () => {
+        ws.data.upstream = null;
+        ws.data.pending.length = 0;
+        if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+          ws.close();
+        }
+      };
+    },
+    message(ws, raw2) {
+      const upstream = ws.data.upstream;
+      const payload = raw2;
+      if (!upstream || upstream.readyState === WebSocket.CONNECTING) {
+        ws.data.pending.push(payload);
+        return;
+      }
+      if (upstream.readyState === WebSocket.OPEN) {
+        upstream.send(payload);
+      }
+    },
+    close(ws) {
+      const upstream = ws.data.upstream;
+      ws.data.upstream = null;
+      ws.data.pending.length = 0;
+      if (!upstream) {
+        return;
+      }
+      if (upstream.readyState === WebSocket.OPEN || upstream.readyState === WebSocket.CONNECTING) {
+        upstream.close();
+      }
     }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[relay] Session ${id}: failed to spawn PTY \u2014 ${message}`);
-    send(ws, { type: "session:error", error: `Failed to spawn terminal: ${message}` });
-    return null;
-  }
-  const orphanTTL = msg.orphanTTL && msg.orphanTTL > 0 ? msg.orphanTTL : DEFAULT_ORPHAN_TTL_MS;
-  const session = {
-    id,
-    pty: ptyProcess,
-    ws,
-    outputBuffer: "",
-    cols,
-    rows,
-    reapTimer: null,
-    orphanTTL,
-    backend,
-    ...backend === "tmux" ? { tmuxSession: tmuxName } : {},
-    exited: false,
-    exitCode: null
   };
-  const startTime = Date.now();
-  ptyProcess.onData((data) => {
-    session.outputBuffer += data;
-    if (session.outputBuffer.length > MAX_BUFFER_SIZE) {
-      session.outputBuffer = session.outputBuffer.slice(-MAX_BUFFER_SIZE);
-    }
-    if (session.ws && session.ws.readyState === 1) {
-      send(session.ws, { type: "terminal:data", data });
-    }
-  });
-  ptyProcess.onExit(({ exitCode }) => {
-    session.exited = true;
-    session.exitCode = exitCode;
-    const uptime = Date.now() - startTime;
-    const crashed = exitCode !== 0 && uptime < 5000;
-    let reason;
-    if (crashed) {
-      const clean = session.outputBuffer.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").trim();
-      const lines = clean.split(`
-`).filter((l) => l.trim()).slice(-5);
-      reason = lines.join(`
-`) || `Process exited with code ${exitCode}`;
-      console.error(`[relay] Session ${id} crashed after ${uptime}ms (code ${exitCode}): ${reason}`);
-    }
-    if (session.ws) {
-      send(session.ws, { type: "session:exit", exitCode, ...reason ? { reason } : {} });
-    }
-    scheduleReap(session, 1e4);
-  });
-  sessions3.set(id, session);
-  console.log(`[relay] Session ${id} created (${cols}x${rows})`);
-  return session;
 }
-function attachSession(session, ws, cols, rows) {
-  if (session.reapTimer) {
-    clearTimeout(session.reapTimer);
-    session.reapTimer = null;
-  }
-  session.ws = ws;
-  if (cols && rows) {
-    const c = Math.max(cols, 20);
-    const r = Math.max(rows, 4);
-    if (c !== session.cols || r !== session.rows) {
-      session.pty.resize(c, r);
-      session.cols = c;
-      session.rows = r;
+
+// packages/web/server/managed-terminal-relay.ts
+import { existsSync as existsSync14 } from "fs";
+import { spawn as spawn5, spawnSync as spawnSync2 } from "child_process";
+import { dirname as dirname13, resolve as resolve10 } from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
+function relayPortForWebPort(webPort) {
+  const configured = process.env.OPENSCOUT_WEB_TERMINAL_RELAY_PORT?.trim();
+  if (configured) {
+    const parsed = Number.parseInt(configured, 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
     }
   }
-  if (session.exited) {
-    send(ws, { type: "session:exit", exitCode: session.exitCode });
-  } else if (session.outputBuffer.length > 0) {
-    send(ws, { type: "terminal:data", data: session.outputBuffer });
-  }
-  console.log(`[relay] Session ${session.id} reconnected`);
+  return webPort + 1;
 }
-function detachSession(session) {
-  session.ws = null;
-  if (session.exited) {
-    scheduleReap(session, 5000);
-  } else {
-    scheduleReap(session, session.orphanTTL);
-    console.log(`[relay] Session ${session.id} detached (orphaned for ${session.orphanTTL / 1000}s)`);
-  }
+function relayHostForWebHost(hostname2) {
+  return process.env.OPENSCOUT_WEB_TERMINAL_RELAY_HOST?.trim() || hostname2;
 }
-function scheduleReap(session, delay) {
-  if (session.reapTimer)
-    clearTimeout(session.reapTimer);
-  session.reapTimer = setTimeout(() => {
-    if (!session.ws) {
-      destroy(session.id);
-    }
-  }, delay);
+function relayLoopbackHost(hostname2) {
+  if (hostname2 === "0.0.0.0" || hostname2 === "::") {
+    return "127.0.0.1";
+  }
+  return hostname2;
 }
-function destroy(sessionId) {
-  const session = sessions3.get(sessionId);
-  if (!session)
-    return;
-  if (session.reapTimer)
-    clearTimeout(session.reapTimer);
+async function isHealthy(targetHttpUrl) {
   try {
-    session.pty.kill();
-  } catch {}
-  sessions3.delete(sessionId);
-  if (session.backend === "tmux") {
-    console.log(`[relay] Session ${sessionId} bridge destroyed (tmux session '${session.tmuxSession}' still alive)`);
-  } else {
-    console.log(`[relay] Session ${sessionId} destroyed`);
+    const response = await fetch(`${targetHttpUrl}/health`, {
+      signal: AbortSignal.timeout(1000)
+    });
+    return response.ok;
+  } catch {
+    return false;
   }
 }
-
-// packages/web/server/relay.ts
-import { mkdir as mkdir7 } from "fs/promises";
-import { join as join20 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
-var UPLOAD_DIR = "/tmp/scout-uploads";
-async function handleRelayUpload(req) {
-  const { name, data } = await req.json();
-  if (!name || !data) {
-    return Response.json({ error: "Missing name or data" }, { status: 400 });
+async function waitForHealthy(targetHttpUrl, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isHealthy(targetHttpUrl)) {
+      return true;
+    }
+    await new Promise((resolveTimer) => setTimeout(resolveTimer, 100));
   }
-  await mkdir7(UPLOAD_DIR, { recursive: true });
-  const filename = `${randomUUID3()}-${name}`;
-  const filepath = join20(UPLOAD_DIR, filename);
-  await Bun.write(filepath, Buffer.from(data, "base64"));
-  return Response.json({ path: filepath });
-}
-function asRelay(ws) {
-  return ws;
+  return false;
 }
-function parseMessage(raw2) {
-  try {
-    const msg = JSON.parse(raw2);
-    if (typeof msg.type === "string")
-      return msg;
-  } catch {}
-  return null;
+function resolveRuntimeEntry() {
+  const selfDir = dirname13(fileURLToPath8(import.meta.url));
+  const sourceEntry = resolve10(selfDir, "terminal-relay-node.ts");
+  const bundledEntry = resolve10(selfDir, "openscout-terminal-relay.mjs");
+  const sourceBundle = resolve10(selfDir, "../dist/openscout-terminal-relay.mjs");
+  if (existsSync14(sourceEntry)) {
+    const build = spawnSync2("bun", [
+      "build",
+      sourceEntry,
+      "--target=node",
+      "--format=esm",
+      "--outfile",
+      sourceBundle,
+      "--external",
+      "node-pty"
+    ], {
+      cwd: resolve10(selfDir, ".."),
+      stdio: "inherit"
+    });
+    if ((build.status ?? 1) !== 0) {
+      throw new Error("Failed to build terminal relay bundle");
+    }
+    return sourceBundle;
+  }
+  if (existsSync14(bundledEntry)) {
+    return bundledEntry;
+  }
+  throw new Error("Could not locate the terminal relay runtime entry");
 }
-var relayWebSocket = {
-  open(_ws) {},
-  message(ws, raw2) {
-    const msg = parseMessage(typeof raw2 === "string" ? raw2 : raw2.toString());
-    if (!msg)
-      return;
-    const rws = asRelay(ws);
-    switch (msg.type) {
-      case "session:init": {
-        if (ws.data.sessionId) {
-          const prev = sessions3.get(ws.data.sessionId);
-          if (prev)
-            detachSession(prev);
-        }
-        const session = createSession(rws, msg);
-        if (!session)
-          break;
-        ws.data.sessionId = session.id;
-        send(rws, { type: "session:ready", sessionId: session.id });
-        break;
-      }
-      case "session:reconnect": {
-        const existing = sessions3.get(msg.sessionId);
-        if (existing && !existing.exited) {
-          if (ws.data.sessionId && ws.data.sessionId !== msg.sessionId) {
-            const prev = sessions3.get(ws.data.sessionId);
-            if (prev)
-              detachSession(prev);
-          }
-          if (existing.ws && existing.ws !== rws) {
-            send(existing.ws, { type: "session:detached" });
-          }
-          ws.data.sessionId = existing.id;
-          attachSession(existing, rws, msg.cols, msg.rows);
-          send(rws, {
-            type: "session:ready",
-            sessionId: existing.id,
-            reconnected: true
-          });
-        } else {
-          send(rws, { type: "session:expired", sessionId: msg.sessionId });
-        }
-        break;
-      }
-      case "terminal:input": {
-        if (!ws.data.sessionId)
-          return;
-        const session = sessions3.get(ws.data.sessionId);
-        if (session && !session.exited) {
-          session.pty.write(msg.data);
-        }
-        break;
-      }
-      case "terminal:resize": {
-        if (!ws.data.sessionId)
-          return;
-        const session = sessions3.get(ws.data.sessionId);
-        if (session && !session.exited) {
-          const cols = Math.max(msg.cols || 80, 20);
-          const rows = Math.max(msg.rows || 24, 4);
-          session.pty.resize(cols, rows);
-          session.cols = cols;
-          session.rows = rows;
+async function startManagedTerminalRelay(args) {
+  const relayPort = relayPortForWebPort(args.webPort);
+  const bindHost = relayHostForWebHost(args.hostname);
+  const loopbackHost = relayLoopbackHost(bindHost);
+  const targetHttpUrl = `http://${loopbackHost}:${relayPort}`;
+  const targetWebSocketUrl = `ws://${loopbackHost}:${relayPort}`;
+  if (await isHealthy(targetHttpUrl)) {
+    return {
+      healthcheck: () => isHealthy(targetHttpUrl),
+      queueCommand: async (command) => {
+        const response = await fetch(`${targetHttpUrl}/api/terminal/run`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ command })
+        });
+        if (!response.ok) {
+          throw new Error("Terminal relay rejected queued command");
         }
-        break;
-      }
+      },
+      shutdown() {},
+      targetHttpUrl,
+      targetWebSocketUrl
+    };
+  }
+  const runtimeEntry = resolveRuntimeEntry();
+  const child = spawn5("node", [runtimeEntry], {
+    cwd: resolve10(dirname13(runtimeEntry), ".."),
+    env: {
+      ...process.env,
+      OPENSCOUT_WEB_TERMINAL_RELAY_HOST: bindHost,
+      OPENSCOUT_WEB_TERMINAL_RELAY_PORT: String(relayPort)
+    },
+    stdio: "inherit"
+  });
+  let spawnError = null;
+  child.once("error", (error) => {
+    spawnError = error;
+  });
+  child.on("exit", (code, signal) => {
+    if (signal === "SIGTERM" || signal === "SIGINT") {
+      return;
     }
-  },
-  close(ws) {
-    if (ws.data.sessionId) {
-      const session = sessions3.get(ws.data.sessionId);
-      if (session)
-        detachSession(session);
-      ws.data.sessionId = null;
+    console.error(`[relay] Managed terminal relay exited unexpectedly (code: ${code ?? "null"}, signal: ${signal ?? "none"})`);
+  });
+  const ready = await waitForHealthy(targetHttpUrl, 5000);
+  if (!ready) {
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
+    if (spawnError) {
+      throw spawnError;
     }
+    throw new Error(`Terminal relay did not become healthy at ${targetHttpUrl}`);
   }
-};
-function destroyAllRelaySessions() {
-  for (const [id] of sessions3)
-    destroy(id);
+  return {
+    healthcheck: () => isHealthy(targetHttpUrl),
+    queueCommand: async (command) => {
+      const response = await fetch(`${targetHttpUrl}/api/terminal/run`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ command })
+      });
+      if (!response.ok) {
+        throw new Error("Terminal relay rejected queued command");
+      }
+    },
+    shutdown() {
+      terminateChild(child);
+    },
+    targetHttpUrl,
+    targetWebSocketUrl
+  };
+}
+function terminateChild(child) {
+  if (child.killed) {
+    return;
+  }
+  child.kill("SIGTERM");
 }
 
 // packages/web/server/index.ts
@@ -21700,13 +22043,13 @@ function resolveStaticRoot2() {
   if (process.env.OPENSCOUT_WEB_STATIC_ROOT?.trim()) {
     return process.env.OPENSCOUT_WEB_STATIC_ROOT.trim();
   }
-  const selfDir = dirname13(fileURLToPath8(import.meta.url));
-  const siblingClientRoot = join21(selfDir, "client");
-  if (existsSync14(join21(siblingClientRoot, "index.html"))) {
+  const selfDir = dirname14(fileURLToPath9(import.meta.url));
+  const siblingClientRoot = join20(selfDir, "client");
+  if (existsSync15(join20(siblingClientRoot, "index.html"))) {
     return siblingClientRoot;
   }
-  const sourceDistClientRoot = resolve10(selfDir, "../dist/client");
-  if (existsSync14(join21(sourceDistClientRoot, "index.html"))) {
+  const sourceDistClientRoot = resolve11(selfDir, "../dist/client");
+  if (existsSync15(join20(sourceDistClientRoot, "index.html"))) {
     return sourceDistClientRoot;
   }
   return;
@@ -21715,26 +22058,47 @@ var staticRoot = resolveStaticRoot2();
 var viteDevUrl = process.env.OPENSCOUT_WEB_VITE_URL?.trim() || undefined;
 var useViteProxy = Boolean(viteDevUrl) || !staticRoot;
 var idleTimeoutSeconds = Number.parseInt(process.env.OPENSCOUT_WEB_IDLE_TIMEOUT_SECONDS?.trim() || (useViteProxy ? "180" : "30"), 10);
+var terminalRelay = null;
+try {
+  terminalRelay = await startManagedTerminalRelay({
+    hostname: hostname2,
+    webPort: port
+  });
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`[scout] Terminal relay unavailable: ${message}`);
+}
 var { app, warmupCaches } = await createOpenScoutWebServer({
   currentDirectory,
   shellStateCacheTtlMs,
   assetMode: useViteProxy ? "vite-proxy" : "static",
   viteDevUrl,
-  staticRoot
+  staticRoot,
+  runTerminalCommand: terminalRelay?.queueCommand
 });
 var honoFetch = app.fetch;
+var relayWebSocket = terminalRelay ? createRelayWebSocketProxy(terminalRelay.targetWebSocketUrl) : {
+  open(ws) {
+    if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+      ws.close(1013, "Terminal relay unavailable");
+    }
+  },
+  message() {},
+  close() {}
+};
 var server = Bun.serve({
   port,
   hostname: hostname2,
   idleTimeout: idleTimeoutSeconds,
-  fetch(req, server2) {
+  async fetch(req, server2) {
     const url = new URL(req.url);
     if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
-      const ok = server2.upgrade(req, { data: { sessionId: null } });
+      const ok = server2.upgrade(req, { data: { upstream: null, pending: [] } });
       return ok ? undefined : new Response("WebSocket upgrade failed", { status: 500 });
     }
     if (req.method === "GET" && url.pathname === "/health") {
-      return Response.json({ ok: true });
+      const relayOk = terminalRelay ? await terminalRelay.healthcheck() : false;
+      return Response.json({ ok: relayOk, relay: relayOk ? "up" : "down" }, { status: relayOk ? 200 : 503 });
     }
     if (req.method === "POST" && (url.pathname === "/api/upload" || url.pathname === "/api/relay/upload")) {
       return handleRelayUpload(req);
@@ -21745,8 +22109,8 @@ var server = Bun.serve({
 });
 var shutdown = () => {
   console.log(`
-[scout] Shutting down relay sessions...`);
-  destroyAllRelaySessions();
+[scout] Shutting down terminal relay...`);
+  terminalRelay?.shutdown();
   server.stop();
   process.exit(0);
 };