@openscout/scout 0.2.92 → 0.2.95

package/dist/pairing-runtime-controller.mjs

@@ -123,28 +123,236 @@ function ensureOpenScoutCleanSlateSync() {
 var OPENSCOUT_RPC_CUTOVER_MARKER = "rpc-runtime-cutover-v1";
 var init_support_paths = () => {};
 
-// ../runtime/src/local-config.ts
+// ../runtime/src/node-identity.ts
+import {
+  createHash,
+  createPrivateKey,
+  createPublicKey,
+  generateKeyPairSync,
+  randomBytes,
+  sign,
+  verify
+} from "crypto";
 import {
+  chmodSync,
   existsSync as existsSync2,
   mkdirSync as mkdirSync2,
   readFileSync,
   renameSync,
+  rmSync as rmSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir2, hostname as osHostname } from "os";
 import { dirname, join as join2 } from "path";
+function stripBonjourCollisionSuffix(value) {
+  if (!value || typeof value !== "string")
+    return "";
+  let trimmed = value.trim();
+  const isDotLocal = /\.local\.?$/i.test(trimmed);
+  if (isDotLocal) {
+    trimmed = trimmed.replace(/\.local\.?$/i, "");
+  }
+  const isHyphenLocalOpenscout = /-local-openscout$/i.test(trimmed);
+  const isHyphenLocal = !isHyphenLocalOpenscout && /-local$/i.test(trimmed);
+  if (isHyphenLocalOpenscout) {
+    trimmed = trimmed.replace(/-local-openscout$/i, "");
+  } else if (isHyphenLocal) {
+    trimmed = trimmed.replace(/-local$/i, "");
+  }
+  if (!isDotLocal && !isHyphenLocalOpenscout && !isHyphenLocal) {
+    return trimmed;
+  }
+  trimmed = trimmed.replace(/(?<=[a-zA-Z].*?)(?:-\d+)+$/, "");
+  if (isDotLocal)
+    return `${trimmed}.local`;
+  if (isHyphenLocalOpenscout)
+    return `${trimmed}-local-openscout`;
+  if (isHyphenLocal)
+    return `${trimmed}-local`;
+  return trimmed;
+}
+function nodeIdentityPath(supportDirectory) {
+  const dir = supportDirectory ?? resolveOpenScoutSupportPaths().supportDirectory;
+  return join2(dir, NODE_IDENTITY_FILE);
+}
+function loadOrCreateNodeIdentity(supportDirectory) {
+  const path = nodeIdentityPath(supportDirectory);
+  if (existsSync2(path)) {
+    return readAndValidateNodeIdentity(path);
+  }
+  return createNodeIdentity(supportDirectory);
+}
+function readStableNodeQualifier(supportDirectory) {
+  const path = nodeIdentityPath(supportDirectory);
+  const cached = stableNodeQualifierCache.get(path);
+  if (cached) {
+    return cached;
+  }
+  if (!existsSync2(path)) {
+    return null;
+  }
+  const nodeQualifier = normalizeNodeQualifier(readAndValidateNodeIdentity(path).nodeQualifier);
+  if (nodeQualifier) {
+    stableNodeQualifierCache.set(path, nodeQualifier);
+  }
+  return nodeQualifier || null;
+}
+function readAndValidateNodeIdentity(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw new Error(`Corrupt node identity at ${path}; remove it to generate a fresh one.`);
+  }
+  if (parsed.version !== 1 || !parsed.publicKey || !parsed.privateKey) {
+    throw new Error(`Corrupt node identity at ${path}; remove it to generate a fresh one.`);
+  }
+  if (parsed.nodeQualifier !== undefined && normalizePersistedNodeQualifier(parsed.nodeQualifier) !== parsed.nodeQualifier) {
+    throw new Error(`Corrupt node identity at ${path}; remove it to generate a fresh one.`);
+  }
+  try {
+    const derived = createPublicKey(importPrivateKey(parsed.privateKey)).export({ type: "spki", format: "der" }).toString("base64");
+    if (derived !== parsed.publicKey) {
+      throw new Error("mismatch");
+    }
+  } catch {
+    throw new Error(`Node identity at ${path} has mismatched or invalid keys; remove it to generate a fresh one.`);
+  }
+  return parsed;
+}
+function normalizePersistedNodeQualifier(value) {
+  return typeof value === "string" ? value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "") : "";
+}
+function normalizeNodeQualifier(value) {
+  return stripBonjourCollisionSuffix(normalizePersistedNodeQualifier(value));
+}
+function createNodeIdentity(supportDirectory) {
+  if (!supportDirectory) {
+    assertTestIsolatedUserData("write the node identity", "OPENSCOUT_SUPPORT_DIRECTORY");
+  }
+  const path = nodeIdentityPath(supportDirectory);
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const identity = {
+    version: 1,
+    publicKey: publicKey.export({ type: "spki", format: "der" }).toString("base64"),
+    privateKey: privateKey.export({ type: "pkcs8", format: "der" }).toString("base64"),
+    createdAt: Date.now()
+  };
+  mkdirSync2(dirname(path), { recursive: true });
+  try {
+    writeFileSync2(path, `${JSON.stringify(identity, null, 2)}
+`, { encoding: "utf8", mode: 384, flag: "wx" });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      return readAndValidateNodeIdentity(path);
+    }
+    throw error;
+  }
+  try {
+    chmodSync(path, 384);
+  } catch {}
+  return identity;
+}
+function nodeKeyId(publicKeyBase64) {
+  return createHash("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest("hex");
+}
+function nodeFingerprint(publicKeyBase64) {
+  const digest = createHash("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest();
+  const encoded = base32Encode(digest.subarray(0, 10)).toLowerCase();
+  return `${NODE_FINGERPRINT_PREFIX}:${encoded.slice(0, 4)}-${encoded.slice(4, 8)}`;
+}
+function signNodePayload(identity, payload) {
+  const key = importPrivateKey(identity.privateKey);
+  return sign(null, typeof payload === "string" ? Buffer.from(payload, "utf8") : payload, key).toString("base64");
+}
+function verifyNodeSignature(publicKeyBase64, payload, signatureBase64) {
+  try {
+    const key = importPublicKey(publicKeyBase64);
+    return verify(null, typeof payload === "string" ? Buffer.from(payload, "utf8") : payload, key, Buffer.from(signatureBase64, "base64"));
+  } catch {
+    return false;
+  }
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+function verifySignedNodeCard(card, now = Date.now()) {
+  if (nodeKeyId(card.publicKey) !== card.keyId) {
+    return false;
+  }
+  if (nodeFingerprint(card.publicKey) !== card.fingerprint) {
+    return false;
+  }
+  if (!Number.isFinite(card.expiresAt) || card.expiresAt <= now) {
+    return false;
+  }
+  if (card.tls !== undefined) {
+    if (typeof card.tls !== "object" || card.tls === null || typeof card.tls.spkiFingerprint !== "string" || !/^[0-9a-f]{64}$/.test(card.tls.spkiFingerprint)) {
+      return false;
+    }
+  }
+  const { signature, ...unsigned } = card;
+  return verifyNodeSignature(card.publicKey, canonicalJson(unsigned), signature);
+}
+function base32Encode(input) {
+  let bits = 0;
+  let value = 0;
+  let output = "";
+  for (const byte of input) {
+    value = value << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      output += BASE32_ALPHABET[value >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) {
+    output += BASE32_ALPHABET[value << 5 - bits & 31];
+  }
+  return output;
+}
+function importPrivateKey(privateKeyBase64) {
+  return createPrivateKey({ key: Buffer.from(privateKeyBase64, "base64"), format: "der", type: "pkcs8" });
+}
+function importPublicKey(publicKeyBase64) {
+  return createPublicKey({ key: Buffer.from(publicKeyBase64, "base64"), format: "der", type: "spki" });
+}
+var NODE_IDENTITY_FILE = "node-identity.json", NODE_FINGERPRINT_PREFIX = "osc1", NODE_CARD_TTL_MS, stableNodeQualifierCache, BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+var init_node_identity = __esm(() => {
+  init_support_paths();
+  NODE_CARD_TTL_MS = 24 * 60 * 60 * 1000;
+  stableNodeQualifierCache = new Map;
+});
+
+// ../runtime/src/local-config.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir2, hostname as osHostname } from "os";
+import { dirname as dirname2, join as join3 } from "path";
 function localConfigHome() {
-  return process.env.OPENSCOUT_HOME ?? join2(homedir2(), ".openscout");
+  return process.env.OPENSCOUT_HOME ?? join3(homedir2(), ".openscout");
 }
 function localConfigPath() {
-  return join2(localConfigHome(), "config.json");
+  return join3(localConfigHome(), "config.json");
 }
 function loadLocalConfig() {
   const configPath = localConfigPath();
-  if (!existsSync2(configPath))
+  if (!existsSync3(configPath))
     return { version: LOCAL_CONFIG_VERSION };
   try {
-    return validateLocalConfig(JSON.parse(readFileSync(configPath, "utf8")));
+    return validateLocalConfig(JSON.parse(readFileSync2(configPath, "utf8")));
   } catch {
     return { version: LOCAL_CONFIG_VERSION };
   }
@@ -228,6 +436,7 @@ function resolveHost() {
 var LOCAL_CONFIG_VERSION = 1, DEFAULT_SCOUT_WEB_PORTAL_HOST = "scout.local", DEFAULT_SCOUT_WEB_DEV_HOST, OPENSCOUT_PORTS, DEFAULT_LOCAL_CONFIG;
 var init_local_config = __esm(() => {
   init_support_paths();
+  init_node_identity();
   DEFAULT_SCOUT_WEB_DEV_HOST = `dev.${DEFAULT_SCOUT_WEB_PORTAL_HOST}`;
   OPENSCOUT_PORTS = {
     broker: 43110,
@@ -252,7 +461,7 @@ var init_local_config = __esm(() => {
 });
 
 // ../runtime/src/open-scout-network.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 function defaultOpenScoutNetworkSettings() {
   return {
     discoveryEnabled: false,
@@ -273,7 +482,7 @@ function normalizeOpenScoutNetworkSettings(input) {
 }
 function readOpenScoutNetworkSettingsSync() {
   try {
-    const raw = readFileSync2(resolveOpenScoutSupportPaths().settingsPath, "utf8");
+    const raw = readFileSync3(resolveOpenScoutSupportPaths().settingsPath, "utf8");
     const parsed = JSON.parse(raw);
     const network = isRecord(parsed) && isRecord(parsed.network) ? parsed.network : {};
     return normalizeOpenScoutNetworkSettings(isRecord(network.openScoutNetwork) ? network.openScoutNetwork : {});
@@ -316,7 +525,7 @@ var init_open_scout_network = __esm(() => {
 // ../agent-sessions/src/codex-executable.ts
 import { execFileSync } from "child_process";
 import { accessSync, constants } from "fs";
-import { delimiter, join as join3 } from "path";
+import { delimiter, join as join4 } from "path";
 function isExecutable(filePath) {
   if (!filePath)
     return false;
@@ -360,11 +569,11 @@ function codexAppBundleCandidates(env) {
   const appNames = ["Codex.app", "ChatGPT.app"];
   const candidates = appNames.flatMap((appName) => [
     {
-      path: join3("/Applications", appName, "Contents", "Resources", "codex"),
+      path: join4("/Applications", appName, "Contents", "Resources", "codex"),
       source: "codex_app_bundle"
     },
     {
-      path: join3(env.HOME ?? "", "Applications", appName, "Contents", "Resources", "codex"),
+      path: join4(env.HOME ?? "", "Applications", appName, "Contents", "Resources", "codex"),
       source: "codex_app_bundle"
     }
   ]);
@@ -372,7 +581,7 @@ function codexAppBundleCandidates(env) {
 }
 function pathCandidates(env) {
   return (env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => ({
-    path: join3(directory, "codex"),
+    path: join4(directory, "codex"),
     source: "path"
   }));
 }
@@ -383,7 +592,7 @@ function commonCandidates(env) {
     "/opt/homebrew/bin",
     "/usr/local/bin"
   ].filter(Boolean).map((directory) => ({
-    path: join3(directory, "codex"),
+    path: join4(directory, "codex"),
     source: "common"
   }));
 }
@@ -667,10 +876,10 @@ var init_auth = __esm(() => {
 
 // ../runtime/src/harness-catalog.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync4, statSync } from "fs";
+import { existsSync as existsSync5, statSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 function readinessFromAuthModel(harness) {
   const model = harnessAuthModel(harness);
   if (!model)
@@ -703,7 +912,7 @@ function expandHomePath(value) {
   if (value === "~")
     return home;
   if (value.startsWith("~/"))
-    return join4(home, value.slice(2));
+    return join5(home, value.slice(2));
   return value;
 }
 function defaultWhichBinary(binary, platform) {
@@ -737,7 +946,7 @@ function defaultRunCommand(command, platform) {
 }
 function defaultRequirementExists(requirement) {
   const expanded = expandHomePath(requirement.path);
-  if (!existsSync4(expanded))
+  if (!existsSync5(expanded))
     return false;
   if (requirement.fileType === "any" || !requirement.fileType)
     return true;
@@ -966,7 +1175,7 @@ async function readHarnessCatalogOverrides(overridePath = resolveOpenScoutSuppor
   }
 }
 async function writeHarnessCatalogOverrides(overrides, overridePath = resolveOpenScoutSupportPaths().harnessCatalogPath) {
-  await mkdir(dirname2(overridePath), { recursive: true });
+  await mkdir(dirname3(overridePath), { recursive: true });
   const payload = {
     version: HARNESS_CATALOG_VERSION,
     entries: overrides,
@@ -976,7 +1185,7 @@ async function writeHarnessCatalogOverrides(overrides, overridePath = resolveOpe
 `, "utf8");
 }
 async function ensureHarnessCatalogOverrideFile(overridePath = resolveOpenScoutSupportPaths().harnessCatalogPath) {
-  if (existsSync4(overridePath))
+  if (existsSync5(overridePath))
     return;
   await writeHarnessCatalogOverrides({}, overridePath);
 }
@@ -2301,6 +2510,104 @@ var init_assigned_roles = () => {};
 // ../protocol/src/orchestrator-prompt.ts
 var init_orchestrator_prompt = () => {};
 
+// ../protocol/src/orchestration-provider-map.ts
+function runtimeDefinition(label, providerId, harness, model, effort, profile, capability, caution) {
+  return {
+    label,
+    route: { providerId, harness, model, effort, profile },
+    capability,
+    caution
+  };
+}
+function roleCandidate(runtimeId, fit, rationale) {
+  return {
+    ...RUNTIMES[runtimeId],
+    fit,
+    taskRationale: rationale ?? RUNTIMES[runtimeId].capability
+  };
+}
+var HOUR_MS, DAY_MS, RUNTIMES, ROLE_POLICIES;
+var init_orchestration_provider_map = __esm(() => {
+  HOUR_MS = 60 * 60000;
+  DAY_MS = 24 * HOUR_MS;
+  RUNTIMES = {
+    fable: runtimeDefinition("Fable 5", "claude", "claude", "claude-fable-5", "max", "Fable", "Premium product taste, rapid design iterations, and premise-level critique.", "Uses the premium shared Claude allowance; do not spend it on routine mechanical work."),
+    sol: runtimeDefinition("GPT-5.6 Sol", "codex", "codex", "gpt-5.6-sol", "xhigh", null, "Load-bearing coding, debugging, integration, and technically grounded judgment.", "Highest Codex tier; reserve deep turns for work where failure is expensive."),
+    grok: runtimeDefinition("Grok 4.6", "grok", "grok", "grok-4.6", null, "Grok", "Independent assumption checking, deletion pressure, and adversarial critique.", "Do not make it the sole implementation authority; verify conclusions against repository evidence."),
+    kimi: runtimeDefinition("Kimi Code", "kimi", "kimi", null, null, "Kimi", "Dense repository and study synthesis through the native Kimi harness.", "The harness owns the concrete model and quota telemetry can be stale; probe before large fan-out."),
+    opus: runtimeDefinition("Opus 5", "claude", "claude", "claude-opus-5", "high", "Opus", "Long-context synthesis, nuanced architecture, and coherent product reasoning.", "Premium shared Claude quota; avoid routine scans and repetitive verification."),
+    glm: runtimeDefinition("GLM-5.2", "opencode", "opencode", "opencode-go/glm-5.2", null, "OpenCode", "Independent broad-context synthesis through OpenCode.", "OpenCode quota is not visible in Scout; use a bounded canary before scaling."),
+    terra: runtimeDefinition("GPT-5.6 Terra", "codex", "codex", "gpt-5.6-terra", "high", null, "Balanced implementation, correctness review, and technical critique.", "Prefer Sol for the hardest integration boundary when its additional spend is justified."),
+    minimax: runtimeDefinition("MiniMax M3", "minimax", "opencode", "opencode-go/minimax-m3", null, "OpenCode", "Cost-effective structured evidence collection and comparison.", "Verify load-bearing conclusions with a stronger reviewer before acceptance."),
+    luna: runtimeDefinition("GPT-5.6 Luna", "codex", "codex", "gpt-5.6-luna", "medium", null, "Inexpensive source mapping, test enumeration, and mechanical audit work.", "Keep it out of sole high-stakes product judgment and final acceptance."),
+    haiku: runtimeDefinition("Haiku 4.5", "claude", "claude", "claude-haiku-4-5", "low", null, "Fast narrow scans and classification inside the Claude harness.", "Lighter reasoning and a smaller context window make broad synthesis a poor fit."),
+    sonnet: runtimeDefinition("Sonnet 4.6", "claude", "claude", "claude-sonnet-4-6", "high", null, "Strong generalist implementation with a large context window.", "Shares Claude's provider allowance and can become a poor choice when that pool is guarded."),
+    deepseek: runtimeDefinition("DeepSeek V4 Pro", "opencode", "opencode", "opencode-go/deepseek-v4-pro", null, "OpenCode", "Code-centric review through an independent model lineage.", "Quota is opaque and findings should not be the sole acceptance authority.")
+  };
+  ROLE_POLICIES = {
+    product_judgment: {
+      label: "Product judgment",
+      objective: "Strategic tradeoffs, UX prioritization, scope shaping, and high-level product decisions.",
+      strategy: "Select models with high nuanced taste, product-level synthesis, and clear communication of architectural tradeoffs.",
+      candidates: [
+        roleCandidate("fable", 100, "Unmatched product taste, rapid design iteration synthesis, and high-fidelity UX direction."),
+        roleCandidate("sol", 87, "Technically grounded product decisions with strong execution realism."),
+        roleCandidate("grok", 82, "Unfiltered perspective on feature bloat and aggressive scope reduction.")
+      ]
+    },
+    large_context_synthesis: {
+      label: "Large-context synthesis",
+      objective: "Repository-wide investigations, deep architectural archaeology, and multi-file code synthesis.",
+      strategy: "Select models with expansive effective context windows and high-density information compression.",
+      candidates: [
+        roleCandidate("kimi", 100, "Native long-context retrieval and dense codebase relationship synthesis."),
+        roleCandidate("opus", 91, "Deep structural understanding across complex multi-package repositories."),
+        roleCandidate("glm", 84, "Independent wide-window scanning and structural cross-referencing.")
+      ]
+    },
+    adversarial_critique: {
+      label: "Adversarial critique",
+      objective: "Challenging design assumptions, rapid design iteration critique, identifying UX/logic gaps, and applying deletion pressure.",
+      strategy: "Select high-taste and contrarian model lineages that stress-test design iterations and probe corner cases without sycophantic approval.",
+      candidates: [
+        roleCandidate("fable", 100, "High-fidelity design critique, rapid UX/visual iteration stress-testing, and premise challenge."),
+        roleCandidate("grok", 91, "Contrarian perspective, uncompromising edge-case discovery, and aggressive premise challenge."),
+        roleCandidate("terra", 84, "Rigorous technical inspection of code correctness and runtime invariants.")
+      ]
+    },
+    evidence_inventory: {
+      label: "Evidence inventory",
+      objective: "Grep and AST inventory, reference tracing, log audit, and structured fact collection.",
+      strategy: "Select fast, cost-effective models with high precision on structured evidence gathering.",
+      candidates: [
+        roleCandidate("minimax", 100, "Fast, cost-effective structured evidence indexing and pattern enumeration."),
+        roleCandidate("luna", 95, "Low-latency source tracing, test inventory, and reference mapping."),
+        roleCandidate("haiku", 87, "Rapid mechanical file scans and categorization.")
+      ]
+    },
+    implementation: {
+      label: "Implementation",
+      objective: "Code creation, refactoring, type checking, unit test writing, and bug fixing.",
+      strategy: "Select code-generation champions with high instruction following and strong language typing skills.",
+      candidates: [
+        roleCandidate("sol", 100, "Deep technical accuracy, robust multi-file refactors, and complex logic execution."),
+        roleCandidate("terra", 91, "Reliable structured implementation with strong type-system adherence."),
+        roleCandidate("sonnet", 87, "Strong generalist coding with fast turn times and clear explanations.")
+      ]
+    },
+    code_review: {
+      label: "Code review",
+      objective: "Diff analysis, security audit, regression detection, and style conformity.",
+      strategy: "Select models with high sensitivity to subtle bugs, invariant violations, and edge-case behaviors.",
+      candidates: [
+        roleCandidate("terra", 100, "Strict invariant checking, subtle logic flaw detection, and boundary test coverage."),
+        roleCandidate("opus", 96, "High-level architectural consistency and API surface evolution review."),
+        roleCandidate("deepseek", 87, "Independent second-opinion review focused on code-level edge cases.")
+      ]
+    }
+  };
+});
+
 // ../protocol/src/permission-policy.ts
 function normalizeScoutPermissionProfile(value) {
   const normalized = value?.trim().replaceAll("-", "_");
@@ -3135,6 +3442,7 @@ var init_src = __esm(() => {
   init_channel_identity();
   init_assigned_roles();
   init_orchestrator_prompt();
+  init_orchestration_provider_map();
   init_agent_runs();
   init_budget();
   init_host_integrations();
@@ -4731,7 +5039,7 @@ var init_model_window_registry = __esm(() => {
 });
 
 // ../agent-sessions/src/history.ts
-import { basename, dirname as dirname3 } from "path";
+import { basename, dirname as dirname4 } from "path";
 function decodeClaudeProjectsSlug(name) {
   if (!name || !name.startsWith("-")) {
     return null;
@@ -4743,7 +5051,7 @@ function decodeClaudeProjectsSlug(name) {
   return `/${tail.replace(/-/g, "/")}`;
 }
 function inferClaudeHistoryCwd(path2) {
-  const parent = basename(dirname3(path2));
+  const parent = basename(dirname4(path2));
   return decodeClaudeProjectsSlug(parent);
 }
 function deriveHistoryName(path2) {
@@ -4751,7 +5059,7 @@ function deriveHistoryName(path2) {
   if (claudeCwd) {
     return basename(claudeCwd) || claudeCwd;
   }
-  const parent = basename(dirname3(path2));
+  const parent = basename(dirname4(path2));
   return parent || basename(path2) || "History Session";
 }
 function normalizeTimestamp(value) {
@@ -6653,9 +6961,9 @@ function createLiveNormalizerContext(sessionId) {
 }
 
 // ../agent-sessions/src/adapters/claude-code/team-topology.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { homedir as homedir5 } from "os";
-import { basename as basename2, dirname as dirname4, join as join5, relative } from "path";
+import { basename as basename2, dirname as dirname5, join as join6, relative } from "path";
 function isObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -6678,7 +6986,7 @@ function sourceRefId(kind, value) {
 }
 function readJsonObject(path2) {
   try {
-    const parsed = JSON.parse(readFileSync4(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path2, "utf8"));
     return isObject(parsed) ? parsed : null;
   } catch {
     return null;
@@ -6699,17 +7007,17 @@ function statIsFile(path2) {
   }
 }
 function readTeamConfigs(homeDir) {
-  const teamsRoot = join5(homeDir, ".claude", "teams");
-  if (!existsSync5(teamsRoot) || !statIsDirectory(teamsRoot)) {
+  const teamsRoot = join6(homeDir, ".claude", "teams");
+  if (!existsSync6(teamsRoot) || !statIsDirectory(teamsRoot)) {
     return [];
   }
   const teams = [];
   for (const entry of readdirSync(teamsRoot)) {
-    const teamDir = join5(teamsRoot, entry);
+    const teamDir = join6(teamsRoot, entry);
     if (!statIsDirectory(teamDir)) {
       continue;
     }
-    const configPath = join5(teamDir, "config.json");
+    const configPath = join6(teamDir, "config.json");
     const config = readJsonObject(configPath);
     if (!config) {
       continue;
@@ -6847,8 +7155,8 @@ function membersFromConfig(team, groupId, configRefId) {
   return { agents, relationships, agentByExternal };
 }
 function readTaskFiles(tasksRoot, teamName) {
-  const teamTasksRoot = join5(tasksRoot, teamName);
-  if (!existsSync5(teamTasksRoot) || !statIsDirectory(teamTasksRoot)) {
+  const teamTasksRoot = join6(tasksRoot, teamName);
+  if (!existsSync6(teamTasksRoot) || !statIsDirectory(teamTasksRoot)) {
     return [];
   }
   const result = [];
@@ -6858,7 +7166,7 @@ function readTaskFiles(tasksRoot, teamName) {
     if (!current)
       continue;
     for (const entry of readdirSync(current)) {
-      const path2 = join5(current, entry);
+      const path2 = join6(current, entry);
       if (statIsDirectory(path2)) {
         stack.push(path2);
       } else if (statIsFile(path2)) {
@@ -6889,14 +7197,14 @@ function firstMarkdownTitle(raw) {
 function parseTaskFile(taskPath, teamName, tasksRoot, sourceRef) {
   let raw;
   try {
-    raw = readFileSync4(taskPath, "utf8");
+    raw = readFileSync5(taskPath, "utf8");
   } catch {
     return null;
   }
-  const relativePath = relative(join5(tasksRoot, teamName), taskPath);
+  const relativePath = relative(join6(tasksRoot, teamName), taskPath);
   const fallbackId = relativePath.replace(/\.[^.]+$/u, "");
   const fallbackTitle = firstMarkdownTitle(raw) ?? basename2(fallbackId);
-  const inferredState = inferTaskStateFromPath(dirname4(relativePath));
+  const inferredState = inferTaskStateFromPath(dirname5(relativePath));
   let parsed = null;
   try {
     const json = JSON.parse(raw);
@@ -6927,7 +7235,7 @@ function parseTaskFile(taskPath, teamName, tasksRoot, sourceRef) {
   };
 }
 function tasksFromFiles(homeDir, teamName, agentByExternal) {
-  const tasksRoot = join5(homeDir, ".claude", "tasks");
+  const tasksRoot = join6(homeDir, ".claude", "tasks");
   const taskFiles = readTaskFiles(tasksRoot, teamName);
   const sourceRefs = [];
   const parsedTasks = [];
@@ -8141,9 +8449,9 @@ function flushLine(line, onLine) {
 }
 
 // ../agent-sessions/src/adapters/claude-code/adapter.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
 import { homedir as homedir6 } from "os";
-import { delimiter as delimiter2, join as join6 } from "path";
+import { delimiter as delimiter2, join as join7 } from "path";
 function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -8156,8 +8464,8 @@ function resolveClaudeResumeContext(config) {
   if (!resumeId) {
     return null;
   }
-  const projectsRoot = join6(homedir6(), ".claude", "projects");
-  if (!existsSync6(projectsRoot)) {
+  const projectsRoot = join7(homedir6(), ".claude", "projects");
+  if (!existsSync7(projectsRoot)) {
     return null;
   }
   let projectSlugs;
@@ -8167,8 +8475,8 @@ function resolveClaudeResumeContext(config) {
     return null;
   }
   for (const slug of projectSlugs) {
-    const sessionPath = join6(projectsRoot, slug, `${resumeId}.jsonl`);
-    if (!existsSync6(sessionPath)) {
+    const sessionPath = join7(projectsRoot, slug, `${resumeId}.jsonl`);
+    if (!existsSync7(sessionPath)) {
       continue;
     }
     const cwd = decodeClaudeProjectsSlug2(slug);
@@ -8208,7 +8516,7 @@ function resolveExecutableFromPath(command, env) {
   for (const directory of pathValue.split(delimiter2)) {
     if (!directory)
       continue;
-    const candidate = join6(directory, command);
+    const candidate = join7(directory, command);
     try {
       if (statSync3(candidate).isFile()) {
         return candidate;
@@ -8515,9 +8823,9 @@ var init_claude_code = __esm(() => {
 });
 
 // ../agent-sessions/src/codex-launch-config.ts
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync7 } from "fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync8 } from "fs";
 import { homedir as homedir7 } from "os";
-import { basename as basename3, delimiter as delimiter3, dirname as dirname5, join as join7, resolve } from "path";
+import { basename as basename3, delimiter as delimiter3, dirname as dirname6, join as join8, resolve } from "path";
 import { fileURLToPath } from "url";
 function isExecutable2(filePath) {
   if (!filePath) {
@@ -8538,7 +8846,7 @@ function ancestorChain(start) {
   let current = resolve(start);
   while (true) {
     chain.push(current);
-    const parent = dirname5(current);
+    const parent = dirname6(current);
     if (parent === current) {
       return chain;
     }
@@ -8548,14 +8856,14 @@ function ancestorChain(start) {
 function resolveExecutableFromSearchPath(names, env) {
   const pathEntries = (env.PATH ?? "").split(delimiter3).filter(Boolean);
   const commonDirectories = [
-    join7(homedir7(), ".local", "bin"),
-    join7(homedir7(), ".bun", "bin"),
+    join8(homedir7(), ".local", "bin"),
+    join8(homedir7(), ".bun", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin"
   ];
   for (const directory of [...pathEntries, ...commonDirectories]) {
     for (const name of names) {
-      const candidate = join7(directory, name);
+      const candidate = join8(directory, name);
       if (isExecutable2(candidate)) {
         return candidate;
       }
@@ -8594,12 +8902,12 @@ function resolveScoutExecutable(env) {
   return resolveExecutableFromSearchPath(["scout"], env);
 }
 function resolveRepoScoutScript(currentDirectory) {
-  const moduleDirectory = dirname5(fileURLToPath(import.meta.url));
+  const moduleDirectory = dirname6(fileURLToPath(import.meta.url));
   const starts = uniquePaths([currentDirectory, moduleDirectory]);
   for (const start of starts) {
     for (const candidate of ancestorChain(start)) {
-      const scriptPath = join7(candidate, "apps", "desktop", "bin", "scout.ts");
-      if (existsSync7(scriptPath)) {
+      const scriptPath = join8(candidate, "apps", "desktop", "bin", "scout.ts");
+      if (existsSync8(scriptPath)) {
         return scriptPath;
       }
     }
@@ -8689,7 +8997,7 @@ var init_secret_redaction = __esm(() => {
 // ../agent-sessions/src/local/transports/codex-app-server.ts
 import { spawn } from "child_process";
 import { appendFile, mkdir as mkdir2, readFile as readFile2, rm, stat, writeFile as writeFile2 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function codexAppServerExitMessage(input) {
   if (input.exitKind === "proactive_shutdown") {
     return `Codex app-server session for ${input.agentName} was stopped by OpenScout` + (input.reason ? `: ${input.reason}` : "") + ".";
@@ -9004,7 +9312,7 @@ function parseCodexMaybeJson(value) {
   }
 }
 async function readCodexSessionCatalog(runtimeDirectory) {
-  const raw = await readOptionalFile(join8(runtimeDirectory, SESSION_CATALOG_FILENAME));
+  const raw = await readOptionalFile(join9(runtimeDirectory, SESSION_CATALOG_FILENAME));
   if (!raw) {
     return { activeSessionId: null, sessions: [] };
   }
@@ -9019,7 +9327,7 @@ async function readCodexSessionCatalog(runtimeDirectory) {
 }
 async function writeCodexSessionCatalog(runtimeDirectory, catalog) {
   await mkdir2(runtimeDirectory, { recursive: true });
-  await writeFile2(join8(runtimeDirectory, SESSION_CATALOG_FILENAME), JSON.stringify(catalog, null, 2) + `
+  await writeFile2(join9(runtimeDirectory, SESSION_CATALOG_FILENAME), JSON.stringify(catalog, null, 2) + `
 `);
 }
 async function recordCodexSessionCatalog(runtimeDirectory, threadId, input) {
@@ -9066,6 +9374,10 @@ function isMissingCodexRolloutError(error) {
   const message = errorMessage(error).toLowerCase();
   return message.includes("no rollout found for thread id");
 }
+function isCodexThreadWriterConflictError(error) {
+  const message = errorMessage(error).toLowerCase();
+  return message.includes("already has an active writer") || message.includes("thread-store conflict");
+}
 
 class CodexAppServerTransport {
   options;
@@ -9088,10 +9400,10 @@ class CodexAppServerTransport {
   errorListeners = new Set;
   constructor(options) {
     this.options = options;
-    this.threadIdPath = join8(options.runtimeDirectory, "codex-thread-id.txt");
-    this.statePath = join8(options.runtimeDirectory, "state.json");
-    this.stdoutLogPath = join8(options.logsDirectory, "stdout.log");
-    this.stderrLogPath = join8(options.logsDirectory, "stderr.log");
+    this.threadIdPath = join9(options.runtimeDirectory, "codex-thread-id.txt");
+    this.statePath = join9(options.runtimeDirectory, "state.json");
+    this.stdoutLogPath = join9(options.logsDirectory, "stdout.log");
+    this.stderrLogPath = join9(options.logsDirectory, "stderr.log");
     this.lastConfigSignature = this.configSignature(options);
   }
   get currentThreadId() {
@@ -9100,6 +9412,9 @@ class CodexAppServerTransport {
   get currentThreadPath() {
     return this.threadPath;
   }
+  get currentDurableThreadId() {
+    return this.durableThreadId;
+  }
   get stdoutLogFile() {
     return this.stdoutLogPath;
   }
@@ -9136,7 +9451,8 @@ class CodexAppServerTransport {
       throw new Error(`Codex app-server session for ${this.options.agentName} has no active thread.`);
     }
     return {
-      threadId: this.threadId
+      threadId: this.threadId,
+      durableThreadId: this.durableThreadId
     };
   }
   async startTurn(prompt) {
@@ -9248,7 +9564,7 @@ class CodexAppServerTransport {
   async startSession() {
     await mkdir2(this.options.runtimeDirectory, { recursive: true });
     await mkdir2(this.options.logsDirectory, { recursive: true });
-    await writeFile2(join8(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
+    await writeFile2(join9(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
     this.proactiveShutdown = null;
     try {
       await assertCodexWorkingDirectory(this.options.cwd, this.options.agentName);
@@ -9354,6 +9670,13 @@ class CodexAppServerTransport {
           await this.persistState();
         }
         if (requestedThreadId || this.options.requireExistingThread) {
+          if (isCodexThreadWriterConflictError(error)) {
+            throw new CodexThreadHeldExternallyError({
+              agentName: this.options.agentName,
+              threadId: storedThreadId,
+              detail: errorMessage(error)
+            });
+          }
           throw new Error(`Failed to resume ${threadOrigin} Codex thread ${storedThreadId}: ${errorMessage(error)}`);
         }
       }
@@ -9993,16 +10316,16 @@ async function shutdownCodexAppServerLocalAgent(options, shutdownOptions = {}) {
   const session = codexAppServerClients.get(key);
   if (!session) {
     if (shutdownOptions.resetThread) {
-      const threadId = await readOptionalFile(join8(options.runtimeDirectory, "codex-thread-id.txt"));
+      const threadId = await readOptionalFile(join9(options.runtimeDirectory, "codex-thread-id.txt"));
       await closeCodexSessionCatalog(options.runtimeDirectory, threadId);
-      await rm(join8(options.runtimeDirectory, "codex-thread-id.txt"), { force: true });
+      await rm(join9(options.runtimeDirectory, "codex-thread-id.txt"), { force: true });
     }
     return;
   }
   codexAppServerClients.delete(key);
   await session.shutdown(shutdownOptions);
 }
-var CodexAppServerExitError, CodexAppServerRequesterTimeoutError, SESSION_CATALOG_FILENAME = "session-catalog.json", SESSION_CATALOG_MAX_ENTRIES = 64, codexAppServerClients;
+var CodexAppServerExitError, CodexAppServerRequesterTimeoutError, CodexThreadHeldExternallyError, SESSION_CATALOG_FILENAME = "session-catalog.json", SESSION_CATALOG_MAX_ENTRIES = 64, codexAppServerClients;
 var init_codex_app_server = __esm(() => {
   init_codex_launch_config();
   init_codex_executable();
@@ -10041,6 +10364,17 @@ var init_codex_app_server = __esm(() => {
       this.timeoutMs = input.timeoutMs;
     }
   };
+  CodexThreadHeldExternallyError = class CodexThreadHeldExternallyError extends Error {
+    code = "CODEX_THREAD_HELD_EXTERNALLY";
+    threadId;
+    agentName;
+    constructor(input) {
+      super(`Codex thread ${input.threadId} is open in another application` + (input.detail ? ` (${input.detail})` : "") + "; it will accept turns once that application releases it.");
+      this.name = "CodexThreadHeldExternallyError";
+      this.threadId = input.threadId;
+      this.agentName = input.agentName;
+    }
+  };
   codexAppServerClients = new Map;
 });
 
@@ -10870,9 +11204,9 @@ var init_normalizer3 = __esm(() => {
 });
 
 // ../agent-sessions/src/adapters/codex/topology.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
 import { homedir as homedir8 } from "os";
-import { basename as basename4, join as join9 } from "path";
+import { basename as basename4, join as join10 } from "path";
 function isObject2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -10989,7 +11323,7 @@ function parseTomlKeyValues(raw) {
 }
 function readTomlKeyValues(path2) {
   try {
-    return parseTomlKeyValues(readFileSync5(path2, "utf8"));
+    return parseTomlKeyValues(readFileSync6(path2, "utf8"));
   } catch {
     return null;
   }
@@ -11003,8 +11337,8 @@ function firstString2(record2, keys) {
   return;
 }
 function readAgentDefinitions(root, scope) {
-  const agentsDir = join9(root, ".codex", "agents");
-  if (!existsSync8(agentsDir) || !statIsDirectory2(agentsDir)) {
+  const agentsDir = join10(root, ".codex", "agents");
+  if (!existsSync9(agentsDir) || !statIsDirectory2(agentsDir)) {
     return { agents: [], sourceRefs: [] };
   }
   const agents = [];
@@ -11012,7 +11346,7 @@ function readAgentDefinitions(root, scope) {
   for (const entry of readdirSync3(agentsDir).sort()) {
     if (!entry.endsWith(".toml"))
       continue;
-    const path2 = join9(agentsDir, entry);
+    const path2 = join10(agentsDir, entry);
     if (!statIsFile2(path2))
       continue;
     const parsed = readTomlKeyValues(path2);
@@ -11051,8 +11385,8 @@ function readAgentDefinitions(root, scope) {
 function readProjectAgentsConfig(cwd) {
   if (!cwd)
     return {};
-  const configPath = join9(cwd, ".codex", "config.toml");
-  if (!existsSync8(configPath) || !statIsFile2(configPath)) {
+  const configPath = join10(cwd, ".codex", "config.toml");
+  if (!existsSync9(configPath) || !statIsFile2(configPath)) {
     return {};
   }
   const parsed = readTomlKeyValues(configPath);
@@ -11315,7 +11649,7 @@ var init_topology = () => {};
 
 // ../agent-sessions/src/adapters/codex/adapter.ts
 import { homedir as homedir9 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function errorMessage2(error) {
   if (error instanceof Error) {
     return error.message;
@@ -11342,7 +11676,7 @@ var init_adapter2 = __esm(() => {
     sequence = 0;
     constructor(config) {
       super(config);
-      const runtimeRoot = join10(homedir9(), ".scout/pairing", "codex", this.session.id);
+      const runtimeRoot = join11(homedir9(), ".scout/pairing", "codex", this.session.id);
       this.observedTopology = new CodexObservedTopologyTracker({
         cwd: config.cwd ?? process.cwd(),
         homeDir: config.env?.HOME,
@@ -11354,8 +11688,8 @@ var init_adapter2 = __esm(() => {
         model: this.session.model,
         providerMeta: {
           ...this.session.providerMeta ?? {},
-          stdoutLogFile: join10(runtimeRoot, "logs/stdout.log"),
-          stderrLogFile: join10(runtimeRoot, "logs/stderr.log")
+          stdoutLogFile: join11(runtimeRoot, "logs/stdout.log"),
+          stderrLogFile: join11(runtimeRoot, "logs/stderr.log")
         }
       });
     }
@@ -11414,7 +11748,7 @@ var init_adapter2 = __esm(() => {
       this.setStatus("closed");
     }
     get codexOptions() {
-      const runtimeRoot = join10(homedir9(), ".scout/pairing", "codex", this.session.id);
+      const runtimeRoot = join11(homedir9(), ".scout/pairing", "codex", this.session.id);
       const configuredThreadId = this.config.options?.["threadId"];
       const requireExistingThread = this.config.options?.["requireExistingThread"];
       const rawLaunchArgs = this.config.options?.["launchArgs"];
@@ -11426,8 +11760,8 @@ var init_adapter2 = __esm(() => {
         sessionId: this.session.id,
         cwd: this.config.cwd ?? process.cwd(),
         systemPrompt: this.systemPrompt,
-        runtimeDirectory: join10(runtimeRoot, "runtime"),
-        logsDirectory: join10(runtimeRoot, "logs"),
+        runtimeDirectory: join11(runtimeRoot, "runtime"),
+        logsDirectory: join11(runtimeRoot, "logs"),
         env: this.config.env,
         launchArgs,
         threadId: typeof configuredThreadId === "string" && configuredThreadId.trim().length > 0 ? configuredThreadId.trim() : undefined,
@@ -11446,10 +11780,10 @@ var init_adapter2 = __esm(() => {
       return typeof raw === "string" && raw.trim().length > 0 ? raw : "You are a helpful agent working through Pairing.";
     }
     get stdoutLogPath() {
-      return this.transport?.stdoutLogFile ?? join10(this.codexOptions.logsDirectory, "stdout.log");
+      return this.transport?.stdoutLogFile ?? join11(this.codexOptions.logsDirectory, "stdout.log");
     }
     get stderrLogPath() {
-      return this.transport?.stderrLogFile ?? join10(this.codexOptions.logsDirectory, "stderr.log");
+      return this.transport?.stderrLogFile ?? join11(this.codexOptions.logsDirectory, "stderr.log");
     }
     enqueue(task) {
       const next = this.serialized.then(task, task);
@@ -11617,9 +11951,9 @@ var init_codex = __esm(() => {
 
 // ../agent-sessions/src/adapters/acp/adapter.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname6, isAbsolute, relative as relative2, resolve as resolve2 } from "path";
+import { dirname as dirname7, isAbsolute, relative as relative2, resolve as resolve2 } from "path";
 import { pathToFileURL } from "url";
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -11998,7 +12332,7 @@ var init_adapter3 = __esm(() => {
         return;
       }
       const options = this.acpOptions;
-      if (!existsSync9(options.cwd)) {
+      if (!existsSync10(options.cwd)) {
         const failure = new Error(`ACP agent working directory does not exist: ${options.cwd}` + ` (harness command: ${options.command})`);
         this.failSession(failure);
         throw failure;
@@ -12658,7 +12992,7 @@ ${plan}`,
         return;
       }
       const filePath = this.resolveAllowedPath(requestedPath);
-      await mkdir3(dirname6(filePath), { recursive: true });
+      await mkdir3(dirname7(filePath), { recursive: true });
       await writeFile3(filePath, params.content, "utf8");
       this.writeResult(message.id, {});
     }
@@ -12858,16 +13192,16 @@ var init_acp = __esm(() => {
 });
 
 // ../agent-sessions/src/adapters/grok-acp/adapter.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function defaultGrokCommand(env) {
   const override = firstNonEmptyString(env?.GROK_CLI_BIN, process.env.GROK_CLI_BIN);
   if (override) {
     return override;
   }
-  const installed = join11(homedir10(), ".grok", "bin", "grok");
-  return existsSync10(installed) ? installed : "grok";
+  const installed = join12(homedir10(), ".grok", "bin", "grok");
+  return existsSync11(installed) ? installed : "grok";
 }
 function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -12942,9 +13276,9 @@ var init_grok_acp = __esm(() => {
 });
 
 // ../agent-sessions/src/adapters/kimi-acp/adapter.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -12973,10 +13307,10 @@ function defaultKimiCommand(env) {
     return override;
   }
   const installedCandidates = [
-    join12(homedir11(), ".kimi-code", "bin", "kimi"),
-    join12(homedir11(), ".local", "bin", "kimi")
+    join13(homedir11(), ".kimi-code", "bin", "kimi"),
+    join13(homedir11(), ".local", "bin", "kimi")
   ];
-  return installedCandidates.find((candidate) => existsSync11(candidate)) ?? "kimi";
+  return installedCandidates.find((candidate) => existsSync12(candidate)) ?? "kimi";
 }
 var DEFAULT_KIMI_ARGS, DEFAULT_KIMI_STARTUP_TIMEOUT_MS = 60000, KIMI_ACP_ADAPTER_TYPE = "kimi-acp", createAdapter5 = (config) => {
   const rawOptions = isRecord5(config.options) ? config.options : {};
@@ -15147,7 +15481,7 @@ var init_service = () => {};
 import { readFile as readFile4 } from "fs/promises";
 import { spawn as spawn3 } from "child_process";
 import { homedir as homedir12 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function discover(options = {}) {
   return (await discoverLocal(options))?.endpoint;
 }
@@ -15259,7 +15593,7 @@ async function stop(options = {}) {
     await kill(existing, options);
 }
 function fallback() {
-  return join13(process.env["XDG_STATE_HOME"] ?? join13(homedir12(), ".local", "state"), "opencode", "service.json");
+  return join14(process.env["XDG_STATE_HOME"] ?? join14(homedir12(), ".local", "state"), "opencode", "service.json");
 }
 function headers(endpoint) {
   if (endpoint.auth === undefined)
@@ -16108,9 +16442,9 @@ var init_normalizer4 = __esm(() => {
 });
 
 // ../agent-sessions/src/adapters/opencode-v2/adapter.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { homedir as homedir13 } from "os";
-import { basename as basename5, isAbsolute as isAbsolute2, join as join14, resolve as resolve3 } from "path";
+import { basename as basename5, isAbsolute as isAbsolute2, join as join15, resolve as resolve3 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 function deferred() {
   let resolvePromise;
@@ -16144,10 +16478,10 @@ function defaultOpenCodeV2Binary(env) {
   const candidates = [
     "/opt/homebrew/bin/opencode2",
     "/usr/local/bin/opencode2",
-    join14(home, ".opencode", "bin", "opencode2"),
-    join14(home, ".local", "bin", "opencode2")
+    join15(home, ".opencode", "bin", "opencode2"),
+    join15(home, ".local", "bin", "opencode2")
   ];
-  return candidates.find((candidate) => existsSync12(candidate)) ?? "opencode2";
+  return candidates.find((candidate) => existsSync13(candidate)) ?? "opencode2";
 }
 function modelRef(value, variantValue) {
   const raw = stringValue8(value);
@@ -17177,9 +17511,9 @@ var init_opencode_v2 = __esm(() => {
 
 // ../agent-sessions/src/adapters/opencode-acp/adapter.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -17210,10 +17544,10 @@ function defaultOpenCodeCommand(env) {
   const installedCandidates = [
     "/opt/homebrew/bin/opencode",
     "/usr/local/bin/opencode",
-    join15(homedir14(), ".opencode", "bin", "opencode"),
-    join15(homedir14(), ".local", "bin", "opencode")
+    join16(homedir14(), ".opencode", "bin", "opencode"),
+    join16(homedir14(), ".local", "bin", "opencode")
   ];
-  return installedCandidates.find((candidate) => existsSync13(candidate)) ?? "opencode";
+  return installedCandidates.find((candidate) => existsSync14(candidate)) ?? "opencode";
 }
 function configContentEnv(rawOptions, env) {
   const model = stringValue9(rawOptions.model);
@@ -17230,7 +17564,7 @@ function configContentEnv(rawOptions, env) {
   return { [OPENCODE_CONFIG_CONTENT_ENV]: JSON.stringify(overlay) };
 }
 function keychainSecret(name, commandOverride) {
-  const candidates = commandOverride ? [commandOverride] : ["secret", join15(homedir14(), ".local", "bin", "secret")];
+  const candidates = commandOverride ? [commandOverride] : ["secret", join16(homedir14(), ".local", "bin", "secret")];
   for (const command of candidates) {
     try {
       const result = spawnSync2(command, ["get", name], { encoding: "utf8", timeout: 5000 });
@@ -18296,184 +18630,6 @@ var init_src2 = __esm(() => {
   init_cost();
 });
 
-// ../runtime/src/node-identity.ts
-import {
-  createHash,
-  createPrivateKey,
-  createPublicKey,
-  generateKeyPairSync,
-  randomBytes,
-  sign,
-  verify
-} from "crypto";
-import {
-  chmodSync,
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync6,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { dirname as dirname7, join as join16 } from "path";
-function nodeIdentityPath(supportDirectory) {
-  const dir = supportDirectory ?? resolveOpenScoutSupportPaths().supportDirectory;
-  return join16(dir, NODE_IDENTITY_FILE);
-}
-function loadOrCreateNodeIdentity(supportDirectory) {
-  const path2 = nodeIdentityPath(supportDirectory);
-  if (existsSync14(path2)) {
-    return readAndValidateNodeIdentity(path2);
-  }
-  return createNodeIdentity(supportDirectory);
-}
-function readStableNodeQualifier(supportDirectory) {
-  const path2 = nodeIdentityPath(supportDirectory);
-  const cached = stableNodeQualifierCache.get(path2);
-  if (cached) {
-    return cached;
-  }
-  if (!existsSync14(path2)) {
-    return null;
-  }
-  const nodeQualifier = normalizeNodeQualifier(readAndValidateNodeIdentity(path2).nodeQualifier);
-  if (nodeQualifier) {
-    stableNodeQualifierCache.set(path2, nodeQualifier);
-  }
-  return nodeQualifier || null;
-}
-function readAndValidateNodeIdentity(path2) {
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync6(path2, "utf8"));
-  } catch {
-    throw new Error(`Corrupt node identity at ${path2}; remove it to generate a fresh one.`);
-  }
-  if (parsed.version !== 1 || !parsed.publicKey || !parsed.privateKey) {
-    throw new Error(`Corrupt node identity at ${path2}; remove it to generate a fresh one.`);
-  }
-  if (parsed.nodeQualifier !== undefined && normalizeNodeQualifier(parsed.nodeQualifier) !== parsed.nodeQualifier) {
-    throw new Error(`Corrupt node identity at ${path2}; remove it to generate a fresh one.`);
-  }
-  try {
-    const derived = createPublicKey(importPrivateKey(parsed.privateKey)).export({ type: "spki", format: "der" }).toString("base64");
-    if (derived !== parsed.publicKey) {
-      throw new Error("mismatch");
-    }
-  } catch {
-    throw new Error(`Node identity at ${path2} has mismatched or invalid keys; remove it to generate a fresh one.`);
-  }
-  return parsed;
-}
-function normalizeNodeQualifier(value) {
-  return typeof value === "string" ? value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "") : "";
-}
-function createNodeIdentity(supportDirectory) {
-  if (!supportDirectory) {
-    assertTestIsolatedUserData("write the node identity", "OPENSCOUT_SUPPORT_DIRECTORY");
-  }
-  const path2 = nodeIdentityPath(supportDirectory);
-  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
-  const identity = {
-    version: 1,
-    publicKey: publicKey.export({ type: "spki", format: "der" }).toString("base64"),
-    privateKey: privateKey.export({ type: "pkcs8", format: "der" }).toString("base64"),
-    createdAt: Date.now()
-  };
-  mkdirSync4(dirname7(path2), { recursive: true });
-  try {
-    writeFileSync4(path2, `${JSON.stringify(identity, null, 2)}
-`, { encoding: "utf8", mode: 384, flag: "wx" });
-  } catch (error) {
-    if (error.code === "EEXIST") {
-      return readAndValidateNodeIdentity(path2);
-    }
-    throw error;
-  }
-  try {
-    chmodSync(path2, 384);
-  } catch {}
-  return identity;
-}
-function nodeKeyId(publicKeyBase64) {
-  return createHash("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest("hex");
-}
-function nodeFingerprint(publicKeyBase64) {
-  const digest = createHash("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest();
-  const encoded = base32Encode(digest.subarray(0, 10)).toLowerCase();
-  return `${NODE_FINGERPRINT_PREFIX}:${encoded.slice(0, 4)}-${encoded.slice(4, 8)}`;
-}
-function signNodePayload(identity, payload) {
-  const key = importPrivateKey(identity.privateKey);
-  return sign(null, typeof payload === "string" ? Buffer.from(payload, "utf8") : payload, key).toString("base64");
-}
-function verifyNodeSignature(publicKeyBase64, payload, signatureBase64) {
-  try {
-    const key = importPublicKey(publicKeyBase64);
-    return verify(null, typeof payload === "string" ? Buffer.from(payload, "utf8") : payload, key, Buffer.from(signatureBase64, "base64"));
-  } catch {
-    return false;
-  }
-}
-function canonicalJson(value) {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map(canonicalJson).join(",")}]`;
-  }
-  const record2 = value;
-  const keys = Object.keys(record2).sort();
-  return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record2[key])}`).join(",")}}`;
-}
-function verifySignedNodeCard(card, now = Date.now()) {
-  if (nodeKeyId(card.publicKey) !== card.keyId) {
-    return false;
-  }
-  if (nodeFingerprint(card.publicKey) !== card.fingerprint) {
-    return false;
-  }
-  if (!Number.isFinite(card.expiresAt) || card.expiresAt <= now) {
-    return false;
-  }
-  if (card.tls !== undefined) {
-    if (typeof card.tls !== "object" || card.tls === null || typeof card.tls.spkiFingerprint !== "string" || !/^[0-9a-f]{64}$/.test(card.tls.spkiFingerprint)) {
-      return false;
-    }
-  }
-  const { signature, ...unsigned } = card;
-  return verifyNodeSignature(card.publicKey, canonicalJson(unsigned), signature);
-}
-function base32Encode(input) {
-  let bits = 0;
-  let value = 0;
-  let output = "";
-  for (const byte of input) {
-    value = value << 8 | byte;
-    bits += 8;
-    while (bits >= 5) {
-      output += BASE32_ALPHABET[value >>> bits - 5 & 31];
-      bits -= 5;
-    }
-  }
-  if (bits > 0) {
-    output += BASE32_ALPHABET[value << 5 - bits & 31];
-  }
-  return output;
-}
-function importPrivateKey(privateKeyBase64) {
-  return createPrivateKey({ key: Buffer.from(privateKeyBase64, "base64"), format: "der", type: "pkcs8" });
-}
-function importPublicKey(publicKeyBase64) {
-  return createPublicKey({ key: Buffer.from(publicKeyBase64, "base64"), format: "der", type: "spki" });
-}
-var NODE_IDENTITY_FILE = "node-identity.json", NODE_FINGERPRINT_PREFIX = "osc1", NODE_CARD_TTL_MS, stableNodeQualifierCache, BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-var init_node_identity = __esm(() => {
-  init_support_paths();
-  NODE_CARD_TTL_MS = 24 * 60 * 60 * 1000;
-  stableNodeQualifierCache = new Map;
-});
-
 // ../../node_modules/.bun/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
 var require_Reflect = __commonJS(() => {
   /*! *****************************************************************************
@@ -28831,6 +28987,9 @@ function defaultSettings() {
       quickHits: [],
       preparedAt: null
     },
+    voice: {
+      realtimeEnabled: false
+    },
     ui: {
       scenes: [],
       activeSceneIdBySurface: {}
@@ -29218,6 +29377,7 @@ async function normalizeSettingsRecord(value, options = {}) {
   const telegram = typeof bridges.telegram === "object" && bridges.telegram ? bridges.telegram : {};
   const network = typeof candidate.network === "object" && candidate.network ? candidate.network : {};
   const phone = typeof candidate.phone === "object" && candidate.phone ? candidate.phone : {};
+  const voice = typeof candidate.voice === "object" && candidate.voice ? candidate.voice : {};
   const ui = typeof candidate.ui === "object" && candidate.ui ? candidate.ui : {};
   const oldOperatorName = typeof candidate.operatorName === "string" ? candidate.operatorName : undefined;
   const seededWorkspaceRoots = await seedWorkspaceRoots({
@@ -29290,6 +29450,9 @@ async function normalizeSettingsRecord(value, options = {}) {
       quickHits: normalizeStringList(phone.quickHits),
       preparedAt: normalizeOptionalTimestamp(phone.preparedAt)
     },
+    voice: {
+      realtimeEnabled: typeof voice.realtimeEnabled === "boolean" ? voice.realtimeEnabled : base.voice.realtimeEnabled
+    },
     ui: normalizeUi(ui)
   };
 }
@@ -30482,21 +30645,45 @@ var init_permission_policy2 = __esm(() => {
 });
 
 // ../runtime/src/user-config.ts
-import { existsSync as existsSync26, readFileSync as readFileSync13, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync13, statSync as statSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir24 } from "os";
 import { dirname as dirname16, join as join30 } from "path";
 function userConfigPath() {
   return join30(process.env.OPENSCOUT_HOME ?? join30(homedir24(), ".openscout"), "user.json");
 }
-function loadUserConfig() {
-  const configPath = userConfigPath();
-  if (!existsSync26(configPath))
-    return {};
+function userConfigFileKey(configPath) {
   try {
-    return JSON.parse(readFileSync13(configPath, "utf8"));
+    const stats = statSync7(configPath);
+    return `${stats.ino}:${stats.mtimeMs}:${stats.size}`;
   } catch {
-    return {};
+    return "missing";
+  }
+}
+function readUserConfigFromDisk(configPath, now) {
+  const fileKey = userConfigFileKey(configPath);
+  let value = {};
+  if (existsSync26(configPath)) {
+    try {
+      value = JSON.parse(readFileSync13(configPath, "utf8"));
+    } catch {
+      value = {};
+    }
   }
+  userConfigCache = { path: configPath, value, fileKey, statCheckedAt: now };
+  return { ...value };
+}
+function loadUserConfig(now = Date.now()) {
+  const configPath = userConfigPath();
+  if (userConfigCache && userConfigCache.path === configPath) {
+    if (now - userConfigCache.statCheckedAt < USER_CONFIG_STAT_INTERVAL_MS) {
+      return { ...userConfigCache.value };
+    }
+    if (userConfigFileKey(configPath) === userConfigCache.fileKey) {
+      userConfigCache.statCheckedAt = now;
+      return { ...userConfigCache.value };
+    }
+  }
+  return readUserConfigFromDisk(configPath, now);
 }
 function readSettingsOperatorName() {
   const settingsPath = resolveOpenScoutSupportPaths().settingsPath;
@@ -30521,6 +30708,7 @@ function resolveOperatorHandle() {
   const config = loadUserConfig();
   return normalizeHandle(config.handle) || normalizeHandle(process.env.OPENSCOUT_OPERATOR_HANDLE) || normalizeHandle(config.name) || normalizeHandle(process.env.OPENSCOUT_OPERATOR_NAME) || normalizeHandle(process.env.USER) || "operator";
 }
+var userConfigCache = null, USER_CONFIG_STAT_INTERVAL_MS = 100;
 var init_user_config = __esm(() => {
   init_support_paths();
 });
@@ -30923,6 +31111,13 @@ async function readLocalAgentRegistry() {
     localAgentRecordFromRelayAgentOverride(agentId, override)
   ]));
 }
+function invalidateArchivedLocalAgentIdsCache() {
+  archivedLocalAgentIdsCache = null;
+}
+async function writeRelayAgentOverrides2(overrides) {
+  await writeRelayAgentOverrides(overrides);
+  invalidateArchivedLocalAgentIdsCache();
+}
 async function writeLocalAgentRegistry(registry2) {
   const overrides = await readRelayAgentOverrides();
   const nextOverrides = {
@@ -30931,7 +31126,7 @@ async function writeLocalAgentRegistry(registry2) {
   for (const [agentId, record2] of Object.entries(registry2)) {
     nextOverrides[agentId] = relayAgentOverrideFromLocalAgentRecord(agentId, record2, overrides[agentId]);
   }
-  await writeRelayAgentOverrides(nextOverrides);
+  await writeRelayAgentOverrides2(nextOverrides);
 }
 function expandHomePath4(value) {
   if (value === "~") {
@@ -31805,7 +32000,7 @@ async function updateLocalAgentCardLifecycle(agentId, input) {
     ...override,
     card: lifecycle
   };
-  await writeRelayAgentOverrides(overrides);
+  await writeRelayAgentOverrides2(overrides);
   return lifecycle;
 }
 function oneTimeCardCreatedAt(lifecycle) {
@@ -31858,7 +32053,7 @@ async function retireLocalAgentOverrides(overrides, agentIds) {
     delete overrides[agentId];
   }
   if (retired.length > 0) {
-    await writeRelayAgentOverrides(overrides);
+    await writeRelayAgentOverrides2(overrides);
   }
   return retired;
 }
@@ -31903,7 +32098,7 @@ async function retireLocalAgent(agentId) {
   await stopLocalAgent(agentId).catch(() => null);
   const nextOverrides = { ...overrides };
   delete nextOverrides[agentId];
-  await writeRelayAgentOverrides(nextOverrides);
+  await writeRelayAgentOverrides2(nextOverrides);
   return {
     ...status,
     isOnline: false
@@ -32557,7 +32752,7 @@ async function startLocalAgent(input) {
         wakePolicy: "on_demand"
       }
     };
-    await writeRelayAgentOverrides(overrides);
+    await writeRelayAgentOverrides2(overrides);
     targetAgentId = instance2.id;
   } else if (requestedDefinitionId && requestedDefinitionId !== matchingOverride.definitionId) {
     const matchingProjectRoot = normalizeProjectPath(matchingOverride.projectRoot);
@@ -32609,7 +32804,7 @@ async function startLocalAgent(input) {
         wakePolicy: "on_demand"
       }
     };
-    await writeRelayAgentOverrides(overrides);
+    await writeRelayAgentOverrides2(overrides);
     targetAgentId = instance2.id;
   } else {
     const operatorAugmentDefaults = operatorAugmentDefaultsForDefinitionId(matchingOverride.definitionId ?? requestedDefinitionId);
@@ -32646,7 +32841,7 @@ async function startLocalAgent(input) {
           wakePolicy: "on_demand"
         } : matchingOverride.runtime
       };
-      await writeRelayAgentOverrides(overrides);
+      await writeRelayAgentOverrides2(overrides);
     }
     targetAgentId = matchingAgentId;
   }
@@ -33032,7 +33227,7 @@ async function ensureLocalAgentBindingOnline(agentId, nodeId, options = {}) {
   const onlineRecord = await ensureLocalAgentOnline(agentId, recordForHarness(localAgentRecordFromRelayAgentOverride(agentId, override), options.harness));
   return buildLocalAgentBinding(agentId, onlineRecord, isLocalAgentRecordOnline(agentId, onlineRecord), nodeId, "relay-agent-registry");
 }
-var MODULE_DIRECTORY, OPENSCOUT_REPO_ROOT, DEFAULT_LOCAL_AGENT_CAPABILITIES, DEFAULT_LOCAL_AGENT_HARNESS = "claude", DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS, SUPPORTED_SCOUT_HARNESSES, DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS, localAgentOnlineFlights, TMUX_VERIFY_IDLE_DEADLINE_MS, TMUX_VERIFY_BUSY_DEADLINE_MS, TMUX_DEFAULT_COLUMNS, TMUX_DEFAULT_ROWS, TMUX_READY_TIMEOUT_MS = 20000, TMUX_READY_POLL_MS = 250, TMUX_READY_TAIL_LINES = 80;
+var MODULE_DIRECTORY, OPENSCOUT_REPO_ROOT, DEFAULT_LOCAL_AGENT_CAPABILITIES, DEFAULT_LOCAL_AGENT_HARNESS = "claude", DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS, SUPPORTED_SCOUT_HARNESSES, archivedLocalAgentIdsCache = null, DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS, localAgentOnlineFlights, TMUX_VERIFY_IDLE_DEADLINE_MS, TMUX_VERIFY_BUSY_DEADLINE_MS, TMUX_DEFAULT_COLUMNS, TMUX_DEFAULT_ROWS, TMUX_READY_TIMEOUT_MS = 20000, TMUX_READY_POLL_MS = 250, TMUX_READY_TAIL_LINES = 80;
 var init_local_agents = __esm(() => {
   init_secret_redaction();
   init_codex_executable();
@@ -33090,7 +33285,7 @@ var init_local_agents = __esm(() => {
 // ../web/server/core/pairing/runtime/config.ts
 init_local_config();
 init_open_scout_network();
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import path from "path";
 var PAIRING_QR_TTL_MS = 5 * 60 * 1000;
@@ -33108,11 +33303,11 @@ function pairingPaths() {
 }
 function loadPairingConfig() {
   const { configPath } = pairingPaths();
-  if (!existsSync3(configPath)) {
+  if (!existsSync4(configPath)) {
     return {};
   }
   try {
-    const payload = JSON.parse(readFileSync3(configPath, "utf8"));
+    const payload = JSON.parse(readFileSync4(configPath, "utf8"));
     return typeof payload === "object" && payload ? payload : {};
   } catch {
     return {};
@@ -34476,7 +34671,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join5(chunks, separator) {
+  function join6(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== undefined) {
@@ -34486,7 +34681,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join5;
+  sql2.join = join6;
   function identifier(value) {
     return new Name(value);
   }
@@ -37428,10 +37623,12 @@ class InMemoryControlRuntime {
   }
 }
 // ../runtime/src/sqlite-store.ts
+init_node_identity();
 init_sqlite_adapter();
 
 // ../runtime/src/control-plane-migrations.ts
 init_support_paths();
+init_node_identity();
 
 // ../runtime/src/budget-observations.ts
 var QUOTA_HISTORY_BUCKET_MS = 60 * 60 * 1000;
@@ -57313,7 +57510,7 @@ function writeJsonAtomically(filePath, value) {
 
 // ../web/server/core/pairing/runtime/runtime.ts
 init_src2();
-import { homedir as homedir41 } from "os";
+import { homedir as homedir40 } from "os";
 
 // ../web/server/core/pairing/runtime/bridge/bridge.ts
 init_src2();
@@ -57488,7 +57685,7 @@ function resolveConfig() {
 
 // ../web/server/core/pairing/runtime/bridge/fileserver.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync33, mkdirSync as mkdirSync15, readFileSync as readFileSync20, realpathSync as realpathSync4, statSync as statSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync15, readFileSync as readFileSync20, realpathSync as realpathSync4, statSync as statSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { BlockList, isIP } from "net";
 import { isAbsolute as isAbsolute6, join as join38, relative as relative5, sep as sep2 } from "path";
 import { homedir as homedir30 } from "os";
@@ -57554,7 +57751,7 @@ function readAuthorizedWebHandoff(token, scope) {
 
 // ../web/server/core/pairing/runtime/bridge/artifact-presentation.ts
 import { randomBytes as randomBytes7 } from "crypto";
-import { realpathSync as realpathSync3, statSync as statSync7 } from "fs";
+import { realpathSync as realpathSync3, statSync as statSync8 } from "fs";
 import { basename as basename11, dirname as dirname19, isAbsolute as isAbsolute5, relative as relative4, resolve as resolve14, sep } from "path";
 var ARTIFACT_PRESENTATION_PATH_PREFIX = "/present/";
 var ARTIFACT_PRESENTATION_DEFAULT_TTL_MS = 30 * 60 * 1000;
@@ -57571,14 +57768,14 @@ function createArtifactPresentation(input, options) {
   if (!isPathInside2(allowedRoot, sourcePath)) {
     throw new Error("sourcePath is outside the session workspace");
   }
-  const source = statSync7(sourcePath);
+  const source = statSync8(sourcePath);
   const rootPath = source.isDirectory() ? sourcePath : dirname19(sourcePath);
   const entryPath = normalizeRelativeEntry(source.isDirectory() ? input.entryPath?.trim() || "index.html" : basename11(sourcePath));
   const entryTarget = requiredRealPath(resolve14(rootPath, entryPath), "entryPath");
   if (!isPathInside2(rootPath, entryTarget)) {
     throw new Error("entryPath leaves the presentation root");
   }
-  if (!statSync7(entryTarget).isFile()) {
+  if (!statSync8(entryTarget).isFile()) {
     throw new Error("entryPath must name a file");
   }
   const id = `present-${randomBytes7(24).toString("base64url")}`;
@@ -57622,14 +57819,14 @@ function serveArtifactPresentation(req, url, now = Date.now()) {
   if (!isPathInside2(grant.rootPath, target2)) {
     return presentationResponse("Forbidden", 403);
   }
-  const targetStat = statSync7(target2);
+  const targetStat = statSync8(target2);
   if (targetStat.isDirectory()) {
     try {
       target2 = requiredRealPath(resolve14(target2, "index.html"), "artifact index");
     } catch {
       return presentationResponse("Not found", 404);
     }
-    if (!isPathInside2(grant.rootPath, target2) || !statSync7(target2).isFile()) {
+    if (!isPathInside2(grant.rootPath, target2) || !statSync8(target2).isFile()) {
       return presentationResponse("Not found", 404);
     }
   } else if (!targetStat.isFile()) {
@@ -57689,7 +57886,7 @@ function normalizeRelativeEntry(value) {
 }
 function requiredRealDirectory(path2, label) {
   const real2 = requiredRealPath(path2, label);
-  if (!statSync7(real2).isDirectory()) {
+  if (!statSync8(real2).isDirectory()) {
     throw new Error(`${label} must be a directory`);
   }
   return real2;
@@ -57937,7 +58134,7 @@ function resolveAllowedFile(filePath) {
       return { status: "forbidden" };
     }
     try {
-      return statSync8(candidate).isFile() ? { status: "allowed", path: candidate } : { status: "missing" };
+      return statSync9(candidate).isFile() ? { status: "allowed", path: candidate } : { status: "missing" };
     } catch {
       return { status: "missing" };
     }
@@ -58571,15 +58768,15 @@ function formatTimestamp(value) {
 // ../web/server/core/pairing/runtime/bridge/server.ts
 init_system_probes();
 init_src2();
-import { readdirSync as readdirSync6, readFileSync as readFileSync25, realpathSync as realpathSync5, statSync as statSync12 } from "fs";
-import { basename as basename13, isAbsolute as isAbsolute7, join as join47, relative as relative6, resolve as resolve18 } from "path";
-import { homedir as homedir38 } from "os";
+import { readdirSync as readdirSync6, readFileSync as readFileSync24, realpathSync as realpathSync5, statSync as statSync13 } from "fs";
+import { basename as basename13, isAbsolute as isAbsolute7, join as join46, relative as relative6, resolve as resolve18 } from "path";
+import { homedir as homedir37 } from "os";
 
 // ../web/server/core/mobile/service.ts
 init_src();
 init_harness_catalog();
 import { basename as basename12, resolve as resolve17 } from "path";
-import { statSync as statSync11 } from "fs";
+import { statSync as statSync12 } from "fs";
 init_setup();
 
 // ../runtime/src/agent-workspace.ts
@@ -58649,6 +58846,372 @@ init_user_config();
 // ../web/server/core/broker/paths.ts
 init_src();
 
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/utils/url.js
+var splitPath = (path2) => {
+  const paths2 = path2.split("/");
+  if (paths2[0] === "") {
+    paths2.shift();
+  }
+  return paths2;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path: path2 } = extractGroupsFromPath(routePath);
+  const paths2 = splitPath(path2);
+  return replaceGroupMarks(paths2, groups);
+};
+var extractGroupsFromPath = (path2) => {
+  const groups = [];
+  path2 = path2.replace(/\{[^}]+\}/g, (match, index2) => {
+    const mark = `@${index2}`;
+    groups.push([mark, match]);
+    return mark;
+  });
+  return { groups, path: path2 };
+};
+var replaceGroupMarks = (paths2, groups) => {
+  for (let i = groups.length - 1;i >= 0; i--) {
+    const [mark] = groups[i];
+    for (let j = paths2.length - 1;j >= 0; j--) {
+      if (paths2[j].includes(mark)) {
+        paths2[j] = paths2[j].replace(mark, groups[i][1]);
+        break;
+      }
+    }
+  }
+  return paths2;
+};
+var patternCache = {};
+var getPattern = (label, next) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
+      if (match[2]) {
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
+      } else {
+        patternCache[cacheKey] = [label, match[1], true];
+      }
+    }
+    return patternCache[cacheKey];
+  }
+  return null;
+};
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decoder(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+};
+var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+var getPath = (request) => {
+  const url = request.url;
+  const start = url.indexOf("/", url.indexOf(":") + 4);
+  let i = start;
+  for (;i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const hashIndex = url.indexOf("#", i);
+      const end = queryIndex === -1 ? hashIndex === -1 ? undefined : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+      const path2 = url.slice(start, end);
+      return tryDecodeURI(path2.includes("%25") ? path2.replace(/%25/g, "%2525") : path2);
+    } else if (charCode === 63 || charCode === 35) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (base, sub, ...rest) => {
+  if (rest.length) {
+    sub = mergePath(sub, ...rest);
+  }
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+};
+var checkOptionalParameter = (path2) => {
+  if (path2.charCodeAt(path2.length - 1) !== 63 || !path2.includes(":")) {
+    return null;
+  }
+  const segments = path2.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment)) {
+      basePath += "/" + segment;
+    } else if (/\:/.test(segment)) {
+      if (/\?/.test(segment)) {
+        if (results.length === 0 && basePath === "") {
+          results.push("/");
+        } else {
+          results.push(basePath);
+        }
+        const optionalSegment = segment.replace("?", "");
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else {
+        basePath += "/" + segment;
+      }
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var _decodeURI = (value) => {
+  if (!/[%+]/.test(value)) {
+    return value;
+  }
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
+};
+var _getQueryParam = (url, key, multiple) => {
+  let encoded;
+  if (!multiple && key && !/[%+]/.test(key)) {
+    let keyIndex2 = url.indexOf("?", 8);
+    if (keyIndex2 === -1) {
+      return;
+    }
+    if (!url.startsWith(key, keyIndex2 + 1)) {
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? undefined : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return;
+    }
+  }
+  const results = {};
+  encoded ??= /[%+]/.test(url);
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1;
+    }
+    let name2 = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? undefined : nextKeyIndex : valueIndex);
+    if (encoded) {
+      name2 = _decodeURI(name2);
+    }
+    keyIndex = nextKeyIndex;
+    if (name2 === "") {
+      continue;
+    }
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? undefined : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
+    }
+    if (multiple) {
+      if (!(results[name2] && Array.isArray(results[name2]))) {
+        results[name2] = [];
+      }
+      results[name2].push(value);
+    } else {
+      results[name2] ??= value;
+    }
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/middleware/serve-static/index.js
+var ENCODINGS = {
+  br: ".br",
+  zstd: ".zst",
+  gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/utils/constants.js
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/helper/ssg/middleware.js
+var X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
+var SSG_DISABLED_RESPONSE = (() => {
+  try {
+    return new Response("SSG is disabled", {
+      status: 404,
+      headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
+    });
+  } catch {
+    return null;
+  }
+})();
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks);
+  } else {
+    return resStr;
+  }
+};
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/adapter/bun/ssg.js
+var { write: write3 } = Bun;
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/helper/websocket/index.js
+var WSContext = class {
+  #init;
+  constructor(init) {
+    this.#init = init;
+    this.raw = init.raw;
+    this.url = init.url ? new URL(init.url) : null;
+    this.protocol = init.protocol ?? null;
+  }
+  send(source, options) {
+    this.#init.send(source, options ?? {});
+  }
+  raw;
+  binaryType = "arraybuffer";
+  get readyState() {
+    return this.#init.readyState;
+  }
+  url;
+  protocol;
+  close(code, reason) {
+    this.#init.close(code, reason);
+  }
+};
+var defineWebSocketHelper = (handler) => {
+  return (...args) => {
+    if (typeof args[0] === "function") {
+      const [createEvents, options] = args;
+      return async function upgradeWebSocket(c, next) {
+        const events2 = await createEvents(c);
+        const result = await handler(c, events2, options);
+        if (result) {
+          return result;
+        }
+        await next();
+      };
+    } else {
+      const [c, events2, options] = args;
+      return (async () => {
+        const upgraded = await handler(c, events2, options);
+        if (!upgraded) {
+          throw new Error("Failed to upgrade WebSocket");
+        }
+        return upgraded;
+      })();
+    }
+  };
+};
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/adapter/bun/server.js
+var getBunServer = (c) => ("server" in c.env) ? c.env.server : c.env;
+
+// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/adapter/bun/websocket.js
+var upgradeWebSocket = defineWebSocketHelper((c, events2) => {
+  const server = getBunServer(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  const upgradeResult = server.upgrade(c.req.raw, {
+    data: {
+      events: events2,
+      url: new URL(c.req.url),
+      protocol: c.req.url
+    }
+  });
+  if (upgradeResult) {
+    return new Response(null);
+  }
+  return;
+});
+
+// ../web/server/server-core.ts
+function coalesce(fn, ttlMs = 2000) {
+  let inflight = null;
+  let cached = null;
+  return () => {
+    if (cached && Date.now() < cached.expiresAt) {
+      return Promise.resolve(cached.value);
+    }
+    if (inflight) {
+      return inflight;
+    }
+    inflight = fn().then((value) => {
+      cached = { value, expiresAt: Date.now() + ttlMs };
+      inflight = null;
+      return value;
+    }).catch((error) => {
+      inflight = null;
+      throw error;
+    });
+    return inflight;
+  };
+}
+var SCOUT_API_LOG_ALL = process.env.SCOUT_PERF_LOG_API === "1";
+
 // ../web/server/core/broker/service.ts
 var DEFAULT_SCOUT_BROKER_SNAPSHOT_WINDOW_MS = 24 * 60 * 60 * 1000;
 var DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS = 60 * 1000;
@@ -58879,6 +59442,7 @@ async function readScoutBrokerHealth(baseUrl = resolveScoutBrokerUrl(), options
       build: health.build ?? null,
       services: health.services ?? null,
       projection: health.projection ?? null,
+      startup: health.startup ?? null,
       counts: health.counts ? {
         nodes: health.counts.nodes ?? 0,
         actors: health.counts.actors ?? 0,
@@ -58911,6 +59475,7 @@ async function readScoutBrokerHealth(baseUrl = resolveScoutBrokerUrl(), options
       build: null,
       services: null,
       projection: null,
+      startup: null,
       counts: null,
       error: error instanceof Error ? error.message : null
     };
@@ -58951,6 +59516,13 @@ async function readScoutBrokerTailRecent(limit = 50, baseUrl = resolveScoutBroke
     return [];
   }
 }
+var readScoutBrokerNodeIdCoalesced = coalesce(async () => {
+  const node = await brokerReadJson(resolveScoutBrokerUrl(), scoutBrokerPaths.v1.node);
+  if (!node?.id) {
+    throw new Error("broker /v1/node returned no node id");
+  }
+  return node.id;
+}, 30000);
 async function recordScoutBrokerReadCursor(input, baseUrl = resolveScoutBrokerUrl()) {
   const path2 = `${scoutBrokerPaths.v1.conversations}/${encodeURIComponent(input.conversationId)}/read-cursors`;
   return brokerPostJson(baseUrl, path2, {
@@ -58961,7 +59533,15 @@ async function recordScoutBrokerReadCursor(input, baseUrl = resolveScoutBrokerUr
 }
 async function loadScoutBrokerContext(baseUrl = resolveScoutBrokerUrl(), options = {}) {
   const since = options.since === undefined ? Math.floor((Date.now() - DEFAULT_SCOUT_BROKER_SNAPSHOT_WINDOW_MS) / DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS) * DEFAULT_SCOUT_BROKER_SNAPSHOT_BUCKET_MS : options.since;
-  const cacheKey = options.signal ? null : [baseUrl, resolveBrokerSocketPathForBaseUrl(baseUrl) ?? "http", since ?? "full"].join("\x00");
+  if (options.force) {
+    invalidateScoutBrokerContextCache(baseUrl);
+  }
+  const cacheKey = options.signal ? null : [
+    baseUrl,
+    resolveBrokerSocketPathForBaseUrl(baseUrl) ?? "http",
+    since ?? "full",
+    options.scope ?? "default"
+  ].join("\x00");
   const now = Date.now();
   for (const [key, entry] of scoutBrokerContextCache) {
     if (entry.expiresAt <= now)
@@ -58976,7 +59556,13 @@ async function loadScoutBrokerContext(baseUrl = resolveScoutBrokerUrl(), options
     if (!health.reachable || !health.ok) {
       return null;
     }
-    const snapshotPath = since && since > 0 ? `${scoutBrokerPaths.v1.snapshot}?since=${Math.trunc(since)}` : scoutBrokerPaths.v1.snapshot;
+    const snapshotQuery = new URLSearchParams;
+    if (since && since > 0)
+      snapshotQuery.set("since", String(Math.trunc(since)));
+    if (options.scope)
+      snapshotQuery.set("scope", options.scope);
+    const queryString = snapshotQuery.toString();
+    const snapshotPath = queryString ? `${scoutBrokerPaths.v1.snapshot}?${queryString}` : scoutBrokerPaths.v1.snapshot;
     try {
       const [node, snapshot] = await Promise.all([
         brokerReadJson(baseUrl, scoutBrokerPaths.v1.node, { signal: options.signal }),
@@ -59756,8 +60342,8 @@ async function watchScoutMessages(options) {
     const messagesById = new Map(Object.values(broker2.snapshot.messages ?? {}).map((message) => [message.id, message]));
     const invocationsById = new Map(Object.values(broker2.snapshot.invocations ?? {}).map((invocation) => [invocation.id, invocation]));
     const clientMessageIdFor = (message) => {
-      const raw = message?.metadata?.clientMessageId;
-      return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : null;
+      const raw2 = message?.metadata?.clientMessageId;
+      return typeof raw2 === "string" && raw2.trim().length > 0 ? raw2.trim() : null;
     };
     const lifecycleStateForFlight = (state) => {
       switch (state) {
@@ -60659,10 +61245,10 @@ init_claude_statusline();
 init_pi_rpc();
 init_system_probes();
 import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync35, mkdirSync as mkdirSync16, readdirSync as readdirSync5, readFileSync as readFileSync21, renameSync as renameSync5, statSync as statSync9, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync16, readdirSync as readdirSync5, readFileSync as readFileSync21, renameSync as renameSync5, statSync as statSync10, writeFileSync as writeFileSync12 } from "fs";
 import { open } from "fs/promises";
 import { homedir as homedir33 } from "os";
-import { dirname as dirname20, join as join41 } from "path";
+import { dirname as dirname21, join as join41 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { Database as Database3 } from "bun:sqlite";
 var CACHE_TTL_MS = 60 * 1000;
@@ -61205,6 +61791,7 @@ function storedQuotaWindowGauge(row, history = []) {
     label: formatStoredQuotaWindowLabel(row),
     ...usage,
     resetAt,
+    ...windowMs === undefined ? {} : { windowMs },
     capturedAt: row.capturedAt,
     source: quotaSnapshotSourceLabel(row),
     ...history.length === 0 ? {} : { history }
@@ -61430,13 +62017,13 @@ function kimiWindowMs(window2) {
   return null;
 }
 function kimiMembershipPlan(payload) {
-  const raw = stringValue10(payload.user?.membership?.level);
-  if (!raw)
+  const raw2 = stringValue10(payload.user?.membership?.level);
+  if (!raw2)
     return;
-  return raw.replace(/^LEVEL_/u, "").toLowerCase().replace(/(^|_)([a-z])/gu, (_match, prefix, letter) => `${prefix ? " " : ""}${letter.toUpperCase()}`);
+  return raw2.replace(/^LEVEL_/u, "").toLowerCase().replace(/(^|_)([a-z])/gu, (_match, prefix, letter) => `${prefix ? " " : ""}${letter.toUpperCase()}`);
 }
 function dashboardImportPath() {
-  return join41(dirname20(resolveDbPath()), "provider-usage-snapshots.json");
+  return join41(dirname21(resolveDbPath()), "provider-usage-snapshots.json");
 }
 function readDashboardUsageStore() {
   const record2 = readJsonRecord(dashboardImportPath());
@@ -62176,7 +62763,7 @@ function homeDir() {
 }
 function safeStat(path2) {
   try {
-    return statSync9(path2);
+    return statSync10(path2);
   } catch {
     return null;
   }
@@ -62419,7 +63006,7 @@ init_src();
 init_support_paths();
 import { mkdir as mkdir10, readFile as readFile11, writeFile as writeFile8 } from "fs/promises";
 import { randomUUID as randomUUID5 } from "crypto";
-import { dirname as dirname21, join as join42 } from "path";
+import { dirname as dirname22, join as join42 } from "path";
 class ScoutbotThreadMapStore {
   filePath;
   constructor(filePath = defaultScoutbotThreadMapPath()) {
@@ -62535,8 +63122,8 @@ class ScoutbotThreadMapStore {
   }
   async read() {
     try {
-      const raw = await readFile11(this.filePath, "utf8");
-      const parsed = JSON.parse(raw);
+      const raw2 = await readFile11(this.filePath, "utf8");
+      const parsed = JSON.parse(raw2);
       const threads = Array.isArray(parsed.threads) ? parsed.threads.filter(isThreadRecord).map((thread) => ({
         ...thread,
         transportSessionId: normalizeSessionId(thread.transportSessionId)
@@ -62554,7 +63141,7 @@ class ScoutbotThreadMapStore {
     }
   }
   async write(map) {
-    await mkdir10(dirname21(this.filePath), { recursive: true });
+    await mkdir10(dirname22(this.filePath), { recursive: true });
     await writeFile8(this.filePath, `${JSON.stringify(map, null, 2)}
 `, "utf8");
   }
@@ -62952,121 +63539,19 @@ function describeError(cause) {
 
 // ../web/server/pairing.ts
 import {
-  existsSync as existsSync37,
-  mkdirSync as mkdirSync18,
-  readFileSync as readFileSync23,
-  statSync as statSync10,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync14
-} from "fs";
-import { homedir as homedir35 } from "os";
-import { dirname as dirname23, join as join44, resolve as resolve15 } from "path";
-init_setup();
-
-// ../runtime/src/pairing-supervisor.ts
-import { execFileSync as execFileSync6 } from "child_process";
-import { randomUUID as randomUUID6 } from "crypto";
-import {
+  closeSync,
   existsSync as existsSync36,
   mkdirSync as mkdirSync17,
+  openSync,
   readFileSync as readFileSync22,
-  renameSync as renameSync6,
-  rmSync as rmSync4,
+  readSync,
+  statSync as statSync11,
+  unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync13
 } from "fs";
 import { homedir as homedir34 } from "os";
-import { dirname as dirname22, join as join43 } from "path";
-var SCOUT_PAIRING_SUPERVISOR_INTENT_FILE = "supervisor.json";
-var SCOUT_PAIRING_RUNTIME_PID_FILE = "runtime.pid";
-var SCOUT_PAIRING_RUNTIME_OWNER_FILE = "runtime-owner.json";
-var SCOUT_PAIRING_SUPERVISOR_PID_FILE = "supervisor.pid";
-var SCOUT_PAIRING_RUNTIME_PROCESS_MARKER = "pairing-runtime-controller";
-function resolveScoutPairingSupervisorPaths(env = process.env) {
-  const configuredRoot = env.OPENSCOUT_PAIRING_HOME?.trim() || env.SCOUT_PAIRING_HOME?.trim();
-  const rootDir = configuredRoot || join43(homedir34(), ".scout", "pairing");
-  return {
-    rootDir,
-    intentPath: join43(rootDir, SCOUT_PAIRING_SUPERVISOR_INTENT_FILE),
-    runtimePidPath: join43(rootDir, SCOUT_PAIRING_RUNTIME_PID_FILE),
-    runtimeOwnerPath: join43(rootDir, SCOUT_PAIRING_RUNTIME_OWNER_FILE),
-    supervisorPidPath: join43(rootDir, SCOUT_PAIRING_SUPERVISOR_PID_FILE)
-  };
-}
-function inspectScoutPairingProcess(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return null;
-  try {
-    const output = execFileSync6("ps", ["-p", String(pid), "-o", "lstart=", "-o", "command="], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    const startedAt = output.slice(0, 24).trim().replace(/\s+/g, " ");
-    const command = output.slice(24).trim();
-    return startedAt && command ? { pid, startedAt, command } : null;
-  } catch {
-    return null;
-  }
-}
-function readScoutPairingRuntimeOwner(ownerPath = resolveScoutPairingSupervisorPaths().runtimeOwnerPath) {
-  if (!existsSync36(ownerPath))
-    return null;
-  try {
-    const value = JSON.parse(readFileSync22(ownerPath, "utf8"));
-    return value.version === 1 && Number.isInteger(value.pid) && (value.pid ?? 0) > 0 && typeof value.token === "string" && value.token.length >= 16 && typeof value.startedAt === "string" && value.startedAt.length > 0 && typeof value.command === "string" && value.command.includes(SCOUT_PAIRING_RUNTIME_PROCESS_MARKER) && typeof value.claimedAt === "number" && Number.isFinite(value.claimedAt) ? value : null;
-  } catch {
-    return null;
-  }
-}
-function isScoutPairingRuntimeOwnerLive(owner, options = {}) {
-  if (!owner || options.expectedToken && owner.token !== options.expectedToken)
-    return false;
-  const current = (options.inspect ?? inspectScoutPairingProcess)(owner.pid);
-  return current !== null && current.startedAt === owner.startedAt && current.command === owner.command && current.command.includes(SCOUT_PAIRING_RUNTIME_PROCESS_MARKER);
-}
-function readLiveScoutPairingRuntimeOwner(ownerPath = resolveScoutPairingSupervisorPaths().runtimeOwnerPath, options = {}) {
-  const owner = readScoutPairingRuntimeOwner(ownerPath);
-  return isScoutPairingRuntimeOwnerLive(owner, options) ? owner : null;
-}
-function claimScoutPairingRuntimeOwnership(options = {}) {
-  const pid = options.pid ?? process.pid;
-  const ownerPath = options.ownerPath ?? resolveScoutPairingSupervisorPaths().runtimeOwnerPath;
-  const inspect = options.inspect ?? inspectScoutPairingProcess;
-  const existing = readLiveScoutPairingRuntimeOwner(ownerPath, { inspect });
-  if (existing && existing.pid !== pid) {
-    throw new Error(`Scout pairing runtime is already owned by pid ${existing.pid}.`);
-  }
-  const identity = inspect(pid);
-  if (!identity || !identity.command.includes(SCOUT_PAIRING_RUNTIME_PROCESS_MARKER)) {
-    throw new Error(`Cannot prove Scout pairing runtime ownership for pid ${pid}.`);
-  }
-  const owner = {
-    version: 1,
-    ...identity,
-    token: options.token?.trim() || randomUUID6(),
-    claimedAt: options.now ?? Date.now()
-  };
-  mkdirSync17(dirname22(ownerPath), { recursive: true });
-  writeFileAtomically(ownerPath, `${JSON.stringify(owner, null, 2)}
-`);
-  return owner;
-}
-function releaseScoutPairingRuntimeOwnership(owner, ownerPath = resolveScoutPairingSupervisorPaths().runtimeOwnerPath) {
-  const current = readScoutPairingRuntimeOwner(ownerPath);
-  if (!current || current.pid !== owner.pid || current.token !== owner.token)
-    return;
-  rmSync4(ownerPath, { force: true });
-}
-function writeFileAtomically(path2, contents) {
-  const temporaryPath = `${path2}.${process.pid}.${Date.now()}.tmp`;
-  try {
-    writeFileSync13(temporaryPath, contents);
-    renameSync6(temporaryPath, path2);
-  } finally {
-    rmSync4(temporaryPath, { force: true });
-  }
-}
-
-// ../web/server/pairing.ts
+import { dirname as dirname23, join as join43, resolve as resolve15 } from "path";
+init_setup();
 init_local_config();
 init_tool_resolution();
 var SCOUT_PAIRING_HOME_DIRECTORY = ".scout/pairing";
@@ -63075,25 +63560,25 @@ var SCOUT_PAIRING_IDENTITY_FILE = "identity.json";
 var SCOUT_PAIRING_TRUSTED_PEERS_FILE = "trusted-peers.json";
 var SCOUT_PAIRING_LOG_FILE = "bridge.log";
 var SCOUT_PAIRING_RUNTIME_STATE_FILE = "runtime.json";
-var SCOUT_PAIRING_RUNTIME_PID_FILE2 = "runtime.pid";
+var SCOUT_PAIRING_RUNTIME_PID_FILE = "runtime.pid";
 var SCOUT_PAIRING_DEFAULT_PORT = 7888;
 var SCOUT_PAIRING_RUNTIME_VERSION = 1;
 var SCOUT_PAIRING_BRIDGE_CONNECT_TIMEOUT_MS = 1500;
 var SCOUT_PAIRING_BRIDGE_REQUEST_TIMEOUT_MS = 2500;
 function resolveScoutPairingHomeDirectory() {
   const configured = process.env.OPENSCOUT_PAIRING_HOME?.trim() || process.env.SCOUT_PAIRING_HOME?.trim();
-  return configured || join44(homedir35(), SCOUT_PAIRING_HOME_DIRECTORY);
+  return configured || join43(homedir34(), SCOUT_PAIRING_HOME_DIRECTORY);
 }
 function resolveScoutPairingPaths() {
   const rootDir = resolveScoutPairingHomeDirectory();
   return {
     rootDir,
-    configPath: join44(rootDir, SCOUT_PAIRING_CONFIG_FILE),
-    identityPath: join44(rootDir, SCOUT_PAIRING_IDENTITY_FILE),
-    trustedPeersPath: join44(rootDir, SCOUT_PAIRING_TRUSTED_PEERS_FILE),
-    logPath: join44(rootDir, SCOUT_PAIRING_LOG_FILE),
-    runtimeStatePath: join44(rootDir, SCOUT_PAIRING_RUNTIME_STATE_FILE),
-    runtimePidPath: join44(rootDir, SCOUT_PAIRING_RUNTIME_PID_FILE2)
+    configPath: join43(rootDir, SCOUT_PAIRING_CONFIG_FILE),
+    identityPath: join43(rootDir, SCOUT_PAIRING_IDENTITY_FILE),
+    trustedPeersPath: join43(rootDir, SCOUT_PAIRING_TRUSTED_PEERS_FILE),
+    logPath: join43(rootDir, SCOUT_PAIRING_LOG_FILE),
+    runtimeStatePath: join43(rootDir, SCOUT_PAIRING_RUNTIME_STATE_FILE),
+    runtimePidPath: join43(rootDir, SCOUT_PAIRING_RUNTIME_PID_FILE)
   };
 }
 function createScoutPairingBridgeUrl(port) {
@@ -63132,10 +63617,10 @@ async function createScoutPairingBridgeClient(port) {
     socket.addEventListener("error", handleError);
   });
   const handleMessage = (event) => {
-    const raw = typeof event.data === "string" ? event.data : String(event.data);
+    const raw2 = typeof event.data === "string" ? event.data : String(event.data);
     let payload;
     try {
-      payload = JSON.parse(raw);
+      payload = JSON.parse(raw2);
     } catch {
       return;
     }
@@ -63234,11 +63719,11 @@ async function loadScoutPairingSessionSnapshots(port) {
 }
 function loadScoutPairingConfig() {
   const { configPath } = resolveScoutPairingPaths();
-  if (!existsSync37(configPath)) {
+  if (!existsSync36(configPath)) {
     return {};
   }
   try {
-    const payload = JSON.parse(readFileSync23(configPath, "utf8"));
+    const payload = JSON.parse(readFileSync22(configPath, "utf8"));
     return typeof payload === "object" && payload ? payload : {};
   } catch {
     return {};
@@ -63259,11 +63744,11 @@ function resolveScoutPairingConfig() {
 }
 function readScoutPairingRuntimeSnapshot() {
   const { runtimeStatePath } = resolveScoutPairingPaths();
-  if (!existsSync37(runtimeStatePath)) {
+  if (!existsSync36(runtimeStatePath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync23(runtimeStatePath, "utf8"));
+    const parsed = JSON.parse(readFileSync22(runtimeStatePath, "utf8"));
     return parsed?.version === SCOUT_PAIRING_RUNTIME_VERSION ? parsed : null;
   } catch {
     return null;
@@ -63271,18 +63756,18 @@ function readScoutPairingRuntimeSnapshot() {
 }
 function readScoutPairingRuntimePid() {
   const { runtimePidPath } = resolveScoutPairingPaths();
-  if (!existsSync37(runtimePidPath)) {
+  if (!existsSync36(runtimePidPath)) {
     return null;
   }
   try {
-    const raw = readFileSync23(runtimePidPath, "utf8").trim();
-    const pid = Number(raw);
+    const raw2 = readFileSync22(runtimePidPath, "utf8").trim();
+    const pid = Number(raw2);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
     return null;
   }
 }
-function isScoutPairingProcessRunning(pid) {
+function isScoutPairingProcessRunning2(pid) {
   if (!pid || !Number.isInteger(pid) || pid <= 0) {
     return false;
   }
@@ -63295,13 +63780,15 @@ function isScoutPairingProcessRunning(pid) {
 }
 function isScoutPairingRuntimeRunning() {
   const pid = readScoutPairingRuntimePid();
-  if (isScoutPairingProcessRunning(pid)) {
+  if (isScoutPairingProcessRunning2(pid)) {
     return true;
   }
   const snapshot = readScoutPairingRuntimeSnapshot();
-  return Boolean(snapshot && isScoutPairingProcessRunning(snapshot.childPid ?? snapshot.pid));
+  return Boolean(snapshot && isScoutPairingProcessRunning2(snapshot.childPid ?? snapshot.pid));
 }
+var SCOUT_PAIRING_LOG_TAIL_WINDOW_BYTES = 256 * 1024;
 var pairingMutationChain = Promise.resolve();
+var coalescedPairingStateReads = new Map;
 async function getScoutWebPairingSessionSnapshots() {
   if (!isScoutPairingRuntimeRunning()) {
     return [];
@@ -63312,8 +63799,8 @@ async function getScoutWebPairingSessionSnapshots() {
 
 // ../web/server/core/agent-endpoints.ts
 init_src();
-import { homedir as homedir36 } from "os";
-import { join as join45, resolve as resolve16 } from "path";
+import { homedir as homedir35 } from "os";
+import { join as join44, resolve as resolve16 } from "path";
 function endpointMetadataRecord(endpoint) {
   return endpoint?.metadata && typeof endpoint.metadata === "object" && !Array.isArray(endpoint.metadata) ? endpoint.metadata : {};
 }
@@ -63347,10 +63834,10 @@ function endpointSessionAliases(endpoint) {
 }
 function expandHomePath5(value) {
   if (value === "~") {
-    return homedir36();
+    return homedir35();
   }
   if (value.startsWith("~/")) {
-    return join45(homedir36(), value.slice(2));
+    return join44(homedir35(), value.slice(2));
   }
   return value;
 }
@@ -63703,7 +64190,7 @@ async function loadMobileWorkspaceInventory(currentDirectory) {
 }
 function isDirectory2(path2) {
   try {
-    return statSync11(path2).isDirectory();
+    return statSync12(path2).isDirectory();
   } catch {
     return false;
   }
@@ -64656,17 +65143,17 @@ init_system_probes();
 import { createHash as createHash9 } from "crypto";
 import {
   chmodSync as chmodSync2,
-  closeSync,
-  existsSync as existsSync38,
-  mkdirSync as mkdirSync19,
-  openSync,
-  readFileSync as readFileSync24,
-  renameSync as renameSync7,
+  closeSync as closeSync2,
+  existsSync as existsSync37,
+  mkdirSync as mkdirSync18,
+  openSync as openSync2,
+  readFileSync as readFileSync23,
+  renameSync as renameSync6,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync14
 } from "fs";
-import { homedir as homedir37, hostname as hostname3, userInfo as userInfo2 } from "os";
-import { join as join46 } from "path";
+import { homedir as homedir36, hostname as hostname3, userInfo as userInfo2 } from "os";
+import { join as join45 } from "path";
 
 // ../web/server/core/pairing/runtime/bridge/ssh-terminal-access.ts
 import { createHash as createHash7 } from "crypto";
@@ -64893,8 +65380,8 @@ function authorizedMobileTerminalSessionName(requestedSessionName, provisionedSe
 
 // ../web/server/core/pairing/runtime/bridge/mobile-terminal-provision.ts
 async function readMobileTerminalStatus(requestedSessionName, deviceId) {
-  const authorizedKeysPath = join46(homedir37(), ".ssh", "authorized_keys");
-  const authorizedKeys = existsSync38(authorizedKeysPath) ? readFileSync24(authorizedKeysPath, "utf8") : "";
+  const authorizedKeysPath = join45(homedir36(), ".ssh", "authorized_keys");
+  const authorizedKeys = existsSync37(authorizedKeysPath) ? readFileSync23(authorizedKeysPath, "utf8") : "";
   const provisionedSessionName = findSshTerminalSessionForDevice(authorizedKeys, deviceId);
   const sessionName = authorizedMobileTerminalSessionName(requestedSessionName, provisionedSessionName);
   const base = {
@@ -64966,17 +65453,17 @@ async function readMobileTerminalStatus(requestedSessionName, deviceId) {
 async function provisionMobileTerminalAccess(sshPublicKey, deviceId, deviceClass = undefined) {
   const id = deviceId?.trim() || "scout-ios-device";
   const sessionName = provisionedMobileTerminalSessionName(sshPublicKey, deviceClass);
-  const sshDir = join46(homedir37(), ".ssh");
-  const authorizedKeysPath = join46(sshDir, "authorized_keys");
+  const sshDir = join45(homedir36(), ".ssh");
+  const authorizedKeysPath = join45(sshDir, "authorized_keys");
   const hostKeyFingerprint = readRequiredHostKeyFingerprint();
   const result = withAuthorizedKeysLock(sshDir, () => {
-    if (!existsSync38(sshDir)) {
-      mkdirSync19(sshDir, { recursive: true, mode: 448 });
+    if (!existsSync37(sshDir)) {
+      mkdirSync18(sshDir, { recursive: true, mode: 448 });
     }
     try {
       chmodSync2(sshDir, 448);
     } catch {}
-    const existing = existsSync38(authorizedKeysPath) ? readFileSync24(authorizedKeysPath, "utf8") : "";
+    const existing = existsSync37(authorizedKeysPath) ? readFileSync23(authorizedKeysPath, "utf8") : "";
     const result2 = provisionSshTerminalAccess({
       authorizedKeys: existing,
       deviceId: id,
@@ -65024,7 +65511,7 @@ function resolveReachableHost() {
 }
 function readRequiredHostKeyFingerprint() {
   try {
-    const pub = readFileSync24("/etc/ssh/ssh_host_ed25519_key.pub", "utf8");
+    const pub = readFileSync23("/etc/ssh/ssh_host_ed25519_key.pub", "utf8");
     const keyData = pub.trim().split(/\s+/)[1];
     if (!keyData)
       throw new Error("missing key data");
@@ -65038,8 +65525,8 @@ function readRequiredHostKeyFingerprint() {
 function writeAuthorizedKeysAtomically(path2, contents) {
   const tmpPath = `${path2}.scout-${process.pid}-${Date.now()}.tmp`;
   try {
-    writeFileSync15(tmpPath, contents, { mode: 384, flag: "wx" });
-    renameSync7(tmpPath, path2);
+    writeFileSync14(tmpPath, contents, { mode: 384, flag: "wx" });
+    renameSync6(tmpPath, path2);
   } catch (error) {
     try {
       unlinkSync4(tmpPath);
@@ -65048,15 +65535,15 @@ function writeAuthorizedKeysAtomically(path2, contents) {
   }
 }
 function withAuthorizedKeysLock(sshDir, action) {
-  if (!existsSync38(sshDir)) {
-    mkdirSync19(sshDir, { recursive: true, mode: 448 });
+  if (!existsSync37(sshDir)) {
+    mkdirSync18(sshDir, { recursive: true, mode: 448 });
   }
-  const lockPath = join46(sshDir, ".scout-authorized-keys.lock");
+  const lockPath = join45(sshDir, ".scout-authorized-keys.lock");
   const deadline = Date.now() + 5000;
   let fd = null;
   while (fd === null) {
     try {
-      fd = openSync(lockPath, "wx", 384);
+      fd = openSync2(lockPath, "wx", 384);
     } catch (error) {
       const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
       if (code !== "EEXIST" || Date.now() >= deadline) {
@@ -65073,7 +65560,7 @@ function withAuthorizedKeysLock(sshDir, action) {
     return action();
   } finally {
     try {
-      closeSync(lockFd);
+      closeSync2(lockFd);
     } finally {
       try {
         unlinkSync4(lockPath);
@@ -65290,7 +65777,7 @@ async function handleRPCInner(bridge, req, rpcContext = {}) {
         if (dirName.startsWith("-")) {
           const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
           try {
-            statSync12(candidate);
+            statSync13(candidate);
             cwd = candidate;
           } catch {
             const config = resolveConfig();
@@ -65347,7 +65834,7 @@ async function handleRPCInner(bridge, req, rpcContext = {}) {
         }
         const root = resolveWorkspaceRoot(configuredRoot);
         const projectPath = resolveWorkspacePath(root, p.path);
-        const stat6 = statSync12(projectPath);
+        const stat6 = statSync13(projectPath);
         if (!stat6.isDirectory()) {
           return { id: req.id, error: { code: -32000, message: "Workspace target is not a directory" } };
         }
@@ -65644,7 +66131,7 @@ async function handleRPCInner(bridge, req, rpcContext = {}) {
         const config = resolveConfig();
         const workspaceRoot = config.workspace?.root ? resolveWorkspaceRoot(config.workspace.root) : null;
         const matches = await readSessionSearch({
-          home: homedir38(),
+          home: homedir37(),
           workspaceRoot,
           maxAgeDays: maxAge,
           limit,
@@ -65659,7 +66146,7 @@ async function handleRPCInner(bridge, req, rpcContext = {}) {
           return { id: req.id, error: { code: -32000, message: "Only .jsonl files can be read" } };
         }
         try {
-          const content = readFileSync25(p.path, "utf-8");
+          const content = readFileSync24(p.path, "utf-8");
           const lines = content.split(`
 `).filter((l) => l.trim().length > 0);
           const trimmed = lines.length > 500 ? lines.slice(-500) : lines;
@@ -65780,13 +66267,13 @@ function resolveMobileCurrentDirectory() {
   }
 }
 function resolveWorkspaceRoot(root) {
-  const expandedRoot = root.replace(/^~/, homedir38());
+  const expandedRoot = root.replace(/^~/, homedir37());
   return realpathSync5(expandedRoot);
 }
 function resolveWorkspacePath(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir38());
-  const candidate = expandedPath ? isAbsolute7(expandedPath) ? expandedPath : join47(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir37());
+  const candidate = expandedPath ? isAbsolute7(expandedPath) ? expandedPath : join46(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync5(candidate);
   const rel = relative6(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute7(rel)) {
@@ -65816,9 +66303,9 @@ function listDirectories(dirPath) {
       continue;
     if (name2 === "node_modules" || name2 === ".build" || name2 === "target")
       continue;
-    const fullPath = join47(dirPath, name2);
+    const fullPath = join46(dirPath, name2);
     try {
-      const stat6 = statSync12(fullPath);
+      const stat6 = statSync13(fullPath);
       if (!stat6.isDirectory())
         continue;
       const children = new Set(readdirSync6(fullPath));
@@ -65842,7 +66329,7 @@ async function discoverSessionFiles(maxAgeDays, limit) {
   const config = resolveConfig();
   const workspaceRoot = config.workspace?.root ? resolveWorkspaceRoot(config.workspace.root) : null;
   const sessions4 = await readSessionFileScan({
-    home: homedir38(),
+    home: homedir37(),
     workspaceRoot,
     maxAgeDays,
     limit
@@ -80248,9 +80735,9 @@ init_src2();
 init_system_probes();
 init_local_config();
 init_local_agents();
-import { readFileSync as readFileSync26, readdirSync as readdirSync7, realpathSync as realpathSync6, statSync as statSync13 } from "fs";
-import { basename as basename14, isAbsolute as isAbsolute8, join as join48, relative as relative7, resolve as resolve19 } from "path";
-import { homedir as homedir39 } from "os";
+import { readFileSync as readFileSync25, readdirSync as readdirSync7, realpathSync as realpathSync6, statSync as statSync14 } from "fs";
+import { basename as basename14, isAbsolute as isAbsolute8, join as join47, relative as relative7, resolve as resolve19 } from "path";
+import { homedir as homedir38 } from "os";
 var t = initTRPC.context().create();
 var logged = t.middleware(async ({ path: path2, type, next }) => {
   const start = Date.now();
@@ -80321,8 +80808,8 @@ var VOICE_LEG_HEALTH_TIMEOUT_MS = 300;
 var VOICE_LEG_HEALTH_TTL_MS = 5000;
 var voiceLegHealthCache = null;
 function resolveVoiceLegPort() {
-  const raw = Number(process.env.SCOUT_RTC_PORT);
-  return Number.isInteger(raw) && raw > 0 && raw < 65536 ? raw : 8090;
+  const raw2 = Number(process.env.SCOUT_RTC_PORT);
+  return Number.isInteger(raw2) && raw2 > 0 && raw2 < 65536 ? raw2 : 8090;
 }
 async function probeVoiceLegHealth(port) {
   const now = Date.now();
@@ -80416,13 +80903,13 @@ function resolveMobileCurrentDirectory2() {
   }
 }
 function resolveWorkspaceRoot2(root) {
-  const expandedRoot = root.replace(/^~/, homedir39());
+  const expandedRoot = root.replace(/^~/, homedir38());
   return realpathSync6(expandedRoot);
 }
 function resolveWorkspacePath2(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot2(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir39());
-  const candidate = expandedPath ? isAbsolute8(expandedPath) ? expandedPath : join48(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir38());
+  const candidate = expandedPath ? isAbsolute8(expandedPath) ? expandedPath : join47(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync6(candidate);
   const rel = relative7(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute8(rel)) {
@@ -80452,9 +80939,9 @@ function listDirectories2(dirPath) {
       continue;
     if (name2 === "node_modules" || name2 === ".build" || name2 === "target")
       continue;
-    const fullPath = join48(dirPath, name2);
+    const fullPath = join47(dirPath, name2);
     try {
-      const stat6 = statSync13(fullPath);
+      const stat6 = statSync14(fullPath);
       if (!stat6.isDirectory())
         continue;
       const children = new Set(readdirSync7(fullPath));
@@ -80485,7 +80972,7 @@ async function discoverSessionFiles2(maxAgeDays, limit) {
   const config2 = resolveConfig();
   const workspaceRoot = config2.workspace?.root ? resolveWorkspaceRoot2(config2.workspace.root) : null;
   const sessions4 = await readSessionFileScan({
-    home: homedir39(),
+    home: homedir38(),
     workspaceRoot,
     maxAgeDays,
     limit
@@ -80717,7 +81204,7 @@ var sessionRouter = t.router({
     if (dirName.startsWith("-")) {
       const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
       try {
-        statSync13(candidate);
+        statSync14(candidate);
         cwd = candidate;
       } catch {
         const config2 = resolveConfig();
@@ -81132,7 +81619,7 @@ var workspaceRouter = t.router({
     }
     const root = resolveWorkspaceRoot2(configuredRoot);
     const projectPath = resolveWorkspacePath2(root, input.path);
-    const stat6 = statSync13(projectPath);
+    const stat6 = statSync14(projectPath);
     if (!stat6.isDirectory()) {
       throw new TRPCError({
         code: "BAD_REQUEST",
@@ -81174,7 +81661,7 @@ var historyRouter = t.router({
     const config2 = resolveConfig();
     const workspaceRoot = config2.workspace?.root ? resolveWorkspaceRoot2(config2.workspace.root) : null;
     const matches = await readSessionSearch({
-      home: homedir39(),
+      home: homedir38(),
       workspaceRoot,
       maxAgeDays: maxAge,
       limit,
@@ -81191,7 +81678,7 @@ var historyRouter = t.router({
       });
     }
     try {
-      const content = readFileSync26(input.path, "utf-8");
+      const content = readFileSync25(input.path, "utf-8");
       const lines = content.split(`
 `).filter((l) => l.trim().length > 0);
       const trimmed = lines.length > 500 ? lines.slice(-500) : lines;
@@ -81223,8 +81710,8 @@ var historyRouter = t.router({
       });
     }
     try {
-      const fileStat = statSync13(input.path);
-      const content = readFileSync26(input.path, "utf-8");
+      const fileStat = statSync14(input.path);
+      const content = readFileSync25(input.path, "utf-8");
       const replay = createHistorySessionSnapshot({
         path: input.path,
         content,
@@ -81528,14 +82015,14 @@ function connectToRelay(relayUrl, identity, bridge, options = {}) {
       events2?.onError?.({ relayUrl: eventRelayUrl, room: qrPayload.room, error: error48 });
     });
   }
-  function handleRelaySocketMessage(raw) {
-    const envelope = parseRelayEnvelope2(raw);
+  function handleRelaySocketMessage(raw2) {
+    const envelope = parseRelayEnvelope2(raw2);
     if (!secure) {
-      handlePlaintextRelayMessage(envelope, raw);
+      handlePlaintextRelayMessage(envelope, raw2);
       return;
     }
     if (!envelope) {
-      const payload = asStringPayload(raw);
+      const payload = asStringPayload(raw2);
       if (!payload)
         return;
       routeSecurePayload(LEGACY_CLIENT_ID, payload);
@@ -81625,14 +82112,14 @@ function connectToRelay(relayUrl, identity, bridge, options = {}) {
     securePeers.delete(clientId);
     maybeReleaseMobileSubscriptions();
   }
-  function handlePlaintextRelayMessage(envelope, raw) {
+  function handlePlaintextRelayMessage(envelope, raw2) {
     if (envelope?.event === "close") {
       plaintextClients.delete(envelope.clientId);
       maybeReleaseMobileSubscriptions();
       return;
     }
     const clientId = envelope?.clientId ?? LEGACY_CLIENT_ID;
-    const payload = envelope?.payload ?? asStringPayload(raw);
+    const payload = envelope?.payload ?? asStringPayload(raw2);
     if (!payload)
       return;
     const isNewClient = !plaintextClients.has(clientId);
@@ -81746,10 +82233,10 @@ function connectToRelay(relayUrl, identity, bridge, options = {}) {
       }));
     }
   }
-  function handlePlaintextMessage(clientId, raw) {
+  function handlePlaintextMessage(clientId, raw2) {
     let req;
     try {
-      req = JSON.parse(raw);
+      req = JSON.parse(raw2);
     } catch {
       sendRelayMessage(clientId, JSON.stringify({ id: null, error: { code: -32700, message: "Parse error" } }));
       return;
@@ -81884,12 +82371,12 @@ function detectHandshakePattern(payload) {
     return null;
   }
 }
-function parseRelayEnvelope2(raw) {
-  if (typeof raw !== "string") {
+function parseRelayEnvelope2(raw2) {
+  if (typeof raw2 !== "string") {
     return null;
   }
   try {
-    const parsed = JSON.parse(raw);
+    const parsed = JSON.parse(raw2);
     if (parsed.phase !== "relay" || typeof parsed.clientId !== "string") {
       return null;
     }
@@ -81908,15 +82395,15 @@ function parseRelayEnvelope2(raw) {
     return null;
   }
 }
-function asStringPayload(raw) {
-  if (typeof raw === "string") {
-    return raw;
+function asStringPayload(raw2) {
+  if (typeof raw2 === "string") {
+    return raw2;
   }
-  if (raw instanceof Uint8Array) {
-    return new TextDecoder().decode(raw);
+  if (raw2 instanceof Uint8Array) {
+    return new TextDecoder().decode(raw2);
   }
-  if (raw instanceof ArrayBuffer) {
-    return new TextDecoder().decode(new Uint8Array(raw));
+  if (raw2 instanceof ArrayBuffer) {
+    return new TextDecoder().decode(new Uint8Array(raw2));
   }
   return null;
 }
@@ -82039,206 +82526,6 @@ var handleParsingNestedValues = (form, key, value) => {
   });
 };
 
-// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/utils/url.js
-var splitPath = (path2) => {
-  const paths2 = path2.split("/");
-  if (paths2[0] === "") {
-    paths2.shift();
-  }
-  return paths2;
-};
-var splitRoutingPath = (routePath) => {
-  const { groups, path: path2 } = extractGroupsFromPath(routePath);
-  const paths2 = splitPath(path2);
-  return replaceGroupMarks(paths2, groups);
-};
-var extractGroupsFromPath = (path2) => {
-  const groups = [];
-  path2 = path2.replace(/\{[^}]+\}/g, (match, index2) => {
-    const mark = `@${index2}`;
-    groups.push([mark, match]);
-    return mark;
-  });
-  return { groups, path: path2 };
-};
-var replaceGroupMarks = (paths2, groups) => {
-  for (let i = groups.length - 1;i >= 0; i--) {
-    const [mark] = groups[i];
-    for (let j = paths2.length - 1;j >= 0; j--) {
-      if (paths2[j].includes(mark)) {
-        paths2[j] = paths2[j].replace(mark, groups[i][1]);
-        break;
-      }
-    }
-  }
-  return paths2;
-};
-var patternCache = {};
-var getPattern = (label, next) => {
-  if (label === "*") {
-    return "*";
-  }
-  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-  if (match) {
-    const cacheKey = `${label}#${next}`;
-    if (!patternCache[cacheKey]) {
-      if (match[2]) {
-        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
-      } else {
-        patternCache[cacheKey] = [label, match[1], true];
-      }
-    }
-    return patternCache[cacheKey];
-  }
-  return null;
-};
-var tryDecode = (str, decoder) => {
-  try {
-    return decoder(str);
-  } catch {
-    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
-      try {
-        return decoder(match);
-      } catch {
-        return match;
-      }
-    });
-  }
-};
-var tryDecodeURI = (str) => tryDecode(str, decodeURI);
-var getPath = (request) => {
-  const url2 = request.url;
-  const start = url2.indexOf("/", url2.indexOf(":") + 4);
-  let i = start;
-  for (;i < url2.length; i++) {
-    const charCode = url2.charCodeAt(i);
-    if (charCode === 37) {
-      const queryIndex = url2.indexOf("?", i);
-      const hashIndex = url2.indexOf("#", i);
-      const end = queryIndex === -1 ? hashIndex === -1 ? undefined : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-      const path2 = url2.slice(start, end);
-      return tryDecodeURI(path2.includes("%25") ? path2.replace(/%25/g, "%2525") : path2);
-    } else if (charCode === 63 || charCode === 35) {
-      break;
-    }
-  }
-  return url2.slice(start, i);
-};
-var getPathNoStrict = (request) => {
-  const result = getPath(request);
-  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
-};
-var mergePath = (base, sub, ...rest) => {
-  if (rest.length) {
-    sub = mergePath(sub, ...rest);
-  }
-  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
-};
-var checkOptionalParameter = (path2) => {
-  if (path2.charCodeAt(path2.length - 1) !== 63 || !path2.includes(":")) {
-    return null;
-  }
-  const segments = path2.split("/");
-  const results = [];
-  let basePath = "";
-  segments.forEach((segment) => {
-    if (segment !== "" && !/\:/.test(segment)) {
-      basePath += "/" + segment;
-    } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
-        if (results.length === 0 && basePath === "") {
-          results.push("/");
-        } else {
-          results.push(basePath);
-        }
-        const optionalSegment = segment.replace("?", "");
-        basePath += "/" + optionalSegment;
-        results.push(basePath);
-      } else {
-        basePath += "/" + segment;
-      }
-    }
-  });
-  return results.filter((v, i, a) => a.indexOf(v) === i);
-};
-var _decodeURI = (value) => {
-  if (!/[%+]/.test(value)) {
-    return value;
-  }
-  if (value.indexOf("+") !== -1) {
-    value = value.replace(/\+/g, " ");
-  }
-  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
-};
-var _getQueryParam = (url2, key, multiple) => {
-  let encoded;
-  if (!multiple && key && !/[%+]/.test(key)) {
-    let keyIndex2 = url2.indexOf("?", 8);
-    if (keyIndex2 === -1) {
-      return;
-    }
-    if (!url2.startsWith(key, keyIndex2 + 1)) {
-      keyIndex2 = url2.indexOf(`&${key}`, keyIndex2 + 1);
-    }
-    while (keyIndex2 !== -1) {
-      const trailingKeyCode = url2.charCodeAt(keyIndex2 + key.length + 1);
-      if (trailingKeyCode === 61) {
-        const valueIndex = keyIndex2 + key.length + 2;
-        const endIndex = url2.indexOf("&", valueIndex);
-        return _decodeURI(url2.slice(valueIndex, endIndex === -1 ? undefined : endIndex));
-      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
-        return "";
-      }
-      keyIndex2 = url2.indexOf(`&${key}`, keyIndex2 + 1);
-    }
-    encoded = /[%+]/.test(url2);
-    if (!encoded) {
-      return;
-    }
-  }
-  const results = {};
-  encoded ??= /[%+]/.test(url2);
-  let keyIndex = url2.indexOf("?", 8);
-  while (keyIndex !== -1) {
-    const nextKeyIndex = url2.indexOf("&", keyIndex + 1);
-    let valueIndex = url2.indexOf("=", keyIndex);
-    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
-      valueIndex = -1;
-    }
-    let name2 = url2.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? undefined : nextKeyIndex : valueIndex);
-    if (encoded) {
-      name2 = _decodeURI(name2);
-    }
-    keyIndex = nextKeyIndex;
-    if (name2 === "") {
-      continue;
-    }
-    let value;
-    if (valueIndex === -1) {
-      value = "";
-    } else {
-      value = url2.slice(valueIndex + 1, nextKeyIndex === -1 ? undefined : nextKeyIndex);
-      if (encoded) {
-        value = _decodeURI(value);
-      }
-    }
-    if (multiple) {
-      if (!(results[name2] && Array.isArray(results[name2]))) {
-        results[name2] = [];
-      }
-      results[name2].push(value);
-    } else {
-      results[name2] ??= value;
-    }
-  }
-  return key ? results[key] : results;
-};
-var getQueryParam = _getQueryParam;
-var getQueryParams = (url2, key) => {
-  return _getQueryParam(url2, key, true);
-};
-var decodeURIComponent_ = decodeURIComponent;
-
 // ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/request.js
 var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
 var HonoRequest = class {
@@ -82296,7 +82583,7 @@ var HonoRequest = class {
     return parseBody(this, options);
   }
   #cachedBody = (key) => {
-    const { bodyCache, raw } = this;
+    const { bodyCache, raw: raw2 } = this;
     const cachedBody = bodyCache[key];
     if (cachedBody) {
       return cachedBody;
@@ -82310,7 +82597,7 @@ var HonoRequest = class {
         return new Response(body)[key]();
       });
     }
-    return bodyCache[key] = raw[key]();
+    return bodyCache[key] = raw2[key]();
   };
   json() {
     return this.#cachedBody("text").then((text2) => JSON.parse(text2));
@@ -82350,44 +82637,6 @@ var HonoRequest = class {
   }
 };
 
-// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/utils/html.js
-var HtmlEscapedCallbackPhase = {
-  Stringify: 1,
-  BeforeStream: 2,
-  Stream: 3
-};
-var raw = (value, callbacks) => {
-  const escapedString = new String(value);
-  escapedString.isEscaped = true;
-  escapedString.callbacks = callbacks;
-  return escapedString;
-};
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
-  if (typeof str === "object" && !(str instanceof String)) {
-    if (!(str instanceof Promise)) {
-      str = str.toString();
-    }
-    if (str instanceof Promise) {
-      str = await str;
-    }
-  }
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return Promise.resolve(str);
-  }
-  if (buffer) {
-    buffer[0] += str;
-  } else {
-    buffer = [str];
-  }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
-  if (preserveCallbacks) {
-    return raw(await resStr, callbacks);
-  } else {
-    return resStr;
-  }
-};
-
 // ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/context.js
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
 var setDefaultContentType = (contentType, headers2) => {
@@ -82540,9 +82789,9 @@ var Context = class {
   json = (object2, arg, headers2) => {
     return this.#newResponse(JSON.stringify(object2), arg, setDefaultContentType("application/json", headers2));
   };
-  html = (html, arg, headers2) => {
-    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers2));
-    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+  html = (html2, arg, headers2) => {
+    const res = (html22) => this.#newResponse(html22, arg, setDefaultContentType("text/html; charset=UTF-8", headers2));
+    return typeof html2 === "object" ? resolveCallback(html2, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html2);
   };
   redirect = (location, status) => {
     const locationString = String(location);
@@ -82555,17 +82804,6 @@ var Context = class {
   };
 };
 
-// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/router.js
-var METHOD_NAME_ALL = "ALL";
-var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = ["get", "post", "put", "delete", "options", "patch"];
-var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-var UnsupportedPathError = class extends Error {
-};
-
-// ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/utils/constants.js
-var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
-
 // ../../node_modules/.bun/hono@4.12.10/node_modules/hono/dist/hono-base.js
 var notFoundHandler = (c) => {
   return c.text("404 Not Found", 404);
@@ -83588,14 +83826,14 @@ function observableToAsyncIterable(observable$1, signal2) {
 }
 // ../web/server/core/pairing/runtime/bridge/server-trpc.ts
 import { realpathSync as realpathSync7 } from "fs";
-import { homedir as homedir40 } from "os";
+import { homedir as homedir39 } from "os";
 function resolveCurrentDirectory() {
   try {
     const config2 = resolveConfig();
     const configuredRoot = config2.workspace?.root;
     if (!configuredRoot)
       return process.cwd();
-    const expanded = configuredRoot.replace(/^~/, homedir40());
+    const expanded = configuredRoot.replace(/^~/, homedir39());
     return realpathSync7(expanded);
   } catch {
     return process.cwd();
@@ -84250,7 +84488,7 @@ async function autoStartConfiguredSessions(bridge, sessions4) {
     try {
       const session = await bridge.createSession(entry.adapter, {
         name: entry.name,
-        cwd: entry.cwd?.replace(/^~/, homedir41()),
+        cwd: entry.cwd?.replace(/^~/, homedir40()),
         options: entry.options
       });
       console.log(`[bridge] session started: ${session.name} (${entry.adapter})`);
@@ -84269,19 +84507,10 @@ var BONJOUR_SERVICE_TYPE = "_oscout-pair._tcp";
 async function runPairingRuntimeController() {
   clearStalePairingRuntimeFiles();
   const existingPid = readPairingRuntimePid();
-  let existingOwner = readLiveScoutPairingRuntimeOwner();
-  if (!existingOwner && existingPid && existingPid !== process.pid) {
-    try {
-      existingOwner = claimScoutPairingRuntimeOwnership({ pid: existingPid });
-    } catch {
-      existingOwner = null;
-    }
-  }
-  if (existingPid && existingPid !== process.pid && existingOwner?.pid === existingPid) {
+  if (existingPid && existingPid !== process.pid && isProcessRunning(existingPid)) {
     console.error(`Scout pairing runtime controller is already running (pid ${existingPid}).`);
     process.exit(1);
   }
-  const runtimeOwner = claimScoutPairingRuntimeOwnership();
   writePairingRuntimePid(process.pid);
   const state = {
     current: writePairingRuntimeSnapshot(createPairingRuntimeSnapshot({ pid: process.pid }, {
@@ -84321,7 +84550,6 @@ async function runPairingRuntimeController() {
       childPid: null
     });
     clearPairingRuntimePid();
-    releaseScoutPairingRuntimeOwnership(runtimeOwner);
     process.exit(0);
   };
   process.on("SIGINT", () => void shutdown());