@openscout/scout 0.2.63 → 0.2.64

package/dist/main.mjs

@@ -191,6 +191,7 @@ function parseSendCommandOptions(args, defaultCurrentDirectory) {
   const parsed = parseContextRootPrefix(args, defaultCurrentDirectory);
   let agentName = null;
   let targetLabel;
+  let targetRef;
   let channel;
   let shouldSpeak = false;
   let harness;
@@ -210,6 +211,13 @@ function parseSendCommandOptions(args, defaultCurrentDirectory) {
       index = value.nextIndex;
       continue;
     }
+    if (current === "--ref" || current.startsWith("--ref=")) {
+      const value = parseFlagValue(parsed.args, index, "--ref");
+      targetRef = value.value.replace(/^ref:/, "");
+      targetLabel = `ref:${targetRef}`;
+      index = value.nextIndex;
+      continue;
+    }
     if (current === "--channel" || current.startsWith("--channel=")) {
       const value = parseFlagValue(parsed.args, index, "--channel");
       channel = value.value;
@@ -250,6 +258,7 @@ function parseSendCommandOptions(args, defaultCurrentDirectory) {
     args: parsed.args,
     agentName,
     targetLabel,
+    targetRef,
     channel,
     shouldSpeak,
     harness,
@@ -261,6 +270,7 @@ function parseAskCommandOptions(args, defaultCurrentDirectory) {
   const parsed = parseContextRootPrefix(args, defaultCurrentDirectory);
   let agentName = null;
   let targetLabel = null;
+  let targetRef;
   let channel;
   let harness;
   let timeoutSeconds;
@@ -280,6 +290,13 @@ function parseAskCommandOptions(args, defaultCurrentDirectory) {
       index = value.nextIndex;
       continue;
     }
+    if (current === "--ref" || current.startsWith("--ref=")) {
+      const value = parseFlagValue(parsed.args, index, "--ref");
+      targetRef = value.value.replace(/^ref:/, "");
+      targetLabel = `ref:${targetRef}`;
+      index = value.nextIndex;
+      continue;
+    }
     if (current === "--channel" || current.startsWith("--channel=")) {
       const value = parseFlagValue(parsed.args, index, "--channel");
       channel = value.value;
@@ -329,6 +346,7 @@ function parseAskCommandOptions(args, defaultCurrentDirectory) {
     args: parsed.args,
     agentName,
     targetLabel,
+    targetRef,
     channel,
     harness,
     timeoutSeconds,
@@ -5289,7 +5307,7 @@ function resolveJavaScriptRuntime(options = {}) {
   };
 }
 function resolveBundledEntrypoint(moduleUrl, filename) {
-  const moduleDirectory = dirname4(fileURLToPath3(moduleUrl));
+  const moduleDirectory = dirname4(fileURLToPath3(moduleUrl.toString()));
   const candidate = join5(moduleDirectory, filename);
   return existsSync4(candidate) ? candidate : null;
 }
@@ -5323,7 +5341,7 @@ function resolveRepoEntrypoint(repoRoot, relativePath) {
   return existsSync4(candidate) ? candidate : null;
 }
 function resolveNodeModulesPackageEntrypoint(moduleUrl, packageSegments, entryRelativePath) {
-  let current = dirname4(fileURLToPath3(moduleUrl));
+  let current = dirname4(fileURLToPath3(moduleUrl.toString()));
   for (let attempt = 0;attempt < 24; attempt += 1) {
     const candidate = join5(current, "node_modules", ...packageSegments, entryRelativePath);
     if (existsSync4(candidate)) {
@@ -11187,6 +11205,7 @@ class CodexAppServerSession {
   key;
   threadIdPath;
   statePath;
+  replyContextPath;
   stdoutLogPath;
   stderrLogPath;
   process = null;
@@ -11204,6 +11223,7 @@ class CodexAppServerSession {
     this.key = sessionKey2(options);
     this.threadIdPath = join11(options.runtimeDirectory, "codex-thread-id.txt");
     this.statePath = join11(options.runtimeDirectory, "state.json");
+    this.replyContextPath = join11(options.runtimeDirectory, "scout-reply-context.json");
     this.stdoutLogPath = join11(options.logsDirectory, "stdout.log");
     this.stderrLogPath = join11(options.logsDirectory, "stderr.log");
     this.lastConfigSignature = this.configSignature(options);
@@ -11227,7 +11247,7 @@ class CodexAppServerSession {
       threadId: this.threadId
     };
   }
-  async invoke(prompt, timeoutMs = 5 * 60000) {
+  async invoke(prompt, timeoutMs = 5 * 60000, replyContext) {
     return this.enqueue(async () => {
       await this.ensureStarted();
       if (!this.threadId) {
@@ -11236,6 +11256,7 @@ class CodexAppServerSession {
       const output = await new Promise(async (resolve8, reject) => {
         const turn = this.createActiveTurn(resolve8, reject, timeoutMs);
         try {
+          await this.writeReplyContext(replyContext ?? null);
           const response = await this.request("turn/start", {
             threadId: this.threadId,
             cwd: this.options.cwd,
@@ -11250,6 +11271,7 @@ class CodexAppServerSession {
           turn.turnId = response.turn.id;
           await this.persistState();
         } catch (error) {
+          await this.clearReplyContext();
           this.clearActiveTurn(turn);
           reject(error instanceof Error ? error : new Error(errorMessage3(error)));
         }
@@ -11398,6 +11420,7 @@ class CodexAppServerSession {
       currentDirectory: this.options.cwd,
       baseEnv: process.env
     });
+    env.OPENSCOUT_REPLY_CONTEXT_FILE = this.replyContextPath;
     const child = spawn3(codexExecutable, [
       "app-server",
       ...buildScoutMcpCodexLaunchArgs({
@@ -11640,6 +11663,20 @@ class CodexAppServerSession {
       error: buildUnsupportedServerRequestError2(message)
     });
   }
+  async writeReplyContext(context) {
+    if (!context) {
+      await this.clearReplyContext();
+      return;
+    }
+    await mkdir5(this.options.runtimeDirectory, { recursive: true });
+    await writeFile5(this.replyContextPath, `${JSON.stringify(context, null, 2)}
+`, "utf8");
+  }
+  async clearReplyContext() {
+    await rm4(this.replyContextPath, { force: true }).catch(() => {
+      return;
+    });
+  }
   handleNotification(message) {
     const method = message.method;
     const params = message.params ?? {};
@@ -11694,6 +11731,7 @@ class CodexAppServerSession {
       return;
     }
     if (method === "turn/completed") {
+      this.clearReplyContext();
       this.completeTurn(params);
       return;
     }
@@ -13494,7 +13532,11 @@ var init_paths = __esm(() => {
       deliver: "/v1/deliver",
       activity: "/v1/activity",
       collaborationRecords: "/v1/collaboration/records",
-      collaborationEvents: "/v1/collaboration/events"
+      collaborationEvents: "/v1/collaboration/events",
+      pairingAttach: "/v1/pairing/attach",
+      pairingDetach: "/v1/pairing/detach",
+      localSessionsAttach: "/v1/local-sessions/attach",
+      localSessionsDetach: "/v1/local-sessions/detach"
     }
   };
 });
@@ -14410,7 +14452,10 @@ async function sendScoutMessage(input) {
   const source = input.source?.trim() || "scout-cli";
   const senderId = await resolveConversationActorId(broker.baseUrl, broker.snapshot, broker.node.id, input.senderId, currentDirectory);
   const requestedTargetLabel = input.targetLabel?.trim();
-  if (requestedTargetLabel) {
+  const requestedTargetRef = input.targetRef?.trim() || (requestedTargetLabel?.startsWith("ref:") ? requestedTargetLabel.slice("ref:".length) : "");
+  if (requestedTargetLabel || requestedTargetRef) {
+    const target = requestedTargetRef ? { kind: "binding_ref", ref: requestedTargetRef } : { kind: "agent_label", label: requestedTargetLabel };
+    const renderedTarget = requestedTargetRef ? `ref:${requestedTargetRef}` : requestedTargetLabel;
     const delivery = await brokerPostDeliver(broker.baseUrl, {
       caller: {
         actorId: senderId,
@@ -14418,11 +14463,8 @@ async function sendScoutMessage(input) {
         currentDirectory,
         metadata: { source }
       },
-      target: {
-        kind: "agent_label",
-        label: requestedTargetLabel
-      },
-      targetLabel: requestedTargetLabel,
+      target,
+      targetLabel: renderedTarget,
       body: input.body,
       intent: "tell",
       channel: input.channel,
@@ -14435,7 +14477,7 @@ async function sendScoutMessage(input) {
       return {
         usedBroker: true,
         invokedTargets: [],
-        unresolvedTargets: [requestedTargetLabel],
+        unresolvedTargets: [renderedTarget],
         targetDiagnostic: scoutTargetDiagnosticFromDeliveryFailure(delivery)
       };
     }
@@ -14443,6 +14485,7 @@ async function sendScoutMessage(input) {
       usedBroker: true,
       conversationId: delivery.conversation.id,
       messageId: delivery.message.id,
+      bindingRef: delivery.receipt?.bindingRef ?? delivery.bindingRef,
       invokedTargets: delivery.targetAgentId ? [delivery.targetAgentId] : [],
       unresolvedTargets: [],
       routeKind: delivery.routeKind
@@ -14557,6 +14600,88 @@ async function sendScoutMessage(input) {
     routeKind: relayRouteKind(conversation)
   };
 }
+async function replyToScoutMessage(input) {
+  const broker = await loadScoutBrokerContext();
+  if (!broker) {
+    return { usedBroker: false, notifiedActorIds: [] };
+  }
+  const conversationId = input.conversationId.trim();
+  const replyToMessageId = input.replyToMessageId.trim();
+  if (!conversationId || !replyToMessageId) {
+    return {
+      usedBroker: true,
+      notifiedActorIds: [],
+      routingError: "missing_reply_context"
+    };
+  }
+  const conversation = broker.snapshot.conversations[conversationId];
+  if (!conversation) {
+    return {
+      usedBroker: true,
+      conversationId,
+      replyToMessageId,
+      notifiedActorIds: [],
+      routingError: "unknown_conversation"
+    };
+  }
+  const replyTarget = broker.snapshot.messages[replyToMessageId];
+  if (!replyTarget) {
+    return {
+      usedBroker: true,
+      conversationId,
+      replyToMessageId,
+      notifiedActorIds: [],
+      routingError: "unknown_reply_target"
+    };
+  }
+  if (replyTarget.conversationId !== conversationId) {
+    return {
+      usedBroker: true,
+      conversationId,
+      replyToMessageId,
+      notifiedActorIds: [],
+      routingError: "reply_target_conversation_mismatch"
+    };
+  }
+  const currentDirectory = input.currentDirectory ?? process.cwd();
+  const source = input.source?.trim() || "scout-mcp";
+  const senderId = await resolveConversationActorId(broker.baseUrl, broker.snapshot, broker.node.id, input.senderId, currentDirectory);
+  const createdAtMs = input.createdAtMs ?? Date.now();
+  const messageId = `m-${createdAtMs.toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+  const notifiedActorIds = replyTarget.actorId !== senderId ? [replyTarget.actorId] : [];
+  const speechText = input.shouldSpeak ? input.body.trim() : "";
+  const returnAddress = buildScoutReturnAddress2(broker.snapshot, senderId, {
+    conversationId,
+    replyToMessageId: messageId
+  });
+  await brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.messages, {
+    id: messageId,
+    conversationId,
+    replyToMessageId,
+    actorId: senderId,
+    originNodeId: broker.node.id,
+    class: conversation.kind === "system" ? "system" : "agent",
+    body: input.body,
+    speech: speechText ? { text: speechText } : undefined,
+    audience: notifiedActorIds.length > 0 ? { notify: notifiedActorIds, reason: "thread_reply" } : undefined,
+    visibility: conversation.visibility,
+    policy: "durable",
+    createdAt: createdAtMs,
+    metadata: {
+      source,
+      relayChannel: relayChannelMetadata(conversation),
+      relayMessageId: messageId,
+      returnAddress
+    }
+  });
+  return {
+    usedBroker: true,
+    conversationId,
+    messageId,
+    replyToMessageId,
+    notifiedActorIds
+  };
+}
 async function sendScoutMessageToAgentIds(input) {
   const broker = await loadScoutBrokerContext();
   if (!broker) {
@@ -14665,6 +14790,18 @@ async function openScoutPeerSession(input) {
     targetId
   };
 }
+async function attachScoutManagedLocalSession(input) {
+  const broker = await requireScoutBrokerContext();
+  return brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.localSessionsAttach, {
+    externalSessionId: input.externalSessionId,
+    transport: input.transport,
+    cwd: input.currentDirectory,
+    ...input.projectRoot ? { projectRoot: input.projectRoot } : {},
+    ...input.agentId ? { agentId: input.agentId } : {},
+    ...input.alias ? { alias: input.alias } : {},
+    ...input.displayName ? { displayName: input.displayName } : {}
+  });
+}
 async function sendScoutDirectMessage(input) {
   const broker = await requireScoutBrokerContext();
   const source = input.source?.trim() || "scout-mobile";
@@ -14683,7 +14820,10 @@ async function sendScoutDirectMessage(input) {
     body: input.body.trim(),
     intent: "consult",
     replyToMessageId: input.replyToMessageId ?? undefined,
-    execution: input.executionHarness ? { harness: input.executionHarness } : undefined,
+    execution: {
+      ...input.executionHarness ? { harness: input.executionHarness } : {},
+      session: "new"
+    },
     ensureAwake: true,
     messageMetadata: {
       source,
@@ -14738,7 +14878,10 @@ async function askScoutAgentById(input) {
     intent: "consult",
     channel: input.channel,
     speechText: input.shouldSpeak ? input.body.trim() : undefined,
-    execution: input.executionHarness ? { harness: input.executionHarness } : undefined,
+    execution: {
+      ...input.executionHarness ? { harness: input.executionHarness } : {},
+      session: "new"
+    },
     ensureAwake: true,
     messageMetadata: {
       source
@@ -14781,6 +14924,9 @@ async function askScoutQuestion(input) {
   const senderId = await resolveConversationActorId(broker.baseUrl, broker.snapshot, broker.node.id, input.senderId, currentDirectory);
   const createdAt = input.createdAtMs ?? Date.now();
   const messageBody = input.body.trim();
+  const targetRef = input.targetRef?.trim() || (input.targetLabel.trim().startsWith("ref:") ? input.targetLabel.trim().slice("ref:".length) : "");
+  const target = targetRef ? { kind: "binding_ref", ref: targetRef } : { kind: "agent_label", label: input.targetLabel };
+  const renderedTarget = targetRef ? `ref:${targetRef}` : input.targetLabel;
   const delivery = await brokerPostDeliver(broker.baseUrl, {
     caller: {
       actorId: senderId,
@@ -14788,16 +14934,16 @@ async function askScoutQuestion(input) {
       currentDirectory,
       metadata: { source }
     },
-    target: {
-      kind: "agent_label",
-      label: input.targetLabel
-    },
-    targetLabel: input.targetLabel,
+    target,
+    targetLabel: renderedTarget,
     body: messageBody,
     intent: "consult",
     channel: input.channel,
     speechText: input.shouldSpeak ? stripScoutAgentSelectorLabels(messageBody) : undefined,
-    execution: input.executionHarness ? { harness: input.executionHarness } : undefined,
+    execution: {
+      ...input.executionHarness ? { harness: input.executionHarness } : {},
+      session: targetRef ? "existing" : "new"
+    },
     ensureAwake: true,
     messageMetadata: {
       source
@@ -14809,7 +14955,7 @@ async function askScoutQuestion(input) {
   if (delivery.kind !== "delivery") {
     return {
       usedBroker: true,
-      unresolvedTarget: input.targetLabel,
+      unresolvedTarget: renderedTarget,
       targetDiagnostic: scoutTargetDiagnosticFromDeliveryFailure(delivery)
     };
   }
@@ -14827,6 +14973,7 @@ async function askScoutQuestion(input) {
     flight: delivery.flight,
     conversationId: delivery.conversation.id,
     messageId: delivery.message.id,
+    bindingRef: delivery.receipt?.bindingRef ?? delivery.bindingRef,
     workItem
   };
 }
@@ -15204,7 +15351,7 @@ __export(exports_ask, {
 });
 function renderAskCommandHelp() {
   return [
-    "Usage: scout ask --to <agent> [--as <sender>] [--channel <name>] [--timeout <seconds>] [--harness <runtime>] [--prompt-file <path> | <message>]",
+    "Usage: scout ask (--to <agent> | --ref <ref>) [--as <sender>] [--channel <name>] [--timeout <seconds>] [--harness <runtime>] [--prompt-file <path> | <message>]",
     "",
     "Ask one agent to do work or return a concrete answer.",
     "",
@@ -15223,6 +15370,7 @@ function renderAskCommandHelp() {
     "",
     "Examples:",
     '  scout ask --to hudson "review the parser"',
+    '  scout ask --ref 7f3a9c21 "continue from that result"',
     "  scout ask --to hudson --prompt-file ./handoff.md",
     '  scout ask --as premotion.master.mini --to hudson "build the editor"',
     '  scout ask --to vox.harness:codex "take another pass on the runtime fix"',
@@ -15300,6 +15448,7 @@ async function runAskWithOptions(context, options) {
   const result = await askScoutQuestion({
     senderId,
     targetLabel: options.targetLabel,
+    targetRef: options.targetRef,
     body,
     channel: options.channel,
     executionHarness: parseScoutHarness(options.harness),
@@ -15320,6 +15469,7 @@ async function runAskWithOptions(context, options) {
     senderId,
     conversationId: result.conversationId ?? null,
     messageId: result.messageId ?? null,
+    bindingRef: result.bindingRef ? `ref:${result.bindingRef}` : null,
     flight: completed,
     output: completed.output ?? completed.summary ?? ""
   }, (value) => value.output);
@@ -15389,6 +15539,9 @@ function renderScoutMessagePostResult(result) {
     const route = result.conversationId.startsWith("dm.") ? "DM" : "Conversation";
     lines.push(`${route}: ${result.conversationId}`);
   }
+  if (result.bindingRef) {
+    lines.push(`Ref: ref:${result.bindingRef}`);
+  }
   if (result.invokedTargets.length > 0) {
     lines.push(`Routed to: ${result.invokedTargets.join(", ")}`);
   }
@@ -15480,7 +15633,7 @@ __export(exports_send, {
 });
 function renderSendCommandHelp() {
   return [
-    "Usage: scout send [--as <sender>] [--to <agent>] [--channel <name>] [--speak] [--harness <runtime>] [--message-file <path> | <message>]",
+    "Usage: scout send [--as <sender>] [--to <agent> | --ref <ref>] [--channel <name>] [--speak] [--harness <runtime>] [--message-file <path> | <message>]",
     "",
     "Tell or update another agent or an explicit channel.",
     "",
@@ -15501,6 +15654,7 @@ function renderSendCommandHelp() {
     "",
     "Examples:",
     '  scout send --to hudson "ready for review; literal @codex stays text"',
+    '  scout send --ref 7f3a9c21 "follow-up for that bound session"',
     '  scout send --to lattices#codex?5.5 "ready for review"',
     "  scout send --channel triage --message-file ./status.md",
     '  scout send --as premotion.master.mini --to hudson "editor branch is green"',
@@ -15565,6 +15719,7 @@ async function runSendCommand(context, args) {
     senderId,
     body,
     targetLabel: options.targetLabel,
+    targetRef: options.targetRef,
     channel: options.channel,
     shouldSpeak: options.shouldSpeak,
     executionHarness: parseScoutHarness(options.harness),
@@ -15583,6 +15738,7 @@ async function runSendCommand(context, args) {
     senderId,
     conversationId: result.conversationId,
     message: body,
+    bindingRef: result.bindingRef,
     invokedTargets: result.invokedTargets,
     unresolvedTargets: result.unresolvedTargets,
     routeKind: result.routeKind
@@ -44505,30 +44661,40 @@ function resolveJavaScriptRuntimeExecutable() {
   }
   throw new Error("No JavaScript runtime found for openscout-runtime script entry. Install Node.js or set OPENSCOUT_RUNTIME_NODE_BIN.");
 }
-function resolveRuntimeServiceEntrypoint() {
-  const installedExecutable = resolveExecutableFromSearch({
-    env: process.env,
+function resolveRuntimeServiceEntrypoint(options = {}) {
+  const env = options.env ?? process.env;
+  const moduleUrl = options.moduleUrl ?? import.meta.url;
+  const currentWorkingDirectory = options.currentWorkingDirectory ?? process.cwd();
+  const explicitRuntimeEntrypoint = resolveExecutableFromSearch({
+    env,
     envKeys: ["OPENSCOUT_RUNTIME_BIN"],
-    names: ["openscout-runtime"]
+    names: []
   });
-  if (installedExecutable) {
-    return installedExecutable.path;
+  if (explicitRuntimeEntrypoint) {
+    return explicitRuntimeEntrypoint.path;
   }
-  const fromNodeModules = resolveNodeModulesPackageEntrypoint(import.meta.url, ["@openscout", "runtime"], "bin/openscout-runtime.mjs");
+  const fromNodeModules = resolveNodeModulesPackageEntrypoint(moduleUrl, ["@openscout", "runtime"], "bin/openscout-runtime.mjs");
   if (fromNodeModules) {
     return fromNodeModules;
   }
   const repoRoot = resolveOpenScoutRepoRoot({
     startDirectories: [
-      process.env.OPENSCOUT_SETUP_CWD,
-      process.cwd(),
-      dirname9(fileURLToPath7(import.meta.url))
+      env.OPENSCOUT_SETUP_CWD,
+      currentWorkingDirectory,
+      dirname9(fileURLToPath7(moduleUrl))
     ]
   });
   const repoEntrypoint = resolveRepoEntrypoint(repoRoot, "packages/runtime/bin/openscout-runtime.mjs");
   if (repoEntrypoint) {
     return repoEntrypoint;
   }
+  const installedExecutable = resolveExecutableFromSearch({
+    env,
+    names: ["openscout-runtime"]
+  });
+  if (installedExecutable) {
+    return installedExecutable.path;
+  }
   throw new Error("openscout-runtime not found on PATH. Install @openscout/runtime (e.g. npm i -g @openscout/runtime) or set OPENSCOUT_RUNTIME_BIN.");
 }
 function spawnArgsForRuntime(entry, serviceArgs) {
@@ -44551,9 +44717,11 @@ async function runRuntimeBrokerService(subcommand) {
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
+    child.stdout?.setEncoding("utf8");
     child.stdout?.on("data", (chunk) => {
       stdoutChunks.push(chunk);
     });
+    child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
       stderrChunks.push(chunk);
     });
@@ -44562,8 +44730,8 @@ async function runRuntimeBrokerService(subcommand) {
       resolveExit(exitCode ?? 1);
     });
   });
-  const stdout = Buffer.concat(stdoutChunks).toString("utf8").trim();
-  const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+  const stdout = stdoutChunks.join("").trim();
+  const stderr = stderrChunks.join("").trim();
   if (code !== 0) {
     const detail = stderr || stdout || `exit ${code}`;
     throw new Error(`openscout-runtime service ${subcommand} failed: ${detail}`);
@@ -45238,7 +45406,7 @@ import {
   renameSync,
   writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir10 } from "os";
+import { homedir as homedir10, hostname as osHostname } from "os";
 import { dirname as dirname12, join as join18 } from "path";
 function localConfigHome() {
   return process.env.OPENSCOUT_HOME ?? join18(homedir10(), ".openscout");
@@ -46268,6 +46436,7 @@ var init_mcp = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/mcp/scout-mcp.ts
+import { readFileSync as readFileSync8 } from "fs";
 import { basename as basename7, resolve as resolve12 } from "path";
 function createAgentPickerFieldMeta(input) {
   return {
@@ -46303,6 +46472,54 @@ function createToolUiMeta(fields) {
     [SCOUT_MCP_UI_META_KEY]: value
   };
 }
+function parseScoutReplyContextFromEnv(env) {
+  const contextFile = env.OPENSCOUT_REPLY_CONTEXT_FILE?.trim();
+  if (contextFile) {
+    try {
+      const rawFileJson = readFileSync8(contextFile, "utf8").trim();
+      if (rawFileJson) {
+        const parsed = JSON.parse(rawFileJson);
+        if (isScoutReplyContext(parsed)) {
+          return parsed;
+        }
+      }
+    } catch {}
+  }
+  const rawJson = env.OPENSCOUT_REPLY_CONTEXT?.trim();
+  if (rawJson) {
+    try {
+      const parsed = JSON.parse(rawJson);
+      if (isScoutReplyContext(parsed)) {
+        return parsed;
+      }
+    } catch {
+      return null;
+    }
+  }
+  const mode = env.OPENSCOUT_REPLY_MODE?.trim();
+  const fromAgentId = env.OPENSCOUT_REPLY_FROM_AGENT_ID?.trim();
+  const toAgentId = env.OPENSCOUT_REPLY_TO_AGENT_ID?.trim();
+  const conversationId = env.OPENSCOUT_REPLY_CONVERSATION_ID?.trim();
+  const messageId = env.OPENSCOUT_REPLY_MESSAGE_ID?.trim();
+  const replyToMessageId = env.OPENSCOUT_REPLY_TO_MESSAGE_ID?.trim() || messageId;
+  const replyPath = env.OPENSCOUT_REPLY_PATH?.trim() || "mcp_reply";
+  if (mode === "broker_reply" && fromAgentId && toAgentId && conversationId && messageId && replyToMessageId && (replyPath === "final_response" || replyPath === "mcp_reply")) {
+    return {
+      mode: "broker_reply",
+      fromAgentId,
+      toAgentId,
+      conversationId,
+      messageId,
+      replyToMessageId,
+      replyPath,
+      ...env.OPENSCOUT_REPLY_ACTION?.trim() ? { action: env.OPENSCOUT_REPLY_ACTION.trim() } : {}
+    };
+  }
+  return null;
+}
+function isScoutReplyContext(value) {
+  return value.mode === "broker_reply" && typeof value.fromAgentId === "string" && value.fromAgentId.length > 0 && typeof value.toAgentId === "string" && value.toAgentId.length > 0 && typeof value.conversationId === "string" && value.conversationId.length > 0 && typeof value.messageId === "string" && value.messageId.length > 0 && typeof value.replyToMessageId === "string" && value.replyToMessageId.length > 0 && (value.replyPath === "final_response" || value.replyPath === "mcp_reply");
+}
 function createTextContent(value) {
   return [{ type: "text", text: JSON.stringify(value, null, 2) }];
 }
@@ -46355,6 +46572,13 @@ function resolveAskReplyMode(input) {
 function workUrlFor(workItem) {
   return workItem ? `/api/work/${encodeURIComponent(workItem.id)}` : null;
 }
+function resolveCurrentCodexThreadId(env) {
+  const threadId = env.CODEX_THREAD_ID?.trim();
+  if (!threadId) {
+    throw new Error("The current host session is not an attachable Codex session. Expected CODEX_THREAD_ID in the environment.");
+  }
+  return threadId;
+}
 function sendScoutReplyNotification(server, params) {
   return server.server.notification({
     method: "notifications/scout/reply",
@@ -46815,6 +47039,23 @@ function defaultScoutMcpDependencies(env) {
       currentDirectory,
       createdById
     }),
+    attachCurrentLocalSession: ({
+      externalSessionId,
+      transport,
+      currentDirectory,
+      projectRoot,
+      agentId,
+      alias,
+      displayName
+    }) => attachScoutManagedLocalSession({
+      externalSessionId,
+      transport,
+      currentDirectory,
+      projectRoot,
+      agentId,
+      alias,
+      displayName
+    }),
     sendMessage: ({
       senderId,
       body,
@@ -46849,6 +47090,23 @@ function defaultScoutMcpDependencies(env) {
       currentDirectory,
       source
     }),
+    replyMessage: ({
+      senderId,
+      body,
+      conversationId,
+      replyToMessageId,
+      shouldSpeak,
+      currentDirectory,
+      source
+    }) => replyToScoutMessage({
+      senderId,
+      body,
+      conversationId,
+      replyToMessageId,
+      shouldSpeak,
+      currentDirectory,
+      source
+    }),
     askQuestion: ({
       senderId,
       targetLabel,
@@ -46932,6 +47190,142 @@ function createScoutMcpServer(options) {
       structuredContent
     };
   });
+  server.registerTool("current_reply_context", {
+    title: "Current Scout Reply Context",
+    description: "Inspect whether this MCP host has an active Scout broker reply context. Use this to distinguish replying to an inbound Scout ask from sending a new message.",
+    inputSchema: object2({}),
+    outputSchema: currentReplyContextResultSchema,
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      destructiveHint: false,
+      openWorldHint: false
+    }
+  }, async () => {
+    const context = parseScoutReplyContextFromEnv(env);
+    const structuredContent = {
+      active: Boolean(context),
+      context
+    };
+    return {
+      content: createTextContent(structuredContent),
+      structuredContent
+    };
+  });
+  server.registerTool("messages_reply", {
+    title: "Reply to Scout Message",
+    description: "Reply to the active inbound Scout broker ask. If conversationId and replyToMessageId are omitted, this uses the active ScoutReplyContext. If there is no active context, use messages_send for a new message or pass both ids explicitly.",
+    inputSchema: object2({
+      body: string2().min(1),
+      currentDirectory: string2().optional(),
+      senderId: string2().optional(),
+      conversationId: string2().optional(),
+      replyToMessageId: string2().optional(),
+      shouldSpeak: boolean2().optional()
+    }),
+    outputSchema: replyResultSchema,
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    }
+  }, async ({
+    body,
+    currentDirectory,
+    senderId,
+    conversationId,
+    replyToMessageId,
+    shouldSpeak
+  }) => {
+    const resolvedCurrentDirectory = resolveToolCurrentDirectory(currentDirectory, options.defaultCurrentDirectory);
+    const context = parseScoutReplyContextFromEnv(env);
+    const resolvedConversationId = conversationId?.trim() || context?.conversationId || "";
+    const resolvedReplyToMessageId = replyToMessageId?.trim() || context?.replyToMessageId || "";
+    const resolvedSenderId = await deps.resolveSenderId(senderId ?? context?.toAgentId, resolvedCurrentDirectory, env);
+    if (!resolvedConversationId || !resolvedReplyToMessageId) {
+      const structuredContent2 = {
+        currentDirectory: resolvedCurrentDirectory,
+        senderId: resolvedSenderId,
+        usedBroker: true,
+        conversationId: resolvedConversationId || null,
+        messageId: null,
+        replyToMessageId: resolvedReplyToMessageId || null,
+        notifiedActorIds: [],
+        routingError: "missing_reply_context"
+      };
+      return {
+        content: createPlainTextContent("No active Scout broker reply context. Use messages_send for a new message, or pass conversationId and replyToMessageId explicitly."),
+        structuredContent: structuredContent2
+      };
+    }
+    const result = await deps.replyMessage({
+      senderId: resolvedSenderId,
+      body,
+      conversationId: resolvedConversationId,
+      replyToMessageId: resolvedReplyToMessageId,
+      shouldSpeak,
+      currentDirectory: resolvedCurrentDirectory,
+      source: "scout-mcp"
+    });
+    const structuredContent = {
+      currentDirectory: resolvedCurrentDirectory,
+      senderId: resolvedSenderId,
+      usedBroker: result.usedBroker,
+      conversationId: result.conversationId ?? resolvedConversationId,
+      messageId: result.messageId ?? null,
+      replyToMessageId: result.replyToMessageId ?? resolvedReplyToMessageId,
+      notifiedActorIds: result.notifiedActorIds,
+      routingError: result.routingError ?? null
+    };
+    return {
+      content: createPlainTextContent(result.routingError ? `Reply was not sent: ${result.routingError}.` : `Reply sent in ${structuredContent.conversationId}${structuredContent.messageId ? ` (${structuredContent.messageId})` : ""}.`),
+      structuredContent
+    };
+  });
+  server.registerTool("session_attach_current", {
+    title: "Attach Current Codex Session",
+    description: "Attach the current live Codex session to Scout so other agents can route direct messages and asks back to it. This requires a Codex host that exposes CODEX_THREAD_ID; Claude and other hosts do not support this attach path yet.",
+    inputSchema: object2({
+      currentDirectory: string2().optional(),
+      projectPath: string2().optional(),
+      agentId: string2().optional(),
+      alias: string2().optional(),
+      displayName: string2().optional()
+    }),
+    outputSchema: currentSessionAttachResultSchema,
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    }
+  }, async ({ currentDirectory, projectPath, agentId, alias, displayName }) => {
+    const resolvedCurrentDirectory = resolveToolCurrentDirectory(currentDirectory, options.defaultCurrentDirectory);
+    const externalSessionId = resolveCurrentCodexThreadId(env);
+    const attached = await deps.attachCurrentLocalSession({
+      externalSessionId,
+      transport: "codex_app_server",
+      currentDirectory: resolvedCurrentDirectory,
+      projectRoot: projectPath?.trim() ? resolve12(projectPath.trim()) : undefined,
+      agentId: agentId?.trim() || undefined,
+      alias: alias?.trim() || undefined,
+      displayName: displayName?.trim() || undefined
+    });
+    const structuredContent = {
+      currentDirectory: resolvedCurrentDirectory,
+      externalSessionId,
+      transport: "codex_app_server",
+      agentId: attached.agentId,
+      selector: attached.selector ?? null,
+      endpointId: attached.endpointId,
+      sessionId: attached.sessionId
+    };
+    return {
+      content: createPlainTextContent(attached.selector ? `Current Codex session attached as ${attached.selector}.` : `Current Codex session attached as ${attached.agentId}.`),
+      structuredContent
+    };
+  });
   server.registerTool("card_create", {
     title: "Create Scout Agent Card",
     description: "Create a dedicated Scout agent card with a reply-ready return address. Use this when another agent should get back to you on a fresh project-scoped inbox or worktree-scoped alias. One target stays private by default; group coordination still requires an explicit channel elsewhere.",
@@ -47136,6 +47530,7 @@ function createScoutMcpServer(options) {
         usedBroker: result2.usedBroker,
         conversationId: result2.conversationId ?? null,
         messageId: result2.messageId ?? null,
+        bindingRef: result2.bindingRef ? `ref:${result2.bindingRef}` : null,
         invokedTargetIds: result2.invokedTargets,
         unresolvedTargetIds: result2.unresolvedTargets,
         targetDiagnostic: result2.targetDiagnostic ?? null,
@@ -47162,6 +47557,7 @@ function createScoutMcpServer(options) {
       usedBroker: result.usedBroker,
       conversationId: result.conversationId ?? null,
       messageId: result.messageId ?? null,
+      bindingRef: result.bindingRef ? `ref:${result.bindingRef}` : null,
       invokedTargetIds: result.invokedTargets,
       unresolvedTargetIds: result.unresolvedTargets,
       targetDiagnostic: result.targetDiagnostic ?? null,
@@ -47319,6 +47715,7 @@ function createScoutMcpServer(options) {
           targetLabel: targetLabel.trim(),
           conversationId: result.conversationId ?? null,
           messageId: result.messageId ?? null,
+          bindingRef: result.bindingRef ? `ref:${result.bindingRef}` : null,
           flightId: result.flight.id,
           workItem: trackedWorkItem,
           workId: trackedWorkItem?.id ?? null,
@@ -47341,6 +47738,7 @@ function createScoutMcpServer(options) {
       } : null,
       conversationId: result.conversationId ?? null,
       messageId: result.messageId ?? null,
+      bindingRef: result.bindingRef ? `ref:${result.bindingRef}` : null,
       flight: completedFlight ?? result.flight ?? null,
       flightId: completedFlight?.id ?? result.flight?.id ?? null,
       output: completedFlight?.output ?? completedFlight?.summary ?? null,
@@ -47402,7 +47800,7 @@ async function runScoutMcpServer(options) {
   const transport = new StdioServerTransport;
   await server.connect(transport);
 }
-var AGENT_STATE_VALUES, REGISTRATION_KIND_VALUES, RESOLVE_KIND_VALUES, MESSAGE_ROUTE_KIND_VALUES, MESSAGE_ROUTING_ERROR_VALUES, REPLY_MODE_VALUES, REPLY_DELIVERY_VALUES, LOCAL_AGENT_HARNESS_VALUES, SCOUT_MCP_UI_META_KEY = "openscout/ui", scoutAgentToolIconMeta, scoutAgentAvatarMeta, targetLabelInputSchema, targetAgentIdInputSchema, mentionAgentIdsInputSchema, flightSchema, trackedWorkItemSchema, workItemInputSchema, waitingOnSchema, progressSchema, workItemUpdateSchema, agentCandidateSchema, scoutReturnAddressSchema, scoutAgentCardSchema, whoAmISchema, searchResultSchema, resolveResultSchema, sendResultSchema, cardCreateResultSchema, askResultSchema, workUpdateResultSchema;
+var AGENT_STATE_VALUES, REGISTRATION_KIND_VALUES, RESOLVE_KIND_VALUES, MESSAGE_ROUTE_KIND_VALUES, MESSAGE_ROUTING_ERROR_VALUES, REPLY_MODE_VALUES, REPLY_DELIVERY_VALUES, LOCAL_AGENT_HARNESS_VALUES, SCOUT_MCP_UI_META_KEY = "openscout/ui", scoutAgentToolIconMeta, scoutAgentAvatarMeta, targetLabelInputSchema, targetAgentIdInputSchema, mentionAgentIdsInputSchema, flightSchema, trackedWorkItemSchema, workItemInputSchema, waitingOnSchema, progressSchema, workItemUpdateSchema, agentCandidateSchema, scoutReturnAddressSchema, scoutAgentCardSchema, whoAmISchema, searchResultSchema, resolveResultSchema, sendResultSchema, replyContextSchema, currentReplyContextResultSchema, replyResultSchema, cardCreateResultSchema, currentSessionAttachResultSchema, askResultSchema, workUpdateResultSchema;
 var init_scout_mcp = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -47599,11 +47997,49 @@ var init_scout_mcp = __esm(() => {
     routeKind: _enum2(MESSAGE_ROUTE_KIND_VALUES).nullable(),
     routingError: _enum2(MESSAGE_ROUTING_ERROR_VALUES).nullable()
   });
+  replyContextSchema = object2({
+    mode: literal("broker_reply"),
+    fromAgentId: string2(),
+    toAgentId: string2(),
+    conversationId: string2(),
+    messageId: string2(),
+    replyToMessageId: string2(),
+    replyPath: _enum2(["final_response", "mcp_reply"]),
+    action: string2().optional()
+  });
+  currentReplyContextResultSchema = object2({
+    active: boolean2(),
+    context: replyContextSchema.nullable()
+  });
+  replyResultSchema = object2({
+    currentDirectory: string2(),
+    senderId: string2(),
+    usedBroker: boolean2(),
+    conversationId: string2().nullable(),
+    messageId: string2().nullable(),
+    replyToMessageId: string2().nullable(),
+    notifiedActorIds: array(string2()),
+    routingError: _enum2([
+      "missing_reply_context",
+      "unknown_conversation",
+      "unknown_reply_target",
+      "reply_target_conversation_mismatch"
+    ]).nullable()
+  });
   cardCreateResultSchema = object2({
     currentDirectory: string2(),
     senderId: string2(),
     card: scoutAgentCardSchema
   });
+  currentSessionAttachResultSchema = object2({
+    currentDirectory: string2(),
+    externalSessionId: string2(),
+    transport: literal("codex_app_server"),
+    agentId: string2(),
+    selector: string2().nullable(),
+    endpointId: string2(),
+    sessionId: string2()
+  });
   askResultSchema = object2({
     currentDirectory: string2(),
     senderId: string2(),
@@ -47639,6 +48075,325 @@ var init_scout_mcp = __esm(() => {
   });
 });
 
+// ../../apps/desktop/src/cli/commands/mcp-install.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { accessSync as accessSync3, constants as constants5, existsSync as existsSync14 } from "fs";
+import { homedir as homedir11 } from "os";
+import { delimiter as delimiter4, join as join19, resolve as resolve13 } from "path";
+function isExecutable4(filePath) {
+  if (!filePath) {
+    return false;
+  }
+  try {
+    accessSync3(filePath, constants5.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveExecutableFromSearchPath2(names, env) {
+  const pathEntries = (env.PATH ?? "").split(delimiter4).filter(Boolean);
+  const commonDirectories = [
+    join19(homedir11(), ".local", "bin"),
+    join19(homedir11(), ".bun", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/Applications/Codex.app/Contents/Resources"
+  ];
+  for (const directory of [...pathEntries, ...commonDirectories]) {
+    for (const name of names) {
+      const candidate = join19(directory, name);
+      if (isExecutable4(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function resolveHostExecutable(host, env) {
+  if (host === "codex") {
+    return resolveExecutableFromSearchPath2(["codex"], env);
+  }
+  return resolveExecutableFromSearchPath2(["claude"], env);
+}
+function resolveCurrentScoutMcpLaunchCommand(env) {
+  const currentScript = process.argv[1];
+  if (currentScript && existsSync14(currentScript) && isExecutable4(process.execPath)) {
+    return {
+      command: process.execPath,
+      args: [resolve13(currentScript), "mcp"]
+    };
+  }
+  const explicitCandidates = [
+    env.OPENSCOUT_CLI_BIN,
+    env.SCOUT_CLI_BIN,
+    env.OPENSCOUT_SCOUT_BIN,
+    env.SCOUT_BIN
+  ];
+  for (const candidate of explicitCandidates) {
+    if (isExecutable4(candidate)) {
+      return {
+        command: candidate,
+        args: ["mcp"]
+      };
+    }
+  }
+  const scoutExecutable = resolveExecutableFromSearchPath2(["scout"], env);
+  if (scoutExecutable) {
+    return {
+      command: scoutExecutable,
+      args: ["mcp"]
+    };
+  }
+  throw new ScoutCliError("Could not resolve a Scout CLI command to register with MCP hosts.");
+}
+function parseFlagValue2(args, index, flag) {
+  const current = args[index] ?? "";
+  if (current === flag) {
+    const value = args[index + 1];
+    if (!value) {
+      throw new ScoutCliError(`missing value for ${flag}`);
+    }
+    return { value, nextIndex: index + 1 };
+  }
+  const prefix = `${flag}=`;
+  if (current.startsWith(prefix)) {
+    return { value: current.slice(prefix.length), nextIndex: index };
+  }
+  throw new ScoutCliError(`missing value for ${flag}`);
+}
+function parseHostValue(value) {
+  if (value === "codex" || value === "claude") {
+    return value;
+  }
+  throw new ScoutCliError(`unsupported MCP host "${value}" (expected codex or claude)`);
+}
+function renderMcpInstallHelp() {
+  return [
+    "Usage: scout mcp install [--host <codex|claude>] [--force] [--dry-run]",
+    "",
+    "Register the current Scout MCP server command with supported local hosts.",
+    "",
+    "Defaults to every detected host. Codex is installed through its global",
+    "config, and Claude Code is installed at user scope.",
+    "",
+    "Examples:",
+    "  scout mcp install",
+    "  scout mcp install --host codex --force",
+    "  scout mcp install --host claude --dry-run"
+  ].join(`
+`);
+}
+function parseMcpInstallCommandOptions(args, env) {
+  const hosts = [];
+  let force = false;
+  let dryRun = false;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index] ?? "";
+    if (!current) {
+      continue;
+    }
+    if (HELP_FLAGS5.has(current)) {
+      continue;
+    }
+    if (current === "--force") {
+      force = true;
+      continue;
+    }
+    if (current === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (current === "--host" || current.startsWith("--host=")) {
+      const parsed = parseFlagValue2(args, index, "--host");
+      hosts.push(parseHostValue(parsed.value));
+      index = parsed.nextIndex;
+      continue;
+    }
+    throw new ScoutCliError(`unexpected argument for mcp install: ${current}`);
+  }
+  const resolvedHosts = hosts.length > 0 ? [...new Set(hosts)] : ["codex", "claude"].filter((host) => resolveHostExecutable(host, env) !== null);
+  return {
+    dryRun,
+    force,
+    hosts: [...resolvedHosts]
+  };
+}
+function defaultCommandRunner(context) {
+  return (command, args) => {
+    const result = spawnSync2(command, args, {
+      cwd: context.cwd,
+      env: context.env,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    return {
+      status: result.status,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      error: result.error
+    };
+  };
+}
+function commandFailed(result) {
+  return Boolean(result.error) || result.status !== 0;
+}
+function installForCodex(input) {
+  const existing = input.run(input.executablePath, ["mcp", "get", "scout"]);
+  if (!commandFailed(existing) && !input.force) {
+    return {
+      host: "codex",
+      status: "already_installed",
+      detail: "Codex already has a scout MCP entry."
+    };
+  }
+  if (input.dryRun) {
+    return {
+      host: "codex",
+      status: "installed",
+      detail: `Would run: ${input.executablePath} mcp add scout -- ${input.launch.command} ${input.launch.args.join(" ")}`
+    };
+  }
+  if (!commandFailed(existing) && input.force) {
+    const removed = input.run(input.executablePath, ["mcp", "remove", "scout"]);
+    if (commandFailed(removed)) {
+      return {
+        host: "codex",
+        status: "failed",
+        detail: removed.stderr.trim() || removed.stdout.trim() || "Failed to replace existing Codex MCP config."
+      };
+    }
+  }
+  const added = input.run(input.executablePath, [
+    "mcp",
+    "add",
+    "scout",
+    "--",
+    input.launch.command,
+    ...input.launch.args
+  ]);
+  if (commandFailed(added)) {
+    return {
+      host: "codex",
+      status: "failed",
+      detail: added.stderr.trim() || added.stdout.trim() || "Failed to install scout MCP into Codex."
+    };
+  }
+  return {
+    host: "codex",
+    status: "installed",
+    detail: "Installed scout MCP for Codex."
+  };
+}
+function installForClaude(input) {
+  const existing = input.run(input.executablePath, ["mcp", "get", "scout"]);
+  if (!commandFailed(existing) && !input.force) {
+    return {
+      host: "claude",
+      status: "already_installed",
+      detail: "Claude Code already has a scout MCP entry."
+    };
+  }
+  if (input.dryRun) {
+    return {
+      host: "claude",
+      status: "installed",
+      detail: `Would run: ${input.executablePath} mcp add --scope user scout -- ${input.launch.command} ${input.launch.args.join(" ")}`
+    };
+  }
+  if (!commandFailed(existing) && input.force) {
+    const removed = input.run(input.executablePath, ["mcp", "remove", "--scope", "user", "scout"]);
+    if (commandFailed(removed)) {
+      return {
+        host: "claude",
+        status: "failed",
+        detail: removed.stderr.trim() || removed.stdout.trim() || "Failed to replace existing Claude Code MCP config."
+      };
+    }
+  }
+  const added = input.run(input.executablePath, [
+    "mcp",
+    "add",
+    "--scope",
+    "user",
+    "scout",
+    "--",
+    input.launch.command,
+    ...input.launch.args
+  ]);
+  if (commandFailed(added)) {
+    return {
+      host: "claude",
+      status: "failed",
+      detail: added.stderr.trim() || added.stdout.trim() || "Failed to install scout MCP into Claude Code."
+    };
+  }
+  return {
+    host: "claude",
+    status: "installed",
+    detail: "Installed scout MCP for Claude Code."
+  };
+}
+function installScoutMcpForHosts(input) {
+  const launch = (input.resolveLaunchCommand ?? resolveCurrentScoutMcpLaunchCommand)(input.env);
+  const run = input.run ?? (input.context ? defaultCommandRunner(input.context) : undefined);
+  const resolveHostPath = input.resolveHostPath ?? resolveHostExecutable;
+  if (!run) {
+    throw new ScoutCliError("A command runner or command context is required.");
+  }
+  return input.hosts.map((host) => {
+    const executablePath = resolveHostPath(host, input.env);
+    if (!executablePath) {
+      return {
+        host,
+        status: "skipped",
+        detail: `Skipped ${host}: executable not found.`
+      };
+    }
+    if (host === "codex") {
+      return installForCodex({
+        executablePath,
+        launch,
+        force: input.force,
+        dryRun: input.dryRun,
+        run
+      });
+    }
+    return installForClaude({
+      executablePath,
+      launch,
+      force: input.force,
+      dryRun: input.dryRun,
+      run
+    });
+  });
+}
+async function runMcpInstallCommand(context, args) {
+  if (args.some((arg) => HELP_FLAGS5.has(arg))) {
+    context.output.writeText(renderMcpInstallHelp());
+    return;
+  }
+  const options = parseMcpInstallCommandOptions(args, context.env);
+  if (options.hosts.length === 0) {
+    context.output.writeText("No supported hosts detected. Looked for codex and claude.");
+    return;
+  }
+  const outcomes = installScoutMcpForHosts({
+    env: context.env,
+    hosts: options.hosts,
+    force: options.force,
+    dryRun: options.dryRun,
+    context
+  });
+  context.output.writeText(outcomes.map((outcome) => `[${outcome.host}] ${outcome.detail}`).join(`
+`));
+}
+var HELP_FLAGS5;
+var init_mcp_install = __esm(() => {
+  init_errors();
+  HELP_FLAGS5 = new Set(["--help", "-h"]);
+});
+
 // ../../apps/desktop/src/cli/commands/mcp.ts
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -47647,31 +48402,42 @@ __export(exports_mcp, {
 });
 function renderMcpCommandHelp() {
   return [
-    "Usage: scout mcp [--context-root <path>]",
+    "Usage:",
+    "  scout mcp [--context-root <path>]",
+    "  scout mcp install [--host <codex|claude>] [--force] [--dry-run]",
     "",
-    "Run a Scout MCP server over stdio.",
+    "Run or install the Scout MCP server.",
     "",
-    "This command is intended to be launched by an MCP host. It exposes",
+    "The stdio server form is intended to be launched by an MCP host. It exposes",
     "the same canonical Scout coordination loop the CLI teaches:",
     "",
     "  whoami           inspect sender identity when the host is unclear",
+    "  session_attach_current",
+    "                   attach the current live Codex session to Scout",
+    "  card_create      fresh reply-ready return address",
     "  agents_search    find likely targets when routing is ambiguous",
     "  agents_resolve   pin one exact target when needed",
     "  messages_send    tell / update with explicit target fields or channel",
     "  invocations_ask  owned work / reply handoff with explicit target fields",
     "  work_update      progress / waiting / review / done for existing work",
-    "  card_create      fresh reply-ready return address",
     "",
     "Pass targets as tool fields. Message body text is payload, so quoted",
-    "handles such as @codex should not become routing instructions."
+    "handles such as @codex should not become routing instructions.",
+    "",
+    renderMcpInstallHelp()
   ].join(`
 `);
 }
 async function runMcpCommand(context, args) {
+  const subcommand = args[0]?.trim() || "";
   if (args.includes("--help") || args.includes("-h")) {
     context.output.writeText(renderMcpCommandHelp());
     return;
   }
+  if (subcommand === "install") {
+    await runMcpInstallCommand(context, args.slice(1));
+    return;
+  }
   const options = parseContextRootCommandOptions("mcp", args, defaultScoutContextDirectory(context));
   await runScoutMcpServer({
     defaultCurrentDirectory: options.currentDirectory,
@@ -47682,6 +48448,7 @@ var init_mcp2 = __esm(() => {
   init_context();
   init_options();
   init_scout_mcp();
+  init_mcp_install();
 });
 
 // ../../apps/desktop/src/cli/commands/menu.ts
@@ -47691,10 +48458,10 @@ __export(exports_menu, {
   renderMenuCommandHelp: () => renderMenuCommandHelp,
   parseMenuCommand: () => parseMenuCommand
 });
-import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync14 } from "fs";
-import { homedir as homedir11 } from "os";
-import { dirname as dirname13, join as join19, resolve as resolve13 } from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync15 } from "fs";
+import { homedir as homedir12 } from "os";
+import { dirname as dirname13, join as join20, resolve as resolve14 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 function renderMenuCommandHelp() {
   return [
@@ -47755,7 +48522,7 @@ function parseMenuCommand(args) {
   }
 }
 function runProcess(command, args, options) {
-  const result = spawnSync2(command, args, {
+  const result = spawnSync3(command, args, {
     cwd: options.cwd,
     env: options.env,
     encoding: "utf8"
@@ -47778,10 +48545,10 @@ function runProcess(command, args, options) {
   };
 }
 function findRepoMenuHelper(startDirectory) {
-  let current = resolve13(startDirectory);
+  let current = resolve14(startDirectory);
   while (true) {
-    const candidate = join19(current, "apps", "macos", "bin", "openscout-menu.ts");
-    if (existsSync14(candidate)) {
+    const candidate = join20(current, "apps", "macos", "bin", "openscout-menu.ts");
+    if (existsSync15(candidate)) {
       return candidate;
     }
     const parent = dirname13(current);
@@ -47790,11 +48557,11 @@ function findRepoMenuHelper(startDirectory) {
     }
     current = parent;
   }
-  const sourceRelativeCandidate = fileURLToPath9(new URL("../../../../macos/bin/openscout-menu.ts", import.meta.url));
-  return existsSync14(sourceRelativeCandidate) ? sourceRelativeCandidate : null;
+  const sourceRelativeCandidate = fileURLToPath9(new URL("../../../../macos/bin/openscout-menu.ts", import.meta.url).toString());
+  return existsSync15(sourceRelativeCandidate) ? sourceRelativeCandidate : null;
 }
 function resolveRepoBundlePath(helperPath) {
-  return resolve13(dirname13(helperPath), "..", "dist", MENU_BUNDLE_NAME);
+  return resolve14(dirname13(helperPath), "..", "dist", MENU_BUNDLE_NAME);
 }
 function isMenuRunning(env) {
   return runProcess("pgrep", ["-x", MENU_PROCESS_NAME], { env, allowFailure: true }).ok;
@@ -47810,7 +48577,7 @@ function resolveInstalledMenuBundlePath(env) {
     return indexedPath;
   }
   for (const candidate of COMMON_MENU_BUNDLE_PATHS) {
-    if (existsSync14(candidate)) {
+    if (existsSync15(candidate)) {
       return candidate;
     }
   }
@@ -47879,7 +48646,7 @@ function runWithRepoHelper(context, helperPath, command) {
   });
   const bundlePath = resolveRepoBundlePath(helperPath);
   const running = command.action === "quit" ? false : isMenuRunning(context.env);
-  const installed = existsSync14(bundlePath) || running;
+  const installed = existsSync15(bundlePath) || running;
   return {
     action: command.action,
     mode: "repo-helper",
@@ -47928,7 +48695,7 @@ function runWithInstalledApp(context, command) {
   };
 }
 async function runMenuCommand(context, args) {
-  if (HELP_FLAGS5.has(args[0] ?? "")) {
+  if (HELP_FLAGS6.has(args[0] ?? "")) {
     context.output.writeText(renderMenuCommandHelp());
     return;
   }
@@ -47940,14 +48707,14 @@ async function runMenuCommand(context, args) {
   const result = helperPath ? runWithRepoHelper(context, helperPath, command) : runWithInstalledApp(context, command);
   context.output.writeValue(result, renderMenuResult);
 }
-var MENU_BUNDLE_ID = "com.openscout.menu", MENU_BUNDLE_NAME = "OpenScoutMenu.app", MENU_PROCESS_NAME = "OpenScoutMenu", HELP_FLAGS5, COMMON_MENU_BUNDLE_PATHS;
+var MENU_BUNDLE_ID = "com.openscout.menu", MENU_BUNDLE_NAME = "OpenScoutMenu.app", MENU_PROCESS_NAME = "OpenScoutMenu", HELP_FLAGS6, COMMON_MENU_BUNDLE_PATHS;
 var init_menu = __esm(() => {
   init_context();
   init_errors();
-  HELP_FLAGS5 = new Set(["help", "--help", "-h"]);
+  HELP_FLAGS6 = new Set(["help", "--help", "-h"]);
   COMMON_MENU_BUNDLE_PATHS = [
-    join19("/Applications", MENU_BUNDLE_NAME),
-    join19(homedir11(), "Applications", MENU_BUNDLE_NAME)
+    join20("/Applications", MENU_BUNDLE_NAME),
+    join20(homedir12(), "Applications", MENU_BUNDLE_NAME)
   ];
 });
 
@@ -48467,11 +49234,11 @@ var init_mesh = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/config.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir12 } from "os";
+import { existsSync as existsSync16, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir13 } from "os";
 import path from "path";
 function pairingPaths() {
-  const rootDir = path.join(homedir12(), ".scout/pairing");
+  const rootDir = path.join(homedir13(), ".scout/pairing");
   return {
     rootDir,
     configPath: path.join(rootDir, "config.json"),
@@ -48484,11 +49251,11 @@ function pairingPaths() {
 }
 function loadPairingConfig() {
   const { configPath } = pairingPaths();
-  if (!existsSync15(configPath)) {
+  if (!existsSync16(configPath)) {
     return {};
   }
   try {
-    const payload = JSON.parse(readFileSync8(configPath, "utf8"));
+    const payload = JSON.parse(readFileSync9(configPath, "utf8"));
     return typeof payload === "object" && payload ? payload : {};
   } catch {
     return {};
@@ -50571,17 +51338,17 @@ var init_noise = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/security/identity.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join20 } from "path";
-import { homedir as homedir13 } from "os";
+import { existsSync as existsSync17, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { join as join21 } from "path";
+import { homedir as homedir14 } from "os";
 function loadOrCreateIdentity() {
-  if (existsSync16(IDENTITY_FILE)) {
+  if (existsSync17(IDENTITY_FILE)) {
     return loadIdentity();
   }
   return createAndSaveIdentity();
 }
 function loadIdentity() {
-  const data = JSON.parse(readFileSync9(IDENTITY_FILE, "utf8"));
+  const data = JSON.parse(readFileSync10(IDENTITY_FILE, "utf8"));
   return {
     publicKey: hexToBytes2(data.publicKey),
     privateKey: hexToBytes2(data.privateKey)
@@ -50599,9 +51366,9 @@ function createAndSaveIdentity() {
   return keyPair;
 }
 function loadTrustedPeers() {
-  if (!existsSync16(TRUSTED_PEERS_FILE))
+  if (!existsSync17(TRUSTED_PEERS_FILE))
     return new Map;
-  const data = JSON.parse(readFileSync9(TRUSTED_PEERS_FILE, "utf8"));
+  const data = JSON.parse(readFileSync10(TRUSTED_PEERS_FILE, "utf8"));
   return new Map(data.map((p) => [p.publicKey, p]));
 }
 function saveTrustedPeer(peer) {
@@ -50650,9 +51417,9 @@ function hexToBytes2(hex3) {
 var PAIRING_DIR, IDENTITY_FILE, TRUSTED_PEERS_FILE, QR_VERSION = 1, QR_EXPIRY_MS;
 var init_identity = __esm(() => {
   init_noise();
-  PAIRING_DIR = join20(homedir13(), ".scout/pairing");
-  IDENTITY_FILE = join20(PAIRING_DIR, "identity.json");
-  TRUSTED_PEERS_FILE = join20(PAIRING_DIR, "trusted-peers.json");
+  PAIRING_DIR = join21(homedir14(), ".scout/pairing");
+  IDENTITY_FILE = join21(PAIRING_DIR, "identity.json");
+  TRUSTED_PEERS_FILE = join21(PAIRING_DIR, "trusted-peers.json");
   QR_EXPIRY_MS = 5 * 60 * 1000;
 });
 
@@ -50797,14 +51564,14 @@ var init_security2 = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/runtime-state.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync10, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync11, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
 function readPairingRuntimeSnapshot() {
   const { runtimeStatePath } = pairingPaths();
-  if (!existsSync17(runtimeStatePath)) {
+  if (!existsSync18(runtimeStatePath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync10(runtimeStatePath, "utf8"));
+    const parsed = JSON.parse(readFileSync11(runtimeStatePath, "utf8"));
     return parsed?.version === 1 ? parsed : null;
   } catch {
     return null;
@@ -50828,8 +51595,8 @@ var init_runtime_state = __esm(() => {
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/log.ts
 import { appendFileSync, mkdirSync as mkdirSync8 } from "fs";
-import { join as join21 } from "path";
-import { homedir as homedir14 } from "os";
+import { join as join22 } from "path";
+import { homedir as homedir15 } from "os";
 function write(level, category, message, data) {
   const ts = new Date().toISOString().slice(11, 23);
   const lvl = level.toUpperCase().padEnd(5);
@@ -50845,8 +51612,8 @@ function write(level, category, message, data) {
 }
 var LOG_DIR, LOG_FILE, log;
 var init_log = __esm(() => {
-  LOG_DIR = join21(homedir14(), ".scout/pairing");
-  LOG_FILE = join21(LOG_DIR, "bridge.log");
+  LOG_DIR = join22(homedir15(), ".scout/pairing");
+  LOG_FILE = join22(LOG_DIR, "bridge.log");
   mkdirSync8(LOG_DIR, { recursive: true });
   log = {
     debug: (cat, msg, data) => write("debug", cat, msg, data),
@@ -50922,15 +51689,15 @@ var init_bridge = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/config.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
-import { join as join22 } from "path";
-import { homedir as homedir15 } from "os";
+import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
+import { join as join23 } from "path";
+import { homedir as homedir16 } from "os";
 function loadConfigFile() {
-  if (!existsSync18(CONFIG_FILE)) {
+  if (!existsSync19(CONFIG_FILE)) {
     return {};
   }
   try {
-    const raw = readFileSync11(CONFIG_FILE, "utf8");
+    const raw = readFileSync12(CONFIG_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch (err) {
@@ -50987,8 +51754,8 @@ var init_config3 = __esm(() => {
     port: 7888,
     secure: true
   };
-  CONFIG_DIR = join22(homedir15(), ".scout/pairing");
-  CONFIG_FILE = join22(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join23(homedir16(), ".scout/pairing");
+  CONFIG_FILE = join23(CONFIG_DIR, "config.json");
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/web-handoff.ts
@@ -51007,10 +51774,12 @@ function scopesMatch(left, right) {
   if (left.sessionId !== right.sessionId) {
     return false;
   }
-  if (left.kind === "session") {
-    return true;
+  switch (left.kind) {
+    case "session":
+      return true;
+    case "file_change":
+      return right.kind === "file_change" && left.turnId === right.turnId && left.blockId === right.blockId;
   }
-  return left.turnId === right.turnId && left.blockId === right.blockId;
 }
 function pathForWebHandoffScope(scope) {
   switch (scope.kind) {
@@ -51054,7 +51823,7 @@ var init_web_handoff = __esm(() => {
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/fileserver.ts
 import { isAbsolute as isAbsolute2 } from "path";
-import { homedir as homedir16 } from "os";
+import { homedir as homedir17 } from "os";
 function isTrustedLoopbackHostname(hostname5) {
   const normalized = hostname5.trim().toLowerCase();
   return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "::1" || LOOPBACK_IPV4_HOST_PATTERN.test(normalized);
@@ -51062,7 +51831,7 @@ function isTrustedLoopbackHostname(hostname5) {
 function isAllowedPath(filePath) {
   if (!isAbsolute2(filePath))
     return false;
-  const relToHome = filePath.slice(homedir16().length + 1);
+  const relToHome = filePath.slice(homedir17().length + 1);
   if (relToHome.startsWith(".") && !relToHome.startsWith(".claude") && !relToHome.startsWith(".scout/pairing")) {
     return false;
   }
@@ -51643,17 +52412,17 @@ function formatTimestamp(value) {
 var ALLOWED_ROOTS, LOOPBACK_IPV4_HOST_PATTERN;
 var init_fileserver = __esm(() => {
   init_web_handoff();
-  ALLOWED_ROOTS = [homedir16(), "/tmp"];
+  ALLOWED_ROOTS = [homedir17(), "/tmp"];
   LOOPBACK_IPV4_HOST_PATTERN = /^127(?:\.\d{1,3}){3}$/;
 });
 
 // ../../apps/desktop/src/server/db-queries.ts
 import { Database } from "bun:sqlite";
-import { homedir as homedir17 } from "os";
-import { join as join23 } from "path";
+import { homedir as homedir18 } from "os";
+import { join as join24 } from "path";
 function resolveDbPath() {
-  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join23(homedir17(), ".openscout", "control-plane");
-  return join23(controlHome, "control-plane.sqlite");
+  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join24(homedir18(), ".openscout", "control-plane");
+  return join24(controlHome, "control-plane.sqlite");
 }
 function db() {
   if (!_db) {
@@ -51925,13 +52694,13 @@ var _db = null, HOME, LATEST_AGENT_ENDPOINT_JOIN = `LEFT JOIN agent_endpoints ep
   LIMIT 1
 )`, ACTIVE_FLIGHT_STATES_SQL, ACTIVE_WORK_STATES_SQL;
 var init_db_queries = __esm(() => {
-  HOME = homedir17();
+  HOME = homedir18();
   ACTIVE_FLIGHT_STATES_SQL = sqlStringList(["running", "waking", "waiting", "queued"]);
   ACTIVE_WORK_STATES_SQL = sqlStringList(["open", "working", "waiting", "review"]);
 });
 
 // ../../apps/desktop/src/core/mobile/service.ts
-import { basename as basename8, resolve as resolve14 } from "path";
+import { basename as basename8, resolve as resolve15 } from "path";
 function normalizeTimestamp2(value) {
   if (!value)
     return null;
@@ -52320,7 +53089,7 @@ async function createScoutSession(input, currentDirectory, deviceId) {
   if (!rawWorkspaceId) {
     throw new Error(`Invalid workspaceId.`);
   }
-  const workspaceRoot = resolve14(rawWorkspaceId);
+  const workspaceRoot = resolve15(rawWorkspaceId);
   const projectName = basename8(workspaceRoot) || workspaceRoot;
   const workspace = {
     id: workspaceRoot,
@@ -52430,17 +53199,17 @@ async function deriveNewAgentName(projectName, branch, harness) {
 }
 async function createGitWorktree(projectRoot, agentName) {
   const { execSync: execSync2 } = await import("child_process");
-  const { join: join24 } = await import("path");
-  const { mkdirSync: mkdirSync9, existsSync: existsSync19 } = await import("fs");
+  const { join: join25 } = await import("path");
+  const { mkdirSync: mkdirSync9, existsSync: existsSync20 } = await import("fs");
   try {
     execSync2("git rev-parse --git-dir", { cwd: projectRoot, stdio: "pipe" });
   } catch {
     return null;
   }
   const branchName = `scout/${agentName}`;
-  const worktreeDir = join24(projectRoot, ".scout-worktrees");
-  const worktreePath = join24(worktreeDir, agentName);
-  if (existsSync19(worktreePath)) {
+  const worktreeDir = join25(projectRoot, ".scout-worktrees");
+  const worktreePath = join25(worktreeDir, agentName);
+  if (existsSync20(worktreePath)) {
     return { path: worktreePath, branch: branchName };
   }
   mkdirSync9(worktreeDir, { recursive: true });
@@ -52481,10 +53250,10 @@ var init_service5 = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/server.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync12, realpathSync, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync13, realpathSync, statSync as statSync3 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { basename as basename9, isAbsolute as isAbsolute3, join as join24, relative as relative2 } from "path";
-import { homedir as homedir18 } from "os";
+import { basename as basename9, isAbsolute as isAbsolute3, join as join25, relative as relative2 } from "path";
+import { homedir as homedir19 } from "os";
 function replaySyncEvents(bridge, sessionId, lastSeq) {
   return bridge.replay(sessionId, lastSeq);
 }
@@ -52847,7 +53616,7 @@ async function handleRPCInner(bridge, req, deviceId) {
           return { id: req.id, error: { code: -32000, message: "Only .jsonl files can be read" } };
         }
         try {
-          const content = readFileSync12(p.path, "utf-8");
+          const content = readFileSync13(p.path, "utf-8");
           const lines = content.split(`
 `).filter((l) => l.trim().length > 0);
           const trimmed = lines.length > 500 ? lines.slice(-500) : lines;
@@ -52965,13 +53734,13 @@ function resolveMobileCurrentDirectory() {
   }
 }
 function resolveWorkspaceRoot(root) {
-  const expandedRoot = root.replace(/^~/, homedir18());
+  const expandedRoot = root.replace(/^~/, homedir19());
   return realpathSync(expandedRoot);
 }
 function resolveWorkspacePath(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir18());
-  const candidate = expandedPath ? isAbsolute3(expandedPath) ? expandedPath : join24(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir19());
+  const candidate = expandedPath ? isAbsolute3(expandedPath) ? expandedPath : join25(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync(candidate);
   const rel = relative2(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute3(rel)) {
@@ -52986,7 +53755,7 @@ function listDirectories(dirPath) {
       continue;
     if (name === "node_modules" || name === ".build" || name === "target")
       continue;
-    const fullPath = join24(dirPath, name);
+    const fullPath = join25(dirPath, name);
     try {
       const stat4 = statSync3(fullPath);
       if (!stat4.isDirectory())
@@ -53009,7 +53778,7 @@ function listDirectories(dirPath) {
   return entries.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function discoverSessionFiles(maxAgeDays, limit) {
-  const home = homedir18();
+  const home = homedir19();
   const results = [];
   const searchPaths = [
     { pattern: `${home}/.claude/projects`, agent: "claude-code" },
@@ -54255,7 +55024,7 @@ function pipeReducer(prev, fn) {
 }
 function observableToPromise(observable$1) {
   const ac = new AbortController;
-  const promise3 = new Promise((resolve15, reject) => {
+  const promise3 = new Promise((resolve16, reject) => {
     let isDone = false;
     function onDone() {
       if (isDone)
@@ -54269,7 +55038,7 @@ function observableToPromise(observable$1) {
     const obs$ = observable$1.subscribe({
       next(data) {
         isDone = true;
-        resolve15(data);
+        resolve16(data);
         onDone();
       },
       error(data) {
@@ -54572,15 +55341,15 @@ function resolveSelfTuple(promise3) {
   return Unpromise.proxy(promise3).then(() => [promise3]);
 }
 function withResolvers() {
-  let resolve15;
+  let resolve16;
   let reject;
   const promise3 = new Promise((_resolve, _reject) => {
-    resolve15 = _resolve;
+    resolve16 = _resolve;
     reject = _reject;
   });
   return {
     promise: promise3,
-    resolve: resolve15,
+    resolve: resolve16,
     reject
   };
 }
@@ -54619,8 +55388,8 @@ function timerResource(ms) {
   return makeResource({ start() {
     if (timer)
       throw new Error("Timer already started");
-    const promise3 = new Promise((resolve15) => {
-      timer = setTimeout(() => resolve15(disposablePromiseTimerResult), ms);
+    const promise3 = new Promise((resolve16) => {
+      timer = setTimeout(() => resolve16(disposablePromiseTimerResult), ms);
     });
     return promise3;
   } }, () => {
@@ -54669,15 +55438,15 @@ function _takeWithGrace() {
   return _takeWithGrace.apply(this, arguments);
 }
 function createDeferred() {
-  let resolve15;
+  let resolve16;
   let reject;
   const promise3 = new Promise((res, rej) => {
-    resolve15 = res;
+    resolve16 = res;
     reject = rej;
   });
   return {
     promise: promise3,
-    resolve: resolve15,
+    resolve: resolve16,
     reject
   };
 }
@@ -55653,8 +56422,8 @@ var import_objectSpread2$13, jsonContentTypeHandler, formDataContentTypeHandler,
         status: "fulfilled",
         value
       };
-      subscribers === null || subscribers === undefined || subscribers.forEach(({ resolve: resolve15 }) => {
-        resolve15(value);
+      subscribers === null || subscribers === undefined || subscribers.forEach(({ resolve: resolve16 }) => {
+        resolve16(value);
       });
     });
     if ("catch" in thenReturn)
@@ -56329,15 +57098,15 @@ var init_loggerLink_ineCN1PO = __esm(() => {
 
 // ../../node_modules/.bun/@trpc+client@11.17.0+3482dd4c4b115906/node_modules/@trpc/client/dist/wsLink-DSf4KOdW.mjs
 function withResolvers2() {
-  let resolve15;
+  let resolve16;
   let reject;
   const promise3 = new Promise((res, rej) => {
-    resolve15 = res;
+    resolve16 = res;
     reject = rej;
   });
   return {
     promise: promise3,
-    resolve: resolve15,
+    resolve: resolve16,
     reject
   };
 }
@@ -56357,10 +57126,10 @@ async function buildConnectionMessage(connectionParams, encoder) {
   return encoder.encode(message);
 }
 function asyncWsOpen(ws) {
-  const { promise: promise3, resolve: resolve15, reject } = withResolvers2();
+  const { promise: promise3, resolve: resolve16, reject } = withResolvers2();
   ws.addEventListener("open", () => {
     ws.removeEventListener("error", reject);
-    resolve15();
+    resolve16();
   });
   ws.addEventListener("error", reject);
   return promise3;
@@ -56474,7 +57243,7 @@ var jsonEncoder, lazyDefaults, keepAliveDefaults, exponentialBackoff = (attemptI
     (0, import_defineProperty$2.default)(this, "pendingRequests", {});
   }
   register(message, callbacks) {
-    const { promise: end, resolve: resolve15 } = withResolvers2();
+    const { promise: end, resolve: resolve16 } = withResolvers2();
     this.outgoingRequests.push({
       id: String(message.id),
       message,
@@ -56483,18 +57252,18 @@ var jsonEncoder, lazyDefaults, keepAliveDefaults, exponentialBackoff = (attemptI
         next: callbacks.next,
         complete: () => {
           callbacks.complete();
-          resolve15();
+          resolve16();
         },
         error: (e) => {
           callbacks.error(e);
-          resolve15();
+          resolve16();
         }
       }
     });
     return () => {
       this.delete(message.id);
       callbacks.complete();
-      resolve15();
+      resolve16();
     };
   }
   delete(messageId) {
@@ -57374,12 +58143,12 @@ var init_tail_fanout = __esm(() => {
 
 // ../runtime/src/mobile-push.ts
 import { Database as Database2 } from "bun:sqlite";
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync13 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync14 } from "fs";
 import { connect as connectHttp2 } from "http2";
 import { createPrivateKey, sign as signWithKey } from "crypto";
-import { dirname as dirname14, join as join25 } from "path";
+import { dirname as dirname14, join as join26 } from "path";
 function resolveControlPlaneDbPath() {
-  return join25(resolveOpenScoutSupportPaths().controlHome, "control-plane.sqlite");
+  return join26(resolveOpenScoutSupportPaths().controlHome, "control-plane.sqlite");
 }
 function ensureMobilePushSchema(database) {
   database.exec("PRAGMA busy_timeout = 5000;");
@@ -57531,7 +58300,7 @@ function deleteMobilePushRegistrationByToken(pushToken) {
   writeDb().query(`DELETE FROM mobile_push_registrations WHERE push_token = ?1`).run(token);
 }
 function base64UrlEncode(input) {
-  const buffer = typeof input === "string" ? Buffer.from(input, "utf8") : input;
+  const buffer = typeof input === "string" ? Buffer.from(input, "utf8") : Buffer.from(Array.from(input));
   return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 function loadApnsCredentials() {
@@ -57545,7 +58314,7 @@ function loadApnsCredentials() {
     privateKeyPem = Buffer.from(inlineBase64, "base64").toString("utf8");
   }
   if (!privateKeyPem && path2) {
-    privateKeyPem = readFileSync13(path2, "utf8");
+    privateKeyPem = readFileSync14(path2, "utf8");
   }
   if (!teamId || !keyId || !privateKeyPem) {
     return null;
@@ -57576,7 +58345,7 @@ function apnsJwt(credentials) {
   }));
   const unsignedToken = `${header}.${claims}`;
   const privateKey = createPrivateKey(credentials.privateKeyPem);
-  const signature = signWithKey("sha256", Buffer.from(unsignedToken), privateKey);
+  const signature = signWithKey("sha256", new TextEncoder().encode(unsignedToken), privateKey);
   const token = `${unsignedToken}.${base64UrlEncode(signature)}`;
   cachedApnsJwt = {
     cacheKey,
@@ -57609,7 +58378,7 @@ async function sendApnsAlertToRegistration(registration, alert) {
     },
     ...alert.payload ? { scout: alert.payload } : {}
   });
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const client = connectHttp2(authority);
     client.once("error", reject);
     const request = client.request({
@@ -57632,11 +58401,11 @@ async function sendApnsAlertToRegistration(registration, alert) {
       apnsId = typeof headers["apns-id"] === "string" ? headers["apns-id"] : null;
     });
     request.on("data", (chunk) => {
-      chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
+      chunks.push(chunk);
     });
     request.on("end", () => {
       client.close();
-      const rawBody = chunks.length > 0 ? Buffer.concat(chunks).toString("utf8") : "";
+      const rawBody = chunks.join("");
       let reason = null;
       if (rawBody.trim().length > 0) {
         try {
@@ -57647,7 +58416,7 @@ async function sendApnsAlertToRegistration(registration, alert) {
         }
       }
       if (status === 200) {
-        resolve15({
+        resolve16({
           delivered: true,
           skipped: false,
           status,
@@ -57659,7 +58428,7 @@ async function sendApnsAlertToRegistration(registration, alert) {
       if (reason === "BadDeviceToken" || reason === "Unregistered") {
         deleteMobilePushRegistrationByToken(registration.pushToken);
       }
-      resolve15({
+      resolve16({
         delivered: false,
         skipped: false,
         status,
@@ -57746,10 +58515,10 @@ var init_mobile_push = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/router.ts
-import { readFileSync as readFileSync14, readdirSync as readdirSync3, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
+import { readFileSync as readFileSync15, readdirSync as readdirSync3, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import { basename as basename10, isAbsolute as isAbsolute4, join as join26, relative as relative3 } from "path";
-import { homedir as homedir19 } from "os";
+import { basename as basename10, isAbsolute as isAbsolute4, join as join27, relative as relative3 } from "path";
+import { homedir as homedir20 } from "os";
 function resolveMobileCurrentDirectory2() {
   const config2 = resolveConfig();
   const configuredRoot = config2.workspace?.root;
@@ -57762,13 +58531,13 @@ function resolveMobileCurrentDirectory2() {
   }
 }
 function resolveWorkspaceRoot2(root) {
-  const expandedRoot = root.replace(/^~/, homedir19());
+  const expandedRoot = root.replace(/^~/, homedir20());
   return realpathSync2(expandedRoot);
 }
 function resolveWorkspacePath2(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot2(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir19());
-  const candidate = expandedPath ? isAbsolute4(expandedPath) ? expandedPath : join26(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir20());
+  const candidate = expandedPath ? isAbsolute4(expandedPath) ? expandedPath : join27(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync2(candidate);
   const rel = relative3(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute4(rel)) {
@@ -57783,7 +58552,7 @@ function listDirectories2(dirPath) {
       continue;
     if (name === "node_modules" || name === ".build" || name === "target")
       continue;
-    const fullPath = join26(dirPath, name);
+    const fullPath = join27(dirPath, name);
     try {
       const stat4 = statSync4(fullPath);
       if (!stat4.isDirectory())
@@ -57822,7 +58591,7 @@ function detectAgent2(filePath) {
   return "unknown";
 }
 async function discoverSessionFiles2(maxAgeDays, limit) {
-  const home = homedir19();
+  const home = homedir20();
   const results = [];
   const searchPaths = [
     { pattern: `${home}/.claude/projects`, agent: "claude-code" },
@@ -57904,23 +58673,23 @@ function bridgeEventIterable(bridge, signal) {
   return {
     [Symbol.asyncIterator]() {
       const buffer = [];
-      let resolve15 = null;
+      let resolve16 = null;
       let done = false;
       const unsub = bridge.onEvent((event) => {
         if (done)
           return;
         buffer.push(event);
-        if (resolve15) {
-          resolve15();
-          resolve15 = null;
+        if (resolve16) {
+          resolve16();
+          resolve16 = null;
         }
       });
       const cleanup = () => {
         done = true;
         unsub();
-        if (resolve15) {
-          resolve15();
-          resolve15 = null;
+        if (resolve16) {
+          resolve16();
+          resolve16 = null;
         }
       };
       signal?.addEventListener("abort", cleanup, { once: true });
@@ -57933,7 +58702,7 @@ function bridgeEventIterable(bridge, signal) {
               return { done: false, value: buffer.shift() };
             }
             await new Promise((r) => {
-              resolve15 = r;
+              resolve16 = r;
             });
           }
         },
@@ -57956,23 +58725,23 @@ function tailEventIterable(signal) {
   return {
     [Symbol.asyncIterator]() {
       const buffer = [];
-      let resolve15 = null;
+      let resolve16 = null;
       let done = false;
       const unsub = getTailFanout().subscribe((event) => {
         if (done)
           return;
         buffer.push(event);
-        if (resolve15) {
-          resolve15();
-          resolve15 = null;
+        if (resolve16) {
+          resolve16();
+          resolve16 = null;
         }
       });
       const cleanup = () => {
         done = true;
         unsub();
-        if (resolve15) {
-          resolve15();
-          resolve15 = null;
+        if (resolve16) {
+          resolve16();
+          resolve16 = null;
         }
       };
       signal?.addEventListener("abort", cleanup, { once: true });
@@ -57985,7 +58754,7 @@ function tailEventIterable(signal) {
               return { done: false, value: buffer.shift() };
             }
             await new Promise((r) => {
-              resolve15 = r;
+              resolve16 = r;
             });
           }
         },
@@ -58543,7 +59312,7 @@ var init_router = __esm(() => {
         });
       }
       try {
-        const content = readFileSync14(input.path, "utf-8");
+        const content = readFileSync15(input.path, "utf-8");
         const lines = content.split(`
 `).filter((l) => l.trim().length > 0);
         const trimmed = lines.length > 500 ? lines.slice(-500) : lines;
@@ -60817,14 +61586,14 @@ var init_dist5 = __esm(() => {
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/server-trpc.ts
 import { realpathSync as realpathSync3 } from "fs";
-import { homedir as homedir20 } from "os";
+import { homedir as homedir21 } from "os";
 function resolveCurrentDirectory() {
   try {
     const config2 = resolveConfig();
     const configuredRoot = config2.workspace?.root;
     if (!configuredRoot)
       return process.cwd();
-    const expanded = configuredRoot.replace(/^~/, homedir20());
+    const expanded = configuredRoot.replace(/^~/, homedir21());
     return realpathSync3(expanded);
   } catch {
     return process.cwd();
@@ -60970,8 +61739,8 @@ function startBridgeServerTRPC(options) {
           }
           const iterable = isObservable(result) ? observableToAsyncIterable(result, abortController.signal) : result;
           const iterator = iterable[Symbol.asyncIterator]();
-          const abortPromise = new Promise((resolve15) => {
-            abortController.signal.addEventListener("abort", () => resolve15("abort"), {
+          const abortPromise = new Promise((resolve16) => {
+            abortController.signal.addEventListener("abort", () => resolve16("abort"), {
               once: true
             });
           });
@@ -61287,7 +62056,7 @@ var init_server_trpc = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/pairing/runtime/runtime.ts
-import { homedir as homedir21 } from "os";
+import { homedir as homedir22 } from "os";
 function createPairingAdapterRegistry(configAdapters) {
   const adapters = {
     "claude-code": createAdapter,
@@ -61366,7 +62135,7 @@ async function autoStartConfiguredSessions(bridge, sessions3) {
     try {
       const session = await bridge.createSession(entry.adapter, {
         name: entry.name,
-        cwd: entry.cwd?.replace(/^~/, homedir21()),
+        cwd: entry.cwd?.replace(/^~/, homedir22()),
         options: entry.options
       });
       console.log(`[bridge] session started: ${session.name} (${entry.adapter})`);
@@ -61636,11 +62405,11 @@ var BRIDGE_ABSENCE_GRACE_MS = 30000, ROOM_IDLE_TIMEOUT_MS = 60000;
 
 // ../../apps/desktop/src/core/pairing/runtime/relay-runtime.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readdirSync as readdirSync4 } from "fs";
-import { homedir as homedir22, networkInterfaces } from "os";
-import { join as join27 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readdirSync as readdirSync4 } from "fs";
+import { homedir as homedir23, networkInterfaces } from "os";
+import { join as join28 } from "path";
 function findStoredCerts() {
-  if (!existsSync19(PAIRING_DIR2)) {
+  if (!existsSync20(PAIRING_DIR2)) {
     return null;
   }
   try {
@@ -61654,8 +62423,8 @@ function findStoredCerts() {
       return null;
     }
     return {
-      cert: join27(PAIRING_DIR2, certFile),
-      key: join27(PAIRING_DIR2, keyFile)
+      cert: join28(PAIRING_DIR2, certFile),
+      key: join28(PAIRING_DIR2, keyFile)
     };
   } catch {
     return null;
@@ -61735,8 +62504,8 @@ function resolveRelayEndpointForTailscaleStatus(port, tailscale, options = {}) {
 }
 function generateTailscaleCerts(hostname5) {
   mkdirSync11(PAIRING_DIR2, { recursive: true });
-  const certPath = join27(PAIRING_DIR2, `${hostname5}.crt`);
-  const keyPath = join27(PAIRING_DIR2, `${hostname5}.key`);
+  const certPath = join28(PAIRING_DIR2, `${hostname5}.crt`);
+  const keyPath = join28(PAIRING_DIR2, `${hostname5}.key`);
   try {
     pairingLog.info("relay", "generating tailscale TLS cert", { hostname: hostname5 });
     execSync4(`tailscale cert --cert-file "${certPath}" --key-file "${keyPath}" "${hostname5}"`, {
@@ -61752,8 +62521,8 @@ function generateTailscaleCerts(hostname5) {
 }
 function generateSelfSignedCert(hostname5) {
   mkdirSync11(PAIRING_DIR2, { recursive: true });
-  const certPath = join27(PAIRING_DIR2, `${hostname5}.crt`);
-  const keyPath = join27(PAIRING_DIR2, `${hostname5}.key`);
+  const certPath = join28(PAIRING_DIR2, `${hostname5}.crt`);
+  const keyPath = join28(PAIRING_DIR2, `${hostname5}.key`);
   try {
     execSync4(`openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 ` + `-keyout "${keyPath}" -out "${certPath}" -days 365 -nodes ` + `-subj "/CN=${hostname5}" -addext "subjectAltName=DNS:${hostname5}"`, {
       stdio: ["pipe", "pipe", "pipe"],
@@ -61866,7 +62635,7 @@ function parseIPv4(address) {
 var PAIRING_DIR2;
 var init_relay_runtime = __esm(() => {
   init_log2();
-  PAIRING_DIR2 = join27(homedir22(), ".scout/pairing");
+  PAIRING_DIR2 = join28(homedir23(), ".scout/pairing");
 });
 
 // ../../node_modules/.bun/uqr@0.1.3/node_modules/uqr/dist/index.mjs
@@ -62738,8 +63507,8 @@ async function runPairCommand(context, args) {
   process.on("SIGINT", handleSignal);
   process.on("SIGTERM", handleSignal);
   try {
-    await new Promise((resolve15) => {
-      controller.signal.addEventListener("abort", () => resolve15(), { once: true });
+    await new Promise((resolve16) => {
+      controller.signal.addEventListener("abort", () => resolve16(), { once: true });
     });
   } finally {
     process.off("SIGINT", handleSignal);
@@ -62813,9 +63582,9 @@ __export(exports_server, {
   normalizeServerOpenPath: () => normalizeServerOpenPath
 });
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, openSync } from "fs";
-import { homedir as homedir23 } from "os";
-import { dirname as dirname15, join as join28, resolve as resolve15 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, openSync } from "fs";
+import { homedir as homedir24 } from "os";
+import { dirname as dirname15, join as join29, resolve as resolve16 } from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 function renderServerCommandHelp() {
   return [
@@ -62835,6 +63604,14 @@ function renderServerCommandHelp() {
     "  --static          Serve built UI from disk",
     "  --static-root DIR Static client root (optional override OPENSCOUT_WEB_STATIC_ROOT)",
     "  --vite-url URL    Dev proxy target for non-API routes (optional override OPENSCOUT_WEB_VITE_URL)",
+    "  --public-origin URL",
+    "                    Public origin behind Caddy, e.g. https://scout.<host>.local",
+    "  --advertised-host HOST",
+    "                    LAN host to advertise/trust (default scout.<machine>.local)",
+    "  --trusted-host HOST",
+    "                    Additional trusted API host; may be repeated",
+    "  --trusted-origin URL",
+    "                    Additional trusted browser origin; may be repeated",
     "  --cwd DIR         Workspace / setup root (optional override OPENSCOUT_SETUP_CWD)",
     "  --path PATH       Browser path for `open` (default /)",
     "",
@@ -62893,6 +63670,34 @@ function parseServerFlags(args) {
       env.OPENSCOUT_WEB_VITE_URL = v;
       continue;
     }
+    if (a === "--public-origin") {
+      const v = args[++i];
+      if (!v)
+        throw new ScoutCliError("--public-origin requires a value");
+      env.OPENSCOUT_WEB_PUBLIC_ORIGIN = v;
+      continue;
+    }
+    if (a === "--advertised-host") {
+      const v = args[++i];
+      if (!v)
+        throw new ScoutCliError("--advertised-host requires a value");
+      env.OPENSCOUT_WEB_ADVERTISED_HOST = v;
+      continue;
+    }
+    if (a === "--trusted-host") {
+      const v = args[++i];
+      if (!v)
+        throw new ScoutCliError("--trusted-host requires a value");
+      appendEnvList(env, "OPENSCOUT_WEB_TRUSTED_HOSTS", v);
+      continue;
+    }
+    if (a === "--trusted-origin") {
+      const v = args[++i];
+      if (!v)
+        throw new ScoutCliError("--trusted-origin requires a value");
+      appendEnvList(env, "OPENSCOUT_WEB_TRUSTED_ORIGINS", v);
+      continue;
+    }
     if (a === "--cwd") {
       const v = args[++i];
       if (!v)
@@ -62919,6 +63724,22 @@ function parseServerFlags(args) {
       env.OPENSCOUT_WEB_VITE_URL = a.slice("--vite-url=".length);
       continue;
     }
+    if (a.startsWith("--public-origin=")) {
+      env.OPENSCOUT_WEB_PUBLIC_ORIGIN = a.slice("--public-origin=".length);
+      continue;
+    }
+    if (a.startsWith("--advertised-host=")) {
+      env.OPENSCOUT_WEB_ADVERTISED_HOST = a.slice("--advertised-host=".length);
+      continue;
+    }
+    if (a.startsWith("--trusted-host=")) {
+      appendEnvList(env, "OPENSCOUT_WEB_TRUSTED_HOSTS", a.slice("--trusted-host=".length));
+      continue;
+    }
+    if (a.startsWith("--trusted-origin=")) {
+      appendEnvList(env, "OPENSCOUT_WEB_TRUSTED_ORIGINS", a.slice("--trusted-origin=".length));
+      continue;
+    }
     if (a.startsWith("--cwd=")) {
       env.OPENSCOUT_SETUP_CWD = a.slice("--cwd=".length);
       continue;
@@ -62931,11 +63752,14 @@ function parseServerFlags(args) {
   }
   return { env, openPath };
 }
+function appendEnvList(env, key, value) {
+  env[key] = env[key] ? `${env[key]},${value}` : value;
+}
 function resolveBundledStaticClientRoot(entry, _mode) {
   const entryDir = dirname15(entry);
-  const clientDirectory = join28(entryDir, "client");
-  const indexPath = join28(clientDirectory, "index.html");
-  return existsSync20(indexPath) ? clientDirectory : null;
+  const clientDirectory = join29(entryDir, "client");
+  const indexPath = join29(clientDirectory, "index.html");
+  return existsSync21(indexPath) ? clientDirectory : null;
 }
 function resolveBunExecutable4(env) {
   const bun = resolveBunExecutable(env);
@@ -63116,9 +63940,9 @@ async function openBrowser(url2) {
   });
 }
 function resolveScoutWebServerLogPath() {
-  const dir = join28(homedir23(), ".scout", "logs");
+  const dir = join29(homedir24(), ".scout", "logs");
   mkdirSync12(dir, { recursive: true });
-  return join28(dir, "web-server.log");
+  return join29(dir, "web-server.log");
 }
 async function spawnDetachedServer(entry, env) {
   const bunExecutable = resolveBunExecutable4(env);
@@ -63149,7 +63973,7 @@ async function waitForScoutServer(port, mode, expectedCurrentDirectory) {
   while (Date.now() < deadline) {
     const probe = await probeScoutServer(port);
     if (probe.status === "healthy") {
-      const actualCurrentDirectory = resolve15(probe.health.currentDirectory);
+      const actualCurrentDirectory = resolve16(probe.health.currentDirectory);
       if (!isCurrentScoutWebSurface(probe.health.surface)) {
         throw new ScoutCliError(`port ${port} is serving Scout ${renderSurfaceLabel(probe.health.surface)}, not ${renderModeLabel(mode)}.`);
       }
@@ -63171,7 +63995,7 @@ async function openScoutServer(options) {
   const browserUrl = new URL(normalizeServerOpenPath(options.openPath), `http://127.0.0.1:${port}`).toString();
   const probe = await probeScoutServer(port);
   if (probe.status === "healthy") {
-    const actualCurrentDirectory = resolve15(probe.health.currentDirectory);
+    const actualCurrentDirectory = resolve16(probe.health.currentDirectory);
     if (!isCurrentScoutWebSurface(probe.health.surface)) {
       throw new ScoutCliError(`port ${port} is already serving Scout ${renderSurfaceLabel(probe.health.surface)}, not ${renderModeLabel(options.mode)}.`);
     }
@@ -63370,11 +64194,11 @@ import { EventEmitter } from "events";
 import { Buffer as Buffer2 } from "buffer";
 import { Buffer as Buffer3 } from "buffer";
 import { EventEmitter as EventEmitter2 } from "events";
-import { resolve as resolve16, dirname as dirname16 } from "path";
+import { resolve as resolve17, dirname as dirname16 } from "path";
 import { fileURLToPath as fileURLToPath11 } from "url";
 import { resolve as resolve22, isAbsolute as isAbsolute5, parse as parse7 } from "path";
-import { existsSync as existsSync21 } from "fs";
-import { basename as basename11, join as join29 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { basename as basename11, join as join30 } from "path";
 import os from "os";
 import path2 from "path";
 import { EventEmitter as EventEmitter3 } from "events";
@@ -63385,7 +64209,7 @@ import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile8 } from
 import * as path3 from "path";
 import { readdir as readdir3 } from "fs/promises";
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr4 } from "bun:ffi";
-import { existsSync as existsSync22, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync23, writeFileSync as writeFileSync8 } from "fs";
 import { EventEmitter as EventEmitter4 } from "events";
 import { toArrayBuffer, ptr } from "bun:ffi";
 import { ptr as ptr2, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
@@ -66506,13 +67330,13 @@ class DebounceController {
   }
   debounce(id, ms, fn) {
     const scopeMap = TIMERS_MAP.get(this.scopeId);
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve19, reject) => {
       if (scopeMap.has(id)) {
         clearTimeout(scopeMap.get(id));
       }
       const timerId = setTimeout(() => {
         try {
-          resolve18(fn());
+          resolve19(fn());
         } catch (error48) {
           reject(error48);
         }
@@ -66602,25 +67426,25 @@ function getParsers() {
         filetype: "javascript",
         aliases: ["javascriptreact"],
         queries: {
-          highlights: [resolve16(dirname16(fileURLToPath11(import.meta.url)), highlights_default)]
+          highlights: [resolve17(dirname16(fileURLToPath11(import.meta.url)), highlights_default)]
         },
-        wasm: resolve16(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_javascript_default)
+        wasm: resolve17(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_javascript_default)
       },
       {
         filetype: "typescript",
         aliases: ["typescriptreact"],
         queries: {
-          highlights: [resolve16(dirname16(fileURLToPath11(import.meta.url)), highlights_default2)]
+          highlights: [resolve17(dirname16(fileURLToPath11(import.meta.url)), highlights_default2)]
         },
-        wasm: resolve16(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_typescript_default)
+        wasm: resolve17(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_typescript_default)
       },
       {
         filetype: "markdown",
         queries: {
-          highlights: [resolve16(dirname16(fileURLToPath11(import.meta.url)), highlights_default3)],
-          injections: [resolve16(dirname16(fileURLToPath11(import.meta.url)), injections_default)]
+          highlights: [resolve17(dirname16(fileURLToPath11(import.meta.url)), highlights_default3)],
+          injections: [resolve17(dirname16(fileURLToPath11(import.meta.url)), injections_default)]
         },
-        wasm: resolve16(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_markdown_default),
+        wasm: resolve17(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_markdown_default),
         injectionMapping: {
           nodeTypes: {
             inline: "markdown_inline",
@@ -66643,16 +67467,16 @@ function getParsers() {
       {
         filetype: "markdown_inline",
         queries: {
-          highlights: [resolve16(dirname16(fileURLToPath11(import.meta.url)), highlights_default4)]
+          highlights: [resolve17(dirname16(fileURLToPath11(import.meta.url)), highlights_default4)]
         },
-        wasm: resolve16(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_markdown_inline_default)
+        wasm: resolve17(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_markdown_inline_default)
       },
       {
         filetype: "zig",
         queries: {
-          highlights: [resolve16(dirname16(fileURLToPath11(import.meta.url)), highlights_default5)]
+          highlights: [resolve17(dirname16(fileURLToPath11(import.meta.url)), highlights_default5)]
         },
-        wasm: resolve16(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_zig_default)
+        wasm: resolve17(dirname16(fileURLToPath11(import.meta.url)), tree_sitter_zig_default)
       }
     ];
   }
@@ -66665,7 +67489,7 @@ function getBunfsRootPath() {
   return process.platform === "win32" ? "B:\\~BUN\\root" : "/$bunfs/root";
 }
 function normalizeBunfsPath(fileName) {
-  return join29(getBunfsRootPath(), basename11(fileName));
+  return join30(getBunfsRootPath(), basename11(fileName));
 }
 function addDefaultParsers(parsers) {
   for (const parser of parsers) {
@@ -72419,7 +73243,7 @@ var __defProp4, __returnValue2 = (v) => v, __export2 = (target, all) => {
       configurable: true,
       set: __exportSetter2.bind(all, name)
     });
-}, exports_src, loadYoga, yoga_wasm_base64_esm_default, Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, LogLevel, MeasureMode, NodeType, Overflow, PositionType, Unit, Wrap, constants5, YGEnums_default, Yoga, src_default, VALID_BORDER_STYLES, BorderChars, BorderCharArrays, KeyHandler, InternalKeyHandler, CSS_COLOR_NAMES, block_default, shade_default, slick_default, tiny_default, huge_default, grid_default, pallet_default, fonts, parsedFonts, TextAttributes, ATTRIBUTE_BASE_BITS = 8, ATTRIBUTE_BASE_MASK = 255, DebugOverlayCorner, TargetChannel, ATTRIBUTE_BASE_MASK2 = 255, LINK_ID_SHIFT = 8, LINK_ID_PAYLOAD_MASK = 16777215, BrandedStyledText, StyledText, black = (input) => applyStyle(input, { fg: "black" }), red = (input) => applyStyle(input, { fg: "red" }), green = (input) => applyStyle(input, { fg: "green" }), yellow = (input) => applyStyle(input, { fg: "yellow" }), blue = (input) => applyStyle(input, { fg: "blue" }), magenta = (input) => applyStyle(input, { fg: "magenta" }), cyan = (input) => applyStyle(input, { fg: "cyan" }), white = (input) => applyStyle(input, { fg: "white" }), brightBlack = (input) => applyStyle(input, { fg: "brightBlack" }), brightRed = (input) => applyStyle(input, { fg: "brightRed" }), brightGreen = (input) => applyStyle(input, { fg: "brightGreen" }), brightYellow = (input) => applyStyle(input, { fg: "brightYellow" }), brightBlue = (input) => applyStyle(input, { fg: "brightBlue" }), brightMagenta = (input) => applyStyle(input, { fg: "brightMagenta" }), brightCyan = (input) => applyStyle(input, { fg: "brightCyan" }), brightWhite = (input) => applyStyle(input, { fg: "brightWhite" }), bgBlack = (input) => applyStyle(input, { bg: "black" }), bgRed = (input) => applyStyle(input, { bg: "red" }), bgGreen = (input) => applyStyle(input, { bg: "green" }), bgYellow = (input) => applyStyle(input, { bg: "yellow" }), bgBlue = (input) => applyStyle(input, { bg: "blue" }), bgMagenta = (input) => applyStyle(input, { bg: "magenta" }), bgCyan = (input) => applyStyle(input, { bg: "cyan" }), bgWhite = (input) => applyStyle(input, { bg: "white" }), bold = (input) => applyStyle(input, { bold: true }), italic = (input) => applyStyle(input, { italic: true }), underline = (input) => applyStyle(input, { underline: true }), strikethrough = (input) => applyStyle(input, { strikethrough: true }), dim = (input) => applyStyle(input, { dim: true }), reverse = (input) => applyStyle(input, { reverse: true }), blink = (input) => applyStyle(input, { blink: true }), fg = (color) => (input) => applyStyle(input, { fg: color }), bg = (color) => (input) => applyStyle(input, { bg: color }), link = (url2) => (input) => {
+}, exports_src, loadYoga, yoga_wasm_base64_esm_default, Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, LogLevel, MeasureMode, NodeType, Overflow, PositionType, Unit, Wrap, constants6, YGEnums_default, Yoga, src_default, VALID_BORDER_STYLES, BorderChars, BorderCharArrays, KeyHandler, InternalKeyHandler, CSS_COLOR_NAMES, block_default, shade_default, slick_default, tiny_default, huge_default, grid_default, pallet_default, fonts, parsedFonts, TextAttributes, ATTRIBUTE_BASE_BITS = 8, ATTRIBUTE_BASE_MASK = 255, DebugOverlayCorner, TargetChannel, ATTRIBUTE_BASE_MASK2 = 255, LINK_ID_SHIFT = 8, LINK_ID_PAYLOAD_MASK = 16777215, BrandedStyledText, StyledText, black = (input) => applyStyle(input, { fg: "black" }), red = (input) => applyStyle(input, { fg: "red" }), green = (input) => applyStyle(input, { fg: "green" }), yellow = (input) => applyStyle(input, { fg: "yellow" }), blue = (input) => applyStyle(input, { fg: "blue" }), magenta = (input) => applyStyle(input, { fg: "magenta" }), cyan = (input) => applyStyle(input, { fg: "cyan" }), white = (input) => applyStyle(input, { fg: "white" }), brightBlack = (input) => applyStyle(input, { fg: "brightBlack" }), brightRed = (input) => applyStyle(input, { fg: "brightRed" }), brightGreen = (input) => applyStyle(input, { fg: "brightGreen" }), brightYellow = (input) => applyStyle(input, { fg: "brightYellow" }), brightBlue = (input) => applyStyle(input, { fg: "brightBlue" }), brightMagenta = (input) => applyStyle(input, { fg: "brightMagenta" }), brightCyan = (input) => applyStyle(input, { fg: "brightCyan" }), brightWhite = (input) => applyStyle(input, { fg: "brightWhite" }), bgBlack = (input) => applyStyle(input, { bg: "black" }), bgRed = (input) => applyStyle(input, { bg: "red" }), bgGreen = (input) => applyStyle(input, { bg: "green" }), bgYellow = (input) => applyStyle(input, { bg: "yellow" }), bgBlue = (input) => applyStyle(input, { bg: "blue" }), bgMagenta = (input) => applyStyle(input, { bg: "magenta" }), bgCyan = (input) => applyStyle(input, { bg: "cyan" }), bgWhite = (input) => applyStyle(input, { bg: "white" }), bold = (input) => applyStyle(input, { bold: true }), italic = (input) => applyStyle(input, { italic: true }), underline = (input) => applyStyle(input, { underline: true }), strikethrough = (input) => applyStyle(input, { strikethrough: true }), dim = (input) => applyStyle(input, { dim: true }), reverse = (input) => applyStyle(input, { reverse: true }), blink = (input) => applyStyle(input, { blink: true }), fg = (color) => (input) => applyStyle(input, { fg: color }), bg = (color) => (input) => applyStyle(input, { bg: color }), link = (url2) => (input) => {
   const chunk = typeof input === "object" && "__isChunk" in input ? input : {
     __isChunk: true,
     text: String(input)
@@ -74079,7 +74903,7 @@ var init_index_vy1rm1x3 = __esm(async () => {
     Wrap2[Wrap2["WrapReverse"] = 2] = "WrapReverse";
     return Wrap2;
   }({});
-  constants5 = {
+  constants6 = {
     ALIGN_AUTO: Align.Auto,
     ALIGN_FLEX_START: Align.FlexStart,
     ALIGN_CENTER: Align.Center,
@@ -74153,7 +74977,7 @@ var init_index_vy1rm1x3 = __esm(async () => {
     WRAP_WRAP: Wrap.Wrap,
     WRAP_WRAP_REVERSE: Wrap.WrapReverse
   };
-  YGEnums_default = constants5;
+  YGEnums_default = constants6;
   Yoga = wrapAssembly(await yoga_wasm_base64_esm_default());
   src_default = Yoga;
   VALID_BORDER_STYLES = ["single", "double", "rounded", "heavy"];
@@ -77587,7 +78411,7 @@ var init_index_vy1rm1x3 = __esm(async () => {
         worker_path = this.options.workerPath;
       } else {
         worker_path = new URL("./parser.worker.js", import.meta.url).href;
-        if (!existsSync21(resolve22(import.meta.dirname, "parser.worker.js"))) {
+        if (!existsSync22(resolve22(import.meta.dirname, "parser.worker.js"))) {
           worker_path = new URL("./parser.worker.ts", import.meta.url).href;
         }
       }
@@ -78419,7 +79243,7 @@ var init_index_vy1rm1x3 = __esm(async () => {
   if (isBunfsPath(targetLibPath)) {
     targetLibPath = targetLibPath.replace("../", "");
   }
-  if (!existsSync22(targetLibPath)) {
+  if (!existsSync23(targetLibPath)) {
     throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
   }
   registerEnvVar({
@@ -95888,14 +96712,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve18, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve19, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve19, reject);
             });
             return;
           } catch (error48) {
@@ -95903,7 +96727,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve18(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve19(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -96079,14 +96903,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve18, reject) {
+          then: function(resolve19, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve19, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -96097,7 +96921,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve18(returnValue);
+                resolve19(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -96113,11 +96937,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve18, reject) {
+        then: function(resolve19, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve18, reject);
-          })) : resolve18(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve19, reject);
+          })) : resolve19(returnValue$jscomp$0);
         }
       };
     };
@@ -98598,8 +99422,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve18) {
-            entangledListeners.push(resolve18);
+          then: function(resolve19) {
+            entangledListeners.push(resolve19);
           }
         };
       }
@@ -98623,8 +99447,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve18) {
-          listeners.push(resolve18);
+        then: function(resolve19) {
+          listeners.push(resolve19);
         }
       };
       thenable.then(function() {
@@ -123778,837 +124602,6 @@ var init_react = __esm(async () => {
   extend2({ "time-to-first-draw": TimeToFirstDrawRenderable });
 });
 
-// ../../../../node_modules/react/cjs/react.development.js
-var require_react_development2 = __commonJS((exports, module2) => {
-  (function() {
-    function defineDeprecationWarning(methodName, info) {
-      Object.defineProperty(Component.prototype, methodName, {
-        get: function() {
-          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
-        }
-      });
-    }
-    function getIteratorFn(maybeIterable) {
-      if (maybeIterable === null || typeof maybeIterable !== "object")
-        return null;
-      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
-      return typeof maybeIterable === "function" ? maybeIterable : null;
-    }
-    function warnNoop(publicInstance, callerName) {
-      publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
-      var warningKey = publicInstance + "." + callerName;
-      didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
-    }
-    function Component(props, context, updater) {
-      this.props = props;
-      this.context = context;
-      this.refs = emptyObject2;
-      this.updater = updater || ReactNoopUpdateQueue;
-    }
-    function ComponentDummy() {}
-    function PureComponent(props, context, updater) {
-      this.props = props;
-      this.context = context;
-      this.refs = emptyObject2;
-      this.updater = updater || ReactNoopUpdateQueue;
-    }
-    function noop4() {}
-    function testStringCoercion(value) {
-      return "" + value;
-    }
-    function checkKeyStringCoercion(value) {
-      try {
-        testStringCoercion(value);
-        var JSCompiler_inline_result = false;
-      } catch (e) {
-        JSCompiler_inline_result = true;
-      }
-      if (JSCompiler_inline_result) {
-        JSCompiler_inline_result = console;
-        var JSCompiler_temp_const = JSCompiler_inline_result.error;
-        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
-        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
-        return testStringCoercion(value);
-      }
-    }
-    function getComponentNameFromType(type) {
-      if (type == null)
-        return null;
-      if (typeof type === "function")
-        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
-      if (typeof type === "string")
-        return type;
-      switch (type) {
-        case REACT_FRAGMENT_TYPE:
-          return "Fragment";
-        case REACT_PROFILER_TYPE:
-          return "Profiler";
-        case REACT_STRICT_MODE_TYPE:
-          return "StrictMode";
-        case REACT_SUSPENSE_TYPE:
-          return "Suspense";
-        case REACT_SUSPENSE_LIST_TYPE:
-          return "SuspenseList";
-        case REACT_ACTIVITY_TYPE:
-          return "Activity";
-      }
-      if (typeof type === "object")
-        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
-          case REACT_PORTAL_TYPE:
-            return "Portal";
-          case REACT_CONTEXT_TYPE:
-            return type.displayName || "Context";
-          case REACT_CONSUMER_TYPE:
-            return (type._context.displayName || "Context") + ".Consumer";
-          case REACT_FORWARD_REF_TYPE:
-            var innerType = type.render;
-            type = type.displayName;
-            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
-            return type;
-          case REACT_MEMO_TYPE:
-            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
-          case REACT_LAZY_TYPE:
-            innerType = type._payload;
-            type = type._init;
-            try {
-              return getComponentNameFromType(type(innerType));
-            } catch (x2) {}
-        }
-      return null;
-    }
-    function getTaskName(type) {
-      if (type === REACT_FRAGMENT_TYPE)
-        return "<>";
-      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
-        return "<...>";
-      try {
-        var name = getComponentNameFromType(type);
-        return name ? "<" + name + ">" : "<...>";
-      } catch (x2) {
-        return "<...>";
-      }
-    }
-    function getOwner() {
-      var dispatcher = ReactSharedInternals.A;
-      return dispatcher === null ? null : dispatcher.getOwner();
-    }
-    function UnknownOwner() {
-      return Error("react-stack-top-frame");
-    }
-    function hasValidKey(config3) {
-      if (hasOwnProperty.call(config3, "key")) {
-        var getter = Object.getOwnPropertyDescriptor(config3, "key").get;
-        if (getter && getter.isReactWarning)
-          return false;
-      }
-      return config3.key !== undefined;
-    }
-    function defineKeyPropWarningGetter(props, displayName) {
-      function warnAboutAccessingKey() {
-        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
-      }
-      warnAboutAccessingKey.isReactWarning = true;
-      Object.defineProperty(props, "key", {
-        get: warnAboutAccessingKey,
-        configurable: true
-      });
-    }
-    function elementRefGetterWithDeprecationWarning() {
-      var componentName = getComponentNameFromType(this.type);
-      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
-      componentName = this.props.ref;
-      return componentName !== undefined ? componentName : null;
-    }
-    function ReactElement(type, key, props, owner, debugStack, debugTask) {
-      var refProp = props.ref;
-      type = {
-        $$typeof: REACT_ELEMENT_TYPE,
-        type,
-        key,
-        props,
-        _owner: owner
-      };
-      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
-        enumerable: false,
-        get: elementRefGetterWithDeprecationWarning
-      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
-      type._store = {};
-      Object.defineProperty(type._store, "validated", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: 0
-      });
-      Object.defineProperty(type, "_debugInfo", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: null
-      });
-      Object.defineProperty(type, "_debugStack", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: debugStack
-      });
-      Object.defineProperty(type, "_debugTask", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: debugTask
-      });
-      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
-      return type;
-    }
-    function cloneAndReplaceKey(oldElement, newKey) {
-      newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask);
-      oldElement._store && (newKey._store.validated = oldElement._store.validated);
-      return newKey;
-    }
-    function validateChildKeys(node) {
-      isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
-    }
-    function isValidElement(object4) {
-      return typeof object4 === "object" && object4 !== null && object4.$$typeof === REACT_ELEMENT_TYPE;
-    }
-    function escape2(key) {
-      var escaperLookup = { "=": "=0", ":": "=2" };
-      return "$" + key.replace(/[=:]/g, function(match2) {
-        return escaperLookup[match2];
-      });
-    }
-    function getElementKey(element, index) {
-      return typeof element === "object" && element !== null && element.key != null ? (checkKeyStringCoercion(element.key), escape2("" + element.key)) : index.toString(36);
-    }
-    function resolveThenable(thenable) {
-      switch (thenable.status) {
-        case "fulfilled":
-          return thenable.value;
-        case "rejected":
-          throw thenable.reason;
-        default:
-          switch (typeof thenable.status === "string" ? thenable.then(noop4, noop4) : (thenable.status = "pending", thenable.then(function(fulfilledValue) {
-            thenable.status === "pending" && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
-          }, function(error48) {
-            thenable.status === "pending" && (thenable.status = "rejected", thenable.reason = error48);
-          })), thenable.status) {
-            case "fulfilled":
-              return thenable.value;
-            case "rejected":
-              throw thenable.reason;
-          }
-      }
-      throw thenable;
-    }
-    function mapIntoArray(children, array3, escapedPrefix, nameSoFar, callback) {
-      var type = typeof children;
-      if (type === "undefined" || type === "boolean")
-        children = null;
-      var invokeCallback = false;
-      if (children === null)
-        invokeCallback = true;
-      else
-        switch (type) {
-          case "bigint":
-          case "string":
-          case "number":
-            invokeCallback = true;
-            break;
-          case "object":
-            switch (children.$$typeof) {
-              case REACT_ELEMENT_TYPE:
-              case REACT_PORTAL_TYPE:
-                invokeCallback = true;
-                break;
-              case REACT_LAZY_TYPE:
-                return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array3, escapedPrefix, nameSoFar, callback);
-            }
-        }
-      if (invokeCallback) {
-        invokeCallback = children;
-        callback = callback(invokeCallback);
-        var childKey = nameSoFar === "" ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
-        isArrayImpl(callback) ? (escapedPrefix = "", childKey != null && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array3, escapedPrefix, "", function(c) {
-          return c;
-        })) : callback != null && (isValidElement(callback) && (callback.key != null && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (callback.key == null || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), nameSoFar !== "" && invokeCallback != null && isValidElement(invokeCallback) && invokeCallback.key == null && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array3.push(callback));
-        return 1;
-      }
-      invokeCallback = 0;
-      childKey = nameSoFar === "" ? "." : nameSoFar + ":";
-      if (isArrayImpl(children))
-        for (var i = 0;i < children.length; i++)
-          nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array3, escapedPrefix, type, callback);
-      else if (i = getIteratorFn(children), typeof i === "function")
-        for (i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = true), children = i.call(children), i = 0;!(nameSoFar = children.next()).done; )
-          nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array3, escapedPrefix, type, callback);
-      else if (type === "object") {
-        if (typeof children.then === "function")
-          return mapIntoArray(resolveThenable(children), array3, escapedPrefix, nameSoFar, callback);
-        array3 = String(children);
-        throw Error("Objects are not valid as a React child (found: " + (array3 === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : array3) + "). If you meant to render a collection of children, use an array instead.");
-      }
-      return invokeCallback;
-    }
-    function mapChildren(children, func, context) {
-      if (children == null)
-        return children;
-      var result = [], count = 0;
-      mapIntoArray(children, result, "", "", function(child) {
-        return func.call(context, child, count++);
-      });
-      return result;
-    }
-    function lazyInitializer(payload) {
-      if (payload._status === -1) {
-        var ioInfo = payload._ioInfo;
-        ioInfo != null && (ioInfo.start = ioInfo.end = performance.now());
-        ioInfo = payload._result;
-        var thenable = ioInfo();
-        thenable.then(function(moduleObject) {
-          if (payload._status === 0 || payload._status === -1) {
-            payload._status = 1;
-            payload._result = moduleObject;
-            var _ioInfo = payload._ioInfo;
-            _ioInfo != null && (_ioInfo.end = performance.now());
-            thenable.status === undefined && (thenable.status = "fulfilled", thenable.value = moduleObject);
-          }
-        }, function(error48) {
-          if (payload._status === 0 || payload._status === -1) {
-            payload._status = 2;
-            payload._result = error48;
-            var _ioInfo2 = payload._ioInfo;
-            _ioInfo2 != null && (_ioInfo2.end = performance.now());
-            thenable.status === undefined && (thenable.status = "rejected", thenable.reason = error48);
-          }
-        });
-        ioInfo = payload._ioInfo;
-        if (ioInfo != null) {
-          ioInfo.value = thenable;
-          var displayName = thenable.displayName;
-          typeof displayName === "string" && (ioInfo.name = displayName);
-        }
-        payload._status === -1 && (payload._status = 0, payload._result = thenable);
-      }
-      if (payload._status === 1)
-        return ioInfo = payload._result, ioInfo === undefined && console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
-
-Your code should look like: 
-  const MyComponent = lazy(() => import('./MyComponent'))
-
-Did you accidentally put curly braces around the import?`, ioInfo), "default" in ioInfo || console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
-
-Your code should look like: 
-  const MyComponent = lazy(() => import('./MyComponent'))`, ioInfo), ioInfo.default;
-      throw payload._result;
-    }
-    function resolveDispatcher() {
-      var dispatcher = ReactSharedInternals.H;
-      dispatcher === null && console.error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
-1. You might have mismatching versions of React and the renderer (such as React DOM)
-2. You might be breaking the Rules of Hooks
-3. You might have more than one copy of React in the same app
-See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`);
-      return dispatcher;
-    }
-    function releaseAsyncTransition() {
-      ReactSharedInternals.asyncTransitions--;
-    }
-    function enqueueTask(task) {
-      if (enqueueTaskImpl === null)
-        try {
-          var requireString = ("require" + Math.random()).slice(0, 7);
-          enqueueTaskImpl = (module2 && module2[requireString]).call(module2, "timers").setImmediate;
-        } catch (_err) {
-          enqueueTaskImpl = function(callback) {
-            didWarnAboutMessageChannel === false && (didWarnAboutMessageChannel = true, typeof MessageChannel === "undefined" && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
-            var channel = new MessageChannel;
-            channel.port1.onmessage = callback;
-            channel.port2.postMessage(undefined);
-          };
-        }
-      return enqueueTaskImpl(task);
-    }
-    function aggregateErrors(errors4) {
-      return 1 < errors4.length && typeof AggregateError === "function" ? new AggregateError(errors4) : errors4[0];
-    }
-    function popActScope(prevActQueue, prevActScopeDepth) {
-      prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
-      actScopeDepth = prevActScopeDepth;
-    }
-    function recursivelyFlushAsyncActWork(returnValue, resolve18, reject) {
-      var queue = ReactSharedInternals.actQueue;
-      if (queue !== null)
-        if (queue.length !== 0)
-          try {
-            flushActQueue(queue);
-            enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
-            });
-            return;
-          } catch (error48) {
-            ReactSharedInternals.thrownErrors.push(error48);
-          }
-        else
-          ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve18(returnValue);
-    }
-    function flushActQueue(queue) {
-      if (!isFlushing) {
-        isFlushing = true;
-        var i = 0;
-        try {
-          for (;i < queue.length; i++) {
-            var callback = queue[i];
-            do {
-              ReactSharedInternals.didUsePromise = false;
-              var continuation = callback(false);
-              if (continuation !== null) {
-                if (ReactSharedInternals.didUsePromise) {
-                  queue[i] = callback;
-                  queue.splice(0, i);
-                  return;
-                }
-                callback = continuation;
-              } else
-                break;
-            } while (1);
-          }
-          queue.length = 0;
-        } catch (error48) {
-          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error48);
-        } finally {
-          isFlushing = false;
-        }
-      }
-    }
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
-      isMounted: function() {
-        return false;
-      },
-      enqueueForceUpdate: function(publicInstance) {
-        warnNoop(publicInstance, "forceUpdate");
-      },
-      enqueueReplaceState: function(publicInstance) {
-        warnNoop(publicInstance, "replaceState");
-      },
-      enqueueSetState: function(publicInstance) {
-        warnNoop(publicInstance, "setState");
-      }
-    }, assign = Object.assign, emptyObject2 = {};
-    Object.freeze(emptyObject2);
-    Component.prototype.isReactComponent = {};
-    Component.prototype.setState = function(partialState, callback) {
-      if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null)
-        throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
-      this.updater.enqueueSetState(this, partialState, callback, "setState");
-    };
-    Component.prototype.forceUpdate = function(callback) {
-      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
-    };
-    var deprecatedAPIs = {
-      isMounted: [
-        "isMounted",
-        "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
-      ],
-      replaceState: [
-        "replaceState",
-        "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
-      ]
-    };
-    for (fnName in deprecatedAPIs)
-      deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
-    ComponentDummy.prototype = Component.prototype;
-    deprecatedAPIs = PureComponent.prototype = new ComponentDummy;
-    deprecatedAPIs.constructor = PureComponent;
-    assign(deprecatedAPIs, Component.prototype);
-    deprecatedAPIs.isPureReactComponent = true;
-    var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
-      H: null,
-      A: null,
-      T: null,
-      S: null,
-      actQueue: null,
-      asyncTransitions: 0,
-      isBatchingLegacy: false,
-      didScheduleLegacyUpdate: false,
-      didUsePromise: false,
-      thrownErrors: [],
-      getCurrentStack: null,
-      recentlyCreatedOwnerStacks: 0
-    }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
-      return null;
-    };
-    deprecatedAPIs = {
-      react_stack_bottom_frame: function(callStackForError) {
-        return callStackForError();
-      }
-    };
-    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
-    var didWarnAboutElementRef = {};
-    var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)();
-    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
-    var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = typeof reportError === "function" ? reportError : function(error48) {
-      if (typeof window === "object" && typeof window.ErrorEvent === "function") {
-        var event = new window.ErrorEvent("error", {
-          bubbles: true,
-          cancelable: true,
-          message: typeof error48 === "object" && error48 !== null && typeof error48.message === "string" ? String(error48.message) : String(error48),
-          error: error48
-        });
-        if (!window.dispatchEvent(event))
-          return;
-      } else if (typeof process === "object" && typeof process.emit === "function") {
-        process.emit("uncaughtException", error48);
-        return;
-      }
-      console.error(error48);
-    }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = typeof queueMicrotask === "function" ? function(callback) {
-      queueMicrotask(function() {
-        return queueMicrotask(callback);
-      });
-    } : enqueueTask;
-    deprecatedAPIs = Object.freeze({
-      __proto__: null,
-      c: function(size) {
-        return resolveDispatcher().useMemoCache(size);
-      }
-    });
-    var fnName = {
-      map: mapChildren,
-      forEach: function(children, forEachFunc, forEachContext) {
-        mapChildren(children, function() {
-          forEachFunc.apply(this, arguments);
-        }, forEachContext);
-      },
-      count: function(children) {
-        var n = 0;
-        mapChildren(children, function() {
-          n++;
-        });
-        return n;
-      },
-      toArray: function(children) {
-        return mapChildren(children, function(child) {
-          return child;
-        }) || [];
-      },
-      only: function(children) {
-        if (!isValidElement(children))
-          throw Error("React.Children.only expected to receive a single React element child.");
-        return children;
-      }
-    };
-    exports.Activity = REACT_ACTIVITY_TYPE;
-    exports.Children = fnName;
-    exports.Component = Component;
-    exports.Fragment = REACT_FRAGMENT_TYPE;
-    exports.Profiler = REACT_PROFILER_TYPE;
-    exports.PureComponent = PureComponent;
-    exports.StrictMode = REACT_STRICT_MODE_TYPE;
-    exports.Suspense = REACT_SUSPENSE_TYPE;
-    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
-    exports.__COMPILER_RUNTIME = deprecatedAPIs;
-    exports.act = function(callback) {
-      var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
-      actScopeDepth++;
-      var queue = ReactSharedInternals.actQueue = prevActQueue !== null ? prevActQueue : [], didAwaitActCall = false;
-      try {
-        var result = callback();
-      } catch (error48) {
-        ReactSharedInternals.thrownErrors.push(error48);
-      }
-      if (0 < ReactSharedInternals.thrownErrors.length)
-        throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
-      if (result !== null && typeof result === "object" && typeof result.then === "function") {
-        var thenable = result;
-        queueSeveralMicrotasks(function() {
-          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
-        });
-        return {
-          then: function(resolve18, reject) {
-            didAwaitActCall = true;
-            thenable.then(function(returnValue) {
-              popActScope(prevActQueue, prevActScopeDepth);
-              if (prevActScopeDepth === 0) {
-                try {
-                  flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
-                  });
-                } catch (error$0) {
-                  ReactSharedInternals.thrownErrors.push(error$0);
-                }
-                if (0 < ReactSharedInternals.thrownErrors.length) {
-                  var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
-                  ReactSharedInternals.thrownErrors.length = 0;
-                  reject(_thrownError);
-                }
-              } else
-                resolve18(returnValue);
-            }, function(error48) {
-              popActScope(prevActQueue, prevActScopeDepth);
-              0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
-            });
-          }
-        };
-      }
-      var returnValue$jscomp$0 = result;
-      popActScope(prevActQueue, prevActScopeDepth);
-      prevActScopeDepth === 0 && (flushActQueue(queue), queue.length !== 0 && queueSeveralMicrotasks(function() {
-        didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
-      }), ReactSharedInternals.actQueue = null);
-      if (0 < ReactSharedInternals.thrownErrors.length)
-        throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
-      return {
-        then: function(resolve18, reject) {
-          didAwaitActCall = true;
-          prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve18, reject);
-          })) : resolve18(returnValue$jscomp$0);
-        }
-      };
-    };
-    exports.cache = function(fn) {
-      return function() {
-        return fn.apply(null, arguments);
-      };
-    };
-    exports.cacheSignal = function() {
-      return null;
-    };
-    exports.captureOwnerStack = function() {
-      var getCurrentStack = ReactSharedInternals.getCurrentStack;
-      return getCurrentStack === null ? null : getCurrentStack();
-    };
-    exports.cloneElement = function(element, config3, children) {
-      if (element === null || element === undefined)
-        throw Error("The argument must be a React element, but you passed " + element + ".");
-      var props = assign({}, element.props), key = element.key, owner = element._owner;
-      if (config3 != null) {
-        var JSCompiler_inline_result;
-        a: {
-          if (hasOwnProperty.call(config3, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config3, "ref").get) && JSCompiler_inline_result.isReactWarning) {
-            JSCompiler_inline_result = false;
-            break a;
-          }
-          JSCompiler_inline_result = config3.ref !== undefined;
-        }
-        JSCompiler_inline_result && (owner = getOwner());
-        hasValidKey(config3) && (checkKeyStringCoercion(config3.key), key = "" + config3.key);
-        for (propName in config3)
-          !hasOwnProperty.call(config3, propName) || propName === "key" || propName === "__self" || propName === "__source" || propName === "ref" && config3.ref === undefined || (props[propName] = config3[propName]);
-      }
-      var propName = arguments.length - 2;
-      if (propName === 1)
-        props.children = children;
-      else if (1 < propName) {
-        JSCompiler_inline_result = Array(propName);
-        for (var i = 0;i < propName; i++)
-          JSCompiler_inline_result[i] = arguments[i + 2];
-        props.children = JSCompiler_inline_result;
-      }
-      props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask);
-      for (key = 2;key < arguments.length; key++)
-        validateChildKeys(arguments[key]);
-      return props;
-    };
-    exports.createContext = function(defaultValue) {
-      defaultValue = {
-        $$typeof: REACT_CONTEXT_TYPE,
-        _currentValue: defaultValue,
-        _currentValue2: defaultValue,
-        _threadCount: 0,
-        Provider: null,
-        Consumer: null
-      };
-      defaultValue.Provider = defaultValue;
-      defaultValue.Consumer = {
-        $$typeof: REACT_CONSUMER_TYPE,
-        _context: defaultValue
-      };
-      defaultValue._currentRenderer = null;
-      defaultValue._currentRenderer2 = null;
-      return defaultValue;
-    };
-    exports.createElement = function(type, config3, children) {
-      for (var i = 2;i < arguments.length; i++)
-        validateChildKeys(arguments[i]);
-      i = {};
-      var key = null;
-      if (config3 != null)
-        for (propName in didWarnAboutOldJSXRuntime || !("__self" in config3) || "key" in config3 || (didWarnAboutOldJSXRuntime = true, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config3) && (checkKeyStringCoercion(config3.key), key = "" + config3.key), config3)
-          hasOwnProperty.call(config3, propName) && propName !== "key" && propName !== "__self" && propName !== "__source" && (i[propName] = config3[propName]);
-      var childrenLength = arguments.length - 2;
-      if (childrenLength === 1)
-        i.children = children;
-      else if (1 < childrenLength) {
-        for (var childArray = Array(childrenLength), _i = 0;_i < childrenLength; _i++)
-          childArray[_i] = arguments[_i + 2];
-        Object.freeze && Object.freeze(childArray);
-        i.children = childArray;
-      }
-      if (type && type.defaultProps)
-        for (propName in childrenLength = type.defaultProps, childrenLength)
-          i[propName] === undefined && (i[propName] = childrenLength[propName]);
-      key && defineKeyPropWarningGetter(i, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
-      var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
-      return ReactElement(type, key, i, getOwner(), propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
-    };
-    exports.createRef = function() {
-      var refObject = { current: null };
-      Object.seal(refObject);
-      return refObject;
-    };
-    exports.forwardRef = function(render) {
-      render != null && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof render !== "function" ? console.error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render) : render.length !== 0 && render.length !== 2 && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
-      render != null && render.defaultProps != null && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?");
-      var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
-      Object.defineProperty(elementType, "displayName", {
-        enumerable: false,
-        configurable: true,
-        get: function() {
-          return ownName;
-        },
-        set: function(name) {
-          ownName = name;
-          render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
-        }
-      });
-      return elementType;
-    };
-    exports.isValidElement = isValidElement;
-    exports.lazy = function(ctor) {
-      ctor = { _status: -1, _result: ctor };
-      var lazyType2 = {
-        $$typeof: REACT_LAZY_TYPE,
-        _payload: ctor,
-        _init: lazyInitializer
-      }, ioInfo = {
-        name: "lazy",
-        start: -1,
-        end: -1,
-        value: null,
-        owner: null,
-        debugStack: Error("react-stack-top-frame"),
-        debugTask: console.createTask ? console.createTask("lazy()") : null
-      };
-      ctor._ioInfo = ioInfo;
-      lazyType2._debugInfo = [{ awaited: ioInfo }];
-      return lazyType2;
-    };
-    exports.memo = function(type, compare) {
-      type == null && console.error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
-      compare = {
-        $$typeof: REACT_MEMO_TYPE,
-        type,
-        compare: compare === undefined ? null : compare
-      };
-      var ownName;
-      Object.defineProperty(compare, "displayName", {
-        enumerable: false,
-        configurable: true,
-        get: function() {
-          return ownName;
-        },
-        set: function(name) {
-          ownName = name;
-          type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
-        }
-      });
-      return compare;
-    };
-    exports.startTransition = function(scope) {
-      var prevTransition = ReactSharedInternals.T, currentTransition = {};
-      currentTransition._updatedFibers = new Set;
-      ReactSharedInternals.T = currentTransition;
-      try {
-        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
-        onStartTransitionFinish !== null && onStartTransitionFinish(currentTransition, returnValue);
-        typeof returnValue === "object" && returnValue !== null && typeof returnValue.then === "function" && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop4, reportGlobalError));
-      } catch (error48) {
-        reportGlobalError(error48);
-      } finally {
-        prevTransition === null && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), prevTransition !== null && currentTransition.types !== null && (prevTransition.types !== null && prevTransition.types !== currentTransition.types && console.error("We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
-      }
-    };
-    exports.unstable_useCacheRefresh = function() {
-      return resolveDispatcher().useCacheRefresh();
-    };
-    exports.use = function(usable) {
-      return resolveDispatcher().use(usable);
-    };
-    exports.useActionState = function(action, initialState, permalink) {
-      return resolveDispatcher().useActionState(action, initialState, permalink);
-    };
-    exports.useCallback = function(callback, deps) {
-      return resolveDispatcher().useCallback(callback, deps);
-    };
-    exports.useContext = function(Context2) {
-      var dispatcher = resolveDispatcher();
-      Context2.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
-      return dispatcher.useContext(Context2);
-    };
-    exports.useDebugValue = function(value, formatterFn) {
-      return resolveDispatcher().useDebugValue(value, formatterFn);
-    };
-    exports.useDeferredValue = function(value, initialValue) {
-      return resolveDispatcher().useDeferredValue(value, initialValue);
-    };
-    exports.useEffect = function(create, deps) {
-      create == null && console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?");
-      return resolveDispatcher().useEffect(create, deps);
-    };
-    exports.useEffectEvent = function(callback) {
-      return resolveDispatcher().useEffectEvent(callback);
-    };
-    exports.useId = function() {
-      return resolveDispatcher().useId();
-    };
-    exports.useImperativeHandle = function(ref, create, deps) {
-      return resolveDispatcher().useImperativeHandle(ref, create, deps);
-    };
-    exports.useInsertionEffect = function(create, deps) {
-      create == null && console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?");
-      return resolveDispatcher().useInsertionEffect(create, deps);
-    };
-    exports.useLayoutEffect = function(create, deps) {
-      create == null && console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?");
-      return resolveDispatcher().useLayoutEffect(create, deps);
-    };
-    exports.useMemo = function(create, deps) {
-      return resolveDispatcher().useMemo(create, deps);
-    };
-    exports.useOptimistic = function(passthrough, reducer) {
-      return resolveDispatcher().useOptimistic(passthrough, reducer);
-    };
-    exports.useReducer = function(reducer, initialArg, init) {
-      return resolveDispatcher().useReducer(reducer, initialArg, init);
-    };
-    exports.useRef = function(initialValue) {
-      return resolveDispatcher().useRef(initialValue);
-    };
-    exports.useState = function(initialState) {
-      return resolveDispatcher().useState(initialState);
-    };
-    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
-      return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    };
-    exports.useTransition = function() {
-      return resolveDispatcher().useTransition();
-    };
-    exports.version = "19.2.4";
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-  })();
-});
-
-// ../../../../node_modules/react/index.js
-var require_react2 = __commonJS((exports, module2) => {
-  var react_development = __toESM(require_react_development2());
-  if (false) {} else {
-    module2.exports = react_development;
-  }
-});
-
 // ../../apps/desktop/src/core/monitor/service.ts
 async function loadScoutMonitorSnapshot(input) {
   const channel = input.channel?.trim() || DEFAULT_MONITOR_CHANNEL;
@@ -125409,7 +125402,7 @@ var init_app = __esm(async () => {
   init_user_config();
   init_jsx_dev_runtime();
   await init_react();
-  import_react13 = __toESM(require_react2(), 1);
+  import_react13 = __toESM(require_react(), 1);
   C2 = {
     accent: "#34d399",
     dim: "#6b7280",
@@ -125433,14 +125426,14 @@ async function runScoutMonitorApp(options) {
   }
   const renderer = await createCliRenderer();
   let closed = false;
-  await new Promise((resolve18) => {
+  await new Promise((resolve19) => {
     const close = () => {
       if (closed) {
         return;
       }
       closed = true;
       renderer.destroy();
-      resolve18();
+      resolve19();
     };
     createRoot(renderer).render(/* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(ScoutMonitorApp, {
       currentDirectory: options.currentDirectory,
@@ -125488,8 +125481,8 @@ var exports_up = {};
 __export(exports_up, {
   runUpCommand: () => runUpCommand
 });
-import { existsSync as existsSync23 } from "fs";
-import { resolve as resolve18 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { resolve as resolve19 } from "path";
 function looksLikePath(value) {
   return value.includes("/") || value.startsWith(".") || value.startsWith("~");
 }
@@ -125551,8 +125544,8 @@ async function runUpCommand(context, args) {
     throw new ScoutCliError("usage: scout up <name|path> [--name <alias>] [--harness <claude|codex>] [--model <model>]");
   }
   let projectPath;
-  if (looksLikePath(target) || existsSync23(resolve18(target))) {
-    projectPath = resolve18(target);
+  if (looksLikePath(target) || existsSync24(resolve19(target))) {
+    projectPath = resolve19(target);
   } else {
     const resolved = await resolveLocalAgentByName(target);
     if (!resolved) {
@@ -125675,10 +125668,10 @@ var init_whoami = __esm(() => {
 });
 
 // ../../apps/desktop/src/cli/main.ts
-import { existsSync as existsSync25, readFileSync as readFileSync15, writeFileSync as writeFileSync9, statSync as statSync5, mkdirSync as mkdirSync13 } from "fs";
-import { join as join32 } from "path";
-import { spawnSync as spawnSync3 } from "child_process";
-import { homedir as homedir24 } from "os";
+import { existsSync as existsSync26, readFileSync as readFileSync16, writeFileSync as writeFileSync9, statSync as statSync5, mkdirSync as mkdirSync13 } from "fs";
+import { join as join33 } from "path";
+import { spawnSync as spawnSync4 } from "child_process";
+import { homedir as homedir25 } from "os";
 
 // ../../apps/desktop/src/cli/argv.ts
 function parseScoutArgv(argv) {
@@ -125963,27 +125956,27 @@ var _scoutBinPath = null;
 function getScoutBinPath() {
   if (_scoutBinPath)
     return _scoutBinPath;
-  _scoutBinPath = join32(homedir24(), ".bun", "bin", "scout");
-  if (!existsSync25(_scoutBinPath)) {
-    _scoutBinPath = spawnSync3("which", ["scout"], { encoding: "utf8" }).stdout.trim();
+  _scoutBinPath = join33(homedir25(), ".bun", "bin", "scout");
+  if (!existsSync26(_scoutBinPath)) {
+    _scoutBinPath = spawnSync4("which", ["scout"], { encoding: "utf8" }).stdout.trim();
   }
   return _scoutBinPath;
 }
 async function ensureBrokerUptodate() {
   try {
     const mtime = normalizeCliBinaryMtimeMs(statSync5(getScoutBinPath()).mtimeMs);
-    const checkpointDir = join32(homedir24(), ".scout");
-    const mtimePath = join32(checkpointDir, "cli-mtime");
-    const lastMtime = existsSync25(mtimePath) ? Number(readFileSync15(mtimePath, "utf8").trim()) : 0;
+    const checkpointDir = join33(homedir25(), ".scout");
+    const mtimePath = join33(checkpointDir, "cli-mtime");
+    const lastMtime = existsSync26(mtimePath) ? Number(readFileSync16(mtimePath, "utf8").trim()) : 0;
     if (shouldRestartBrokerForCliMtime(mtime, lastMtime)) {
       const uid = process.getuid();
-      const plistPath = join32(homedir24(), "Library", "LaunchAgents", "dev.openscout.broker.plist");
-      spawnSync3("launchctl", ["bootout", `gui/${uid}/dev.openscout.broker`], { stdio: "ignore" });
-      await new Promise((resolve19) => setTimeout(resolve19, 1500));
-      spawnSync3("launchctl", ["bootstrap", `gui/${uid}`, plistPath], { stdio: "ignore" });
-      await new Promise((resolve19) => setTimeout(resolve19, 2000));
+      const plistPath = join33(homedir25(), "Library", "LaunchAgents", "dev.openscout.broker.plist");
+      spawnSync4("launchctl", ["bootout", `gui/${uid}/dev.openscout.broker`], { stdio: "ignore" });
+      await new Promise((resolve20) => setTimeout(resolve20, 1500));
+      spawnSync4("launchctl", ["bootstrap", `gui/${uid}`, plistPath], { stdio: "ignore" });
+      await new Promise((resolve20) => setTimeout(resolve20, 2000));
     }
-    if (!existsSync25(checkpointDir)) {
+    if (!existsSync26(checkpointDir)) {
       mkdirSync13(checkpointDir, { recursive: true });
     }
     writeFileSync9(mtimePath, String(mtime), { encoding: "utf8", flag: "w" });