@openscout/scout 0.2.58 → 0.2.61

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

@@ -5501,116 +5501,6 @@ var init_mesh = () => {};
 
 // packages/protocol/dist/conversations.js
 var init_conversations = () => {};
-
-// packages/protocol/dist/collaboration.js
-function isQuestionTerminalState(state) {
-  return state === "closed" || state === "declined";
-}
-function isWorkItemTerminalState(state) {
-  return state === "done" || state === "cancelled";
-}
-function collaborationRequiresNextMoveOwner(record) {
-  if (record.kind === "question") {
-    return !isQuestionTerminalState(record.state);
-  }
-  return !isWorkItemTerminalState(record.state);
-}
-function collaborationRequiresOwner(record) {
-  return record.kind === "work_item" && !isWorkItemTerminalState(record.state);
-}
-function collaborationRequiresWaitingOn(record) {
-  return record.kind === "work_item" && record.state === "waiting";
-}
-function collaborationRequiresAcceptance(record) {
-  if (record.acceptanceState === "none") {
-    return false;
-  }
-  if (record.kind === "question") {
-    return Boolean(record.askedById && record.askedOfId);
-  }
-  return Boolean(record.requestedById);
-}
-function validateCollaborationRecord(record) {
-  const errors = [];
-  if (!record.id.trim()) {
-    errors.push("collaboration record id is required");
-  }
-  if (!record.title.trim()) {
-    errors.push("collaboration title is required");
-  }
-  if (!record.createdById.trim()) {
-    errors.push("createdById is required");
-  }
-  if (record.parentId && record.parentId === record.id) {
-    errors.push("parentId cannot reference the record itself");
-  }
-  if (record.createdAt > record.updatedAt) {
-    errors.push("updatedAt must be greater than or equal to createdAt");
-  }
-  if (collaborationRequiresOwner(record) && !record.ownerId) {
-    errors.push("non-terminal work items require ownerId");
-  }
-  if (collaborationRequiresNextMoveOwner(record) && !record.nextMoveOwnerId) {
-    errors.push("non-terminal collaboration records require nextMoveOwnerId");
-  }
-  if (record.kind === "work_item" && collaborationRequiresWaitingOn(record) && !record.waitingOn) {
-    errors.push("waiting work items require waitingOn");
-  }
-  if (record.kind === "question") {
-    if (record.spawnedWorkItemId && record.spawnedWorkItemId === record.id) {
-      errors.push("question spawnedWorkItemId cannot reference the question itself");
-    }
-  } else if (record.waitingOn?.targetId && record.waitingOn.targetId === record.id) {
-    errors.push("waitingOn.targetId cannot reference the work item itself");
-  }
-  if (record.acceptanceState !== "none" && !collaborationRequiresAcceptance(record)) {
-    errors.push("acceptanceState requires the corresponding requester and reviewer identities");
-  }
-  return errors;
-}
-function assertValidCollaborationRecord(record) {
-  const errors = validateCollaborationRecord(record);
-  if (errors.length > 0) {
-    throw new Error(errors.join("; "));
-  }
-}
-function validateCollaborationEvent(event, record) {
-  const errors = [];
-  if (!event.id.trim()) {
-    errors.push("collaboration event id is required");
-  }
-  if (!event.recordId.trim()) {
-    errors.push("collaboration event recordId is required");
-  }
-  if (!event.actorId.trim()) {
-    errors.push("collaboration event actorId is required");
-  }
-  if (record) {
-    if (record.id !== event.recordId) {
-      errors.push("collaboration event recordId does not match the target record");
-    }
-    if (record.kind !== event.recordKind) {
-      errors.push("collaboration event recordKind does not match the target record");
-    }
-  }
-  if (event.kind === "answered" && event.recordKind !== "question") {
-    errors.push("answered events only apply to questions");
-  }
-  if (event.kind === "declined" && event.recordKind !== "question") {
-    errors.push("declined events only apply to questions");
-  }
-  if ((event.kind === "waiting" || event.kind === "progressed" || event.kind === "review_requested" || event.kind === "done" || event.kind === "cancelled") && event.recordKind !== "work_item") {
-    errors.push(`${event.kind} events only apply to work items`);
-  }
-  return errors;
-}
-function assertValidCollaborationEvent(event, record) {
-  const errors = validateCollaborationEvent(event, record);
-  if (errors.length > 0) {
-    throw new Error(errors.join("; "));
-  }
-}
-
 // packages/protocol/dist/messages.js
 var init_messages = () => {};
 
@@ -8902,8 +8792,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 +9695,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 +9891,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 +9913,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 +9924,8 @@ class CodexAppServerSession {
       ...buildScoutMcpCodexLaunchArgs({
         currentDirectory: this.options.cwd,
         env
-      })
+      }),
+      ...launchArgs
     ], {
       cwd: this.options.cwd,
       env,
@@ -10025,6 +10023,8 @@ class CodexAppServerSession {
       turnId: "",
       startedAt: Date.now(),
       timer: null,
+      graceTimer: null,
+      timedOutAt: null,
       messageOrder: [],
       messageByItemId: new Map,
       resolve: resolve5,
@@ -10032,20 +10032,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 +10102,9 @@ class CodexAppServerSession {
     if (turn.timer) {
       clearTimeout(turn.timer);
     }
+    if (turn.graceTimer) {
+      clearTimeout(turn.graceTimer);
+    }
     if (this.activeTurn === turn) {
       this.activeTurn = null;
     }
@@ -11454,6 +11480,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 +11617,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 +11626,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 +11634,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 +11646,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 +11670,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 +11719,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 +11788,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 +11813,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 +11939,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 +11950,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 +12155,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 +12527,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 +12541,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 +12569,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 +12582,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 +12603,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 +12731,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 +12756,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 +12784,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 +12818,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         nodeQualifier: instance.nodeQualifier,
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
+        ...configuredModel ? { model: configuredModel } : {},
         ...externalSessionId ? { externalSessionId } : {}
       }
     }
@@ -12841,11 +13020,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 +15924,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 +16093,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 +16819,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 +16838,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 +16924,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);
 }
@@ -17828,2359 +18018,79 @@ function whoEntryState(endpoints, registrationKind) {
 
 // packages/web/server/core/observe/service.ts
 init_src();
+await init_local_agents();
 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";
-
-// packages/runtime/src/registry.ts
-function createRuntimeRegistrySnapshot(value = {}) {
-  return {
-    nodes: value.nodes ?? {},
-    actors: value.actors ?? {},
-    agents: value.agents ?? {},
-    endpoints: value.endpoints ?? {},
-    conversations: value.conversations ?? {},
-    bindings: value.bindings ?? {},
-    messages: value.messages ?? {},
-    flights: value.flights ?? {},
-    collaborationRecords: value.collaborationRecords ?? {}
+var HISTORY_SNAPSHOT_CACHE_LIMIT = 128;
+var historySnapshotCache = new Map;
+var OBSERVE_SUMMARY_TAIL_SIZE = 8;
+function activeEndpoint(snapshot, agentId) {
+  const candidates = Object.values(snapshot.endpoints ?? {}).filter((endpoint) => endpoint.agentId === agentId);
+  const rank = (state) => {
+    switch (state) {
+      case "active":
+        return 0;
+      case "idle":
+        return 1;
+      case "waiting":
+        return 2;
+      case "offline":
+        return 5;
+      default:
+        return 4;
+    }
   };
+  return [...candidates].sort((left, right) => rank(left.state) - rank(right.state))[0] ?? null;
 }
-
-// packages/runtime/src/index.ts
-init_harness_catalog();
-
-// packages/runtime/src/planner.ts
-function createDeliveryId(messageId, targetId, reason, transport) {
-  return `del-${messageId}-${targetId}-${reason}-${transport}`;
-}
-function unique(values) {
-  return [...new Set(values)];
-}
-function resolveVisibilityAudience(message, conversation) {
-  if (message.audience?.visibleTo?.length) {
-    return unique(message.audience.visibleTo);
+function expandHome(value) {
+  if (!value) {
+    return null;
   }
-  return unique(conversation.participantIds.filter((participantId) => participantId !== message.actorId));
-}
-function resolveNotifyAudience(message) {
-  const fromMentions = (message.mentions ?? []).map((mention) => mention.actorId);
-  const explicit = message.audience?.notify ?? [];
-  return unique([...fromMentions, ...explicit].filter((actorId) => actorId !== message.actorId));
-}
-function resolveInvocationAudience(message) {
-  return unique((message.audience?.invoke ?? []).filter((actorId) => actorId !== message.actorId));
+  if (value === "~") {
+    return homedir12();
+  }
+  if (value.startsWith("~/")) {
+    return join18(homedir12(), value.slice(2));
+  }
+  return value;
 }
-function planTargetDelivery(message, route, reason, policy) {
-  return {
-    id: createDeliveryId(message.id, route.targetId, reason, route.transport),
-    messageId: message.id,
-    targetId: route.targetId,
-    targetNodeId: route.nodeId,
-    targetKind: route.targetKind,
-    transport: route.transport,
-    reason,
-    policy,
-    status: "pending",
-    bindingId: route.bindingId
-  };
+function encodeClaudeProjectsSlug2(absolutePath) {
+  const normalized = resolve8(absolutePath);
+  return `-${normalized.replace(/^\//u, "").replace(/\//gu, "-")}`;
 }
-function planMessageDeliveries(input) {
-  const visibilityIds = new Set(resolveVisibilityAudience(input.message, input.conversation));
-  const notifyIds = new Set(resolveNotifyAudience(input.message));
-  const invokeIds = new Set(resolveInvocationAudience(input.message));
-  const deliveries2 = new Map;
-  for (const route of input.participantRoutes) {
-    if (visibilityIds.has(route.targetId)) {
-      const intent = planTargetDelivery(input.message, {
-        ...route,
-        transport: route.nodeId && input.localNodeId && route.nodeId !== input.localNodeId ? "peer_broker" : route.transport
-      }, input.conversation.kind === "direct" || input.conversation.kind === "group_direct" ? "direct_message" : "conversation_visibility", "durable");
-      deliveries2.set(intent.id, intent);
-    }
-    if (notifyIds.has(route.targetId)) {
-      const intent = planTargetDelivery(input.message, {
-        ...route,
-        transport: route.nodeId && input.localNodeId && route.nodeId !== input.localNodeId ? "peer_broker" : route.transport
-      }, "mention", "must_ack");
-      deliveries2.set(intent.id, intent);
-    }
-    if (invokeIds.has(route.targetId)) {
-      const intent = planTargetDelivery(input.message, {
-        ...route,
-        transport: route.nodeId && input.localNodeId && route.nodeId !== input.localNodeId ? "peer_broker" : route.transport
-      }, "invocation", "must_ack");
-      deliveries2.set(intent.id, intent);
-    }
-    if (input.message.speech?.text && route.speechEnabled) {
-      const speechIntent = planTargetDelivery(input.message, {
-        ...route,
-        transport: route.transport === "local_socket" ? "native_voice" : "tts",
-        targetKind: route.targetKind === "device" ? "voice_session" : route.targetKind
-      }, "speech", "best_effort");
-      deliveries2.set(speechIntent.id, speechIntent);
-    }
-  }
-  for (const route of input.bindingRoutes ?? []) {
-    const intent = planTargetDelivery(input.message, route, "bridge_outbound", "durable");
-    deliveries2.set(intent.id, intent);
-  }
-  return [...deliveries2.values()];
-}
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/entity.js
-var entityKind = Symbol.for("drizzle:entityKind");
-var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
-function is(value, type) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  if (value instanceof type) {
-    return true;
+function resolveClaudeHistoryPath(cwd, sessionId) {
+  const normalizedCwd = expandHome(cwd)?.trim();
+  if (!normalizedCwd) {
+    return null;
   }
-  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
-    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+  const projectDir = join18(homedir12(), ".claude", "projects", encodeClaudeProjectsSlug2(normalizedCwd));
+  const normalizedSessionId = sessionId?.trim().replace(/\.jsonl$/u, "") || "";
+  if (normalizedSessionId) {
+    const exactPath = join18(projectDir, `${normalizedSessionId}.jsonl`);
+    if (existsSync12(exactPath)) {
+      return exactPath;
+    }
   }
-  let cls = Object.getPrototypeOf(value).constructor;
-  if (cls) {
-    while (cls) {
-      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
-        return true;
+  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 };
       }
-      cls = Object.getPrototypeOf(cls);
     }
-  }
-  return false;
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/column.js
-class Column {
-  constructor(table, config) {
-    this.table = table;
-    this.config = config;
-    this.name = config.name;
-    this.keyAsName = config.keyAsName;
-    this.notNull = config.notNull;
-    this.default = config.default;
-    this.defaultFn = config.defaultFn;
-    this.onUpdateFn = config.onUpdateFn;
-    this.hasDefault = config.hasDefault;
-    this.primary = config.primaryKey;
-    this.isUnique = config.isUnique;
-    this.uniqueName = config.uniqueName;
-    this.uniqueType = config.uniqueType;
-    this.dataType = config.dataType;
-    this.columnType = config.columnType;
-    this.generated = config.generated;
-    this.generatedIdentity = config.generatedIdentity;
-  }
-  static [entityKind] = "Column";
-  name;
-  keyAsName;
-  primary;
-  notNull;
-  default;
-  defaultFn;
-  onUpdateFn;
-  hasDefault;
-  isUnique;
-  uniqueName;
-  uniqueType;
-  dataType;
-  columnType;
-  enumValues = undefined;
-  generated = undefined;
-  generatedIdentity = undefined;
-  config;
-  mapFromDriverValue(value) {
-    return value;
-  }
-  mapToDriverValue(value) {
-    return value;
-  }
-  shouldDisableInsert() {
-    return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
-  }
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/column-builder.js
-class ColumnBuilder {
-  static [entityKind] = "ColumnBuilder";
-  config;
-  constructor(name, dataType, columnType) {
-    this.config = {
-      name,
-      keyAsName: name === "",
-      notNull: false,
-      default: undefined,
-      hasDefault: false,
-      primaryKey: false,
-      isUnique: false,
-      uniqueName: undefined,
-      uniqueType: undefined,
-      dataType,
-      columnType,
-      generated: undefined
-    };
-  }
-  $type() {
-    return this;
-  }
-  notNull() {
-    this.config.notNull = true;
-    return this;
-  }
-  default(value) {
-    this.config.default = value;
-    this.config.hasDefault = true;
-    return this;
-  }
-  $defaultFn(fn) {
-    this.config.defaultFn = fn;
-    this.config.hasDefault = true;
-    return this;
-  }
-  $default = this.$defaultFn;
-  $onUpdateFn(fn) {
-    this.config.onUpdateFn = fn;
-    this.config.hasDefault = true;
-    return this;
-  }
-  $onUpdate = this.$onUpdateFn;
-  primaryKey() {
-    this.config.primaryKey = true;
-    this.config.notNull = true;
-    return this;
-  }
-  setName(name) {
-    if (this.config.name !== "")
-      return;
-    this.config.name = name;
-  }
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/table.utils.js
-var TableName = Symbol.for("drizzle:Name");
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/tracing-utils.js
-function iife(fn, ...args) {
-  return fn(...args);
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/unique-constraint.js
-function uniqueKeyName(table, columns) {
-  return `${table[TableName]}_${columns.join("_")}_unique`;
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/columns/common.js
-class PgColumn extends Column {
-  constructor(table, config) {
-    if (!config.uniqueName) {
-      config.uniqueName = uniqueKeyName(table, [config.name]);
-    }
-    super(table, config);
-    this.table = table;
-  }
-  static [entityKind] = "PgColumn";
-}
-
-class ExtraConfigColumn extends PgColumn {
-  static [entityKind] = "ExtraConfigColumn";
-  getSQLType() {
-    return this.getSQLType();
-  }
-  indexConfig = {
-    order: this.config.order ?? "asc",
-    nulls: this.config.nulls ?? "last",
-    opClass: this.config.opClass
-  };
-  defaultConfig = {
-    order: "asc",
-    nulls: "last",
-    opClass: undefined
-  };
-  asc() {
-    this.indexConfig.order = "asc";
-    return this;
-  }
-  desc() {
-    this.indexConfig.order = "desc";
-    return this;
-  }
-  nullsFirst() {
-    this.indexConfig.nulls = "first";
-    return this;
-  }
-  nullsLast() {
-    this.indexConfig.nulls = "last";
-    return this;
-  }
-  op(opClass) {
-    this.indexConfig.opClass = opClass;
-    return this;
-  }
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/columns/enum.js
-class PgEnumObjectColumn extends PgColumn {
-  static [entityKind] = "PgEnumObjectColumn";
-  enum;
-  enumValues = this.config.enum.enumValues;
-  constructor(table, config) {
-    super(table, config);
-    this.enum = config.enum;
-  }
-  getSQLType() {
-    return this.enum.enumName;
-  }
-}
-var isPgEnumSym = Symbol.for("drizzle:isPgEnum");
-function isPgEnum(obj) {
-  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
-}
-class PgEnumColumn extends PgColumn {
-  static [entityKind] = "PgEnumColumn";
-  enum = this.config.enum;
-  enumValues = this.config.enum.enumValues;
-  constructor(table, config) {
-    super(table, config);
-    this.enum = config.enum;
-  }
-  getSQLType() {
-    return this.enum.enumName;
-  }
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/subquery.js
-class Subquery {
-  static [entityKind] = "Subquery";
-  constructor(sql, fields, alias, isWith = false, usedTables = []) {
-    this._ = {
-      brand: "Subquery",
-      sql,
-      selectedFields: fields,
-      alias,
-      isWith,
-      usedTables
-    };
-  }
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/version.js
-var version = "0.45.2";
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/tracing.js
-var otel;
-var rawTracer;
-var tracer = {
-  startActiveSpan(name, fn) {
-    if (!otel) {
-      return fn();
-    }
-    if (!rawTracer) {
-      rawTracer = otel.trace.getTracer("drizzle-orm", version);
-    }
-    return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
-      try {
-        return fn(span);
-      } catch (e) {
-        span.setStatus({
-          code: otel2.SpanStatusCode.ERROR,
-          message: e instanceof Error ? e.message : "Unknown error"
-        });
-        throw e;
-      } finally {
-        span.end();
-      }
-    }), otel, rawTracer);
-  }
-};
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/view-common.js
-var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/table.js
-var Schema = Symbol.for("drizzle:Schema");
-var Columns = Symbol.for("drizzle:Columns");
-var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
-var OriginalName = Symbol.for("drizzle:OriginalName");
-var BaseName = Symbol.for("drizzle:BaseName");
-var IsAlias = Symbol.for("drizzle:IsAlias");
-var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
-var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
-
-class Table {
-  static [entityKind] = "Table";
-  static Symbol = {
-    Name: TableName,
-    Schema,
-    OriginalName,
-    Columns,
-    ExtraConfigColumns,
-    BaseName,
-    IsAlias,
-    ExtraConfigBuilder
-  };
-  [TableName];
-  [OriginalName];
-  [Schema];
-  [Columns];
-  [ExtraConfigColumns];
-  [BaseName];
-  [IsAlias] = false;
-  [IsDrizzleTable] = true;
-  [ExtraConfigBuilder] = undefined;
-  constructor(name, schema, baseName) {
-    this[TableName] = this[OriginalName] = name;
-    this[Schema] = schema;
-    this[BaseName] = baseName;
-  }
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/sql.js
-function isSQLWrapper(value) {
-  return value !== null && value !== undefined && typeof value.getSQL === "function";
-}
-function mergeQueries(queries) {
-  const result = { sql: "", params: [] };
-  for (const query of queries) {
-    result.sql += query.sql;
-    result.params.push(...query.params);
-    if (query.typings?.length) {
-      if (!result.typings) {
-        result.typings = [];
-      }
-      result.typings.push(...query.typings);
-    }
-  }
-  return result;
-}
-
-class StringChunk {
-  static [entityKind] = "StringChunk";
-  value;
-  constructor(value) {
-    this.value = Array.isArray(value) ? value : [value];
-  }
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-
-class SQL {
-  constructor(queryChunks) {
-    this.queryChunks = queryChunks;
-    for (const chunk of queryChunks) {
-      if (is(chunk, Table)) {
-        const schemaName = chunk[Table.Symbol.Schema];
-        this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
-      }
-    }
-  }
-  static [entityKind] = "SQL";
-  decoder = noopDecoder;
-  shouldInlineParams = false;
-  usedTables = [];
-  append(query) {
-    this.queryChunks.push(...query.queryChunks);
-    return this;
-  }
-  toQuery(config) {
-    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
-      const query = this.buildQueryFromSourceParams(this.queryChunks, config);
-      span?.setAttributes({
-        "drizzle.query.text": query.sql,
-        "drizzle.query.params": JSON.stringify(query.params)
-      });
-      return query;
-    });
-  }
-  buildQueryFromSourceParams(chunks, _config) {
-    const config = Object.assign({}, _config, {
-      inlineParams: _config.inlineParams || this.shouldInlineParams,
-      paramStartIndex: _config.paramStartIndex || { value: 0 }
-    });
-    const {
-      casing,
-      escapeName,
-      escapeParam,
-      prepareTyping,
-      inlineParams,
-      paramStartIndex
-    } = config;
-    return mergeQueries(chunks.map((chunk) => {
-      if (is(chunk, StringChunk)) {
-        return { sql: chunk.value.join(""), params: [] };
-      }
-      if (is(chunk, Name)) {
-        return { sql: escapeName(chunk.value), params: [] };
-      }
-      if (chunk === undefined) {
-        return { sql: "", params: [] };
-      }
-      if (Array.isArray(chunk)) {
-        const result = [new StringChunk("(")];
-        for (const [i, p] of chunk.entries()) {
-          result.push(p);
-          if (i < chunk.length - 1) {
-            result.push(new StringChunk(", "));
-          }
-        }
-        result.push(new StringChunk(")"));
-        return this.buildQueryFromSourceParams(result, config);
-      }
-      if (is(chunk, SQL)) {
-        return this.buildQueryFromSourceParams(chunk.queryChunks, {
-          ...config,
-          inlineParams: inlineParams || chunk.shouldInlineParams
-        });
-      }
-      if (is(chunk, Table)) {
-        const schemaName = chunk[Table.Symbol.Schema];
-        const tableName = chunk[Table.Symbol.Name];
-        return {
-          sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
-          params: []
-        };
-      }
-      if (is(chunk, Column)) {
-        const columnName = casing.getColumnCasing(chunk);
-        if (_config.invokeSource === "indexes") {
-          return { sql: escapeName(columnName), params: [] };
-        }
-        const schemaName = chunk.table[Table.Symbol.Schema];
-        return {
-          sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
-          params: []
-        };
-      }
-      if (is(chunk, View)) {
-        const schemaName = chunk[ViewBaseConfig].schema;
-        const viewName = chunk[ViewBaseConfig].name;
-        return {
-          sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
-          params: []
-        };
-      }
-      if (is(chunk, Param)) {
-        if (is(chunk.value, Placeholder)) {
-          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-        }
-        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
-        if (is(mappedValue, SQL)) {
-          return this.buildQueryFromSourceParams([mappedValue], config);
-        }
-        if (inlineParams) {
-          return { sql: this.mapInlineParam(mappedValue, config), params: [] };
-        }
-        let typings = ["none"];
-        if (prepareTyping) {
-          typings = [prepareTyping(chunk.encoder)];
-        }
-        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
-      }
-      if (is(chunk, Placeholder)) {
-        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-      }
-      if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
-        return { sql: escapeName(chunk.fieldAlias), params: [] };
-      }
-      if (is(chunk, Subquery)) {
-        if (chunk._.isWith) {
-          return { sql: escapeName(chunk._.alias), params: [] };
-        }
-        return this.buildQueryFromSourceParams([
-          new StringChunk("("),
-          chunk._.sql,
-          new StringChunk(") "),
-          new Name(chunk._.alias)
-        ], config);
-      }
-      if (isPgEnum(chunk)) {
-        if (chunk.schema) {
-          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
-        }
-        return { sql: escapeName(chunk.enumName), params: [] };
-      }
-      if (isSQLWrapper(chunk)) {
-        if (chunk.shouldOmitSQLParens?.()) {
-          return this.buildQueryFromSourceParams([chunk.getSQL()], config);
-        }
-        return this.buildQueryFromSourceParams([
-          new StringChunk("("),
-          chunk.getSQL(),
-          new StringChunk(")")
-        ], config);
-      }
-      if (inlineParams) {
-        return { sql: this.mapInlineParam(chunk, config), params: [] };
-      }
-      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-    }));
-  }
-  mapInlineParam(chunk, { escapeString }) {
-    if (chunk === null) {
-      return "null";
-    }
-    if (typeof chunk === "number" || typeof chunk === "boolean") {
-      return chunk.toString();
-    }
-    if (typeof chunk === "string") {
-      return escapeString(chunk);
-    }
-    if (typeof chunk === "object") {
-      const mappedValueAsString = chunk.toString();
-      if (mappedValueAsString === "[object Object]") {
-        return escapeString(JSON.stringify(chunk));
-      }
-      return escapeString(mappedValueAsString);
-    }
-    throw new Error("Unexpected param value: " + chunk);
-  }
-  getSQL() {
-    return this;
-  }
-  as(alias) {
-    if (alias === undefined) {
-      return this;
-    }
-    return new SQL.Aliased(this, alias);
-  }
-  mapWith(decoder) {
-    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
-    return this;
-  }
-  inlineParams() {
-    this.shouldInlineParams = true;
-    return this;
-  }
-  if(condition) {
-    return condition ? this : undefined;
-  }
-}
-
-class Name {
-  constructor(value) {
-    this.value = value;
-  }
-  static [entityKind] = "Name";
-  brand;
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-var noopDecoder = {
-  mapFromDriverValue: (value) => value
-};
-var noopEncoder = {
-  mapToDriverValue: (value) => value
-};
-var noopMapper = {
-  ...noopDecoder,
-  ...noopEncoder
-};
-
-class Param {
-  constructor(value, encoder = noopEncoder) {
-    this.value = value;
-    this.encoder = encoder;
-  }
-  static [entityKind] = "Param";
-  brand;
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-function sql(strings, ...params) {
-  const queryChunks = [];
-  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
-    queryChunks.push(new StringChunk(strings[0]));
-  }
-  for (const [paramIndex, param2] of params.entries()) {
-    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
-  }
-  return new SQL(queryChunks);
-}
-((sql2) => {
-  function empty() {
-    return new SQL([]);
-  }
-  sql2.empty = empty;
-  function fromList(list) {
-    return new SQL(list);
-  }
-  sql2.fromList = fromList;
-  function raw2(str) {
-    return new SQL([new StringChunk(str)]);
-  }
-  sql2.raw = raw2;
-  function join18(chunks, separator) {
-    const result = [];
-    for (const [i, chunk] of chunks.entries()) {
-      if (i > 0 && separator !== undefined) {
-        result.push(separator);
-      }
-      result.push(chunk);
-    }
-    return new SQL(result);
-  }
-  sql2.join = join18;
-  function identifier(value) {
-    return new Name(value);
-  }
-  sql2.identifier = identifier;
-  function placeholder2(name2) {
-    return new Placeholder(name2);
-  }
-  sql2.placeholder = placeholder2;
-  function param2(value, encoder) {
-    return new Param(value, encoder);
-  }
-  sql2.param = param2;
-})(sql || (sql = {}));
-((SQL2) => {
-
-  class Aliased {
-    constructor(sql2, fieldAlias) {
-      this.sql = sql2;
-      this.fieldAlias = fieldAlias;
-    }
-    static [entityKind] = "SQL.Aliased";
-    isSelectionField = false;
-    getSQL() {
-      return this.sql;
-    }
-    clone() {
-      return new Aliased(this.sql, this.fieldAlias);
-    }
-  }
-  SQL2.Aliased = Aliased;
-})(SQL || (SQL = {}));
-
-class Placeholder {
-  constructor(name2) {
-    this.name = name2;
-  }
-  static [entityKind] = "Placeholder";
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
-
-class View {
-  static [entityKind] = "View";
-  [ViewBaseConfig];
-  [IsDrizzleView] = true;
-  constructor({ name: name2, schema, selectedFields, query }) {
-    this[ViewBaseConfig] = {
-      name: name2,
-      originalName: name2,
-      schema,
-      selectedFields,
-      query,
-      isExisting: !query,
-      isAlias: false
-    };
-  }
-  getSQL() {
-    return new SQL([this]);
-  }
-}
-Column.prototype.getSQL = function() {
-  return new SQL([this]);
-};
-Table.prototype.getSQL = function() {
-  return new SQL([this]);
-};
-Subquery.prototype.getSQL = function() {
-  return new SQL([this]);
-};
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/utils.js
-function getColumnNameAndConfig(a, b) {
-  return {
-    name: typeof a === "string" && a.length > 0 ? a : "",
-    config: typeof a === "object" ? a : b
-  };
-}
-var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
-class ForeignKeyBuilder {
-  static [entityKind] = "SQLiteForeignKeyBuilder";
-  reference;
-  _onUpdate;
-  _onDelete;
-  constructor(config, actions) {
-    this.reference = () => {
-      const { name, columns, foreignColumns } = config();
-      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
-    };
-    if (actions) {
-      this._onUpdate = actions.onUpdate;
-      this._onDelete = actions.onDelete;
-    }
-  }
-  onUpdate(action) {
-    this._onUpdate = action;
-    return this;
-  }
-  onDelete(action) {
-    this._onDelete = action;
-    return this;
-  }
-  build(table) {
-    return new ForeignKey(table, this);
-  }
-}
-
-class ForeignKey {
-  constructor(table, builder) {
-    this.table = table;
-    this.reference = builder.reference;
-    this.onUpdate = builder._onUpdate;
-    this.onDelete = builder._onDelete;
-  }
-  static [entityKind] = "SQLiteForeignKey";
-  reference;
-  onUpdate;
-  onDelete;
-  getName() {
-    const { name, columns, foreignColumns } = this.reference();
-    const columnNames = columns.map((column) => column.name);
-    const foreignColumnNames = foreignColumns.map((column) => column.name);
-    const chunks = [
-      this.table[TableName],
-      ...columnNames,
-      foreignColumns[0].table[TableName],
-      ...foreignColumnNames
-    ];
-    return name ?? `${chunks.join("_")}_fk`;
-  }
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
-function uniqueKeyName2(table, columns) {
-  return `${table[TableName]}_${columns.join("_")}_unique`;
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/common.js
-class SQLiteColumnBuilder extends ColumnBuilder {
-  static [entityKind] = "SQLiteColumnBuilder";
-  foreignKeyConfigs = [];
-  references(ref, actions = {}) {
-    this.foreignKeyConfigs.push({ ref, actions });
-    return this;
-  }
-  unique(name) {
-    this.config.isUnique = true;
-    this.config.uniqueName = name;
-    return this;
-  }
-  generatedAlwaysAs(as, config) {
-    this.config.generated = {
-      as,
-      type: "always",
-      mode: config?.mode ?? "virtual"
-    };
-    return this;
-  }
-  buildForeignKeys(column, table) {
-    return this.foreignKeyConfigs.map(({ ref, actions }) => {
-      return ((ref2, actions2) => {
-        const builder = new ForeignKeyBuilder(() => {
-          const foreignColumn = ref2();
-          return { columns: [column], foreignColumns: [foreignColumn] };
-        });
-        if (actions2.onUpdate) {
-          builder.onUpdate(actions2.onUpdate);
-        }
-        if (actions2.onDelete) {
-          builder.onDelete(actions2.onDelete);
-        }
-        return builder.build(table);
-      })(ref, actions);
-    });
-  }
-}
-
-class SQLiteColumn extends Column {
-  constructor(table, config) {
-    if (!config.uniqueName) {
-      config.uniqueName = uniqueKeyName2(table, [config.name]);
-    }
-    super(table, config);
-    this.table = table;
-  }
-  static [entityKind] = "SQLiteColumn";
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/blob.js
-class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBigIntBuilder";
-  constructor(name) {
-    super(name, "bigint", "SQLiteBigInt");
-  }
-  build(table) {
-    return new SQLiteBigInt(table, this.config);
-  }
-}
-
-class SQLiteBigInt extends SQLiteColumn {
-  static [entityKind] = "SQLiteBigInt";
-  getSQLType() {
-    return "blob";
-  }
-  mapFromDriverValue(value) {
-    if (typeof Buffer !== "undefined" && Buffer.from) {
-      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
-      return BigInt(buf.toString("utf8"));
-    }
-    return BigInt(textDecoder.decode(value));
-  }
-  mapToDriverValue(value) {
-    return Buffer.from(value.toString());
-  }
-}
-
-class SQLiteBlobJsonBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBlobJsonBuilder";
-  constructor(name) {
-    super(name, "json", "SQLiteBlobJson");
-  }
-  build(table) {
-    return new SQLiteBlobJson(table, this.config);
-  }
-}
-
-class SQLiteBlobJson extends SQLiteColumn {
-  static [entityKind] = "SQLiteBlobJson";
-  getSQLType() {
-    return "blob";
-  }
-  mapFromDriverValue(value) {
-    if (typeof Buffer !== "undefined" && Buffer.from) {
-      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
-      return JSON.parse(buf.toString("utf8"));
-    }
-    return JSON.parse(textDecoder.decode(value));
-  }
-  mapToDriverValue(value) {
-    return Buffer.from(JSON.stringify(value));
-  }
-}
-
-class SQLiteBlobBufferBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBlobBufferBuilder";
-  constructor(name) {
-    super(name, "buffer", "SQLiteBlobBuffer");
-  }
-  build(table) {
-    return new SQLiteBlobBuffer(table, this.config);
-  }
-}
-
-class SQLiteBlobBuffer extends SQLiteColumn {
-  static [entityKind] = "SQLiteBlobBuffer";
-  mapFromDriverValue(value) {
-    if (Buffer.isBuffer(value)) {
-      return value;
-    }
-    return Buffer.from(value);
-  }
-  getSQLType() {
-    return "blob";
-  }
-}
-function blob(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config?.mode === "json") {
-    return new SQLiteBlobJsonBuilder(name);
-  }
-  if (config?.mode === "bigint") {
-    return new SQLiteBigIntBuilder(name);
-  }
-  return new SQLiteBlobBufferBuilder(name);
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/custom.js
-class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteCustomColumnBuilder";
-  constructor(name, fieldConfig, customTypeParams) {
-    super(name, "custom", "SQLiteCustomColumn");
-    this.config.fieldConfig = fieldConfig;
-    this.config.customTypeParams = customTypeParams;
-  }
-  build(table) {
-    return new SQLiteCustomColumn(table, this.config);
-  }
-}
-
-class SQLiteCustomColumn extends SQLiteColumn {
-  static [entityKind] = "SQLiteCustomColumn";
-  sqlName;
-  mapTo;
-  mapFrom;
-  constructor(table, config) {
-    super(table, config);
-    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
-    this.mapTo = config.customTypeParams.toDriver;
-    this.mapFrom = config.customTypeParams.fromDriver;
-  }
-  getSQLType() {
-    return this.sqlName;
-  }
-  mapFromDriverValue(value) {
-    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
-  }
-  mapToDriverValue(value) {
-    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
-  }
-}
-function customType(customTypeParams) {
-  return (a, b) => {
-    const { name, config } = getColumnNameAndConfig(a, b);
-    return new SQLiteCustomColumnBuilder(name, config, customTypeParams);
-  };
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/integer.js
-class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBaseIntegerBuilder";
-  constructor(name, dataType, columnType) {
-    super(name, dataType, columnType);
-    this.config.autoIncrement = false;
-  }
-  primaryKey(config) {
-    if (config?.autoIncrement) {
-      this.config.autoIncrement = true;
-    }
-    this.config.hasDefault = true;
-    return super.primaryKey();
-  }
-}
-
-class SQLiteBaseInteger extends SQLiteColumn {
-  static [entityKind] = "SQLiteBaseInteger";
-  autoIncrement = this.config.autoIncrement;
-  getSQLType() {
-    return "integer";
-  }
-}
-
-class SQLiteIntegerBuilder extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteIntegerBuilder";
-  constructor(name) {
-    super(name, "number", "SQLiteInteger");
-  }
-  build(table) {
-    return new SQLiteInteger(table, this.config);
-  }
-}
-
-class SQLiteInteger extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteInteger";
-}
-
-class SQLiteTimestampBuilder extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteTimestampBuilder";
-  constructor(name, mode) {
-    super(name, "date", "SQLiteTimestamp");
-    this.config.mode = mode;
-  }
-  defaultNow() {
-    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
-  }
-  build(table) {
-    return new SQLiteTimestamp(table, this.config);
-  }
-}
-
-class SQLiteTimestamp extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteTimestamp";
-  mode = this.config.mode;
-  mapFromDriverValue(value) {
-    if (this.config.mode === "timestamp") {
-      return new Date(value * 1000);
-    }
-    return new Date(value);
-  }
-  mapToDriverValue(value) {
-    const unix = value.getTime();
-    if (this.config.mode === "timestamp") {
-      return Math.floor(unix / 1000);
-    }
-    return unix;
-  }
-}
-
-class SQLiteBooleanBuilder extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteBooleanBuilder";
-  constructor(name, mode) {
-    super(name, "boolean", "SQLiteBoolean");
-    this.config.mode = mode;
-  }
-  build(table) {
-    return new SQLiteBoolean(table, this.config);
-  }
-}
-
-class SQLiteBoolean extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteBoolean";
-  mode = this.config.mode;
-  mapFromDriverValue(value) {
-    return Number(value) === 1;
-  }
-  mapToDriverValue(value) {
-    return value ? 1 : 0;
-  }
-}
-function integer(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") {
-    return new SQLiteTimestampBuilder(name, config.mode);
-  }
-  if (config?.mode === "boolean") {
-    return new SQLiteBooleanBuilder(name, config.mode);
-  }
-  return new SQLiteIntegerBuilder(name);
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
-class SQLiteNumericBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericBuilder";
-  constructor(name) {
-    super(name, "string", "SQLiteNumeric");
-  }
-  build(table) {
-    return new SQLiteNumeric(table, this.config);
-  }
-}
-
-class SQLiteNumeric extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumeric";
-  mapFromDriverValue(value) {
-    if (typeof value === "string")
-      return value;
-    return String(value);
-  }
-  getSQLType() {
-    return "numeric";
-  }
-}
-
-class SQLiteNumericNumberBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericNumberBuilder";
-  constructor(name) {
-    super(name, "number", "SQLiteNumericNumber");
-  }
-  build(table) {
-    return new SQLiteNumericNumber(table, this.config);
-  }
-}
-
-class SQLiteNumericNumber extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumericNumber";
-  mapFromDriverValue(value) {
-    if (typeof value === "number")
-      return value;
-    return Number(value);
-  }
-  mapToDriverValue = String;
-  getSQLType() {
-    return "numeric";
-  }
-}
-
-class SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericBigIntBuilder";
-  constructor(name) {
-    super(name, "bigint", "SQLiteNumericBigInt");
-  }
-  build(table) {
-    return new SQLiteNumericBigInt(table, this.config);
-  }
-}
-
-class SQLiteNumericBigInt extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumericBigInt";
-  mapFromDriverValue = BigInt;
-  mapToDriverValue = String;
-  getSQLType() {
-    return "numeric";
-  }
-}
-function numeric(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  const mode = config?.mode;
-  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/real.js
-class SQLiteRealBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteRealBuilder";
-  constructor(name) {
-    super(name, "number", "SQLiteReal");
-  }
-  build(table) {
-    return new SQLiteReal(table, this.config);
-  }
-}
-
-class SQLiteReal extends SQLiteColumn {
-  static [entityKind] = "SQLiteReal";
-  getSQLType() {
-    return "real";
-  }
-}
-function real(name) {
-  return new SQLiteRealBuilder(name ?? "");
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/text.js
-class SQLiteTextBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteTextBuilder";
-  constructor(name, config) {
-    super(name, "string", "SQLiteText");
-    this.config.enumValues = config.enum;
-    this.config.length = config.length;
-  }
-  build(table) {
-    return new SQLiteText(table, this.config);
-  }
-}
-
-class SQLiteText extends SQLiteColumn {
-  static [entityKind] = "SQLiteText";
-  enumValues = this.config.enumValues;
-  length = this.config.length;
-  constructor(table, config) {
-    super(table, config);
-  }
-  getSQLType() {
-    return `text${this.config.length ? `(${this.config.length})` : ""}`;
-  }
-}
-
-class SQLiteTextJsonBuilder extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteTextJsonBuilder";
-  constructor(name) {
-    super(name, "json", "SQLiteTextJson");
-  }
-  build(table) {
-    return new SQLiteTextJson(table, this.config);
-  }
-}
-
-class SQLiteTextJson extends SQLiteColumn {
-  static [entityKind] = "SQLiteTextJson";
-  getSQLType() {
-    return "text";
-  }
-  mapFromDriverValue(value) {
-    return JSON.parse(value);
-  }
-  mapToDriverValue(value) {
-    return JSON.stringify(value);
-  }
-}
-function text(a, b = {}) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config.mode === "json") {
-    return new SQLiteTextJsonBuilder(name);
-  }
-  return new SQLiteTextBuilder(name, config);
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/all.js
-function getSQLiteColumnBuilders() {
-  return {
-    blob,
-    customType,
-    integer,
-    numeric,
-    real,
-    text
-  };
-}
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/table.js
-var InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
-
-class SQLiteTable extends Table {
-  static [entityKind] = "SQLiteTable";
-  static Symbol = Object.assign({}, Table.Symbol, {
-    InlineForeignKeys
-  });
-  [Table.Symbol.Columns];
-  [InlineForeignKeys] = [];
-  [Table.Symbol.ExtraConfigBuilder] = undefined;
-}
-function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
-  const rawTable = new SQLiteTable(name, schema, baseName);
-  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
-  const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
-    const colBuilder = colBuilderBase;
-    colBuilder.setName(name2);
-    const column = colBuilder.build(rawTable);
-    rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
-    return [name2, column];
-  }));
-  const table = Object.assign(rawTable, builtColumns);
-  table[Table.Symbol.Columns] = builtColumns;
-  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
-  if (extraConfig) {
-    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
-  }
-  return table;
-}
-var sqliteTable = (name, columns, extraConfig) => {
-  return sqliteTableBase(name, columns, extraConfig);
-};
-
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/indexes.js
-class IndexBuilderOn {
-  constructor(name, unique2) {
-    this.name = name;
-    this.unique = unique2;
-  }
-  static [entityKind] = "SQLiteIndexBuilderOn";
-  on(...columns) {
-    return new IndexBuilder(this.name, columns, this.unique);
-  }
-}
-
-class IndexBuilder {
-  static [entityKind] = "SQLiteIndexBuilder";
-  config;
-  constructor(name, columns, unique2) {
-    this.config = {
-      name,
-      columns,
-      unique: unique2,
-      where: undefined
-    };
-  }
-  where(condition) {
-    this.config.where = condition;
-    return this;
-  }
-  build(table) {
-    return new Index(this.config, table);
-  }
-}
-
-class Index {
-  static [entityKind] = "SQLiteIndex";
-  config;
-  constructor(config, table) {
-    this.config = { ...config, table };
-  }
-}
-function index(name) {
-  return new IndexBuilderOn(name, false);
-}
-
-// packages/runtime/src/drizzle-schema.ts
-var deliveriesTable = sqliteTable("deliveries", {
-  id: text("id").primaryKey(),
-  messageId: text("message_id"),
-  invocationId: text("invocation_id"),
-  targetId: text("target_id").notNull(),
-  targetNodeId: text("target_node_id"),
-  targetKind: text("target_kind").$type().notNull(),
-  transport: text("transport").$type().notNull(),
-  reason: text("reason").$type().notNull(),
-  policy: text("policy").$type().notNull(),
-  status: text("status").$type().notNull(),
-  bindingId: text("binding_id"),
-  leaseOwner: text("lease_owner"),
-  leaseExpiresAt: integer("lease_expires_at"),
-  metadataJson: text("metadata_json"),
-  createdAt: integer("created_at").notNull().default(sql`(unixepoch())`)
-}, (table) => [
-  index("idx_deliveries_status_transport").on(table.status, table.transport)
-]);
-var deliveryAttemptsTable = sqliteTable("delivery_attempts", {
-  id: text("id").primaryKey(),
-  deliveryId: text("delivery_id").notNull(),
-  attempt: integer("attempt").notNull(),
-  status: text("status").$type().notNull(),
-  error: text("error"),
-  externalRef: text("external_ref"),
-  metadataJson: text("metadata_json"),
-  createdAt: integer("created_at").notNull()
-});
-// packages/runtime/src/broker.ts
-init_dist2();
-function createRuntimeId(prefix) {
-  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function toTargetKind(actor) {
-  if (!actor)
-    return "participant";
-  if (actor.kind === "agent")
-    return "agent";
-  if (actor.kind === "device")
-    return "device";
-  if (actor.kind === "bridge")
-    return "bridge";
-  return "participant";
-}
-function defaultTransportForActor(actor) {
-  if (!actor)
-    return "local_socket";
-  switch (actor.kind) {
-    case "bridge":
-      return "webhook";
-    case "device":
-      return "local_socket";
-    case "agent":
-      return "local_socket";
-    default:
-      return "local_socket";
-  }
-}
-function endpointTransportRank(transport) {
-  switch (transport) {
-    case "codex_app_server":
-      return 0;
-    case "claude_stream_json":
-      return 1;
-    case "tmux":
-      return 2;
-    case "local_socket":
-      return 3;
-    default:
-      return 4;
-  }
-}
-function shouldBridgeMessageToBinding(binding, message) {
-  if (binding.platform !== "telegram") {
-    return true;
-  }
-  const source = typeof message.metadata?.source === "string" ? String(message.metadata.source) : "";
-  if (source === "telegram") {
-    return false;
-  }
-  const outboundMode = typeof binding.metadata?.outboundMode === "string" ? String(binding.metadata.outboundMode) : "operator_only";
-  const operatorId = typeof binding.metadata?.operatorId === "string" ? String(binding.metadata.operatorId) : "operator";
-  const allowedActorIds = Array.isArray(binding.metadata?.allowedActorIds) ? binding.metadata.allowedActorIds.map((entry) => String(entry).trim()).filter(Boolean) : [];
-  if (outboundMode === "all") {
-    return true;
-  }
-  if (outboundMode === "allowlist") {
-    return allowedActorIds.includes(message.actorId);
-  }
-  return message.actorId === operatorId;
-}
-function resolveBindingRoutes(bindings, message) {
-  return bindings.filter((binding) => shouldBridgeMessageToBinding(binding, message)).map((binding) => ({
-    targetId: binding.id,
-    targetKind: "bridge",
-    transport: binding.platform === "telegram" ? "telegram" : binding.platform === "discord" ? "discord" : "webhook",
-    bindingId: binding.id
-  }));
-}
-function preferredEndpoint(endpoints) {
-  let preferred;
-  let preferredRank = Number.POSITIVE_INFINITY;
-  for (const endpoint of endpoints) {
-    const rank = endpointTransportRank(endpoint.transport);
-    if (!preferred || rank < preferredRank) {
-      preferred = endpoint;
-      preferredRank = rank;
-    }
-  }
-  return preferred;
-}
-
-class InMemoryControlRuntime {
-  registry;
-  listeners = new Set;
-  eventBuffer = [];
-  localNodeId;
-  endpointIdsByAgentId = new Map;
-  bindingIdsByConversationId = new Map;
-  flightIdByInvocationId = new Map;
-  constructor(initial = {}, options = {}) {
-    this.registry = createRuntimeRegistrySnapshot(initial);
-    this.localNodeId = options.localNodeId;
-    this.rebuildIndexes();
-  }
-  snapshot() {
-    return createRuntimeRegistrySnapshot({
-      nodes: { ...this.registry.nodes },
-      actors: { ...this.registry.actors },
-      agents: { ...this.registry.agents },
-      endpoints: { ...this.registry.endpoints },
-      conversations: { ...this.registry.conversations },
-      bindings: { ...this.registry.bindings },
-      messages: { ...this.registry.messages },
-      flights: { ...this.registry.flights },
-      collaborationRecords: { ...this.registry.collaborationRecords }
-    });
-  }
-  peek() {
-    return this.registry;
-  }
-  node(nodeId) {
-    return this.registry.nodes[nodeId];
-  }
-  agent(agentId) {
-    return this.registry.agents[agentId];
-  }
-  conversation(conversationId) {
-    return this.registry.conversations[conversationId];
-  }
-  message(messageId) {
-    return this.registry.messages[messageId];
-  }
-  collaborationRecord(recordId) {
-    return this.registry.collaborationRecords[recordId];
-  }
-  flightForInvocation(invocationId) {
-    const flightId = this.flightIdByInvocationId.get(invocationId);
-    return flightId ? this.registry.flights[flightId] : undefined;
-  }
-  bindingsForConversation(conversationId) {
-    const bindingIds = this.bindingIdsByConversationId.get(conversationId);
-    if (!bindingIds) {
-      return [];
-    }
-    const bindings = [];
-    for (const bindingId of bindingIds) {
-      const binding = this.registry.bindings[bindingId];
-      if (binding) {
-        bindings.push(binding);
-      }
-    }
-    return bindings;
-  }
-  endpointsForAgent(agentId, options = {}) {
-    const endpointIds = this.endpointIdsByAgentId.get(agentId);
-    if (!endpointIds) {
-      return [];
-    }
-    const endpoints = [];
-    for (const endpointId of endpointIds) {
-      const endpoint = this.registry.endpoints[endpointId];
-      if (!endpoint)
-        continue;
-      if (!options.includeOffline && endpoint.state === "offline")
-        continue;
-      if (options.nodeId && endpoint.nodeId !== options.nodeId)
-        continue;
-      if (options.harness && endpoint.harness !== options.harness)
-        continue;
-      endpoints.push(endpoint);
-    }
-    return endpoints;
-  }
-  recentEvents(limit = 100) {
-    return this.eventBuffer.slice(-limit);
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  async dispatch(command) {
-    switch (command.kind) {
-      case "node.upsert":
-        await this.upsertNode(command.node);
-        return;
-      case "actor.upsert":
-        await this.upsertActor(command.actor);
-        return;
-      case "agent.upsert":
-        await this.upsertAgent(command.agent);
-        return;
-      case "agent.endpoint.upsert":
-        await this.upsertEndpoint(command.endpoint);
-        return;
-      case "conversation.upsert":
-        await this.upsertConversation(command.conversation);
-        return;
-      case "binding.upsert":
-        await this.upsertBinding(command.binding);
-        return;
-      case "collaboration.upsert":
-        await this.upsertCollaboration(command.record);
-        return;
-      case "collaboration.event.append":
-        await this.appendCollaborationEvent(command.event);
-        return;
-      case "conversation.post":
-        await this.postMessage(command.message);
-        return;
-      case "agent.invoke":
-        await this.invokeAgent(command.invocation);
-        return;
-      case "agent.ensure_awake":
-        this.emit({
-          id: createRuntimeId("evt"),
-          kind: "flight.updated",
-          ts: Date.now(),
-          actorId: command.requesterId,
-          nodeId: this.localNodeId,
-          payload: {
-            flight: {
-              id: createRuntimeId("flt"),
-              invocationId: command.agentId,
-              requesterId: command.requesterId,
-              targetAgentId: command.agentId,
-              state: "waking",
-              summary: command.reason
-            }
-          }
-        });
-        return;
-      case "stream.subscribe":
-        return;
-      default: {
-        const exhaustive = command;
-        return exhaustive;
-      }
-    }
-  }
-  async upsertNode(node) {
-    this.registry.nodes[node.id] = node;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "node.upserted",
-      ts: Date.now(),
-      actorId: node.id,
-      nodeId: node.id,
-      payload: { node }
-    });
-  }
-  async upsertActor(actor) {
-    this.registry.actors[actor.id] = {
-      id: actor.id,
-      kind: actor.kind,
-      displayName: actor.displayName,
-      handle: actor.handle,
-      labels: actor.labels,
-      metadata: actor.metadata
-    };
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "actor.registered",
-      ts: Date.now(),
-      actorId: actor.id,
-      nodeId: this.localNodeId,
-      payload: { actor }
-    });
-  }
-  async upsertAgent(agent) {
-    if (!this.registry.actors[agent.id]) {
-      this.registry.actors[agent.id] = {
-        id: agent.id,
-        kind: agent.kind,
-        displayName: agent.displayName,
-        handle: agent.handle,
-        labels: agent.labels,
-        metadata: agent.metadata
-      };
-    }
-    this.registry.agents[agent.id] = agent;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "agent.registered",
-      ts: Date.now(),
-      actorId: agent.id,
-      nodeId: agent.authorityNodeId,
-      payload: { agent }
-    });
-  }
-  async upsertEndpoint(endpoint) {
-    const previous = this.registry.endpoints[endpoint.id];
-    if (previous) {
-      this.unindexEndpoint(previous);
-    }
-    this.registry.endpoints[endpoint.id] = endpoint;
-    this.indexEndpoint(endpoint);
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "agent.endpoint.upserted",
-      ts: Date.now(),
-      actorId: endpoint.agentId,
-      nodeId: endpoint.nodeId,
-      payload: { endpoint }
-    });
-  }
-  async upsertConversation(conversation) {
-    this.registry.conversations[conversation.id] = conversation;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "conversation.upserted",
-      ts: Date.now(),
-      actorId: "system",
-      nodeId: conversation.authorityNodeId,
-      payload: { conversation }
-    });
-  }
-  async upsertBinding(binding) {
-    const previous = this.registry.bindings[binding.id];
-    if (previous) {
-      this.unindexBinding(previous);
-    }
-    this.registry.bindings[binding.id] = binding;
-    this.indexBinding(binding);
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "binding.upserted",
-      ts: Date.now(),
-      actorId: "system",
-      nodeId: this.localNodeId,
-      payload: { binding }
-    });
-  }
-  async upsertCollaboration(record) {
-    assertValidCollaborationRecord(record);
-    this.registry.collaborationRecords[record.id] = record;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "collaboration.upserted",
-      ts: Date.now(),
-      actorId: record.createdById,
-      nodeId: this.localNodeId,
-      payload: { record }
-    });
-  }
-  async appendCollaborationEvent(event) {
-    const record = this.registry.collaborationRecords[event.recordId];
-    if (!record) {
-      throw new Error(`unknown collaboration record: ${event.recordId}`);
-    }
-    assertValidCollaborationEvent(event, record);
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "collaboration.event.appended",
-      ts: Date.now(),
-      actorId: event.actorId,
-      nodeId: this.localNodeId,
-      payload: { event }
-    });
-  }
-  async upsertFlight(flight) {
-    const previous = this.registry.flights[flight.id];
-    if (previous && this.flightIdByInvocationId.get(previous.invocationId) === previous.id) {
-      this.flightIdByInvocationId.delete(previous.invocationId);
-    }
-    this.registry.flights[flight.id] = flight;
-    this.flightIdByInvocationId.set(flight.invocationId, flight.id);
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "flight.updated",
-      ts: Date.now(),
-      actorId: flight.requesterId,
-      nodeId: this.localNodeId,
-      payload: { flight }
-    });
-  }
-  async postMessage(message, options = {}) {
-    const deliveries2 = this.planMessage(message, options);
-    await this.commitMessage(message, deliveries2);
-    return deliveries2;
-  }
-  planMessage(message, options = {}) {
-    const conversation = this.registry.conversations[message.conversationId];
-    if (!conversation) {
-      throw new Error(`unknown conversation: ${message.conversationId}`);
-    }
-    const bindingRoutes = resolveBindingRoutes(this.bindingsForConversation(conversation.id), message);
-    const plannedParticipantRoutes = this.resolveParticipantRoutes(conversation.participantIds);
-    const participantRoutes = options.localOnly ? plannedParticipantRoutes.filter((route) => !route.nodeId || route.nodeId === this.localNodeId) : plannedParticipantRoutes;
-    const deliveries2 = planMessageDeliveries({
-      localNodeId: this.localNodeId,
-      message,
-      conversation,
-      participantRoutes,
-      bindingRoutes: options.localOnly ? [] : bindingRoutes
-    });
-    return deliveries2;
-  }
-  async commitMessage(message, deliveries2) {
-    this.registry.messages[message.id] = message;
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "message.posted",
-      ts: Date.now(),
-      actorId: message.actorId,
-      nodeId: message.originNodeId,
-      payload: { message }
-    });
-    for (const delivery of deliveries2) {
-      this.emit({
-        id: createRuntimeId("evt"),
-        kind: "delivery.planned",
-        ts: Date.now(),
-        actorId: message.actorId,
-        nodeId: message.originNodeId,
-        payload: { delivery }
-      });
-    }
-  }
-  async invokeAgent(invocation) {
-    const flight = this.planInvocation(invocation);
-    await this.commitInvocation(invocation, flight);
-    return flight;
-  }
-  planInvocation(invocation) {
-    const targetAgent = this.registry.agents[invocation.targetAgentId];
-    if (!targetAgent) {
-      throw new Error(`unknown agent: ${invocation.targetAgentId}`);
-    }
-    const targetEndpoints = this.endpointsForAgent(invocation.targetAgentId, {
-      nodeId: targetAgent.authorityNodeId,
-      harness: invocation.execution?.harness
-    });
-    const isLocalAuthority = !this.localNodeId || targetAgent.authorityNodeId === this.localNodeId;
-    const startedAt = Date.now();
-    let state = invocation.ensureAwake ? "waking" : "queued";
-    let summary;
-    let error;
-    let completedAt;
-    if (isLocalAuthority) {
-      if (targetEndpoints.length == 0) {
-        state = invocation.ensureAwake ? "waking" : "queued";
-        summary = invocation.ensureAwake ? invocation.execution?.harness ? `${targetAgent.displayName} waking on ${invocation.execution.harness}.` : `${targetAgent.displayName} waking.` : `Message stored for ${targetAgent.displayName}. Will deliver when online.`;
-      } else {
-        state = "queued";
-        summary = `${targetAgent.displayName} queued for local execution.`;
-      }
-    }
-    const flight = {
-      id: createRuntimeId("flt"),
-      invocationId: invocation.id,
-      requesterId: invocation.requesterId,
-      targetAgentId: invocation.targetAgentId,
-      state,
-      summary,
-      error,
-      startedAt,
-      completedAt,
-      metadata: invocation.metadata
-    };
-    return flight;
-  }
-  async commitInvocation(invocation, flight) {
-    const previous = this.registry.flights[flight.id];
-    if (previous && this.flightIdByInvocationId.get(previous.invocationId) === previous.id) {
-      this.flightIdByInvocationId.delete(previous.invocationId);
-    }
-    this.registry.flights[flight.id] = flight;
-    this.flightIdByInvocationId.set(flight.invocationId, flight.id);
-    const targetAgent = this.registry.agents[invocation.targetAgentId];
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "invocation.requested",
-      ts: Date.now(),
-      actorId: invocation.requesterId,
-      nodeId: invocation.requesterNodeId,
-      payload: { invocation }
-    });
-    this.emit({
-      id: createRuntimeId("evt"),
-      kind: "flight.updated",
-      ts: Date.now(),
-      actorId: invocation.requesterId,
-      nodeId: targetAgent?.authorityNodeId,
-      payload: { flight }
-    });
-  }
-  rebuildIndexes() {
-    for (const endpoint of Object.values(this.registry.endpoints)) {
-      this.indexEndpoint(endpoint);
-    }
-    for (const binding of Object.values(this.registry.bindings)) {
-      this.indexBinding(binding);
-    }
-    for (const flight of Object.values(this.registry.flights)) {
-      this.flightIdByInvocationId.set(flight.invocationId, flight.id);
-    }
-  }
-  indexEndpoint(endpoint) {
-    this.addIndexedId(this.endpointIdsByAgentId, endpoint.agentId, endpoint.id);
-  }
-  unindexEndpoint(endpoint) {
-    this.removeIndexedId(this.endpointIdsByAgentId, endpoint.agentId, endpoint.id);
-  }
-  indexBinding(binding) {
-    this.addIndexedId(this.bindingIdsByConversationId, binding.conversationId, binding.id);
-  }
-  unindexBinding(binding) {
-    this.removeIndexedId(this.bindingIdsByConversationId, binding.conversationId, binding.id);
-  }
-  addIndexedId(index2, key, value) {
-    const ids = index2.get(key) ?? new Set;
-    ids.add(value);
-    index2.set(key, ids);
-  }
-  removeIndexedId(index2, key, value) {
-    const ids = index2.get(key);
-    if (!ids) {
-      return;
-    }
-    ids.delete(value);
-    if (ids.size === 0) {
-      index2.delete(key);
-    }
-  }
-  resolveParticipantRoutes(participantIds) {
-    const routes = [];
-    for (const participantId of participantIds) {
-      const actor = this.registry.actors[participantId];
-      const agent = this.registry.agents[participantId];
-      const targetIdentity = actor ?? agent;
-      const endpoints = this.endpointsForAgent(participantId);
-      const endpoint = preferredEndpoint(endpoints);
-      if (!endpoint) {
-        if (agent?.authorityNodeId && agent.authorityNodeId !== this.localNodeId) {
-          routes.push({
-            targetId: participantId,
-            nodeId: agent.authorityNodeId,
-            targetKind: toTargetKind(targetIdentity),
-            transport: defaultTransportForActor(targetIdentity),
-            speechEnabled: false
-          });
-        } else if (agent) {
-          routes.push({
-            targetId: participantId,
-            nodeId: agent.authorityNodeId ?? this.localNodeId,
-            targetKind: toTargetKind(targetIdentity),
-            transport: defaultTransportForActor(targetIdentity),
-            speechEnabled: false
-          });
-        }
-        continue;
-      }
-      routes.push({
-        targetId: participantId,
-        nodeId: endpoint.nodeId ?? agent?.authorityNodeId,
-        targetKind: toTargetKind(targetIdentity),
-        transport: endpoint.transport ?? defaultTransportForActor(targetIdentity),
-        speechEnabled: Boolean(actor?.kind === "device" || endpoints.some((candidate) => candidate.transport === "local_socket" || candidate.transport === "websocket"))
-      });
-    }
-    return routes;
-  }
-  emit(event) {
-    this.eventBuffer.push(event);
-    if (this.eventBuffer.length > 500) {
-      this.eventBuffer.shift();
-    }
-    for (const listener of this.listeners) {
-      listener(event);
-    }
-  }
-}
-// packages/runtime/src/tailscale.ts
-import { readFile as readFile7 } from "fs/promises";
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-function parseStatusJson(raw2) {
-  return JSON.parse(raw2);
-}
-function parsePeers(status) {
-  const peers = Object.entries(status.Peer ?? {});
-  return peers.map(([fallbackId, peer]) => ({
-    id: peer.ID ?? fallbackId,
-    name: peer.HostName ?? peer.DNSName ?? fallbackId,
-    dnsName: peer.DNSName,
-    addresses: peer.TailscaleIPs ?? [],
-    online: peer.Online ?? false,
-    hostName: peer.HostName,
-    os: peer.OS,
-    tags: peer.Tags ?? []
-  }));
-}
-function parseSelf(status) {
-  const self = status.Self;
-  if (!self) {
-    return null;
-  }
-  return {
-    id: self.ID ?? self.DNSName ?? self.HostName ?? "self",
-    name: self.HostName ?? self.DNSName ?? "self",
-    dnsName: self.DNSName,
-    addresses: self.TailscaleIPs ?? [],
-    online: self.Online ?? true,
-    hostName: self.HostName,
-    os: self.OS,
-    tailnetName: status.CurrentTailnet?.Name,
-    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);
-}
-async function readStatusJson() {
-  const fixturePath = process.env.OPENSCOUT_TAILSCALE_STATUS_JSON;
-  if (fixturePath) {
-    return readStatusJsonFromFile(fixturePath);
-  }
-  try {
-    const tailscaleBin = process.env.OPENSCOUT_TAILSCALE_BIN ?? "tailscale";
-    const { stdout } = await execFileAsync(tailscaleBin, ["status", "--json"]);
-    return parseStatusJson(stdout);
-  } catch {
-    return null;
-  }
-}
-async function readTailscaleSelf() {
-  const summary = await readTailscaleStatusSummary();
-  if (!summary) {
-    return null;
-  }
-  return summary.self;
-}
-async function readTailscaleStatusSummary() {
-  const status = await readStatusJson();
-  if (!status) {
-    return null;
-  }
-  return {
-    backendState: status.BackendState ?? null,
-    running: isBackendRunning(status),
-    health: status.Health ?? [],
-    peers: parsePeers(status),
-    self: parseSelf(status)
-  };
-}
-
-// packages/runtime/src/index.ts
-init_broker_service();
-init_local_agents();
-
-// packages/runtime/src/scout-broker.ts
-init_dist2();
-init_setup();
-init_support_paths();
-await __promiseAll([
-  init_local_agents(),
-  init_broker_service()
-]);
-
-// packages/runtime/src/index.ts
-init_codex_app_server();
-init_setup();
-init_support_paths();
-
-// packages/runtime/src/scout-agent-cards.ts
-init_dist2();
-// packages/runtime/src/thread-events.ts
-class ThreadWatchProtocolError extends Error {
-  status;
-  body;
-  constructor(status, body) {
-    super(body.message);
-    this.status = status;
-    this.body = body;
-  }
-}
-function watchKey(conversationId, watcherNodeId, watcherId) {
-  return `${conversationId}:${watcherNodeId}:${watcherId}`;
-}
-function writeSse(response, eventName, payload) {
-  response.write(`event: ${eventName}
-data: ${JSON.stringify(payload)}
-
-`);
-}
-
-class ThreadEventPlane {
-  options;
-  watches = new Map;
-  watchIdsByKey = new Map;
-  watchIdsByConversation = new Map;
-  constructor(options) {
-    this.options = options;
-  }
-  async openWatch(request) {
-    const conversation = this.requireConversationAuthority(request.conversationId);
-    this.requireRemoteWatchAllowed(conversation);
-    const afterSeq = Math.max(0, request.afterSeq ?? 0);
-    const oldestSeq = await this.options.projection.oldestThreadSeq(conversation.id);
-    const latestSeq = await this.options.projection.latestThreadSeq(conversation.id);
-    if (latestSeq > 0 && oldestSeq > 0 && afterSeq < oldestSeq - 1) {
-      throw new ThreadWatchProtocolError(409, {
-        code: "cursor_out_of_range",
-        message: `thread cursor ${afterSeq} is older than retained seq ${oldestSeq}`
-      });
-    }
-    const key = watchKey(conversation.id, request.watcherNodeId, request.watcherId);
-    const existingWatchId = this.watchIdsByKey.get(key);
-    if (existingWatchId) {
-      this.closeWatchInternal(existingWatchId);
-    }
-    const watchId = `thread-watch:${conversation.id}:${request.watcherNodeId}:${request.watcherId}`;
-    const leaseExpiresAt = Date.now() + this.normalizeLeaseMs(request.leaseMs);
-    const watch = {
-      watchId,
-      conversationId: conversation.id,
-      watcherNodeId: request.watcherNodeId,
-      watcherId: request.watcherId,
-      acceptedAfterSeq: afterSeq,
-      leaseExpiresAt,
-      mode: conversation.shareMode === "summary" ? "summary" : "shared",
-      clients: new Set
-    };
-    this.watches.set(watchId, watch);
-    this.watchIdsByKey.set(key, watchId);
-    this.indexWatch(watch);
-    return {
-      watchId,
-      conversationId: conversation.id,
-      authorityNodeId: conversation.authorityNodeId,
-      acceptedAfterSeq: afterSeq,
-      latestSeq,
-      leaseExpiresAt,
-      mode: watch.mode
-    };
-  }
-  async renewWatch(request) {
-    const watch = this.requireLiveWatch(request.watchId);
-    watch.leaseExpiresAt = Date.now() + this.normalizeLeaseMs(request.leaseMs);
-    return {
-      watchId: watch.watchId,
-      leaseExpiresAt: watch.leaseExpiresAt
-    };
-  }
-  async closeWatch(request) {
-    this.closeWatchInternal(request.watchId);
-  }
-  async replay(options) {
-    const conversation = this.requireConversationAuthority(options.conversationId);
-    this.requireRemoteWatchAllowed(conversation);
-    const oldestSeq = await this.options.projection.oldestThreadSeq(conversation.id);
-    const latestSeq = await this.options.projection.latestThreadSeq(conversation.id);
-    if (latestSeq > 0 && oldestSeq > 0 && options.afterSeq < oldestSeq - 1) {
-      throw new ThreadWatchProtocolError(409, {
-        code: "cursor_out_of_range",
-        message: `thread cursor ${options.afterSeq} is older than retained seq ${oldestSeq}`
-      });
-    }
-    return this.options.projection.listThreadEvents({
-      conversationId: conversation.id,
-      afterSeq: options.afterSeq,
-      limit: Math.min(options.limit ?? 500, this.options.maxReplayLimit ?? 2000)
-    });
-  }
-  async snapshot(conversationId) {
-    const conversation = this.requireConversationAuthority(conversationId);
-    this.requireRemoteWatchAllowed(conversation);
-    const snapshot = await this.options.projection.getThreadSnapshot(conversation.id);
-    if (!snapshot) {
-      throw new ThreadWatchProtocolError(404, {
-        code: "unknown_conversation",
-        message: `unknown conversation ${conversation.id}`
-      });
-    }
-    return snapshot;
-  }
-  async streamWatch(watchId, request, response) {
-    const watch = this.requireLiveWatch(watchId);
-    const backlog = await this.options.projection.listThreadEvents({
-      conversationId: watch.conversationId,
-      afterSeq: watch.acceptedAfterSeq,
-      limit: this.options.maxReplayLimit ?? 2000
-    });
-    response.writeHead(200, {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache, no-transform",
-      connection: "keep-alive"
-    });
-    writeSse(response, "hello", {
-      watchId: watch.watchId,
-      conversationId: watch.conversationId,
-      leaseExpiresAt: watch.leaseExpiresAt
-    });
-    for (const event of backlog) {
-      writeSse(response, "thread.event", event);
-    }
-    watch.clients.add(response);
-    request.on("close", () => {
-      watch.clients.delete(response);
-      response.end();
-    });
-  }
-  publish(events2) {
-    for (const event of events2) {
-      const watchIds = this.watchIdsByConversation.get(event.conversationId);
-      if (!watchIds || watchIds.size === 0) {
-        continue;
-      }
-      for (const watchId of [...watchIds]) {
-        const watch = this.watches.get(watchId);
-        if (!watch) {
-          watchIds.delete(watchId);
-          continue;
-        }
-        if (watch.leaseExpiresAt <= Date.now()) {
-          this.closeWatchInternal(watchId);
-          continue;
-        }
-        for (const client of watch.clients) {
-          writeSse(client, "thread.event", event);
-        }
-      }
-    }
-  }
-  normalizeLeaseMs(requestedLeaseMs) {
-    const defaultLeaseMs = this.options.defaultLeaseMs ?? 30000;
-    const maxLeaseMs = this.options.maxLeaseMs ?? 300000;
-    if (!requestedLeaseMs || !Number.isFinite(requestedLeaseMs) || requestedLeaseMs <= 0) {
-      return defaultLeaseMs;
-    }
-    return Math.min(Math.max(requestedLeaseMs, 5000), maxLeaseMs);
-  }
-  requireConversationAuthority(conversationId) {
-    const conversation = this.options.runtime.conversation(conversationId);
-    if (!conversation) {
-      throw new ThreadWatchProtocolError(404, {
-        code: "unknown_conversation",
-        message: `unknown conversation ${conversationId}`
-      });
-    }
-    if (conversation.authorityNodeId !== this.options.nodeId) {
-      throw new ThreadWatchProtocolError(409, {
-        code: "no_responder",
-        message: `conversation ${conversationId} is owned by ${conversation.authorityNodeId}`
-      });
-    }
-    return conversation;
-  }
-  requireRemoteWatchAllowed(conversation) {
-    if (conversation.shareMode === "local") {
-      throw new ThreadWatchProtocolError(403, {
-        code: "forbidden",
-        message: `conversation ${conversation.id} does not allow remote watches`
-      });
-    }
-  }
-  requireLiveWatch(watchId) {
-    const watch = this.watches.get(watchId);
-    if (!watch) {
-      throw new ThreadWatchProtocolError(404, {
-        code: "invalid_request",
-        message: `unknown watch ${watchId}`
-      });
-    }
-    if (watch.leaseExpiresAt <= Date.now()) {
-      this.closeWatchInternal(watchId);
-      throw new ThreadWatchProtocolError(410, {
-        code: "lease_expired",
-        message: `watch ${watchId} lease expired`
-      });
-    }
-    return watch;
-  }
-  indexWatch(watch) {
-    const ids = this.watchIdsByConversation.get(watch.conversationId) ?? new Set;
-    ids.add(watch.watchId);
-    this.watchIdsByConversation.set(watch.conversationId, ids);
-  }
-  closeWatchInternal(watchId) {
-    const watch = this.watches.get(watchId);
-    if (!watch) {
-      return;
-    }
-    this.watches.delete(watchId);
-    this.watchIdsByKey.delete(watchKey(watch.conversationId, watch.watcherNodeId, watch.watcherId));
-    const ids = this.watchIdsByConversation.get(watch.conversationId);
-    if (ids) {
-      ids.delete(watchId);
-      if (ids.size === 0) {
-        this.watchIdsByConversation.delete(watch.conversationId);
-      }
-    }
-    for (const client of watch.clients) {
-      client.end();
-    }
-    watch.clients.clear();
-  }
-}
-// packages/runtime/src/mobile-push.ts
-init_support_paths();
-// packages/web/server/core/observe/service.ts
-var HISTORY_SNAPSHOT_CACHE_LIMIT = 128;
-var historySnapshotCache = new Map;
-var OBSERVE_SUMMARY_TAIL_SIZE = 8;
-function activeEndpoint(snapshot, agentId) {
-  const candidates = Object.values(snapshot.endpoints ?? {}).filter((endpoint) => endpoint.agentId === agentId);
-  const rank = (state) => {
-    switch (state) {
-      case "active":
-        return 0;
-      case "idle":
-        return 1;
-      case "waiting":
-        return 2;
-      case "offline":
-        return 5;
-      default:
-        return 4;
-    }
-  };
-  return [...candidates].sort((left, right) => rank(left.state) - rank(right.state))[0] ?? null;
-}
-function expandHome(value) {
-  if (!value) {
-    return null;
-  }
-  if (value === "~") {
-    return homedir12();
-  }
-  if (value.startsWith("~/")) {
-    return join18(homedir12(), value.slice(2));
-  }
-  return value;
-}
-function encodeClaudeProjectsSlug2(absolutePath) {
-  const normalized = resolve8(absolutePath);
-  return `-${normalized.replace(/^\//u, "").replace(/\//gu, "-")}`;
-}
-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 (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 best?.path ?? null;
+  } catch {
+    return null;
   }
 }
 function historyAdapterAlias(value) {
@@ -20498,8 +18408,8 @@ function syntheticContextUsage(eventCount) {
     return [];
   }
   const length = Math.max(2, Math.min(eventCount, 24));
-  return Array.from({ length }, (_, index2) => {
-    const progress = length <= 1 ? 1 : index2 / (length - 1);
+  return Array.from({ length }, (_, index) => {
+    const progress = length <= 1 ? 1 : index / (length - 1);
     return Math.min(0.92, 0.08 + progress * 0.66);
   });
 }
@@ -20630,9 +18540,9 @@ function buildObserveDataFromSnapshot(snapshot, timedEvents = [], live = false)
     }
   }
   const seconds = timelineSeconds(eventDrafts.map((draft) => draft.timestampMs), timing.baseTimestampMs);
-  const builtEntries = eventDrafts.map((draft, index2) => ({
+  const builtEntries = eventDrafts.map((draft, index) => ({
     draft,
-    event: draft.build(seconds[index2] ?? 0)
+    event: draft.build(seconds[index] ?? 0)
   })).filter(({ event }) => event.text.length > 0 || event.kind === "tool" || event.kind === "boot");
   const events2 = builtEntries.map((entry) => entry.event);
   for (const { draft, event } of builtEntries) {
@@ -20663,8 +18573,8 @@ function unavailableObserveData(agent) {
     live: false
   };
 }
-async function resolveSnapshotSource(agent, broker2) {
-  const endpoint = broker2 ? activeEndpoint(broker2.snapshot, agent.id) : null;
+async function resolveSnapshotSource(agent, broker) {
+  const endpoint = broker ? activeEndpoint(broker.snapshot, agent.id) : null;
   const liveSnapshot = await readLiveSnapshot(endpoint);
   const live = Boolean(liveSnapshot && (liveSnapshot.currentTurnId || liveSnapshot.session.status === "active"));
   const historyCandidate = resolveHistoryCandidate(agent, liveSnapshot);
@@ -20707,8 +18617,8 @@ async function resolveSnapshotSource(agent, broker2) {
     sessionId: null
   };
 }
-async function buildAgentObservePayload(agent, broker2) {
-  const source = await resolveSnapshotSource(agent, broker2);
+async function buildAgentObservePayload(agent, broker) {
+  const source = await resolveSnapshotSource(agent, broker);
   if (source.source === "unavailable") {
     return {
       agentId: agent.id,
@@ -20737,8 +18647,8 @@ async function loadAgentObservePayloadsInternal(agentIds) {
   if (filteredAgents.length === 0) {
     return [];
   }
-  const broker2 = await loadScoutBrokerContext();
-  return await Promise.all(filteredAgents.map((agent) => buildAgentObservePayload(agent, broker2)));
+  const broker = await loadScoutBrokerContext();
+  return await Promise.all(filteredAgents.map((agent) => buildAgentObservePayload(agent, broker)));
 }
 function summarizeAgentObservePayload(payload) {
   return {
@@ -20750,19 +18660,100 @@ function summarizeAgentObservePayload(payload) {
     }
   };
 }
-async function loadAgentObserveSummaries(agentIds) {
-  const payloads = await loadAgentObservePayloadsInternal(agentIds);
-  return payloads.map(summarizeAgentObservePayload);
-}
-async function loadAgentObservePayload(agentId) {
-  const payloads = await loadAgentObservePayloadsInternal([agentId]);
-  return payloads[0] ?? null;
-}
+async function loadAgentObserveSummaries(agentIds) {
+  const payloads = await loadAgentObservePayloadsInternal(agentIds);
+  return payloads.map(summarizeAgentObservePayload);
+}
+async function loadAgentObservePayload(agentId) {
+  const payloads = await loadAgentObservePayloadsInternal([agentId]);
+  return payloads[0] ?? null;
+}
+
+// packages/web/server/core/mesh/service.ts
+await init_broker_service();
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// packages/runtime/src/tailscale.ts
+import { readFile as readFile7 } from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function parseStatusJson(raw2) {
+  return JSON.parse(raw2);
+}
+function parsePeers(status) {
+  const peers = Object.entries(status.Peer ?? {});
+  return peers.map(([fallbackId, peer]) => ({
+    id: peer.ID ?? fallbackId,
+    name: peer.HostName ?? peer.DNSName ?? fallbackId,
+    dnsName: peer.DNSName,
+    addresses: peer.TailscaleIPs ?? [],
+    online: peer.Online ?? false,
+    hostName: peer.HostName,
+    os: peer.OS,
+    tags: peer.Tags ?? []
+  }));
+}
+function parseSelf(status) {
+  const self = status.Self;
+  if (!self) {
+    return null;
+  }
+  return {
+    id: self.ID ?? self.DNSName ?? self.HostName ?? "self",
+    name: self.HostName ?? self.DNSName ?? "self",
+    dnsName: self.DNSName,
+    addresses: self.TailscaleIPs ?? [],
+    online: self.Online ?? true,
+    hostName: self.HostName,
+    os: self.OS,
+    tailnetName: status.CurrentTailnet?.Name,
+    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);
+}
+async function readStatusJson() {
+  const fixturePath = process.env.OPENSCOUT_TAILSCALE_STATUS_JSON;
+  if (fixturePath) {
+    return readStatusJsonFromFile(fixturePath);
+  }
+  try {
+    const tailscaleBin = process.env.OPENSCOUT_TAILSCALE_BIN ?? "tailscale";
+    const { stdout } = await execFileAsync(tailscaleBin, ["status", "--json"]);
+    return parseStatusJson(stdout);
+  } catch {
+    return null;
+  }
+}
+async function readTailscaleSelf() {
+  const summary = await readTailscaleStatusSummary();
+  if (!summary) {
+    return null;
+  }
+  return summary.self;
+}
+async function readTailscaleStatusSummary() {
+  const status = await readStatusJson();
+  if (!status) {
+    return null;
+  }
+  return {
+    backendState: status.BackendState ?? null,
+    running: isBackendRunning(status),
+    health: status.Health ?? [],
+    peers: parsePeers(status),
+    self: parseSelf(status)
+  };
+}
 
 // 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();
@@ -20808,7 +18799,7 @@ async function readTailscaleStatus() {
 function formatIssueWarning(issue) {
   return issue.action ? `${issue.title} \u2014 ${issue.summary} ${issue.action}` : `${issue.title} \u2014 ${issue.summary}`;
 }
-function computeIssues(health, localNode, nodes, tailscale2) {
+function computeIssues(health, localNode, nodes, tailscale) {
   const issues = [];
   if (!health.reachable) {
     issues.push({
@@ -20821,7 +18812,7 @@ function computeIssues(health, localNode, nodes, tailscale2) {
     });
     return issues;
   }
-  if (tailscale2.available && !tailscale2.running) {
+  if (tailscale.available && !tailscale.running) {
     issues.push({
       code: "tailscale_stopped",
       severity: "warning",
@@ -20851,7 +18842,7 @@ function computeIssues(health, localNode, nodes, tailscale2) {
     });
   }
   const remoteNodes = Object.values(nodes).filter((n) => n.id !== localNode?.id);
-  if (!tailscale2.available && remoteNodes.length === 0) {
+  if (!tailscale.available && remoteNodes.length === 0) {
     issues.push({
       code: "discovery_unconfigured",
       severity: "warning",
@@ -20940,7 +18931,7 @@ function filterCurrentMeshNodes(allNodes, meshId, localNodeId, now) {
 }
 async function loadMeshStatus() {
   const brokerUrl = resolveScoutBrokerUrl();
-  const [health, context, tailscale2] = await Promise.all([
+  const [health, context, tailscale] = await Promise.all([
     readScoutBrokerHealth(brokerUrl),
     loadScoutBrokerContext(brokerUrl),
     readTailscaleStatus()
@@ -20950,9 +18941,9 @@ async function loadMeshStatus() {
   const meshId = health.meshId ?? localNode?.meshId ?? null;
   const identity = computeIdentitySummary(health, localNode, meshId);
   const nodes = filterCurrentMeshNodes(allNodes, meshId, localNode?.id, Date.now());
-  const issues = computeIssues(health, localNode, nodes, tailscale2);
+  const issues = computeIssues(health, localNode, nodes, tailscale);
   const warnings = issues.map(formatIssueWarning);
-  return { brokerUrl, health, localNode, meshId, identity, nodes, tailscale: tailscale2, issues, warnings };
+  return { brokerUrl, health, localNode, meshId, identity, nodes, tailscale, issues, warnings };
 }
 function preferredAnnounceHost(self, currentBrokerUrl) {
   const dnsName = stripTrailingDot(self?.dnsName);
@@ -21055,415 +19046,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 +19100,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 +19373,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 +19477,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 +19734,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 +19749,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 +19800,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);
 };