@openscout/scout 0.2.58 → 0.2.60

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

@@ -8902,8 +8902,107 @@ var init_claude_stream_json = __esm(() => {
 
 // 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;
@@ -9706,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;
@@ -9895,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() {
@@ -9917,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,
@@ -9927,7 +10034,8 @@ class CodexAppServerSession {
       ...buildScoutMcpCodexLaunchArgs({
         currentDirectory: this.options.cwd,
         env
-      })
+      }),
+      ...launchArgs
     ], {
       cwd: this.options.cwd,
       env,
@@ -10025,6 +10133,8 @@ class CodexAppServerSession {
       turnId: "",
       startedAt: Date.now(),
       timer: null,
+      graceTimer: null,
+      timedOutAt: null,
       messageOrder: [],
       messageByItemId: new Map,
       resolve: resolve5,
@@ -10032,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,
@@ -10079,6 +10212,9 @@ class CodexAppServerSession {
     if (turn.timer) {
       clearTimeout(turn.timer);
     }
+    if (turn.graceTimer) {
+      clearTimeout(turn.graceTimer);
+    }
     if (this.activeTurn === turn) {
       this.activeTurn = null;
     }
@@ -11454,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;
 }
@@ -11469,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);
@@ -11478,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]) {
@@ -11486,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"]) {
@@ -11498,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;
@@ -11522,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)
         }
       }
     };
@@ -11571,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) {
@@ -11640,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,
@@ -11665,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
@@ -11791,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) {
@@ -11802,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) {
@@ -12007,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"))}`;
   }
@@ -12379,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.`);
@@ -12392,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: {
@@ -12419,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,
@@ -12429,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,
@@ -12444,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", {
@@ -12556,6 +12841,7 @@ function readPersistedClaudeSessionId(agentName) {
 }
 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;
@@ -12580,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: {
@@ -12607,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),
@@ -12640,6 +12928,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         nodeQualifier: instance.nodeQualifier,
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
+        ...configuredModel ? { model: configuredModel } : {},
         ...externalSessionId ? { externalSessionId } : {}
       }
     }
@@ -12841,11 +13130,11 @@ var init_local_agents = __esm(async () => {
 
 // packages/web/server/index.ts
 import { existsSync as existsSync15 } from "fs";
-import { dirname as dirname13, join as join21, resolve as resolve10 } from "path";
-import { fileURLToPath as fileURLToPath8 } from "url";
+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 existsSync14, 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";
 
@@ -15745,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":
@@ -15908,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) => ({
@@ -16637,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,
@@ -16655,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);
@@ -16738,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);
 }
@@ -21055,415 +21355,6 @@ init_setup();
 init_support_paths();
 init_claude_stream_json();
 init_harness_catalog();
-
-// ../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;
-  }
-}
-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 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}`);
-  }
-  return pty.spawn("tmux", ["attach", "-t", tmuxName], {
-    name: "xterm-256color",
-    cols,
-    rows,
-    cwd,
-    env
-  });
-}
-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;
-  }
-  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;
-  }
-  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);
-  }
-  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
-      });
-    }
-  } 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;
-    }
-  }
-  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`);
-}
-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 scheduleReap(session, delay) {
-  if (session.reapTimer)
-    clearTimeout(session.reapTimer);
-  session.reapTimer = setTimeout(() => {
-    if (!session.ws) {
-      destroy(session.id);
-    }
-  }, delay);
-}
-function destroy(sessionId) {
-  const session = sessions3.get(sessionId);
-  if (!session)
-    return;
-  if (session.reapTimer)
-    clearTimeout(session.reapTimer);
-  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`);
-  }
-}
-
-// 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 });
-  }
-  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 });
-}
-var _pendingCommand = null;
-function queueTerminalCommand(cmd) {
-  for (const [, session] of sessions3) {
-    if (!session.exited) {
-      session.pty.write(cmd + `
-`);
-      return;
-    }
-  }
-  _pendingCommand = cmd;
-}
-function drainPendingCommand() {
-  const cmd = _pendingCommand;
-  _pendingCommand = null;
-  return cmd;
-}
-function asRelay(ws) {
-  return ws;
-}
-function parseMessage(raw2) {
-  try {
-    const msg = JSON.parse(raw2);
-    if (typeof msg.type === "string")
-      return msg;
-  } catch {}
-  return null;
-}
-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 });
-        const pending = drainPendingCommand();
-        if (pending)
-          setTimeout(() => session.pty.write(pending + `
-`), 400);
-        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
-          });
-          const pending = drainPendingCommand();
-          if (pending)
-            setTimeout(() => existing.pty.write(pending + `
-`), 400);
-        } 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;
-        }
-        break;
-      }
-    }
-  },
-  close(ws) {
-    if (ws.data.sessionId) {
-      const session = sessions3.get(ws.data.sessionId);
-      if (session)
-        detachSession(session);
-      ws.data.sessionId = null;
-    }
-  }
-};
-function destroyAllRelaySessions() {
-  for (const [id] of sessions3)
-    destroy(id);
-}
-
-// packages/web/server/create-openscout-web-server.ts
 function parseOptionalPositiveInt(value, fallback) {
   if (typeof value !== "string" || value.trim().length === 0) {
     return fallback;
@@ -21518,7 +21409,7 @@ function resolveStaticRoot(staticRoot) {
     return configured;
   }
   const bundled = resolveBundledStaticClientRoot(import.meta.url);
-  if (existsSync14(resolve9(bundled, "index.html"))) {
+  if (existsSync13(resolve9(bundled, "index.html"))) {
     return bundled;
   }
   return resolveSourceStaticClientRoot(import.meta.url);
@@ -21791,7 +21682,15 @@ async function createOpenScoutWebServer(options) {
     const body = await c.req.json();
     if (!body.command)
       return c.json({ error: "missing command" }, 400);
-    queueTerminalCommand(body.command);
+    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) => {
@@ -21887,6 +21786,254 @@ async function createOpenScoutWebServer(options) {
   return { app, warmupCaches };
 }
 
+// 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 flushPending(ws) {
+  const upstream = ws.data.upstream;
+  if (!upstream || upstream.readyState !== WebSocket.OPEN) {
+    return;
+  }
+  for (const payload of ws.data.pending) {
+    upstream.send(payload);
+  }
+  ws.data.pending.length = 0;
+}
+function forwardToClient(ws, data) {
+  if (ws.readyState !== WebSocket.OPEN) {
+    return;
+  }
+  if (typeof data === "string") {
+    ws.send(data);
+    return;
+  }
+  if (data instanceof Blob) {
+    data.arrayBuffer().then((buffer) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(buffer);
+      }
+    }).catch(() => {});
+    return;
+  }
+  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();
+      }
+    }
+  };
+}
+
+// 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;
+    }
+  }
+  return webPort + 1;
+}
+function relayHostForWebHost(hostname2) {
+  return process.env.OPENSCOUT_WEB_TERMINAL_RELAY_HOST?.trim() || hostname2;
+}
+function relayLoopbackHost(hostname2) {
+  if (hostname2 === "0.0.0.0" || hostname2 === "::") {
+    return "127.0.0.1";
+  }
+  return hostname2;
+}
+async function isHealthy(targetHttpUrl) {
+  try {
+    const response = await fetch(`${targetHttpUrl}/health`, {
+      signal: AbortSignal.timeout(1000)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+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));
+  }
+  return false;
+}
+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");
+}
+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");
+        }
+      },
+      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;
+    }
+    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}`);
+  }
+  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
 var port = Number(process.env.OPENSCOUT_WEB_PORT ?? process.env.SCOUT_WEB_PORT ?? "3200");
 var hostname2 = process.env.OPENSCOUT_WEB_HOST?.trim() || process.env.SCOUT_WEB_HOST?.trim() || "127.0.0.1";
@@ -21896,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 (existsSync15(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 (existsSync15(join21(sourceDistClientRoot, "index.html"))) {
+  const sourceDistClientRoot = resolve11(selfDir, "../dist/client");
+  if (existsSync15(join20(sourceDistClientRoot, "index.html"))) {
     return sourceDistClientRoot;
   }
   return;
@@ -21911,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);
@@ -21941,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);
 };