@openscout/scout 0.2.51 → 0.2.53

package/dist/pair-supervisor.mjs

@@ -3376,7 +3376,7 @@ function writeJsonAtomically(filePath, value) {
 }
 
 // ../../apps/desktop/src/core/pairing/runtime/runtime.ts
-import { homedir as homedir17 } from "os";
+import { homedir as homedir18 } from "os";
 // ../agent-sessions/src/protocol/adapter.ts
 class BaseAdapter {
   config;
@@ -4436,9 +4436,144 @@ function decodeClaudeProjectsSlug(slug) {
 }
 // ../agent-sessions/src/adapters/codex.ts
 import { spawn } from "child_process";
-import { access, appendFile, constants, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { delimiter, join as join4 } from "path";
+import { access, appendFile, constants as constants2, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { delimiter as delimiter2, join as join5 } from "path";
+import { homedir as homedir6 } from "os";
+
+// ../agent-sessions/src/codex-launch-config.ts
+import { accessSync, constants, existsSync as existsSync6 } from "fs";
 import { homedir as homedir5 } from "os";
+import { basename, delimiter, dirname, join as join4, resolve } from "path";
+import { fileURLToPath } from "url";
+function isExecutable(filePath) {
+  if (!filePath) {
+    return false;
+  }
+  try {
+    accessSync(filePath, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function uniquePaths(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => resolve(value)))];
+}
+function ancestorChain(start) {
+  const chain = [];
+  let current = resolve(start);
+  while (true) {
+    chain.push(current);
+    const parent = dirname(current);
+    if (parent === current) {
+      return chain;
+    }
+    current = parent;
+  }
+}
+function resolveExecutableFromSearchPath(names, env) {
+  const pathEntries = (env.PATH ?? "").split(delimiter).filter(Boolean);
+  const commonDirectories = [
+    join4(homedir5(), ".local", "bin"),
+    join4(homedir5(), ".bun", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin"
+  ];
+  for (const directory of [...pathEntries, ...commonDirectories]) {
+    for (const name of names) {
+      const candidate = join4(directory, name);
+      if (isExecutable(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function resolveBunExecutable(env) {
+  const explicitCandidates = [
+    env.OPENSCOUT_BUN_BIN,
+    env.SCOUT_BUN_BIN,
+    env.BUN_BIN
+  ];
+  for (const candidate of explicitCandidates) {
+    if (isExecutable(candidate)) {
+      return candidate;
+    }
+  }
+  if (basename(process.execPath).startsWith("bun") && isExecutable(process.execPath)) {
+    return process.execPath;
+  }
+  return resolveExecutableFromSearchPath(["bun"], env);
+}
+function resolveScoutExecutable(env) {
+  const explicitCandidates = [
+    env.OPENSCOUT_CLI_BIN,
+    env.SCOUT_CLI_BIN,
+    env.OPENSCOUT_SCOUT_BIN,
+    env.SCOUT_BIN
+  ];
+  for (const candidate of explicitCandidates) {
+    if (isExecutable(candidate)) {
+      return candidate;
+    }
+  }
+  return resolveExecutableFromSearchPath(["scout"], env);
+}
+function resolveRepoScoutScript(currentDirectory) {
+  const moduleDirectory = dirname(fileURLToPath(import.meta.url));
+  const starts = uniquePaths([currentDirectory, moduleDirectory]);
+  for (const start of starts) {
+    for (const candidate of ancestorChain(start)) {
+      const scriptPath = join4(candidate, "apps", "desktop", "bin", "scout.ts");
+      if (existsSync6(scriptPath)) {
+        return scriptPath;
+      }
+    }
+  }
+  return null;
+}
+function resolveContextRoot(currentDirectory, env) {
+  const configured = env.OPENSCOUT_SETUP_CWD?.trim();
+  return resolve(configured || currentDirectory);
+}
+function resolveScoutMcpCommand(options) {
+  const env = options.env ?? process.env;
+  const contextRoot = resolveContextRoot(options.currentDirectory, env);
+  const scoutExecutable = resolveScoutExecutable(env);
+  if (scoutExecutable) {
+    return {
+      command: scoutExecutable,
+      args: ["mcp", "--context-root", contextRoot],
+      cwd: contextRoot
+    };
+  }
+  const scoutScript = resolveRepoScoutScript(options.currentDirectory);
+  const bunExecutable = resolveBunExecutable(env);
+  if (scoutScript && bunExecutable) {
+    return {
+      command: bunExecutable,
+      args: [scoutScript, "mcp", "--context-root", contextRoot],
+      cwd: contextRoot
+    };
+  }
+  return null;
+}
+function buildScoutMcpCodexLaunchArgs(options) {
+  const resolved = resolveScoutMcpCommand(options);
+  if (!resolved) {
+    return [];
+  }
+  return [
+    "-c",
+    `mcp_servers.scout.command=${JSON.stringify(resolved.command)}`,
+    "-c",
+    `mcp_servers.scout.args=${JSON.stringify(resolved.args)}`,
+    "-c",
+    `mcp_servers.scout.cwd=${JSON.stringify(resolved.cwd)}`
+  ];
+}
+
+// ../agent-sessions/src/adapters/codex.ts
 function parseJsonLine(line) {
   try {
     return JSON.parse(line);
@@ -4559,12 +4694,12 @@ function renderActionOutput(item) {
 function isMissingCodexRolloutError(error) {
   return errorMessage(error).toLowerCase().includes("no rollout found for thread id");
 }
-async function isExecutable(filePath) {
+async function isExecutable2(filePath) {
   if (!filePath) {
     return false;
   }
   try {
-    await access(filePath, constants.X_OK);
+    await access(filePath, constants2.X_OK);
     return true;
   } catch {
     return false;
@@ -4576,11 +4711,11 @@ async function resolveCodexExecutable() {
     process.env.CODEX_BIN
   ].filter(Boolean);
   for (const candidate of explicitCandidates) {
-    if (await isExecutable(candidate)) {
+    if (await isExecutable2(candidate)) {
       return candidate;
     }
   }
-  const pathEntries = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  const pathEntries = (process.env.PATH ?? "").split(delimiter2).filter(Boolean);
   const commonDirectories = [
     `${process.env.HOME ?? ""}/.local/bin`,
     `${process.env.HOME ?? ""}/.bun/bin`,
@@ -4588,8 +4723,8 @@ async function resolveCodexExecutable() {
     "/usr/local/bin"
   ].filter(Boolean);
   for (const directory of [...pathEntries, ...commonDirectories]) {
-    const candidate = join4(directory, "codex");
-    if (await isExecutable(candidate)) {
+    const candidate = join5(directory, "codex");
+    if (await isExecutable2(candidate)) {
       return candidate;
     }
   }
@@ -4691,7 +4826,7 @@ class CodexAdapter extends BaseAdapter {
     this.pendingRequests.clear();
     if (child && child.exitCode === null && !child.killed) {
       child.kill("SIGTERM");
-      await new Promise((resolve) => setTimeout(resolve, 250));
+      await new Promise((resolve2) => setTimeout(resolve2, 250));
       if (child.exitCode === null && !child.killed) {
         child.kill("SIGKILL");
       }
@@ -4700,7 +4835,7 @@ class CodexAdapter extends BaseAdapter {
     await this.persistState();
   }
   get codexOptions() {
-    const runtimeRoot = join4(homedir5(), ".scout/pairing", "codex", this.session.id);
+    const runtimeRoot = join5(homedir6(), ".scout/pairing", "codex", this.session.id);
     const configuredThreadId = this.config.options?.["threadId"];
     const requireExistingThread = this.config.options?.["requireExistingThread"];
     const rawLaunchArgs = this.config.options?.["launchArgs"];
@@ -4710,8 +4845,8 @@ class CodexAdapter extends BaseAdapter {
       sessionId: this.session.id,
       cwd: this.config.cwd ?? process.cwd(),
       systemPrompt: this.systemPrompt,
-      runtimeDirectory: join4(runtimeRoot, "runtime"),
-      logsDirectory: join4(runtimeRoot, "logs"),
+      runtimeDirectory: join5(runtimeRoot, "runtime"),
+      logsDirectory: join5(runtimeRoot, "logs"),
       launchArgs,
       threadId: typeof configuredThreadId === "string" && configuredThreadId.trim().length > 0 ? configuredThreadId.trim() : undefined,
       requireExistingThread: requireExistingThread ?? Boolean(configuredThreadId)
@@ -4722,16 +4857,16 @@ class CodexAdapter extends BaseAdapter {
     return typeof raw === "string" && raw.trim().length > 0 ? raw : "You are a helpful agent working through Pairing.";
   }
   get threadIdPath() {
-    return join4(this.codexOptions.runtimeDirectory, "codex-thread-id.txt");
+    return join5(this.codexOptions.runtimeDirectory, "codex-thread-id.txt");
   }
   get statePath() {
-    return join4(this.codexOptions.runtimeDirectory, "state.json");
+    return join5(this.codexOptions.runtimeDirectory, "state.json");
   }
   get stdoutLogPath() {
-    return join4(this.codexOptions.logsDirectory, "stdout.log");
+    return join5(this.codexOptions.logsDirectory, "stdout.log");
   }
   get stderrLogPath() {
-    return join4(this.codexOptions.logsDirectory, "stderr.log");
+    return join5(this.codexOptions.logsDirectory, "stderr.log");
   }
   enqueue(task) {
     const next = this.serialized.then(task, task);
@@ -4760,14 +4895,22 @@ class CodexAdapter extends BaseAdapter {
     const options = this.codexOptions;
     await mkdir(options.runtimeDirectory, { recursive: true });
     await mkdir(options.logsDirectory, { recursive: true });
-    await writeFile(join4(options.runtimeDirectory, "prompt.txt"), options.systemPrompt);
+    await writeFile(join5(options.runtimeDirectory, "prompt.txt"), options.systemPrompt);
     const codexExecutable = await resolveCodexExecutable();
-    const child = spawn(codexExecutable, ["app-server", ...options.launchArgs], {
+    const childEnv = {
+      ...process.env,
+      ...this.config.env ?? {}
+    };
+    const child = spawn(codexExecutable, [
+      "app-server",
+      ...buildScoutMcpCodexLaunchArgs({
+        currentDirectory: options.cwd,
+        env: childEnv
+      }),
+      ...options.launchArgs
+    ], {
       cwd: options.cwd,
-      env: {
-        ...process.env,
-        ...this.config.env ?? {}
-      },
+      env: childEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.process = child;
@@ -5477,9 +5620,9 @@ class CodexAdapter extends BaseAdapter {
   }
   async request(method, params) {
     const id = String(this.nextRequestId++);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.pendingRequests.set(id, {
-        resolve: (value) => resolve(value),
+        resolve: (value) => resolve2(value),
         reject
       });
       try {
@@ -6825,8 +6968,8 @@ class EchoAdapter extends BaseAdapter {
         blockId: actionId,
         approval: { version: 1, description: `Run echo tool with: ${text}`, risk: "low" }
       });
-      const decision = await new Promise((resolve) => {
-        this.pendingApprovals.set(this.approvalKey(turnId, actionId), { resolve });
+      const decision = await new Promise((resolve2) => {
+        this.pendingApprovals.set(this.approvalKey(turnId, actionId), { resolve: resolve2 });
       });
       if (this.interrupted) {
         this.emitTurnEnd(sessionId, turnId, "stopped");
@@ -6901,15 +7044,15 @@ class EchoAdapter extends BaseAdapter {
   delay() {
     if (this.stepDelay <= 0)
       return Promise.resolve();
-    return new Promise((resolve) => setTimeout(resolve, this.stepDelay));
+    return new Promise((resolve2) => setTimeout(resolve2, this.stepDelay));
   }
 }
 // ../../apps/desktop/src/core/pairing/runtime/bridge/log.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir6 } from "os";
-var LOG_DIR = join5(homedir6(), ".scout/pairing");
-var LOG_FILE = join5(LOG_DIR, "bridge.log");
+import { join as join6 } from "path";
+import { homedir as homedir7 } from "os";
+var LOG_DIR = join6(homedir7(), ".scout/pairing");
+var LOG_FILE = join6(LOG_DIR, "bridge.log");
 mkdirSync6(LOG_DIR, { recursive: true });
 function write2(level, category, message, data) {
   const ts = new Date().toISOString().slice(11, 23);
@@ -6993,17 +7136,17 @@ class Bridge {
 }
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir7 } from "os";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir8 } from "os";
 var DEFAULTS = {
   port: 7888,
   secure: true
 };
-var CONFIG_DIR = join6(homedir7(), ".scout/pairing");
-var CONFIG_FILE = join6(CONFIG_DIR, "config.json");
+var CONFIG_DIR = join7(homedir8(), ".scout/pairing");
+var CONFIG_FILE = join7(CONFIG_DIR, "config.json");
 function loadConfigFile() {
-  if (!existsSync6(CONFIG_FILE)) {
+  if (!existsSync7(CONFIG_FILE)) {
     return {};
   }
   try {
@@ -7061,12 +7204,12 @@ function resolveConfig() {
 
 // ../../apps/desktop/src/core/pairing/runtime/bridge/fileserver.ts
 import { isAbsolute } from "path";
-import { homedir as homedir8 } from "os";
-var ALLOWED_ROOTS = [homedir8(), "/tmp"];
+import { homedir as homedir9 } from "os";
+var ALLOWED_ROOTS = [homedir9(), "/tmp"];
 function isAllowedPath(filePath) {
   if (!isAbsolute(filePath))
     return false;
-  const relToHome = filePath.slice(homedir8().length + 1);
+  const relToHome = filePath.slice(homedir9().length + 1);
   if (relToHome.startsWith(".") && !relToHome.startsWith(".claude") && !relToHome.startsWith(".scout/pairing")) {
     return false;
   }
@@ -7127,56 +7270,56 @@ function serveFile(url) {
 // ../../apps/desktop/src/core/pairing/runtime/bridge/server.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync8, realpathSync, statSync as statSync3 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import { basename as basename5, isAbsolute as isAbsolute3, join as join16, relative as relative2 } from "path";
-import { homedir as homedir14 } from "os";
+import { basename as basename6, isAbsolute as isAbsolute3, join as join17, relative as relative2 } from "path";
+import { homedir as homedir15 } from "os";
 
 // ../../apps/desktop/src/core/mobile/service.ts
-import { basename as basename4, resolve as resolve5 } from "path";
+import { basename as basename5, resolve as resolve6 } from "path";
 
 // ../runtime/src/harness-catalog.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync8, statSync as statSync2 } from "fs";
+import { existsSync as existsSync9, statSync as statSync2 } from "fs";
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join as join8 } from "path";
+import { dirname as dirname2, join as join9 } from "path";
 
 // ../runtime/src/support-paths.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, rmSync, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join8 } from "path";
 var OPENSCOUT_RPC_CUTOVER_MARKER = "rpc-runtime-cutover-v1";
 function resolveOpenScoutSupportPaths() {
-  const home = homedir9();
-  const supportDirectory = process.env.OPENSCOUT_SUPPORT_DIRECTORY ?? join7(home, "Library", "Application Support", "OpenScout");
-  const logsDirectory = join7(supportDirectory, "logs");
-  const runtimeDirectory = join7(supportDirectory, "runtime");
-  const catalogDirectory = join7(supportDirectory, "catalog");
+  const home = homedir10();
+  const supportDirectory = process.env.OPENSCOUT_SUPPORT_DIRECTORY ?? join8(home, "Library", "Application Support", "OpenScout");
+  const logsDirectory = join8(supportDirectory, "logs");
+  const runtimeDirectory = join8(supportDirectory, "runtime");
+  const catalogDirectory = join8(supportDirectory, "catalog");
   return {
     supportDirectory,
     logsDirectory,
-    appLogsDirectory: join7(logsDirectory, "app"),
-    brokerLogsDirectory: join7(logsDirectory, "broker"),
+    appLogsDirectory: join8(logsDirectory, "app"),
+    brokerLogsDirectory: join8(logsDirectory, "broker"),
     runtimeDirectory,
     catalogDirectory,
-    relayAgentsDirectory: join7(runtimeDirectory, "agents"),
-    settingsPath: join7(supportDirectory, "settings.json"),
-    harnessCatalogPath: join7(catalogDirectory, "harness-catalog.json"),
-    relayAgentsRegistryPath: join7(supportDirectory, "relay-agents.json"),
-    relayHubDirectory: process.env.OPENSCOUT_RELAY_HUB ?? join7(home, ".openscout", "relay"),
-    controlHome: process.env.OPENSCOUT_CONTROL_HOME ?? join7(home, ".openscout", "control-plane"),
-    desktopStatusPath: join7(supportDirectory, "agent-status.json"),
-    workspaceStatePath: join7(supportDirectory, "workspace-state.json"),
-    cutoverMarkerPath: join7(supportDirectory, OPENSCOUT_RPC_CUTOVER_MARKER)
+    relayAgentsDirectory: join8(runtimeDirectory, "agents"),
+    settingsPath: join8(supportDirectory, "settings.json"),
+    harnessCatalogPath: join8(catalogDirectory, "harness-catalog.json"),
+    relayAgentsRegistryPath: join8(supportDirectory, "relay-agents.json"),
+    relayHubDirectory: process.env.OPENSCOUT_RELAY_HUB ?? join8(home, ".openscout", "relay"),
+    controlHome: process.env.OPENSCOUT_CONTROL_HOME ?? join8(home, ".openscout", "control-plane"),
+    desktopStatusPath: join8(supportDirectory, "agent-status.json"),
+    workspaceStatePath: join8(supportDirectory, "workspace-state.json"),
+    cutoverMarkerPath: join8(supportDirectory, OPENSCOUT_RPC_CUTOVER_MARKER)
   };
 }
 function relayAgentRuntimeDirectory(agentId) {
-  return join7(resolveOpenScoutSupportPaths().relayAgentsDirectory, agentId);
+  return join8(resolveOpenScoutSupportPaths().relayAgentsDirectory, agentId);
 }
 function relayAgentLogsDirectory(agentId) {
-  return join7(relayAgentRuntimeDirectory(agentId), "logs");
+  return join8(relayAgentRuntimeDirectory(agentId), "logs");
 }
 function ensureOpenScoutCleanSlateSync() {
   const paths = resolveOpenScoutSupportPaths();
-  if (existsSync7(paths.cutoverMarkerPath)) {
+  if (existsSync8(paths.cutoverMarkerPath)) {
     return;
   }
   rmSync(paths.supportDirectory, { recursive: true, force: true });
@@ -7267,7 +7410,7 @@ function expandHomePath(value) {
   if (value === "~")
     return process.env.HOME || value;
   if (value.startsWith("~/"))
-    return join8(process.env.HOME || "~", value.slice(2));
+    return join9(process.env.HOME || "~", value.slice(2));
   return value;
 }
 function defaultWhichBinary(binary, platform) {
@@ -7301,7 +7444,7 @@ function defaultRunCommand(command, platform) {
 }
 function defaultRequirementExists(requirement) {
   const expanded = expandHomePath(requirement.path);
-  if (!existsSync8(expanded))
+  if (!existsSync9(expanded))
     return false;
   if (requirement.fileType === "any" || !requirement.fileType)
     return true;
@@ -7496,7 +7639,7 @@ async function readHarnessCatalogOverrides(overridePath = resolveOpenScoutSuppor
   }
 }
 async function writeHarnessCatalogOverrides(overrides, overridePath = resolveOpenScoutSupportPaths().harnessCatalogPath) {
-  await mkdir2(dirname(overridePath), { recursive: true });
+  await mkdir2(dirname2(overridePath), { recursive: true });
   const payload = {
     version: HARNESS_CATALOG_VERSION,
     entries: overrides,
@@ -7506,7 +7649,7 @@ async function writeHarnessCatalogOverrides(overrides, overridePath = resolveOpe
 `, "utf8");
 }
 async function ensureHarnessCatalogOverrideFile(overridePath = resolveOpenScoutSupportPaths().harnessCatalogPath) {
-  if (existsSync8(overridePath))
+  if (existsSync9(overridePath))
     return;
   await writeHarnessCatalogOverrides({}, overridePath);
 }
@@ -7529,11 +7672,11 @@ async function loadHarnessCatalogSnapshot(options = {}) {
 
 // ../runtime/src/setup.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync5 } from "fs";
 import { access as access2, mkdir as mkdir3, readdir as readdir2, readFile as readFile4, realpath, rm as rm2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
-import { homedir as homedir11, hostname, userInfo } from "os";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join10, relative, resolve as resolve2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { homedir as homedir12, hostname, userInfo } from "os";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, join as join11, relative, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // ../../node_modules/.bun/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
 /*!
@@ -8766,9 +8909,9 @@ function buildScoutReturnAddress(input) {
 }
 // ../runtime/src/user-project-hints.ts
 import { readdir, readFile as readFile3, stat } from "fs/promises";
-import { homedir as homedir10 } from "os";
-import { dirname as dirname2, join as join9, resolve } from "path";
-import { fileURLToPath } from "url";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname3, join as join10, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var PROJECT_HINT_MARKERS = [
   ".git",
   ".openscout/project.json",
@@ -8793,18 +8936,18 @@ function decodeClaudeProjectsSlug2(name) {
   return `/${tail.replace(/-/g, "/")}`;
 }
 function encodeClaudeProjectsSlug(absolutePath) {
-  const normalized = resolve(absolutePath);
+  const normalized = resolve2(absolutePath);
   return `-${normalized.replace(/^\//, "").replace(/\//g, "-")}`;
 }
 async function resolveExistingDirectoryHint(pathLike) {
-  const absolutePath = resolve(pathLike);
+  const absolutePath = resolve2(pathLike);
   try {
     const info = await stat(absolutePath);
     if (info.isDirectory()) {
       return absolutePath;
     }
     if (info.isFile()) {
-      return dirname2(absolutePath);
+      return dirname3(absolutePath);
     }
   } catch {
     return null;
@@ -8820,18 +8963,18 @@ async function pathExists(pathLike) {
   }
 }
 async function findLikelyProjectRoot(absolutePath) {
-  let current = resolve(absolutePath);
+  let current = resolve2(absolutePath);
   let lastCandidate = null;
   while (true) {
     for (const marker of PROJECT_HINT_MARKERS) {
-      if (await pathExists(join9(current, marker))) {
+      if (await pathExists(join10(current, marker))) {
         lastCandidate = current;
         if (marker === ".git" || marker === ".openscout/project.json") {
           return current;
         }
       }
     }
-    const parent = dirname2(current);
+    const parent = dirname3(current);
     if (parent === current) {
       return lastCandidate ?? absolutePath;
     }
@@ -8847,16 +8990,16 @@ async function appendPathHint(pathLike, roots) {
 }
 function cursorWorkspaceStoragePath(home) {
   if (process.platform === "darwin") {
-    return join9(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+    return join10(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage");
   }
   if (process.platform === "win32") {
     const appData = process.env.APPDATA;
     if (appData) {
-      return join9(appData, "Cursor", "User", "workspaceStorage");
+      return join10(appData, "Cursor", "User", "workspaceStorage");
     }
-    return join9(home, "AppData", "Roaming", "Cursor", "User", "workspaceStorage");
+    return join10(home, "AppData", "Roaming", "Cursor", "User", "workspaceStorage");
   }
-  return join9(home, ".config", "Cursor", "User", "workspaceStorage");
+  return join10(home, ".config", "Cursor", "User", "workspaceStorage");
 }
 function collectPathLikeStrings(value, out, depth) {
   if (depth > 4 || value === null || value === undefined) {
@@ -8885,7 +9028,7 @@ function collectPathLikeStrings(value, out, depth) {
   }
 }
 async function appendCodexHistoryPaths(home, roots) {
-  const candidates = [join9(home, ".codex", "history.jsonl"), join9(home, ".openai-codex", "history.jsonl")];
+  const candidates = [join10(home, ".codex", "history.jsonl"), join10(home, ".openai-codex", "history.jsonl")];
   const maxLines = 2500;
   const maxBytes = 4 * 1024 * 1024;
   for (const filePath of candidates) {
@@ -8936,7 +9079,7 @@ async function appendCursorWorkspacePaths(home, roots) {
     return;
   }
   for (const id of ids) {
-    const workspaceJsonPath = join9(base, id, "workspace.json");
+    const workspaceJsonPath = join10(base, id, "workspace.json");
     let raw;
     try {
       raw = await readFile3(workspaceJsonPath, "utf8");
@@ -8951,13 +9094,13 @@ async function appendCursorWorkspacePaths(home, roots) {
     }
     if (typeof doc.folder === "string" && doc.folder.startsWith("file://")) {
       try {
-        const folderPath = fileURLToPath(doc.folder);
+        const folderPath = fileURLToPath2(doc.folder);
         await appendPathHint(folderPath, roots);
       } catch {}
     }
     if (typeof doc.workspace === "string" && doc.workspace.startsWith("file://")) {
       try {
-        const wsFile = fileURLToPath(doc.workspace);
+        const wsFile = fileURLToPath2(doc.workspace);
         if (!wsFile.endsWith(".code-workspace")) {
           continue;
         }
@@ -8972,12 +9115,12 @@ async function appendCursorWorkspacePaths(home, roots) {
         }
         const wsRaw = await readFile3(wsFile, "utf8");
         const wsDoc = JSON.parse(wsRaw);
-        const wsDir = dirname2(wsFile);
+        const wsDir = dirname3(wsFile);
         for (const f of wsDoc.folders ?? []) {
           if (typeof f.path !== "string" || !f.path) {
             continue;
           }
-          const resolvedPath = resolve(wsDir, f.path);
+          const resolvedPath = resolve2(wsDir, f.path);
           await appendPathHint(resolvedPath, roots);
         }
       } catch {}
@@ -8985,7 +9128,7 @@ async function appendCursorWorkspacePaths(home, roots) {
   }
 }
 async function appendClaudeProjectSlugs(home, roots) {
-  const projectsDir = join9(home, ".claude", "projects");
+  const projectsDir = join10(home, ".claude", "projects");
   let names = [];
   try {
     names = await readdir(projectsDir, { withFileTypes: false });
@@ -9001,7 +9144,7 @@ async function appendClaudeProjectSlugs(home, roots) {
   }
 }
 async function appendClaudeSessionPaths(home, roots) {
-  const projectsDir = join9(home, ".claude", "projects");
+  const projectsDir = join10(home, ".claude", "projects");
   const maxProjectDirectories = 200;
   const maxSessionFiles = 400;
   const maxLinesPerFile = 400;
@@ -9016,7 +9159,7 @@ async function appendClaudeSessionPaths(home, roots) {
   for (const projectName of projectNames) {
     let entries = [];
     try {
-      entries = await readdir(join9(projectsDir, projectName), { withFileTypes: false });
+      entries = await readdir(join10(projectsDir, projectName), { withFileTypes: false });
     } catch {
       continue;
     }
@@ -9027,7 +9170,7 @@ async function appendClaudeSessionPaths(home, roots) {
       if (!entry.endsWith(".jsonl")) {
         continue;
       }
-      const sessionPath = join9(projectsDir, projectName, entry);
+      const sessionPath = join10(projectsDir, projectName, entry);
       let info;
       try {
         info = await stat(sessionPath);
@@ -9069,7 +9212,7 @@ async function appendClaudeSessionPaths(home, roots) {
   }
 }
 async function collectUserLevelProjectRootHints(options = {}) {
-  const home = options.home ?? homedir10();
+  const home = options.home ?? homedir11();
   const roots = new Set;
   try {
     await appendClaudeProjectSlugs(home, roots);
@@ -9237,7 +9380,7 @@ async function matchNestedMarkers(projectRoot, nestedMarkers) {
   if (nestedMarkers.length === 0) {
     return [];
   }
-  const hits = await Promise.all(nestedMarkers.map(async (marker) => await pathExists2(join10(projectRoot, marker)) ? marker : null));
+  const hits = await Promise.all(nestedMarkers.map(async (marker) => await pathExists2(join11(projectRoot, marker)) ? marker : null));
   return hits.filter((marker) => Boolean(marker));
 }
 function nowSeconds() {
@@ -9245,21 +9388,21 @@ function nowSeconds() {
 }
 function expandHomePath2(value) {
   if (value === "~") {
-    return homedir11();
+    return homedir12();
   }
   if (value.startsWith("~/")) {
-    return join10(homedir11(), value.slice(2));
+    return join11(homedir12(), value.slice(2));
   }
   return value;
 }
 function normalizePath(value) {
-  return resolve2(expandHomePath2(value.trim() || "."));
+  return resolve3(expandHomePath2(value.trim() || "."));
 }
 function normalizeProjectRelativePath(projectRoot, value) {
   const expanded = expandHomePath2(value.trim() || ".");
-  return isAbsolute2(expanded) ? resolve2(expanded) : resolve2(projectRoot, expanded);
+  return isAbsolute2(expanded) ? resolve3(expanded) : resolve3(projectRoot, expanded);
 }
-function uniquePaths(values) {
+function uniquePaths2(values) {
   return Array.from(new Set(Array.from(values).map((value) => normalizePath(value))));
 }
 function normalizeAgentId(value) {
@@ -9326,16 +9469,16 @@ function resolveTelegramConfigSeedValue(key, currentDirectory) {
     return envValue;
   }
   if (currentDirectory) {
-    const currentDirValue = readEnvFileValue(join10(currentDirectory, ".env.local"), key).trim();
+    const currentDirValue = readEnvFileValue(join11(currentDirectory, ".env.local"), key).trim();
     if (currentDirValue) {
       return currentDirValue;
     }
   }
-  const home = homedir11();
+  const home = homedir12();
   if (!home) {
     return "";
   }
-  return readEnvFileValue(join10(home, ".env.local"), key).trim();
+  return readEnvFileValue(join11(home, ".env.local"), key).trim();
 }
 function normalizeTelegramBridgeMode(value) {
   const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
@@ -9612,13 +9755,13 @@ function defaultSettings() {
   };
 }
 function projectConfigPath(projectRoot) {
-  return join10(projectRoot, ".openscout", "project.json");
+  return join11(projectRoot, ".openscout", "project.json");
 }
 function projectGitignorePath(projectRoot) {
-  return join10(projectRoot, ".gitignore");
+  return join11(projectRoot, ".gitignore");
 }
 function legacyLocalRelayLinkPath(projectRoot) {
-  return join10(projectRoot, ".openscout", "relay.json");
+  return join11(projectRoot, ".openscout", "relay.json");
 }
 async function pathExists2(filePath) {
   try {
@@ -9644,15 +9787,15 @@ async function readJsonFile(filePath) {
   }
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir3(dirname3(filePath), { recursive: true });
+  await mkdir3(dirname4(filePath), { recursive: true });
   await writeFile3(filePath, JSON.stringify(value, null, 2) + `
 `, "utf8");
 }
 function codexEnvironmentPath(projectRoot) {
-  return join10(projectRoot, ".codex", "environments", "environment.toml");
+  return join11(projectRoot, ".codex", "environments", "environment.toml");
 }
 function currentHomeDirectory() {
-  return process.env.HOME?.trim() || homedir11();
+  return process.env.HOME?.trim() || homedir12();
 }
 function normalizeProjectScriptSet(value) {
   if (typeof value !== "object" || !value) {
@@ -9808,11 +9951,11 @@ async function readCodexEnvironmentImport(projectRoot) {
 }
 async function readClaudeProjectImport(projectRoot) {
   const slug = encodeClaudeProjectsSlug(projectRoot);
-  const sourcePath = join10(currentHomeDirectory(), ".claude", "projects", slug);
+  const sourcePath = join11(currentHomeDirectory(), ".claude", "projects", slug);
   if (!await isDirectory(sourcePath)) {
     return null;
   }
-  const memoryPath = await pathExists2(join10(sourcePath, "memory", "MEMORY.md")) ? join10(sourcePath, "memory", "MEMORY.md") : undefined;
+  const memoryPath = await pathExists2(join11(sourcePath, "memory", "MEMORY.md")) ? join11(sourcePath, "memory", "MEMORY.md") : undefined;
   let entries = [];
   try {
     entries = await readdir2(sourcePath, { withFileTypes: false });
@@ -9827,7 +9970,7 @@ async function readClaudeProjectImport(projectRoot) {
       continue;
     }
     sessionCount += 1;
-    const sessionPath = join10(sourcePath, entry);
+    const sessionPath = join11(sourcePath, entry);
     let body;
     try {
       body = await readFile4(sessionPath, "utf8");
@@ -9889,7 +10032,7 @@ function applyImportedEnvironmentSeeds(config, codexImport, projectRoot) {
       ...(config.environment?.actions?.length ?? 0) === 0 && importedEnvironment.actions ? { actions: importedEnvironment.actions } : {}
     };
   }
-  const defaultProjectName = titleCase(basename(projectRoot));
+  const defaultProjectName = titleCase(basename2(projectRoot));
   if (codexImport?.name?.trim() && (!config.project.name?.trim() || config.project.name === defaultProjectName)) {
     next.project = {
       ...config.project,
@@ -9942,11 +10085,11 @@ async function ensureProjectConfigIgnored(projectRoot) {
 }
 async function readLegacyRelayConfig() {
   const relayHub = resolveOpenScoutSupportPaths().relayHubDirectory;
-  return readJsonFile(join10(relayHub, "config.json"));
+  return readJsonFile(join11(relayHub, "config.json"));
 }
 async function readLegacyAgentRegistry() {
   const relayHub = resolveOpenScoutSupportPaths().relayHubDirectory;
-  return await readJsonFile(join10(relayHub, "agents.json")) ?? {};
+  return await readJsonFile(join11(relayHub, "agents.json")) ?? {};
 }
 async function detectHarnessMarkers(projectRoot) {
   const detected = {
@@ -9955,7 +10098,7 @@ async function detectHarnessMarkers(projectRoot) {
   };
   for (const harness of MANAGED_AGENT_HARNESSES) {
     for (const marker of PROJECT_HARNESS_MARKERS[harness]) {
-      if (await pathExists2(join10(projectRoot, marker))) {
+      if (await pathExists2(join11(projectRoot, marker))) {
         detected[harness].push(marker);
       }
     }
@@ -9992,8 +10135,8 @@ async function normalizeSettingsRecord(value, options = {}) {
     legacyAgents: options.legacyAgents ?? {}
   });
   const rawWorkspaceRoots = Array.isArray(discovery.workspaceRoots) ? discovery.workspaceRoots.map((entry) => String(entry)) : [];
-  const workspaceRoots = uniquePaths(rawWorkspaceRoots.length > 0 ? rawWorkspaceRoots : seededWorkspaceRoots);
-  const hiddenProjectRoots = uniquePaths(Array.isArray(discovery.hiddenProjectRoots) ? discovery.hiddenProjectRoots.map((entry) => String(entry)) : []);
+  const workspaceRoots = uniquePaths2(rawWorkspaceRoots.length > 0 ? rawWorkspaceRoots : seededWorkspaceRoots);
+  const hiddenProjectRoots = uniquePaths2(Array.isArray(discovery.hiddenProjectRoots) ? discovery.hiddenProjectRoots.map((entry) => String(entry)) : []);
   const contextRoot = normalizeOptionalString(discovery.contextRoot) ? normalizePath(String(discovery.contextRoot)) : null;
   const seededTelegramBotToken = resolveTelegramConfigSeedValue("TELEGRAM_BOT_TOKEN", options.currentDirectory);
   const seededTelegramSecretToken = resolveTelegramConfigSeedValue("TELEGRAM_WEBHOOK_SECRET_TOKEN", options.currentDirectory);
@@ -10057,7 +10200,7 @@ async function seedWorkspaceRoots(options) {
   const roots = new Set;
   const currentProjectRoot = options.currentDirectory ? await findNearestProjectRoot(options.currentDirectory) : null;
   if (currentProjectRoot) {
-    roots.add(dirname3(currentProjectRoot));
+    roots.add(dirname4(currentProjectRoot));
   }
   const legacyRoot = options.legacyRelayConfig?.projectRoot?.trim();
   if (legacyRoot) {
@@ -10065,11 +10208,11 @@ async function seedWorkspaceRoots(options) {
   }
   for (const record of Object.values(options.legacyAgents ?? {})) {
     if (record.cwd?.trim()) {
-      roots.add(dirname3(normalizePath(record.cwd)));
+      roots.add(dirname4(normalizePath(record.cwd)));
     }
   }
   if (roots.size === 0) {
-    roots.add(join10(homedir11(), "dev"));
+    roots.add(join11(homedir12(), "dev"));
   }
   return Array.from(roots);
 }
@@ -10086,11 +10229,11 @@ async function readOpenScoutSettings(options = {}) {
   });
 }
 var SCOUT_SKILL_FILE_NAME = "SKILL.md";
-var SETUP_MODULE_DIRECTORY = dirname3(fileURLToPath2(import.meta.url));
-var SCOUT_SKILL_REPO_ROOT = resolve2(SETUP_MODULE_DIRECTORY, "..", "..", "..");
+var SETUP_MODULE_DIRECTORY = dirname4(fileURLToPath3(import.meta.url));
+var SCOUT_SKILL_REPO_ROOT = resolve3(SETUP_MODULE_DIRECTORY, "..", "..", "..");
 var SCOUT_SKILL_INSTALL_PATHS = {
-  claude: join10(homedir11(), ".claude", "skills", "scout", SCOUT_SKILL_FILE_NAME),
-  codex: join10(homedir11(), ".agents", "skills", "scout", SCOUT_SKILL_FILE_NAME)
+  claude: join11(homedir12(), ".claude", "skills", "scout", SCOUT_SKILL_FILE_NAME),
+  codex: join11(homedir12(), ".agents", "skills", "scout", SCOUT_SKILL_FILE_NAME)
 };
 async function readRelayAgentOverrides() {
   const supportPaths = resolveOpenScoutSupportPaths();
@@ -10173,13 +10316,13 @@ async function findNearestProjectRoot(startDirectory) {
   let current = normalizePath(startDirectory);
   let lastCandidate = null;
   while (true) {
-    if (await pathExists2(join10(current, ".git"))) {
+    if (await pathExists2(join11(current, ".git"))) {
       return current;
     }
-    if (await pathExists2(projectConfigPath(current)) || await pathExists2(join10(current, "package.json")) || await pathExists2(join10(current, "AGENTS.md")) || await pathExists2(join10(current, "CLAUDE.md"))) {
+    if (await pathExists2(projectConfigPath(current)) || await pathExists2(join11(current, "package.json")) || await pathExists2(join11(current, "AGENTS.md")) || await pathExists2(join11(current, "CLAUDE.md"))) {
       lastCandidate = current;
     }
-    const parent = dirname3(current);
+    const parent = dirname4(current);
     if (parent === current) {
       return lastCandidate;
     }
@@ -10187,7 +10330,7 @@ async function findNearestProjectRoot(startDirectory) {
   }
 }
 function defaultProjectConfig(projectRoot, settings, preferredHarness) {
-  const projectName = basename(projectRoot);
+  const projectName = basename2(projectRoot);
   const definitionId = normalizeAgentId(projectName);
   const relativeRoot = relative(projectRoot, projectRoot) || ".";
   return {
@@ -10361,7 +10504,7 @@ async function scanSourceRoot(sourceRoot) {
       if (PROJECT_SCAN_SKIP_DIRECTORIES.has(entry.name)) {
         continue;
       }
-      const nextPath = join10(currentDirectory, entry.name);
+      const nextPath = join11(currentDirectory, entry.name);
       if (entry.isSymbolicLink()) {
         if (!await isDirectory(nextPath)) {
           continue;
@@ -10402,7 +10545,7 @@ function relativeProjectPath(projectRoot, sourceRoot) {
   return relative(sourceRoot, projectRoot) || ".";
 }
 function resolveProjectRootFromConfig(projectRoot, config) {
-  return normalizePath(join10(projectRoot, config.project.root ?? "."));
+  return normalizePath(join11(projectRoot, config.project.root ?? "."));
 }
 function mergeResolvedAgentConfig(base, override, settings) {
   if (!override) {
@@ -10494,8 +10637,8 @@ function selectorFromInput(value) {
 }
 async function resolveManifestBackedAgent(projectRoot, config, settings, override) {
   const resolvedProjectRoot = resolveProjectRootFromConfig(projectRoot, config);
-  const projectName = config.project.name?.trim() || titleCase(config.project.id || basename(resolvedProjectRoot));
-  const fallbackDefinitionId = normalizeAgentId(config.project.id || basename(resolvedProjectRoot));
+  const projectName = config.project.name?.trim() || titleCase(config.project.id || basename2(resolvedProjectRoot));
+  const fallbackDefinitionId = normalizeAgentId(config.project.id || basename2(resolvedProjectRoot));
   const definitionId = normalizeAgentId(config.agent?.id || override?.definitionId || fallbackDefinitionId);
   const detectedHarness = await detectPreferredHarness(resolvedProjectRoot, settings.agents.defaultHarness);
   const runtimeDefaults = config.agent?.runtime?.defaults;
@@ -10532,7 +10675,7 @@ async function resolveManifestBackedAgent(projectRoot, config, settings, overrid
   return mergeResolvedAgentConfig(base, override, settings);
 }
 async function resolveInferredAgent(projectRoot, settings, override) {
-  const projectName = basename(projectRoot);
+  const projectName = basename2(projectRoot);
   const definitionId = normalizeAgentId(override?.definitionId?.trim() || projectName);
   const detectedHarness = await detectPreferredHarness(projectRoot, settings.agents.defaultHarness);
   const defaultHarness = normalizeManagedHarness(override?.defaultHarness ?? override?.runtime?.harness, normalizeManagedHarness(detectedHarness, "claude"));
@@ -10568,7 +10711,7 @@ async function resolveInferredAgent(projectRoot, settings, override) {
   return mergeResolvedAgentConfig(base, override, settings);
 }
 async function buildProjectInventoryEntry(agent, sourceRoot) {
-  const manifestRoot = agent.projectConfigPath ? normalizePath(join10(dirname3(agent.projectConfigPath), "..")) : null;
+  const manifestRoot = agent.projectConfigPath ? normalizePath(join11(dirname4(agent.projectConfigPath), "..")) : null;
   const manifest = manifestRoot ? await readProjectConfig(manifestRoot) : null;
   const markers = await detectHarnessMarkers(agent.projectRoot);
   const harnesses = new Map;
@@ -10676,7 +10819,7 @@ async function loadResolvedRelayAgents(options = {}) {
   const sourceRootByProject = new Map(workspaceCandidates.map((candidate) => [candidate.projectRoot, candidate.sourceRoot]));
   if (process.env.OPENSCOUT_SKIP_USER_PROJECT_HINTS !== "1") {
     try {
-      const hintHome = options.userLevelHintsHome ?? homedir11();
+      const hintHome = options.userLevelHintsHome ?? homedir12();
       const userHints = await collectUserLevelProjectRootHints({ home: hintHome });
       for (const hint of userHints) {
         const normalized = normalizePath(hint);
@@ -10814,16 +10957,16 @@ async function ensureRelayAgentConfigured(value, options = {}) {
 
 // ../runtime/src/local-agents.ts
 import { execFileSync as execFileSync3, execSync as execSync2 } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
 import { mkdir as mkdir6, rm as rm5, stat as stat3, writeFile as writeFile6 } from "fs/promises";
-import { basename as basename3, dirname as dirname5, join as join14, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { basename as basename4, dirname as dirname6, join as join15, resolve as resolve5 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 
 // ../runtime/src/claude-stream-json.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn2 } from "child_process";
 import { appendFile as appendFile2, mkdir as mkdir4, readFile as readFile5, rm as rm3, writeFile as writeFile4 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // ../runtime/src/managed-agent-environment.ts
 function managedAgentEnvironmentEntries(options) {
@@ -10885,9 +11028,9 @@ class ClaudeStreamJsonSession {
   lastConfigSignature;
   constructor(options) {
     this.options = options;
-    this.sessionStatePath = join11(options.runtimeDirectory, "claude-session-id.txt");
-    this.stdoutLogPath = join11(options.logsDirectory, "stdout.log");
-    this.stderrLogPath = join11(options.logsDirectory, "stderr.log");
+    this.sessionStatePath = join12(options.runtimeDirectory, "claude-session-id.txt");
+    this.stdoutLogPath = join12(options.logsDirectory, "stdout.log");
+    this.stderrLogPath = join12(options.logsDirectory, "stderr.log");
     this.lastConfigSignature = this.configSignature(options);
   }
   matches(options) {
@@ -10914,13 +11057,13 @@ class ClaudeStreamJsonSession {
     if (this.activeTurn) {
       throw new Error(`Claude stream-json session for ${this.options.agentName} already has an active turn.`);
     }
-    const outputPromise = new Promise((resolve3, reject) => {
+    const outputPromise = new Promise((resolve4, reject) => {
       const turn = {
         id: randomUUID(),
         output: [],
         timer: null,
         stallMs: stallTimeoutMs,
-        resolve: resolve3,
+        resolve: resolve4,
         reject
       };
       this.activeTurn = turn;
@@ -11019,7 +11162,7 @@ class ClaudeStreamJsonSession {
   async startSession() {
     await mkdir4(this.options.runtimeDirectory, { recursive: true });
     await mkdir4(this.options.logsDirectory, { recursive: true });
-    await writeFile4(join11(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
+    await writeFile4(join12(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
     this.claudeSessionId = await readOptionalFile2(this.sessionStatePath);
     const args = [
       "--print",
@@ -11163,7 +11306,7 @@ async function shutdownClaudeStreamJsonAgent(options, shutdownOptions = {}) {
   const session = sessions.get(key);
   if (!session) {
     if (shutdownOptions.resetSession) {
-      await rm3(join11(options.runtimeDirectory, "claude-session-id.txt"), { force: true });
+      await rm3(join12(options.runtimeDirectory, "claude-session-id.txt"), { force: true });
     }
     return;
   }
@@ -11173,8 +11316,8 @@ async function shutdownClaudeStreamJsonAgent(options, shutdownOptions = {}) {
 
 // ../runtime/src/codex-app-server.ts
 import { spawn as spawn3 } from "child_process";
-import { access as access3, appendFile as appendFile3, constants as constants2, mkdir as mkdir5, readFile as readFile6, rm as rm4, writeFile as writeFile5 } from "fs/promises";
-import { delimiter as delimiter2, join as join12 } from "path";
+import { access as access3, appendFile as appendFile3, constants as constants3, mkdir as mkdir5, readFile as readFile6, rm as rm4, writeFile as writeFile5 } from "fs/promises";
+import { delimiter as delimiter3, join as join13 } from "path";
 function sessionKey2(options) {
   return `${options.agentName}:${options.sessionId}`;
 }
@@ -11189,12 +11332,12 @@ function metadataRecord(metadata, key) {
   }
   return value;
 }
-async function isExecutable2(filePath) {
+async function isExecutable3(filePath) {
   if (!filePath) {
     return false;
   }
   try {
-    await access3(filePath, constants2.X_OK);
+    await access3(filePath, constants3.X_OK);
     return true;
   } catch {
     return false;
@@ -11206,20 +11349,20 @@ async function resolveCodexExecutable2() {
     process.env.CODEX_BIN
   ].filter(Boolean);
   for (const candidate of explicitCandidates) {
-    if (await isExecutable2(candidate)) {
+    if (await isExecutable3(candidate)) {
       return candidate;
     }
   }
   const bundledCandidates = [
     "/Applications/Codex.app/Contents/Resources/codex",
-    join12(process.env.HOME ?? "", "Applications", "Codex.app", "Contents", "Resources", "codex")
+    join13(process.env.HOME ?? "", "Applications", "Codex.app", "Contents", "Resources", "codex")
   ].filter(Boolean);
   for (const candidate of bundledCandidates) {
-    if (await isExecutable2(candidate)) {
+    if (await isExecutable3(candidate)) {
       return candidate;
     }
   }
-  const pathEntries = (process.env.PATH ?? "").split(delimiter2).filter(Boolean);
+  const pathEntries = (process.env.PATH ?? "").split(delimiter3).filter(Boolean);
   const commonDirectories = [
     `${process.env.HOME ?? ""}/.local/bin`,
     `${process.env.HOME ?? ""}/.bun/bin`,
@@ -11227,8 +11370,8 @@ async function resolveCodexExecutable2() {
     "/usr/local/bin"
   ].filter(Boolean);
   for (const directory of [...pathEntries, ...commonDirectories]) {
-    const candidate = join12(directory, "codex");
-    if (await isExecutable2(candidate)) {
+    const candidate = join13(directory, "codex");
+    if (await isExecutable3(candidate)) {
       return candidate;
     }
   }
@@ -11304,10 +11447,10 @@ class CodexAppServerSession {
   constructor(options) {
     this.options = options;
     this.key = sessionKey2(options);
-    this.threadIdPath = join12(options.runtimeDirectory, "codex-thread-id.txt");
-    this.statePath = join12(options.runtimeDirectory, "state.json");
-    this.stdoutLogPath = join12(options.logsDirectory, "stdout.log");
-    this.stderrLogPath = join12(options.logsDirectory, "stderr.log");
+    this.threadIdPath = join13(options.runtimeDirectory, "codex-thread-id.txt");
+    this.statePath = join13(options.runtimeDirectory, "state.json");
+    this.stdoutLogPath = join13(options.logsDirectory, "stdout.log");
+    this.stderrLogPath = join13(options.logsDirectory, "stderr.log");
     this.lastConfigSignature = this.configSignature(options);
   }
   matches(options) {
@@ -11335,8 +11478,8 @@ class CodexAppServerSession {
       if (!this.threadId) {
         throw new Error(`Codex app-server session for ${this.options.agentName} has no active thread.`);
       }
-      const output = await new Promise(async (resolve3, reject) => {
-        const turn = this.createActiveTurn(resolve3, reject, timeoutMs);
+      const output = await new Promise(async (resolve4, reject) => {
+        const turn = this.createActiveTurn(resolve4, reject, timeoutMs);
         try {
           const response = await this.request("turn/start", {
             threadId: this.threadId,
@@ -11374,8 +11517,8 @@ class CodexAppServerSession {
     if (!activeTurn?.turnId) {
       return this.invoke(prompt, timeoutMs);
     }
-    const output = await new Promise(async (resolve3, reject) => {
-      const watcher = this.addTurnWatcher(activeTurn, resolve3, reject, timeoutMs);
+    const output = await new Promise(async (resolve4, reject) => {
+      const watcher = this.addTurnWatcher(activeTurn, resolve4, reject, timeoutMs);
       try {
         await this.request("turn/steer", {
           threadId: this.threadId,
@@ -11444,7 +11587,7 @@ class CodexAppServerSession {
     this.lineBuffer = "";
     if (child && child.exitCode === null && !child.killed) {
       child.kill("SIGTERM");
-      await new Promise((resolve3) => setTimeout(resolve3, 250));
+      await new Promise((resolve4) => setTimeout(resolve4, 250));
       if (child.exitCode === null && !child.killed) {
         child.kill("SIGKILL");
       }
@@ -11492,15 +11635,22 @@ class CodexAppServerSession {
   async startSession() {
     await mkdir5(this.options.runtimeDirectory, { recursive: true });
     await mkdir5(this.options.logsDirectory, { recursive: true });
-    await writeFile5(join12(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
+    await writeFile5(join13(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
     const codexExecutable = await resolveCodexExecutable2();
-    const child = spawn3(codexExecutable, ["app-server"], {
-      cwd: this.options.cwd,
-      env: buildManagedAgentEnvironment({
-        agentName: this.options.agentName,
+    const env = buildManagedAgentEnvironment({
+      agentName: this.options.agentName,
+      currentDirectory: this.options.cwd,
+      baseEnv: process.env
+    });
+    const child = spawn3(codexExecutable, [
+      "app-server",
+      ...buildScoutMcpCodexLaunchArgs({
         currentDirectory: this.options.cwd,
-        baseEnv: process.env
-      }),
+        env
+      })
+    ], {
+      cwd: this.options.cwd,
+      env,
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.process = child;
@@ -11587,7 +11737,7 @@ class CodexAppServerSession {
     this.threadPath = started.thread.path ?? null;
     await this.persistThreadId();
   }
-  createActiveTurn(resolve3, reject, timeoutMs) {
+  createActiveTurn(resolve4, reject, timeoutMs) {
     if (this.activeTurn) {
       throw new Error(`Codex app-server session for ${this.options.agentName} already has an active turn.`);
     }
@@ -11597,7 +11747,7 @@ class CodexAppServerSession {
       timer: null,
       messageOrder: [],
       messageByItemId: new Map,
-      resolve: resolve3,
+      resolve: resolve4,
       reject,
       watchers: []
     };
@@ -11616,9 +11766,9 @@ class CodexAppServerSession {
     this.activeTurn = turn;
     return turn;
   }
-  addTurnWatcher(turn, resolve3, reject, timeoutMs) {
+  addTurnWatcher(turn, resolve4, reject, timeoutMs) {
     const watcher = {
-      resolve: resolve3,
+      resolve: resolve4,
       reject,
       timer: null
     };
@@ -11877,9 +12027,9 @@ class CodexAppServerSession {
   }
   async request(method, params) {
     const id = String(this.nextRequestId++);
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       this.pendingRequests.set(id, {
-        resolve: (value) => resolve3(value),
+        resolve: (value) => resolve4(value),
         reject
       });
       try {
@@ -11936,7 +12086,7 @@ async function shutdownCodexAppServerAgent(options, shutdownOptions = {}) {
   if (!session) {
     if (shutdownOptions.resetThread) {
       const runtimeDirectory = options.runtimeDirectory;
-      await rm4(join12(runtimeDirectory, "codex-thread-id.txt"), { force: true });
+      await rm4(join13(runtimeDirectory, "codex-thread-id.txt"), { force: true });
     }
     return;
   }
@@ -11949,10 +12099,13 @@ function buildCollaborationContractPrompt(agentId) {
   return [
     "Collaboration contract:",
     `  - Identity: act as the stable OpenScout agent "${agentId}" for this turn`,
+    "  - Default loop: orient -> resolve -> choose venue -> keep follow-up in that same venue",
     "  - Treat information-seeking requests as questions and durable execution as work",
     "  - Use collaboration verbs intentionally: answer, delegate, wait, review, complete",
     "  - @mention another agent only when handing off real work or requesting a concrete answer",
+    "  - One target means DM; group coordination means an explicit channel or separate DMs",
     "  - Do not broadcast ordinary delegation or wake agents who do not own the next move",
+    "  - Tell / update stays on the message path; owned work or a requested reply goes on the ask path",
     "  - If you can answer safely, answer directly",
     "  - If more work is required, make the next responsible agent explicit",
     "  - If blocked, say what you are waiting on and who owns the next move",
@@ -11964,10 +12117,10 @@ function buildCollaborationContractPrompt(agentId) {
 
 // ../runtime/src/broker-service.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir12 } from "os";
-import { basename as basename2, dirname as dirname4, join as join13, resolve as resolve3 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir13 } from "os";
+import { basename as basename3, dirname as dirname5, join as join14, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function isTmpPath(p) {
   return /^\/(?:private\/)?tmp\//.test(p);
 }
@@ -12006,17 +12159,17 @@ function runtimePackageDir() {
   const fromCwd = findWorkspaceRuntimeDir(process.cwd());
   if (fromCwd)
     return fromCwd;
-  const moduleDir = dirname4(fileURLToPath3(import.meta.url));
-  return resolve3(moduleDir, "..");
+  const moduleDir = dirname5(fileURLToPath4(import.meta.url));
+  return resolve4(moduleDir, "..");
 }
 function isInstalledRuntimePackageDir(candidate) {
-  return existsSync10(join13(candidate, "package.json")) && existsSync10(join13(candidate, "bin", "openscout-runtime.mjs"));
+  return existsSync11(join14(candidate, "package.json")) && existsSync11(join14(candidate, "bin", "openscout-runtime.mjs"));
 }
 function findGlobalRuntimeDir() {
   const candidates = [
-    join13(homedir12(), ".bun", "node_modules", "@openscout", "runtime"),
-    join13(homedir12(), ".bun", "install", "global", "node_modules", "@openscout", "runtime"),
-    join13(homedir12(), ".bun", "install", "global", "node_modules", "@openscout", "scout", "node_modules", "@openscout", "runtime")
+    join14(homedir13(), ".bun", "node_modules", "@openscout", "runtime"),
+    join14(homedir13(), ".bun", "install", "global", "node_modules", "@openscout", "runtime"),
+    join14(homedir13(), ".bun", "install", "global", "node_modules", "@openscout", "scout", "node_modules", "@openscout", "runtime")
   ];
   for (const c of candidates) {
     if (isInstalledRuntimePackageDir(c))
@@ -12026,11 +12179,11 @@ function findGlobalRuntimeDir() {
     const result = spawnSync("which", ["scout"], { encoding: "utf8", timeout: 3000 });
     const scoutBin = result.stdout?.trim();
     if (scoutBin) {
-      const scoutPkg = resolve3(scoutBin, "..", "..");
-      const nested = join13(scoutPkg, "node_modules", "@openscout", "runtime");
+      const scoutPkg = resolve4(scoutBin, "..", "..");
+      const nested = join14(scoutPkg, "node_modules", "@openscout", "runtime");
       if (isInstalledRuntimePackageDir(nested))
         return nested;
-      const sibling = resolve3(scoutPkg, "..", "runtime");
+      const sibling = resolve4(scoutPkg, "..", "runtime");
       if (isInstalledRuntimePackageDir(sibling))
         return sibling;
     }
@@ -12038,35 +12191,35 @@ function findGlobalRuntimeDir() {
   return null;
 }
 function findWorkspaceRuntimeDir(startDir) {
-  let current = resolve3(startDir);
+  let current = resolve4(startDir);
   while (true) {
-    const candidate = join13(current, "packages", "runtime");
-    if (existsSync10(join13(candidate, "package.json")) && existsSync10(join13(candidate, "src"))) {
+    const candidate = join14(current, "packages", "runtime");
+    if (existsSync11(join14(candidate, "package.json")) && existsSync11(join14(candidate, "src"))) {
       return candidate;
     }
-    const parent = dirname4(current);
+    const parent = dirname5(current);
     if (parent === current)
       return null;
     current = parent;
   }
 }
-function resolveBunExecutable() {
+function resolveBunExecutable2() {
   const explicit = process.env.OPENSCOUT_BUN_BIN ?? process.env.BUN_BIN;
   if (explicit && explicit.trim().length > 0) {
     return explicit;
   }
-  if (basename2(process.execPath).startsWith("bun") && existsSync10(process.execPath)) {
+  if (basename3(process.execPath).startsWith("bun") && existsSync11(process.execPath)) {
     return process.execPath;
   }
   const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
   for (const entry of pathEntries) {
-    const candidate = join13(entry, "bun");
-    if (existsSync10(candidate)) {
+    const candidate = join14(entry, "bun");
+    if (existsSync11(candidate)) {
       return candidate;
     }
   }
-  const homeBun = join13(homedir12(), ".bun", "bin", "bun");
-  if (existsSync10(homeBun)) {
+  const homeBun = join14(homedir13(), ".bun", "bin", "bun");
+  if (existsSync11(homeBun)) {
     return homeBun;
   }
   return "bun";
@@ -12108,15 +12261,15 @@ function resolveBrokerServiceConfig() {
   const label = resolveBrokerServiceLabel(mode);
   const uid = typeof process.getuid === "function" ? process.getuid() : Number.parseInt(process.env.UID ?? "0", 10);
   const supportPaths = resolveOpenScoutSupportPaths();
-  const defaultSupportDir = join13(homedir12(), "Library", "Application Support", "OpenScout");
+  const defaultSupportDir = join14(homedir13(), "Library", "Application Support", "OpenScout");
   const supportDirectory = isTmpPath(supportPaths.supportDirectory) ? defaultSupportDir : supportPaths.supportDirectory;
-  const logsDirectory = join13(supportDirectory, "logs", "broker");
-  const controlHome = isTmpPath(supportPaths.controlHome) ? join13(homedir12(), ".openscout", "control-plane") : supportPaths.controlHome;
+  const logsDirectory = join14(supportDirectory, "logs", "broker");
+  const controlHome = isTmpPath(supportPaths.controlHome) ? join14(homedir13(), ".openscout", "control-plane") : supportPaths.controlHome;
   const advertiseScope = resolveAdvertiseScope();
   const brokerHost = resolveBrokerHost(advertiseScope);
   const brokerPort = Number.parseInt(process.env.OPENSCOUT_BROKER_PORT ?? String(DEFAULT_BROKER_PORT), 10);
   const brokerUrl = process.env.OPENSCOUT_BROKER_URL ?? buildDefaultBrokerUrl(brokerHost, brokerPort);
-  const launchAgentPath = join13(homedir12(), "Library", "LaunchAgents", `${label}.plist`);
+  const launchAgentPath = join14(homedir13(), "Library", "LaunchAgents", `${label}.plist`);
   return {
     label,
     mode,
@@ -12126,11 +12279,11 @@ function resolveBrokerServiceConfig() {
     launchAgentPath,
     supportDirectory,
     logsDirectory,
-    stdoutLogPath: join13(logsDirectory, "stdout.log"),
-    stderrLogPath: join13(logsDirectory, "stderr.log"),
+    stdoutLogPath: join14(logsDirectory, "stdout.log"),
+    stderrLogPath: join14(logsDirectory, "stderr.log"),
     controlHome,
     runtimePackageDir: runtimePackageDir(),
-    bunExecutable: resolveBunExecutable(),
+    bunExecutable: resolveBunExecutable2(),
     brokerHost,
     brokerPort,
     brokerUrl,
@@ -12147,7 +12300,7 @@ function renderLaunchAgentPlist(config) {
     OPENSCOUT_BROKER_SERVICE_MODE: config.mode,
     OPENSCOUT_BROKER_SERVICE_LABEL: config.label,
     OPENSCOUT_ADVERTISE_SCOPE: config.advertiseScope,
-    HOME: homedir12(),
+    HOME: homedir13(),
     PATH: launchPath,
     ...collectOptionalEnvVars([
       "OPENSCOUT_MESH_ID",
@@ -12173,7 +12326,7 @@ function renderLaunchAgentPlist(config) {
   <key>ProgramArguments</key>
   <array>
     <string>${xmlEscape(config.bunExecutable)}</string>
-    <string>${xmlEscape(join13(config.runtimePackageDir, "bin", "openscout-runtime.mjs"))}</string>
+    <string>${xmlEscape(join14(config.runtimePackageDir, "bin", "openscout-runtime.mjs"))}</string>
     <string>broker</string>
   </array>
   <key>WorkingDirectory</key>
@@ -12209,7 +12362,7 @@ function collectOptionalEnvVars(keys) {
 function resolveLaunchAgentPATH() {
   const entries = [
     ...(process.env.PATH ?? "").split(":").filter(Boolean),
-    join13(homedir12(), ".bun", "bin"),
+    join14(homedir13(), ".bun", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -12223,7 +12376,7 @@ function xmlEscape(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
 function ensureParentDirectory(filePath) {
-  mkdirSync8(dirname4(filePath), { recursive: true });
+  mkdirSync8(dirname5(filePath), { recursive: true });
 }
 function ensureServiceDirectories(config) {
   ensureOpenScoutCleanSlateSync();
@@ -12256,7 +12409,7 @@ function launchctlPath() {
   return "/bin/launchctl";
 }
 function readLogLines(path2) {
-  if (!existsSync10(path2)) {
+  if (!existsSync11(path2)) {
     return [];
   }
   return readFileSync6(path2, "utf8").split(`
@@ -12356,7 +12509,7 @@ async function brokerServiceStatus(config = resolveBrokerServiceConfig()) {
   ensureServiceDirectories(config);
   const launchctl = inspectLaunchctl(config);
   const health = await fetchHealthSnapshot(config);
-  const installed = existsSync10(config.launchAgentPath);
+  const installed = existsSync11(config.launchAgentPath);
   const lastLogLine = health.reachable ? readLastLogLine([config.stdoutLogPath, config.stderrLogPath]) : readLastLogLine([config.stderrLogPath, config.stdoutLogPath]);
   return {
     label: config.label,
@@ -12399,7 +12552,7 @@ async function startBrokerService(config = resolveBrokerServiceConfig()) {
   throw new Error(status.lastLogLine ?? status.health.error ?? "Broker service did not become healthy.");
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 async function stopBrokerService(config = resolveBrokerServiceConfig()) {
   runCommand(launchctlPath(), ["bootout", config.serviceTarget], { allowFailure: true });
@@ -12418,7 +12571,7 @@ async function restartBrokerService(config = resolveBrokerServiceConfig()) {
 }
 async function uninstallBrokerService(config = resolveBrokerServiceConfig()) {
   await stopBrokerService(config);
-  if (existsSync10(config.launchAgentPath)) {
+  if (existsSync11(config.launchAgentPath)) {
     rmSync2(config.launchAgentPath, { force: true });
   }
   return brokerServiceStatus(config);
@@ -12476,7 +12629,7 @@ function formatBrokerServiceStatus(status) {
   return lines.join(`
 `);
 }
-if (process.argv[1] && fileURLToPath3(import.meta.url) === process.argv[1]) {
+if (process.argv[1] && fileURLToPath4(import.meta.url) === process.argv[1]) {
   await main();
 }
 
@@ -12488,8 +12641,8 @@ var LOCAL_AGENT_SYSTEM_PROMPT_TEMPLATE_HINT = [
 ].join("");
 
 // ../runtime/src/local-agents.ts
-var MODULE_DIRECTORY = dirname5(fileURLToPath4(import.meta.url));
-var OPENSCOUT_REPO_ROOT = resolve4(MODULE_DIRECTORY, "..", "..", "..");
+var MODULE_DIRECTORY = dirname6(fileURLToPath5(import.meta.url));
+var OPENSCOUT_REPO_ROOT = resolve5(MODULE_DIRECTORY, "..", "..", "..");
 var DEFAULT_LOCAL_AGENT_CAPABILITIES = ["chat", "invoke", "deliver"];
 var DEFAULT_LOCAL_AGENT_HARNESS = "claude";
 function resolveRelayHub() {
@@ -12497,18 +12650,18 @@ function resolveRelayHub() {
 }
 function resolveProjectsRoot(projectPath) {
   if (process.env.OPENSCOUT_PROJECTS_ROOT?.trim()) {
-    return resolve4(process.env.OPENSCOUT_PROJECTS_ROOT.trim());
+    return resolve5(process.env.OPENSCOUT_PROJECTS_ROOT.trim());
   }
   try {
     const supportPaths = resolveOpenScoutSupportPaths();
-    if (!existsSync11(supportPaths.settingsPath)) {
-      return dirname5(projectPath);
+    if (!existsSync12(supportPaths.settingsPath)) {
+      return dirname6(projectPath);
     }
     const raw = JSON.parse(readFileSync7(supportPaths.settingsPath, "utf8"));
     const workspaceRoot = raw.discovery?.workspaceRoots?.find((entry) => typeof entry === "string" && entry.trim().length > 0);
-    return workspaceRoot ? resolve4(workspaceRoot) : dirname5(projectPath);
+    return workspaceRoot ? resolve5(workspaceRoot) : dirname6(projectPath);
   } catch {
-    return dirname5(projectPath);
+    return dirname6(projectPath);
   }
 }
 function resolveBrokerUrl() {
@@ -12518,20 +12671,20 @@ function nowSeconds2() {
   return Math.floor(Date.now() / 1000);
 }
 function brokerRelayCommand() {
-  return `node ${JSON.stringify(join14(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs"))}`;
+  return `node ${JSON.stringify(join15(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs"))}`;
 }
 function titleCaseLocalAgentName(value) {
   return value.split(/[-_.\s]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
 }
 function resolveScoutSkillPath() {
   const candidatePaths = [
-    join14(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
-    join14(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
-    join14(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
-    join14(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
+    join15(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
+    join15(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
+    join15(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
+    join15(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
   ];
   for (const path2 of candidatePaths) {
-    if (existsSync11(path2)) {
+    if (existsSync12(path2)) {
       return path2;
     }
   }
@@ -12583,12 +12736,18 @@ function buildLocalAgentTmuxProtocolPrompt(context) {
   return [
     "Relay protocol:",
     `  - Read recent context with: ${context.relayCommand} read --as ${context.agentId}`,
-    `  - Reply with: ${context.relayCommand} send --as ${context.agentId} "your message"`,
-    `  - Ask another agent and stay attached with: ${context.relayCommand} ask --to <agent> --as ${context.agentId} "your request"`,
+    `  - Tell one agent with: ${context.relayCommand} send --as ${context.agentId} "@<agent> your message"`,
+    `  - Ask one agent and stay attached with: ${context.relayCommand} ask --to <agent> --as ${context.agentId} "your request"`,
     "",
     "Rules:",
     "  - Do not use file-backed relay state or side channels directly",
     "  - Always reply via the broker-backed relay command above so other agents and the app can see your response",
+    "  - Default Scout loop: resolve identity, resolve one target, choose DM vs explicit channel, keep follow-up in that same venue",
+    "  - Keep one-to-one handoffs in a DM: do not pin a channel when the request is for exactly one agent",
+    "  - If you need multiple agents, use separate DMs or an explicit channel; do not guess a venue from multiple mentions",
+    "  - Do not use channel.shared for ordinary delegation or follow-up; reserve it for explicit group updates or broadcasts",
+    "  - If a short @handle may be ambiguous, resolve the exact target before sending; do not guess and do not fall back to shared",
+    "  - Use send for tells and status; use ask when the meaning is 'do this and get back to me'",
     "  - When replying to an [ask:<id>] request, include the same [ask:<id>] tag in your reply",
     "  - Use the broker-backed relay read command above to inspect recent context before responding",
     `  - Follow the scout skill at ${context.scoutSkill} for agent-to-agent communication`
@@ -12602,7 +12761,14 @@ function buildLocalAgentDirectProtocolPrompt(context) {
     "  - Return your final answer in the assistant message for the current turn",
     "  - Do not shell out to send the final answer through relay yourself",
     `  - If you need recent relay context, inspect it with: ${context.relayCommand} read --as ${context.agentId}`,
+    `  - If you need to tell one agent something, use: ${context.relayCommand} send --as ${context.agentId} "@<agent> your message"`,
     `  - If you need another agent to do work, use: ${context.relayCommand} ask --to <agent> --as ${context.agentId} "your request"`,
+    "  - Default Scout loop: resolve identity, resolve one target, choose DM vs explicit channel, keep follow-up in that same venue",
+    "  - Keep one-to-one handoffs in a DM: do not pin a channel when the request is for exactly one agent",
+    "  - If you need multiple agents, use separate DMs or an explicit channel; do not guess a venue from multiple mentions",
+    "  - Do not use channel.shared for ordinary delegation or follow-up; reserve it for explicit group updates or broadcasts",
+    "  - If a short @handle may be ambiguous, resolve the exact target before sending; do not guess and do not fall back to shared",
+    "  - Use send for tells and status; use ask when the meaning is 'do this and get back to me'",
     `  - Follow the scout skill at ${context.scoutSkill} for agent-to-agent communication`
   ].join(`
 `);
@@ -12664,7 +12830,7 @@ function buildLegacySimpleRelayPrompt(agentId, projectName, projectPath, relayCo
     "A primary agent may call into you for context, execution, follow-through, and handoff.",
     "",
     `You have full access to the codebase at ${projectPath}.`,
-    `There is a structured relay event stream at ${join14(relayHub, "channel.jsonl")} shared by all agents.`,
+    `There is a structured relay event stream at ${join15(relayHub, "channel.jsonl")} shared by all agents.`,
     "",
     "Your job:",
     `  - Respond to @${agentId} mentions from other agents`,
@@ -12757,12 +12923,12 @@ function expandHomePath3(value) {
     return process.env.HOME ?? process.cwd();
   }
   if (value.startsWith("~/")) {
-    return join14(process.env.HOME ?? process.cwd(), value.slice(2));
+    return join15(process.env.HOME ?? process.cwd(), value.slice(2));
   }
   return value;
 }
 function normalizeProjectPath(value) {
-  return resolve4(expandHomePath3(value.trim() || "."));
+  return resolve5(expandHomePath3(value.trim() || "."));
 }
 function normalizeTmuxSessionName2(value, agentId) {
   const fallback = `relay-${agentId}`;
@@ -12903,7 +13069,7 @@ function recordForHarness(record, harnessOverride) {
 function normalizeLocalAgentRecord(agentId, record) {
   const cwd = normalizeProjectPath(record.cwd || process.cwd());
   const projectRoot = normalizeProjectPath(record.projectRoot || cwd);
-  const project = record.project?.trim() || basename3(projectRoot);
+  const project = record.project?.trim() || basename4(projectRoot);
   const definitionId = record.definitionId?.trim() || agentId;
   const defaultHarness = activeLocalHarness(record);
   const harnessProfiles = normalizeLocalHarnessProfiles(agentId, {
@@ -12968,7 +13134,7 @@ function localAgentRecordFromResolvedConfig(config) {
 function localAgentRecordFromRelayAgentOverride(agentId, override) {
   return normalizeLocalAgentRecord(agentId, {
     definitionId: override.definitionId ?? agentId,
-    project: override.projectName ?? basename3(override.projectRoot || override.runtime?.cwd || agentId),
+    project: override.projectName ?? basename4(override.projectRoot || override.runtime?.cwd || agentId),
     projectRoot: override.projectRoot ?? override.runtime?.cwd,
     tmuxSession: override.runtime?.sessionId ?? `relay-${agentId}`,
     cwd: override.runtime?.cwd ?? override.projectRoot,
@@ -13064,7 +13230,7 @@ function buildLocalAgentBootstrapPrompt(_harness, _systemPrompt, initialMessage)
 function buildLocalAgentLaunchCommand(agentName, record, projectPath, promptFile, workerScript) {
   const extraArgs = shellQuoteArguments(normalizeLocalAgentLaunchArgs(record.launchArgs));
   if (normalizeLocalAgentHarness(record.harness) === "codex") {
-    return `exec bash ${JSON.stringify(workerScript ?? join14(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
+    return `exec bash ${JSON.stringify(workerScript ?? join15(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
   }
   return [
     "claude",
@@ -13110,7 +13276,7 @@ async function ensureLocalAgentOnline(agentName, record) {
     return normalizedRecord;
   }
   const projectPath = normalizedRecord.cwd;
-  const projectName = normalizedRecord.project || basename3(projectPath);
+  const projectName = normalizedRecord.project || basename4(projectPath);
   const systemPromptTemplate = normalizedRecord.systemPrompt || buildLocalAgentSystemPromptTemplate();
   const systemPrompt = renderLocalAgentSystemPromptTemplate(systemPromptTemplate, buildLocalAgentTemplateContext(agentName, projectName, projectPath), { transport: normalizedRecord.transport });
   const agentRuntimeDir = relayAgentRuntimeDirectory(agentName);
@@ -13118,7 +13284,7 @@ async function ensureLocalAgentOnline(agentName, record) {
   await mkdir6(agentRuntimeDir, { recursive: true });
   await mkdir6(logsDir, { recursive: true });
   if (normalizedRecord.transport === "codex_app_server") {
-    await writeFile6(join14(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile6(join15(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureCodexAppServerAgentOnline(buildCodexAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry2 = await readLocalAgentRegistry();
     registry2[agentName] = {
@@ -13130,7 +13296,7 @@ async function ensureLocalAgentOnline(agentName, record) {
     return registry2[agentName];
   }
   if (normalizedRecord.transport === "claude_stream_json") {
-    await writeFile6(join14(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile6(join15(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureClaudeStreamJsonAgentOnline(buildClaudeAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry2 = await readLocalAgentRegistry();
     registry2[agentName] = {
@@ -13143,17 +13309,17 @@ async function ensureLocalAgentOnline(agentName, record) {
   }
   const initialMessage = buildLocalAgentInitialMessage(projectName, agentName);
   const bootstrapPrompt = buildLocalAgentBootstrapPrompt(normalizeLocalAgentHarness(normalizedRecord.harness), systemPrompt, initialMessage);
-  const queueDirectory = join14(agentRuntimeDir, "queue");
-  const processingDirectory = join14(queueDirectory, "processing");
-  const processedDirectory = join14(queueDirectory, "processed");
-  const promptFile = join14(agentRuntimeDir, "prompt.txt");
-  const initialFile = join14(agentRuntimeDir, "initial.txt");
-  const launchScript = join14(agentRuntimeDir, "launch.sh");
-  const workerScript = join14(agentRuntimeDir, "codex-worker.sh");
-  const codexSessionIdFile = join14(agentRuntimeDir, "codex-session-id.txt");
-  const stateFile = join14(agentRuntimeDir, "state.json");
-  const stdoutLogFile = join14(logsDir, "stdout.log");
-  const stderrLogFile = join14(logsDir, "stderr.log");
+  const queueDirectory = join15(agentRuntimeDir, "queue");
+  const processingDirectory = join15(queueDirectory, "processing");
+  const processedDirectory = join15(queueDirectory, "processed");
+  const promptFile = join15(agentRuntimeDir, "prompt.txt");
+  const initialFile = join15(agentRuntimeDir, "initial.txt");
+  const launchScript = join15(agentRuntimeDir, "launch.sh");
+  const workerScript = join15(agentRuntimeDir, "codex-worker.sh");
+  const codexSessionIdFile = join15(agentRuntimeDir, "codex-session-id.txt");
+  const stateFile = join15(agentRuntimeDir, "state.json");
+  const stdoutLogFile = join15(logsDir, "stdout.log");
+  const stderrLogFile = join15(logsDir, "stderr.log");
   await writeFile6(promptFile, systemPrompt);
   await writeFile6(initialFile, bootstrapPrompt);
   await writeFile6(stderrLogFile, "");
@@ -13215,10 +13381,10 @@ async function ensureLocalAgentOnline(agentName, record) {
     if (isLocalAgentSessionAlive(normalizedRecord.tmuxSession)) {
       break;
     }
-    await new Promise((resolve5) => setTimeout(resolve5, 100));
+    await new Promise((resolve6) => setTimeout(resolve6, 100));
   }
   if (!isLocalAgentSessionAlive(normalizedRecord.tmuxSession)) {
-    const stderrTail = existsSync11(stderrLogFile) ? readFileSync7(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
+    const stderrTail = existsSync12(stderrLogFile) ? readFileSync7(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
 `).trim() : "";
     throw new Error(stderrTail ? `Relay agent ${agentName} failed to stay online:
 ${stderrTail}` : `Relay agent ${agentName} failed to stay online.`);
@@ -13320,7 +13486,7 @@ async function startLocalAgent(input) {
   }
   if (!matchingOverride) {
     const configDefinitionId = coldProjectConfig?.agent?.id?.trim() ? normalizeAgentSelectorSegment(coldProjectConfig.agent.id.trim()) : "";
-    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename3(projectRoot)) || "agent";
+    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename4(projectRoot)) || "agent";
     const configDisplayName = coldProjectConfig?.agent?.displayName?.trim() || "";
     const effectiveDisplayName = input.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
     const instance = buildRelayAgentInstance(definitionId, projectRoot);
@@ -13336,7 +13502,7 @@ async function startLocalAgent(input) {
       agentId: instance.id,
       definitionId,
       displayName: effectiveDisplayName,
-      projectName: basename3(projectRoot),
+      projectName: basename4(projectRoot),
       projectRoot,
       projectConfigPath: coldProjectConfigPath,
       source: "manual",
@@ -13372,7 +13538,7 @@ async function startLocalAgent(input) {
       agentId: instance.id,
       definitionId: requestedDefinitionId,
       displayName: input.displayName || titleCaseLocalAgentName(requestedDefinitionId),
-      projectName: matchingOverride.projectName ?? basename3(matchingProjectRoot),
+      projectName: matchingOverride.projectName ?? basename4(matchingProjectRoot),
       projectRoot: matchingProjectRoot,
       projectConfigPath: matchingOverride.projectConfigPath ?? null,
       source: "manual",
@@ -14090,11 +14256,11 @@ async function upScoutAgent(input) {
 
 // ../../apps/desktop/src/server/db-queries.ts
 import { Database } from "bun:sqlite";
-import { homedir as homedir13 } from "os";
-import { join as join15 } from "path";
+import { homedir as homedir14 } from "os";
+import { join as join16 } from "path";
 function resolveDbPath() {
-  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join15(homedir13(), ".openscout", "control-plane");
-  return join15(controlHome, "control-plane.sqlite");
+  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join16(homedir14(), ".openscout", "control-plane");
+  return join16(controlHome, "control-plane.sqlite");
 }
 var _db = null;
 function db() {
@@ -14105,7 +14271,7 @@ function db() {
   }
   return _db;
 }
-var HOME = homedir13();
+var HOME = homedir14();
 function compact(p) {
   if (!p)
     return null;
@@ -14753,8 +14919,8 @@ async function createScoutSession(input, currentDirectory, deviceId) {
   if (!rawWorkspaceId) {
     throw new Error(`Invalid workspaceId.`);
   }
-  const workspaceRoot = resolve5(rawWorkspaceId);
-  const projectName = basename4(workspaceRoot) || workspaceRoot;
+  const workspaceRoot = resolve6(rawWorkspaceId);
+  const projectName = basename5(workspaceRoot) || workspaceRoot;
   const workspace = {
     id: workspaceRoot,
     title: projectName,
@@ -14863,17 +15029,17 @@ async function deriveNewAgentName(projectName, branch, harness) {
 }
 async function createGitWorktree(projectRoot, agentName) {
   const { execSync: execSync3 } = await import("child_process");
-  const { join: join16 } = await import("path");
-  const { mkdirSync: mkdirSync9, existsSync: existsSync12 } = await import("fs");
+  const { join: join17 } = await import("path");
+  const { mkdirSync: mkdirSync9, existsSync: existsSync13 } = await import("fs");
   try {
     execSync3("git rev-parse --git-dir", { cwd: projectRoot, stdio: "pipe" });
   } catch {
     return null;
   }
   const branchName = `scout/${agentName}`;
-  const worktreeDir = join16(projectRoot, ".scout-worktrees");
-  const worktreePath = join16(worktreeDir, agentName);
-  if (existsSync12(worktreePath)) {
+  const worktreeDir = join17(projectRoot, ".scout-worktrees");
+  const worktreePath = join17(worktreeDir, agentName);
+  if (existsSync13(worktreePath)) {
     return { path: worktreePath, branch: branchName };
   }
   mkdirSync9(worktreeDir, { recursive: true });
@@ -15050,9 +15216,9 @@ async function handleRPCInner(bridge, req, deviceId) {
       }
       case "session/resume": {
         const p = req.params;
-        const sessionFilename = basename5(p.sessionPath, ".jsonl");
+        const sessionFilename = basename6(p.sessionPath, ".jsonl");
         const parentDir = p.sessionPath.substring(0, p.sessionPath.lastIndexOf("/"));
-        const dirName = basename5(parentDir);
+        const dirName = basename6(parentDir);
         let cwd;
         if (dirName.startsWith("-")) {
           const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
@@ -15119,7 +15285,7 @@ async function handleRPCInner(bridge, req, deviceId) {
           return { id: req.id, error: { code: -32000, message: "Workspace target is not a directory" } };
         }
         const adapterType = p.adapter ?? "claude-code";
-        const name = p.name ?? basename5(projectPath);
+        const name = p.name ?? basename6(projectPath);
         const session = await bridge.createSession(adapterType, {
           name,
           cwd: projectPath
@@ -15359,13 +15525,13 @@ function resolveMobileCurrentDirectory() {
   }
 }
 function resolveWorkspaceRoot(root) {
-  const expandedRoot = root.replace(/^~/, homedir14());
+  const expandedRoot = root.replace(/^~/, homedir15());
   return realpathSync(expandedRoot);
 }
 function resolveWorkspacePath(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir14());
-  const candidate = expandedPath ? isAbsolute3(expandedPath) ? expandedPath : join16(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir15());
+  const candidate = expandedPath ? isAbsolute3(expandedPath) ? expandedPath : join17(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync(candidate);
   const rel = relative2(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute3(rel)) {
@@ -15395,7 +15561,7 @@ function listDirectories(dirPath) {
       continue;
     if (name === "node_modules" || name === ".build" || name === "target")
       continue;
-    const fullPath = join16(dirPath, name);
+    const fullPath = join17(dirPath, name);
     try {
       const stat4 = statSync3(fullPath);
       if (!stat4.isDirectory())
@@ -15418,7 +15584,7 @@ function listDirectories(dirPath) {
   return entries.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function discoverSessionFiles(maxAgeDays, limit) {
-  const home = homedir14();
+  const home = homedir15();
   const results = [];
   const searchPaths = [
     { pattern: `${home}/.claude/projects`, agent: "claude-code" },
@@ -18007,8 +18173,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter3) => {
-  const escapedDelim = escapeRegex(delimiter3 ?? ":");
+var mac = (delimiter4) => {
+  const escapedDelim = escapeRegex(delimiter4 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -29958,8 +30124,8 @@ config(en_default());
 // ../../apps/desktop/src/core/pairing/runtime/bridge/router.ts
 import { readFileSync as readFileSync9, readdirSync as readdirSync4, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import { basename as basename6, isAbsolute as isAbsolute4, join as join17, relative as relative3 } from "path";
-import { homedir as homedir15 } from "os";
+import { basename as basename7, isAbsolute as isAbsolute4, join as join18, relative as relative3 } from "path";
+import { homedir as homedir16 } from "os";
 var t = initTRPC.context().create();
 var logged = t.middleware(async ({ path: path2, type, next }) => {
   const start = Date.now();
@@ -29986,13 +30152,13 @@ function resolveMobileCurrentDirectory2() {
   }
 }
 function resolveWorkspaceRoot2(root) {
-  const expandedRoot = root.replace(/^~/, homedir15());
+  const expandedRoot = root.replace(/^~/, homedir16());
   return realpathSync2(expandedRoot);
 }
 function resolveWorkspacePath2(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot2(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir15());
-  const candidate = expandedPath ? isAbsolute4(expandedPath) ? expandedPath : join17(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir16());
+  const candidate = expandedPath ? isAbsolute4(expandedPath) ? expandedPath : join18(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync2(candidate);
   const rel = relative3(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute4(rel)) {
@@ -30022,7 +30188,7 @@ function listDirectories2(dirPath) {
       continue;
     if (name === "node_modules" || name === ".build" || name === "target")
       continue;
-    const fullPath = join17(dirPath, name);
+    const fullPath = join18(dirPath, name);
     try {
       const stat4 = statSync4(fullPath);
       if (!stat4.isDirectory())
@@ -30061,7 +30227,7 @@ function detectAgent2(filePath) {
   return "unknown";
 }
 async function discoverSessionFiles2(maxAgeDays, limit) {
-  const home = homedir15();
+  const home = homedir16();
   const results = [];
   const searchPaths = [
     { pattern: `${home}/.claude/projects`, agent: "claude-code" },
@@ -30143,23 +30309,23 @@ function bridgeEventIterable(bridge, signal) {
   return {
     [Symbol.asyncIterator]() {
       const buffer = [];
-      let resolve6 = null;
+      let resolve7 = null;
       let done = false;
       const unsub = bridge.onEvent((event) => {
         if (done)
           return;
         buffer.push(event);
-        if (resolve6) {
-          resolve6();
-          resolve6 = null;
+        if (resolve7) {
+          resolve7();
+          resolve7 = null;
         }
       });
       const cleanup = () => {
         done = true;
         unsub();
-        if (resolve6) {
-          resolve6();
-          resolve6 = null;
+        if (resolve7) {
+          resolve7();
+          resolve7 = null;
         }
       };
       signal?.addEventListener("abort", cleanup, { once: true });
@@ -30172,7 +30338,7 @@ function bridgeEventIterable(bridge, signal) {
               return { done: false, value: buffer.shift() };
             }
             await new Promise((r) => {
-              resolve6 = r;
+              resolve7 = r;
             });
           }
         },
@@ -30239,9 +30405,9 @@ var sessionRouter = t.router({
     adapterType: exports_external.string().optional(),
     name: exports_external.string().optional()
   })).mutation(async ({ input, ctx }) => {
-    const sessionFilename = basename6(input.sessionPath, ".jsonl");
+    const sessionFilename = basename7(input.sessionPath, ".jsonl");
     const parentDir = input.sessionPath.substring(0, input.sessionPath.lastIndexOf("/"));
-    const dirName = basename6(parentDir);
+    const dirName = basename7(parentDir);
     let cwd;
     if (dirName.startsWith("-")) {
       const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
@@ -30445,7 +30611,7 @@ var workspaceRouter = t.router({
       });
     }
     const adapterType = input.adapter ?? "claude-code";
-    const name = input.name ?? basename6(projectPath);
+    const name = input.name ?? basename7(projectPath);
     return ctx.bridge.createSession(adapterType, {
       name,
       cwd: projectPath
@@ -32965,8 +33131,8 @@ var Unpromise = class Unpromise2 {
         status: "fulfilled",
         value
       };
-      subscribers === null || subscribers === undefined || subscribers.forEach(({ resolve: resolve6 }) => {
-        resolve6(value);
+      subscribers === null || subscribers === undefined || subscribers.forEach(({ resolve: resolve7 }) => {
+        resolve7(value);
       });
     });
     if ("catch" in thenReturn)
@@ -33074,15 +33240,15 @@ function resolveSelfTuple(promise2) {
   return Unpromise.proxy(promise2).then(() => [promise2]);
 }
 function withResolvers() {
-  let resolve6;
+  let resolve7;
   let reject;
   const promise2 = new Promise((_resolve, _reject) => {
-    resolve6 = _resolve;
+    resolve7 = _resolve;
     reject = _reject;
   });
   return {
     promise: promise2,
-    resolve: resolve6,
+    resolve: resolve7,
     reject
   };
 }
@@ -33128,8 +33294,8 @@ function timerResource(ms) {
   return makeResource({ start() {
     if (timer)
       throw new Error("Timer already started");
-    const promise2 = new Promise((resolve6) => {
-      timer = setTimeout(() => resolve6(disposablePromiseTimerResult), ms);
+    const promise2 = new Promise((resolve7) => {
+      timer = setTimeout(() => resolve7(disposablePromiseTimerResult), ms);
     });
     return promise2;
   } }, () => {
@@ -33332,15 +33498,15 @@ function _takeWithGrace() {
   return _takeWithGrace.apply(this, arguments);
 }
 function createDeferred() {
-  let resolve6;
+  let resolve7;
   let reject;
   const promise2 = new Promise((res, rej) => {
-    resolve6 = res;
+    resolve7 = res;
     reject = rej;
   });
   return {
     promise: promise2,
-    resolve: resolve6,
+    resolve: resolve7,
     reject
   };
 }
@@ -34571,14 +34737,14 @@ function parseTRPCMessage(obj, transformer) {
 }
 // ../../apps/desktop/src/core/pairing/runtime/bridge/server-trpc.ts
 import { realpathSync as realpathSync3 } from "fs";
-import { homedir as homedir16 } from "os";
+import { homedir as homedir17 } from "os";
 function resolveCurrentDirectory() {
   try {
     const config2 = resolveConfig();
     const configuredRoot = config2.workspace?.root;
     if (!configuredRoot)
       return process.cwd();
-    const expanded = configuredRoot.replace(/^~/, homedir16());
+    const expanded = configuredRoot.replace(/^~/, homedir17());
     return realpathSync3(expanded);
   } catch {
     return process.cwd();
@@ -34696,8 +34862,8 @@ function startBridgeServerTRPC(options) {
           }
           const iterable = isObservable(result) ? observableToAsyncIterable(result, abortController.signal) : result;
           const iterator = iterable[Symbol.asyncIterator]();
-          const abortPromise = new Promise((resolve6) => {
-            abortController.signal.addEventListener("abort", () => resolve6("abort"), {
+          const abortPromise = new Promise((resolve7) => {
+            abortController.signal.addEventListener("abort", () => resolve7("abort"), {
               once: true
             });
           });
@@ -35056,7 +35222,7 @@ async function autoStartConfiguredSessions(bridge, sessions3) {
     try {
       const session = await bridge.createSession(entry.adapter, {
         name: entry.name,
-        cwd: entry.cwd?.replace(/^~/, homedir17()),
+        cwd: entry.cwd?.replace(/^~/, homedir18()),
         options: entry.options
       });
       console.log(`[bridge] session started: ${session.name} (${entry.adapter})`);