@openscout/scout 0.2.84 → 0.2.86

package/dist/pairing-runtime-controller.mjs

@@ -51,12 +51,18 @@ var __require = import.meta.require;
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+function isTestRunnerProcess() {
+  if (false)
+    ;
+  const entry = typeof Bun !== "undefined" ? Bun.main : process.argv[1] ?? "";
+  return /[._](test|spec)\.[cm]?[jt]sx?$/.test(entry);
+}
 function assertTestIsolatedUserData(operation, isolationEnvKey) {
-  if (true)
+  if (!isTestRunnerProcess())
     return;
   if (process.env[isolationEnvKey]?.trim())
     return;
-  throw new Error(`Refusing to ${operation} while NODE_ENV=test without ${isolationEnvKey} set. ` + "Tests must isolate OpenScout user data in a temp directory (see prepareHome in onboarding.test.ts).");
+  throw new Error(`Refusing to ${operation} under a test runner without ${isolationEnvKey} set. ` + "Tests must isolate OpenScout user data in a temp directory (see prepareHome in onboarding.test.ts).");
 }
 function resolveOpenScoutSupportPaths() {
   const home = homedir();
@@ -117,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 };
   }
@@ -222,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,
@@ -246,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,
@@ -267,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 : {});
@@ -310,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;
@@ -354,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"
     }
   ]);
@@ -366,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"
   }));
 }
@@ -377,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"
   }));
 }
@@ -661,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)
@@ -697,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) {
@@ -731,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;
@@ -813,6 +1028,7 @@ function codexCandidateReport(candidate, selectedPath) {
 function createBuiltInHarnessCatalog() {
   return BUILT_IN_HARNESS_CATALOG.map((entry) => ({
     ...entry,
+    aliases: entry.aliases ? [...entry.aliases] : undefined,
     tags: [...entry.tags],
     support: { ...entry.support },
     install: entry.install ? { ...entry.install, requires: [...entry.install.requires ?? []] } : undefined,
@@ -959,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,
@@ -969,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);
 }
@@ -1181,6 +1397,7 @@ var init_harness_catalog = __esm(() => {
     {
       name: "opencode",
       harness: "opencode",
+      aliases: ["oc", "opencode2"],
       label: "OpenCode",
       description: "OpenCode's coding agent over ACP, fronting many model vendors via OpenCode Zen",
       homepage: "https://opencode.ai/docs/",
@@ -1378,7 +1595,8 @@ function canonicalizeIdentity(input) {
   const definitionId = normalizeAgentIdentitySegment(input.definitionId);
   const workspaceQualifier = input.workspaceQualifier ? normalizeAgentIdentitySegment(input.workspaceQualifier) : undefined;
   const profile = input.profile ? normalizeAgentIdentitySegment(input.profile) : undefined;
-  const harness = input.harness ? normalizeAgentIdentitySegment(input.harness) : undefined;
+  const rawHarness = input.harness ? normalizeAgentIdentitySegment(input.harness) : undefined;
+  const harness = rawHarness === "oc" ? "opencode" : rawHarness;
   const model = input.model ? normalizeAgentIdentitySegment(input.model) : undefined;
   const nodeQualifier = input.nodeQualifier ? normalizeAgentIdentitySegment(input.nodeQualifier) : undefined;
   if (!definitionId) {
@@ -2341,6 +2559,20 @@ var init_agent_runs = __esm(() => {
 // ../protocol/src/budget.ts
 var init_budget = () => {};
 
+// ../protocol/src/presence.ts
+function presenceLifecycle(beat, now, options = {}) {
+  if (now < beat.staleAt)
+    return "fresh";
+  const goneAfterStaleMs = options.goneAfterStaleMs ?? PRESENCE_GONE_AFTER_STALE_MS;
+  if (now < beat.staleAt + goneAfterStaleMs)
+    return "stale";
+  return "gone";
+}
+function isPresenceGone(beat, now, options = {}) {
+  return presenceLifecycle(beat, now, options) === "gone";
+}
+var PRESENCE_STALE_AFTER_MS = 45000, PRESENCE_GONE_AFTER_STALE_MS = 60000;
+
 // ../protocol/src/host-integrations.ts
 var init_host_integrations = () => {};
 
@@ -2807,7 +3039,9 @@ var init_runtime_profiles = __esm(() => {
     "fable",
     "kimi",
     "grok",
-    "opus"
+    "opus",
+    "oc",
+    "opencode"
   ];
 });
 
@@ -3018,6 +3252,14 @@ var init_scout_composer = __esm(() => {
 // ../protocol/src/inbox.ts
 var init_inbox = () => {};
 
+// ../protocol/src/events.ts
+var EPHEMERAL_CONTROL_EVENT_KINDS;
+var init_events = __esm(() => {
+  EPHEMERAL_CONTROL_EVENT_KINDS = new Set([
+    "presence.updated"
+  ]);
+});
+
 // ../protocol/src/cursor-transport.ts
 var init_cursor_transport = () => {};
 
@@ -3112,6 +3354,7 @@ var init_src = __esm(() => {
   init_reserved_vocabulary();
   init_scout_composer();
   init_inbox();
+  init_events();
   init_permission_policy();
   init_cursor_transport();
   init_terminal_surface_id();
@@ -4697,7 +4940,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;
@@ -4709,7 +4952,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) {
@@ -4717,7 +4960,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) {
@@ -6619,9 +6862,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);
 }
@@ -6644,7 +6887,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;
@@ -6665,17 +6908,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;
@@ -6813,8 +7056,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 = [];
@@ -6824,7 +7067,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)) {
@@ -6855,14 +7098,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);
@@ -6893,7 +7136,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 = [];
@@ -8107,9 +8350,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;
 }
@@ -8122,8 +8365,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;
@@ -8133,8 +8376,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);
@@ -8174,7 +8417,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;
@@ -8481,9 +8724,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) {
@@ -8504,7 +8747,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;
     }
@@ -8514,14 +8757,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;
       }
@@ -8560,12 +8803,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;
       }
     }
@@ -8655,7 +8898,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}` : "") + ".";
@@ -8970,7 +9213,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: [] };
   }
@@ -8985,7 +9228,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) {
@@ -9013,9 +9256,15 @@ async function recordCodexSessionCatalog(runtimeDirectory, threadId, input) {
   });
 }
 async function closeCodexSessionCatalog(runtimeDirectory, threadId) {
+  if (!threadId) {
+    return;
+  }
   const catalog = await readCodexSessionCatalog(runtimeDirectory);
+  if (catalog.activeSessionId !== threadId) {
+    return;
+  }
+  const activeSessionId = threadId;
   const now = Date.now();
-  const activeSessionId = threadId ?? catalog.activeSessionId;
   const sessions = catalog.sessions.map((session) => session.id === activeSessionId && !session.endedAt ? { ...session, endedAt: now } : session);
   await writeCodexSessionCatalog(runtimeDirectory, {
     activeSessionId: null,
@@ -9038,18 +9287,20 @@ class CodexAppServerTransport {
   nextRequestId = 1;
   pendingRequests = new Map;
   starting = null;
+  threadPersistence = Promise.resolve();
   threadId = null;
   threadPath = null;
+  durableThreadId = null;
   proactiveShutdown = null;
   lastConfigSignature;
   notificationListeners = new Set;
   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() {
@@ -9107,7 +9358,7 @@ class CodexAppServerTransport {
       cwd: this.options.cwd,
       input: this.textInput(prompt)
     });
-    await this.persistState();
+    await this.persistThreadId();
     return response;
   }
   async steerTurn(prompt, expectedTurnId) {
@@ -9157,10 +9408,12 @@ class CodexAppServerTransport {
         child.kill("SIGKILL");
       }
     }
+    await this.threadPersistence;
     if (options.resetThread) {
-      await closeCodexSessionCatalog(this.options.runtimeDirectory, this.threadId);
+      await closeCodexSessionCatalog(this.options.runtimeDirectory, this.durableThreadId);
       this.threadId = null;
       this.threadPath = null;
+      this.durableThreadId = null;
       await rm(this.threadIdPath, { force: true });
     }
     await this.persistState();
@@ -9204,7 +9457,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);
@@ -9283,6 +9536,7 @@ class CodexAppServerTransport {
     const requestedThreadId = this.options.threadId?.trim() || null;
     const storedThreadId = requestedThreadId ?? await readOptionalFile(this.threadIdPath);
     if (storedThreadId) {
+      const threadOrigin = requestedThreadId ? "requested" : "stored";
       try {
         const resumed = await this.request("thread/resume", {
           threadId: storedThreadId,
@@ -9294,11 +9548,10 @@ class CodexAppServerTransport {
         });
         this.threadId = resumed.thread.id;
         this.threadPath = resumed.thread.path ?? null;
-        await this.persistThreadId();
-        await recordCodexSessionCatalog(this.options.runtimeDirectory, this.threadId, this.catalogRuntimeMeta());
+        await this.persistThreadId({ confirmed: true });
         return;
       } catch (error) {
-        await appendFile(this.stderrLogPath, `[openscout] failed to resume stored Codex thread ${storedThreadId}: ${errorMessage(error)}
+        await appendFile(this.stderrLogPath, `[openscout] failed to resume ${threadOrigin} Codex thread ${storedThreadId}: ${errorMessage(error)}
 `).catch(() => {
           return;
         });
@@ -9306,9 +9559,11 @@ class CodexAppServerTransport {
           await rm(this.threadIdPath, { force: true }).catch(() => {
             return;
           });
+          await closeCodexSessionCatalog(this.options.runtimeDirectory, storedThreadId);
+          await this.persistState();
         }
         if (requestedThreadId || this.options.requireExistingThread) {
-          throw new Error(`Failed to resume requested Codex thread ${storedThreadId}: ${errorMessage(error)}`);
+          throw new Error(`Failed to resume ${threadOrigin} Codex thread ${storedThreadId}: ${errorMessage(error)}`);
         }
       }
     }
@@ -9327,8 +9582,10 @@ class CodexAppServerTransport {
     });
     this.threadId = started.thread.id;
     this.threadPath = started.thread.path ?? null;
+    if (this.durableThreadId !== this.threadId) {
+      this.durableThreadId = null;
+    }
     await this.persistThreadId();
-    await recordCodexSessionCatalog(this.options.runtimeDirectory, this.threadId, this.catalogRuntimeMeta());
   }
   catalogRuntimeMeta() {
     return {
@@ -9398,12 +9655,17 @@ class CodexAppServerTransport {
     if (method === "thread/started" || method === "thread/name/updated") {
       const thread = params.thread;
       if (thread?.id) {
+        if (thread.id !== this.threadId) {
+          this.durableThreadId = null;
+        }
         this.threadId = thread.id;
       }
       if ("path" in (thread ?? {})) {
         this.threadPath = thread?.path ?? null;
       }
       this.persistThreadId();
+    } else if (this.threadId && !this.durableThreadId) {
+      this.persistThreadId();
     }
     this.emitNotification(message);
   }
@@ -9455,16 +9717,46 @@ class CodexAppServerTransport {
     });
     this.persistState();
   }
-  async persistThreadId() {
-    if (!this.threadId) {
+  persistThreadId(options = {}) {
+    const persistence = this.threadPersistence.then(() => this.persistThreadIdNow(options));
+    this.threadPersistence = persistence.catch(() => {
+      return;
+    });
+    return persistence;
+  }
+  async persistThreadIdNow(options) {
+    const threadId = this.threadId;
+    if (!threadId) {
+      this.durableThreadId = null;
+      await rm(this.threadIdPath, { force: true });
+      await this.persistState();
+      return;
+    }
+    let rolloutExists = false;
+    if (this.threadPath) {
+      try {
+        rolloutExists = (await stat(this.threadPath)).isFile();
+      } catch {
+        rolloutExists = false;
+      }
+    }
+    if (!options.confirmed && !rolloutExists && this.durableThreadId !== threadId) {
+      this.durableThreadId = null;
       await rm(this.threadIdPath, { force: true });
+      await this.persistState();
       return;
     }
-    await writeFile2(this.threadIdPath, `${this.threadId}
+    const becameDurable = this.durableThreadId !== threadId;
+    await writeFile2(this.threadIdPath, `${threadId}
 `);
+    this.durableThreadId = threadId;
     await this.persistState();
+    if (becameDurable) {
+      await recordCodexSessionCatalog(this.options.runtimeDirectory, threadId, this.catalogRuntimeMeta());
+    }
   }
   async persistState() {
+    const durableThreadPath = this.durableThreadId === this.threadId ? this.threadPath : null;
     await mkdir2(this.options.runtimeDirectory, { recursive: true });
     await writeFile2(this.statePath, JSON.stringify({
       agentId: this.options.agentName,
@@ -9472,8 +9764,8 @@ class CodexAppServerTransport {
       sessionId: this.options.sessionId,
       projectRoot: this.options.cwd,
       cwd: this.options.cwd,
-      threadId: this.threadId,
-      threadPath: this.threadPath,
+      threadId: this.durableThreadId,
+      threadPath: durableThreadPath,
       requestedThreadId: this.options.threadId ?? null,
       requireExistingThread: this.options.requireExistingThread === true,
       pid: this.process?.pid ?? null,
@@ -9910,9 +10202,9 @@ 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;
   }
@@ -10787,9 +11079,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);
 }
@@ -10906,7 +11198,7 @@ function parseTomlKeyValues(raw) {
 }
 function readTomlKeyValues(path2) {
   try {
-    return parseTomlKeyValues(readFileSync5(path2, "utf8"));
+    return parseTomlKeyValues(readFileSync6(path2, "utf8"));
   } catch {
     return null;
   }
@@ -10920,8 +11212,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 = [];
@@ -10929,7 +11221,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);
@@ -10968,8 +11260,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);
@@ -11232,7 +11524,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;
@@ -11259,7 +11551,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,
@@ -11271,8 +11563,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")
         }
       });
     }
@@ -11331,7 +11623,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"];
@@ -11343,8 +11635,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,
@@ -11363,10 +11655,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);
@@ -11534,9 +11826,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));
@@ -11915,7 +12207,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;
@@ -12575,7 +12867,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, {});
     }
@@ -12775,16 +13067,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));
@@ -12859,9 +13151,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));
 }
@@ -12890,10 +13182,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 : {};
@@ -15064,7 +15356,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;
 }
@@ -15176,7 +15468,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)
@@ -16025,9 +16317,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;
@@ -16061,10 +16353,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);
@@ -17094,9 +17386,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));
 }
@@ -17127,10 +17419,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);
@@ -17147,7 +17439,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 });
@@ -18213,184 +18505,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(() => {
   /*! *****************************************************************************
@@ -22452,13 +22566,13 @@ function resolveBrokerUrl(host, port, scope, env = process.env, lanHost = findLa
     return explicit;
   }
   if (scope === "mesh") {
+    if (lanHost) {
+      return buildDefaultBrokerHttpsUrl(lanHost, port);
+    }
     const tailnetHost = readTailscaleSelfWebHostsSync(env)[0];
     if (tailnetHost) {
       return buildDefaultBrokerHttpsUrl(tailnetHost, port);
     }
-    if (lanHost) {
-      return buildDefaultBrokerHttpsUrl(lanHost, port);
-    }
   }
   return buildDefaultBrokerUrl(host, port);
 }
@@ -28357,6 +28471,9 @@ function normalizeManagedHarness(value, fallback2) {
   if (value === "pi") {
     return "pi";
   }
+  if (value === "opencode") {
+    return "opencode";
+  }
   return fallback2;
 }
 function titleCase(value) {
@@ -29096,7 +29213,8 @@ async function detectHarnessMarkers(projectRoot) {
     grok: [],
     "grok-acp": [],
     kimi: [],
-    pi: []
+    pi: [],
+    opencode: []
   };
   for (const harness of MANAGED_AGENT_HARNESSES) {
     for (const marker of PROJECT_HARNESS_MARKERS[harness]) {
@@ -29313,6 +29431,8 @@ async function readRelayAgentOverrides() {
   }));
 }
 async function writeRelayAgentOverrides(overrides) {
+  assertTestIsolatedUserData("write the relay-agents registry", "OPENSCOUT_SUPPORT_DIRECTORY");
+  const registryPath = resolveOpenScoutSupportPaths().relayAgentsRegistryPath;
   const normalizedAgents = Object.fromEntries(Object.entries(overrides).map(([agentId, record2]) => {
     const definitionId = normalizeAgentId(record2.definitionId || record2.agentId || agentId);
     const projectRoot = normalizePath(record2.projectRoot);
@@ -29346,7 +29466,11 @@ async function writeRelayAgentOverrides(overrides) {
       }
     ];
   }));
-  await writeJsonFile(resolveOpenScoutSupportPaths().relayAgentsRegistryPath, {
+  const registryPathNow = resolveOpenScoutSupportPaths().relayAgentsRegistryPath;
+  if (registryPathNow !== registryPath) {
+    throw new Error(`Refusing to write the relay-agents registry: target moved from ${registryPath} to ${registryPathNow} mid-write (test teardown?).`);
+  }
+  await writeJsonFile(registryPath, {
     version: 1,
     agents: normalizedAgents
   });
@@ -30074,7 +30198,7 @@ var init_setup = __esm(() => {
   init_open_scout_network();
   init_support_paths();
   init_user_project_hints();
-  MANAGED_AGENT_HARNESSES = ["claude", "codex", "cursor", "grok", "grok-acp", "kimi", "pi"];
+  MANAGED_AGENT_HARNESSES = ["claude", "codex", "cursor", "grok", "grok-acp", "kimi", "pi", "opencode"];
   DEFAULT_OPERATOR_NAME = guessedOperatorName();
   DEFAULT_CAPABILITIES = ["chat", "invoke", "deliver"];
   PROJECT_SCAN_SKIP_DIRECTORIES = new Set([
@@ -30177,6 +30301,10 @@ var init_setup = __esm(() => {
     pi: [
       "PI.md",
       ".pi"
+    ],
+    opencode: [
+      "OPENCODE.md",
+      ".opencode"
     ]
   };
   PROJECT_STRONG_MARKERS_FLAT_NESTED = partitionFlatAndNestedMarkers(PROJECT_STRONG_MARKERS);
@@ -32993,7 +33121,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;
@@ -33011,11 +33139,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 {};
@@ -34379,7 +34507,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) {
@@ -34389,7 +34517,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join5;
+  sql2.join = join6;
   function identifier(value) {
     return new Name(value);
   }
@@ -37331,10 +37459,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;
@@ -50102,8 +50232,8 @@ function buildMeshRendezvousPresence(node, options = {}) {
   });
 }
 async function publishMeshRendezvousPresence(node, options) {
-  const presence = buildMeshRendezvousPresence(node, { ttlMs: options.config.ttlMs });
-  if (!presence) {
+  const presence2 = buildMeshRendezvousPresence(node, { ttlMs: options.config.ttlMs });
+  if (!presence2) {
     options.logger?.warn("[openscout-runtime] mesh rendezvous skipped: no reachable entrypoints to publish");
     return false;
   }
@@ -50115,7 +50245,7 @@ async function publishMeshRendezvousPresence(node, options) {
       accept: "application/json",
       ...rendezvousAuthHeaders(options.config)
     },
-    body: JSON.stringify(presence)
+    body: JSON.stringify(presence2)
   });
   if (!response.ok) {
     const detail = await response.text().catch(() => "");
@@ -51827,14 +51957,14 @@ class BrokerRendezvousService {
       }
       return consumedResponse(activeMatch, input.participantId);
     }
-    const presence = this.presences.get(key);
-    if (presence && presence.participantId !== input.participantId) {
+    const presence2 = this.presences.get(key);
+    if (presence2 && presence2.participantId !== input.participantId) {
       const match = {
         id: this.createMatchId(),
-        projectRoot: presence.projectRoot,
-        codename: presence.codename,
-        normalizedCodename: presence.normalizedCodename,
-        participantIds: [presence.participantId, input.participantId],
+        projectRoot: presence2.projectRoot,
+        codename: presence2.codename,
+        normalizedCodename: presence2.normalizedCodename,
+        participantIds: [presence2.participantId, input.participantId],
         createdAt: now,
         expiresAt: now + this.matchTtlMs
       };
@@ -51843,7 +51973,7 @@ class BrokerRendezvousService {
       this.resolveMatchedWaiters(key, match);
       return matchedResponse(match, input.participantId);
     }
-    if (!presence) {
+    if (!presence2) {
       const expiredInvite = this.expiredInvites.get(key);
       if (expiredInvite) {
         return expiredResponse(expiredInvite, input.participantId);
@@ -51860,9 +51990,9 @@ class BrokerRendezvousService {
       };
     }
     if (input.waitMs === 0) {
-      return waitingResponse(presence);
+      return waitingResponse(presence2);
     }
-    return await this.waitForMatch(key, presence, input.waitMs);
+    return await this.waitForMatch(key, presence2, input.waitMs);
   }
   create(projectRoot, participantId, requestedCodename) {
     const now = this.now();
@@ -51884,15 +52014,15 @@ class BrokerRendezvousService {
           suggestion: "choose_another_codename"
         };
       }
-      const presence = this.presences.get(key);
-      if (presence) {
+      const presence2 = this.presences.get(key);
+      if (presence2) {
         return {
           status: "codename_busy",
-          codename: presence.codename,
+          codename: presence2.codename,
           projectRoot,
           participantId,
           participantCount: 1,
-          expiresAt: presence.expiresAt,
+          expiresAt: presence2.expiresAt,
           suggestion: "choose_another_codename"
         };
       }
@@ -51910,7 +52040,7 @@ class BrokerRendezvousService {
     throw new Error("could not allocate a unique match codename");
   }
   createPresence(projectRoot, participantId, codename, normalizedCodename, now) {
-    const presence = {
+    const presence2 = {
       participantId,
       projectRoot,
       codename,
@@ -51918,14 +52048,14 @@ class BrokerRendezvousService {
       joinedAt: now,
       expiresAt: now + this.presenceTtlMs
     };
-    this.presences.set(rendezvousKey(projectRoot, normalizedCodename), presence);
+    this.presences.set(rendezvousKey(projectRoot, normalizedCodename), presence2);
     return {
       status: "created",
       codename,
       projectRoot,
       participantId,
       createdAt: now,
-      expiresAt: presence.expiresAt
+      expiresAt: presence2.expiresAt
     };
   }
   hasCodenameInAnotherProject(projectRoot, normalizedCodename) {
@@ -51937,11 +52067,11 @@ class BrokerRendezvousService {
   }
   cleanupExpired() {
     const now = this.now();
-    for (const [key, presence] of this.presences) {
-      if (presence.expiresAt > now)
+    for (const [key, presence2] of this.presences) {
+      if (presence2.expiresAt > now)
         continue;
       this.presences.delete(key);
-      const expiredInvite = this.recordExpiredInvite(presence);
+      const expiredInvite = this.recordExpiredInvite(presence2);
       this.resolveExpiredWaiters(key, expiredInvite);
     }
     for (const [key, match] of this.matches) {
@@ -51959,18 +52089,18 @@ class BrokerRendezvousService {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
     }
-    for (const [key, presence] of this.presences) {
-      this.resolveExpiredWaiters(key, this.recordExpiredInvite(presence));
+    for (const [key, presence2] of this.presences) {
+      this.resolveExpiredWaiters(key, this.recordExpiredInvite(presence2));
     }
     this.presences.clear();
     this.matches.clear();
     this.expiredInvites.clear();
   }
-  waitForMatch(key, presence, waitMs) {
+  waitForMatch(key, presence2, waitMs) {
     return new Promise((resolveWait) => {
-      const waitDuration = Math.min(waitMs, Math.max(0, presence.expiresAt - this.now()));
+      const waitDuration = Math.min(waitMs, Math.max(0, presence2.expiresAt - this.now()));
       const waiter = {
-        participantId: presence.participantId,
+        participantId: presence2.participantId,
         resolve: resolveWait,
         timer: setTimeout(() => {
           this.removeWaiter(key, waiter);
@@ -51991,7 +52121,7 @@ class BrokerRendezvousService {
             resolveWait(expiredResponse(expiredInvite, waiter.participantId));
             return;
           }
-          resolveWait(notFoundResponse(presence, waiter.participantId));
+          resolveWait(notFoundResponse(presence2, waiter.participantId));
         }, waitDuration)
       };
       waiter.timer.unref?.();
@@ -52020,15 +52150,15 @@ class BrokerRendezvousService {
       waiter.resolve(expiredResponse(expiredInvite, waiter.participantId));
     }
   }
-  recordExpiredInvite(presence) {
+  recordExpiredInvite(presence2) {
     const expiredInvite = {
-      projectRoot: presence.projectRoot,
-      codename: presence.codename,
-      normalizedCodename: presence.normalizedCodename,
-      inviteExpiresAt: presence.expiresAt,
+      projectRoot: presence2.projectRoot,
+      codename: presence2.codename,
+      normalizedCodename: presence2.normalizedCodename,
+      inviteExpiresAt: presence2.expiresAt,
       retainUntil: this.now() + this.matchTtlMs
     };
-    this.expiredInvites.set(rendezvousKey(presence.projectRoot, presence.normalizedCodename), expiredInvite);
+    this.expiredInvites.set(rendezvousKey(presence2.projectRoot, presence2.normalizedCodename), expiredInvite);
     return expiredInvite;
   }
   removeWaiter(key, waiter) {
@@ -52107,14 +52237,14 @@ function createRandomInviteCodename() {
 function rendezvousKey(projectRoot, normalizedCodename) {
   return `${projectRoot}\x00${normalizedCodename}`;
 }
-function waitingResponse(presence) {
+function waitingResponse(presence2) {
   return {
     status: "waiting",
-    codename: presence.codename,
-    projectRoot: presence.projectRoot,
-    participantId: presence.participantId,
-    joinedAt: presence.joinedAt,
-    expiresAt: presence.expiresAt
+    codename: presence2.codename,
+    projectRoot: presence2.projectRoot,
+    participantId: presence2.participantId,
+    joinedAt: presence2.joinedAt,
+    expiresAt: presence2.expiresAt
   };
 }
 function matchedResponse(match, participantId) {
@@ -52159,11 +52289,11 @@ function projectMismatchResponse(input) {
     suggestion: "run_in_invitation_project"
   };
 }
-function notFoundResponse(presence, participantId) {
+function notFoundResponse(presence2, participantId) {
   return {
     status: "not_found",
-    codename: presence.codename,
-    projectRoot: presence.projectRoot,
+    codename: presence2.codename,
+    projectRoot: presence2.projectRoot,
     participantId,
     suggestion: "check_codename_or_create"
   };
@@ -53765,6 +53895,126 @@ async function broadcastApnsAlertToActiveMobileDevices(alert) {
 // ../runtime/src/index.ts
 init_permission_policy2();
 
+// ../runtime/src/activity-transitions.ts
+class ActivityTransitionTracker {
+  transitions = new Map;
+  record(agentId, activity2, observedAt, now) {
+    const previous = this.transitions.get(agentId);
+    if (previous && previous.activity === activity2) {
+      return previous.transitionAt;
+    }
+    const transitionAt = Number.isFinite(observedAt) ? Math.min(observedAt, now) : now;
+    this.transitions.set(agentId, { activity: activity2, transitionAt });
+    return transitionAt;
+  }
+  peek(agentId) {
+    const transition = this.transitions.get(agentId);
+    return transition ? { ...transition } : undefined;
+  }
+  forget(agentId) {
+    this.transitions.delete(agentId);
+  }
+  clear() {
+    this.transitions.clear();
+  }
+  size() {
+    return this.transitions.size;
+  }
+}
+// ../runtime/src/presence-map.ts
+init_src();
+var DEFAULT_DETAIL_DEBOUNCE_MS = 5000;
+
+class BrokerPresenceMap {
+  beats = new Map;
+  lastDetailChangeAt = new Map;
+  staleAfterMs;
+  goneAfterStaleMs;
+  detailDebounceMs;
+  transitions;
+  constructor(options = {}) {
+    this.staleAfterMs = options.staleAfterMs ?? PRESENCE_STALE_AFTER_MS;
+    this.goneAfterStaleMs = options.goneAfterStaleMs ?? PRESENCE_GONE_AFTER_STALE_MS;
+    this.detailDebounceMs = options.detailDebounceMs ?? DEFAULT_DETAIL_DEBOUNCE_MS;
+    this.transitions = options.transitions ?? new ActivityTransitionTracker;
+  }
+  observe(observation, now) {
+    const agentId = observation.agentId ?? observation.status.agentId ?? observation.status.subjectId;
+    if (!agentId)
+      return;
+    const status = observation.status;
+    if (isTransportInferredStall(status))
+      return;
+    const updatedAt = Math.min(status.updatedAt, now);
+    const staleAt = Math.max(status.staleAt ?? 0, updatedAt + this.staleAfterMs);
+    if (isPresenceGone({ staleAt }, now, { goneAfterStaleMs: this.goneAfterStaleMs })) {
+      this.forget(agentId);
+      return;
+    }
+    const previous = this.beats.get(agentId);
+    const detail = status.detail?.title ?? undefined;
+    const transitionAt = this.transitions.record(agentId, status.activity, status.transitionAt ?? status.updatedAt, now);
+    const activityChanged = previous?.activity !== status.activity;
+    const detailChanged = previous !== undefined && previous.detail !== detail;
+    const debounceElapsed = now - (this.lastDetailChangeAt.get(agentId) ?? 0) >= this.detailDebounceMs;
+    const transitioned = previous === undefined || activityChanged || detailChanged && debounceElapsed;
+    if (activityChanged || detailChanged && debounceElapsed) {
+      this.lastDetailChangeAt.set(agentId, now);
+    }
+    const beat = {
+      agentId,
+      displayName: observation.displayName ?? previous?.displayName,
+      activity: status.activity,
+      phase: status.phase,
+      detail,
+      transitionAt,
+      updatedAt,
+      staleAt,
+      confidence: status.confidence,
+      needRef: observation.needRef,
+      boundConversationId: observation.boundConversationId
+    };
+    this.beats.set(agentId, beat);
+    return { beat, transitioned, previousActivity: previous?.activity };
+  }
+  snapshot(now) {
+    this.prune(now);
+    return { at: now, beats: [...this.beats.values()] };
+  }
+  get(agentId) {
+    return this.beats.get(agentId);
+  }
+  prune(now) {
+    const dropped = [];
+    for (const [agentId, beat] of this.beats) {
+      if (!isPresenceGone(beat, now, { goneAfterStaleMs: this.goneAfterStaleMs }))
+        continue;
+      this.beats.delete(agentId);
+      this.lastDetailChangeAt.delete(agentId);
+      this.transitions.forget(agentId);
+      dropped.push(agentId);
+    }
+    return dropped;
+  }
+  forget(agentId) {
+    this.beats.delete(agentId);
+    this.lastDetailChangeAt.delete(agentId);
+    this.transitions.forget(agentId);
+  }
+  clear() {
+    this.beats.clear();
+    this.lastDetailChangeAt.clear();
+    this.transitions.clear();
+  }
+  size() {
+    return this.beats.size;
+  }
+}
+function isTransportInferredStall(status) {
+  if (status.activity !== "stalled")
+    return false;
+  return status.provenance.some((entry) => entry.source === "staleness_inference");
+}
 // ../runtime/src/session-attention.ts
 init_src2();
 var BLOCKED_STATUS_PATTERN = /\b(blocked|needs[-_\s]?input|awaiting[-_\s]?(input|answer|approval)|waiting[-_\s]?for[-_\s]?(input|approval)|requires[-_\s]?action)\b/i;
@@ -62960,7 +63210,7 @@ function readScoutPairingRuntimePid() {
     return null;
   }
 }
-function isScoutPairingProcessRunning(pid) {
+function isScoutPairingProcessRunning2(pid) {
   if (!pid || !Number.isInteger(pid) || pid <= 0) {
     return false;
   }
@@ -62973,11 +63223,11 @@ 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 pairingMutationChain = Promise.resolve();
 async function getScoutWebPairingSessionSnapshots() {