usebeeline 0.1.180 → 0.1.183

package/dist/usebeeline.mjs

@@ -173,6 +173,121 @@ var init_lifecycle_test_guard = __esm({
   }
 });
 
+// apps/body/dist/self-update-manifest.js
+function resolveManifestUrl(env = process.env) {
+  const override = env.BEELINE_UPDATE_MANIFEST_URL?.trim();
+  if (override)
+    return override;
+  const channel = env.BEELINE_RELEASE_CHANNEL?.trim() || "latest";
+  if (!["latest", "next"].includes(channel))
+    throw new Error(`invalid helper release channel: ${channel}`);
+  return channel === "next" ? "https://usebeeline.app/dl/next/manifest.json" : DEFAULT_UPDATE_MANIFEST_URL;
+}
+function parseUpdateManifest(raw, platform) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`update manifest is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("update manifest is not an object");
+  }
+  const manifest = parsed;
+  const bundles = manifest.bundles;
+  if (typeof bundles !== "object" || bundles === null) {
+    throw new Error("update manifest has no bundles table");
+  }
+  const entry = bundles[platform];
+  if (typeof entry !== "object" || entry === null) {
+    throw new Error(`update manifest has no bundle for platform ${platform}`);
+  }
+  const bundle = entry;
+  const file = typeof bundle.file === "string" ? bundle.file : "";
+  const sha256 = typeof bundle.sha256 === "string" ? bundle.sha256.toLowerCase() : "";
+  if (!file || !/^[a-z0-9][a-z0-9._-]*$/i.test(file)) {
+    throw new Error(`update manifest names an unusable bundle file: ${JSON.stringify(bundle.file)}`);
+  }
+  if (!/^[0-9a-f]{64}$/.test(sha256)) {
+    throw new Error(`update manifest carries no usable sha256 for ${platform}`);
+  }
+  const sourceCommit = typeof bundle.commit === "string" && bundle.commit ? bundle.commit : typeof manifest.sourceCommit === "string" ? manifest.sourceCommit : void 0;
+  const version = typeof bundle.version === "string" && bundle.version ? bundle.version : typeof manifest.version === "string" ? manifest.version : void 0;
+  return {
+    schemaVersion: typeof manifest.schemaVersion === "number" ? manifest.schemaVersion : 1,
+    ...sourceCommit ? { sourceCommit } : {},
+    ...version ? { version } : {},
+    bundles,
+    bundle: {
+      file,
+      sha256,
+      ...typeof bundle.bytes === "number" ? { bytes: bundle.bytes } : {},
+      ...sourceCommit ? { commit: sourceCommit } : {},
+      ...version ? { version } : {},
+      ...typeof bundle.node === "string" ? { node: bundle.node } : {}
+    }
+  };
+}
+function compareBundleIdentity(installed, published) {
+  if (installed?.commit && published.commit) {
+    if (installed.commit === published.commit)
+      return { kind: "current" };
+    return { kind: "update-available", published };
+  }
+  if (installed?.version && published.version) {
+    const ordering = compareVersions(installed.version, published.version);
+    if (ordering > 0)
+      return { kind: "current" };
+    if (ordering < 0)
+      return { kind: "update-available", published };
+    if (installed.commit && published.commit)
+      return { kind: "current" };
+    return { kind: "current" };
+  }
+  const missing = [
+    ...installed?.commit || installed?.version ? [] : ["installed identity"],
+    ...published.commit || published.version ? [] : ["published identity"]
+  ];
+  return {
+    kind: "indeterminate",
+    reason: `cannot compare: ${missing.join(" and ")} unknown`
+  };
+}
+function compareVersions(a, b) {
+  const parse = (value) => {
+    const parts = value.split(/[.+-]/).filter(Boolean);
+    if (parts.length === 0)
+      return void 0;
+    return parts.map((part) => /^\d+$/.test(part) ? Number(part) : part);
+  };
+  const left = parse(a);
+  const right = parse(b);
+  if (!left || !right)
+    return a === b ? 0 : a > b ? 1 : -1;
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const l = left[index];
+    const r = right[index];
+    if (l === void 0)
+      return -1;
+    if (r === void 0)
+      return 1;
+    if (l === r)
+      continue;
+    if (typeof l === "number" && typeof r === "number")
+      return l > r ? 1 : -1;
+    return String(l) > String(r) ? 1 : -1;
+  }
+  return 0;
+}
+var DEFAULT_UPDATE_MANIFEST_URL;
+var init_self_update_manifest = __esm({
+  "apps/body/dist/self-update-manifest.js"() {
+    "use strict";
+    DEFAULT_UPDATE_MANIFEST_URL = "https://usebeeline.app/dl/manifest.json";
+  }
+});
+
 // apps/body/dist/trusty-squire-storage.js
 import { homedir as homedir2 } from "node:os";
 import { isAbsolute, resolve as resolve4 } from "node:path";
@@ -328,151 +443,250 @@ visit(root)
   }
 });
 
-// apps/body/dist/self-update-manifest.js
-function resolveManifestUrl(env = process.env) {
-  const override = env.BEELINE_UPDATE_MANIFEST_URL?.trim();
-  return override && override.length > 0 ? override : DEFAULT_UPDATE_MANIFEST_URL;
-}
-function parseUpdateManifest(raw, platform) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`update manifest is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error("update manifest is not an object");
+// apps/body/dist/self-update-activate-release.js
+import { join, dirname as dirname4, resolve as resolve6 } from "node:path";
+import { access, mkdir as mkdir3, rename as rename2, rm as rm3, symlink, copyFile, readFile as readFile2, readdir as readdir3, lstat as lstat3 } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+async function activateRelease(layout, releaseId, options = {}) {
+  assertInstallTestIsolation(layout);
+  let releaseDir = join(layout.releasesRoot, releaseId);
+  let previousReleaseId = await activeReleaseId(layout);
+  await access(join(releaseDir, BUNDLE_ENTRYPOINT), fsConstants.F_OK);
+  await mkdir3(layout.releasesRoot, { recursive: true });
+  await mkdir3(layout.binDir, { recursive: true });
+  const kind = await pathKind(layout.libDir);
+  if (kind === "directory") {
+    const legacyIdentity = await readBundleJson(layout.libDir);
+    const legacyId = sanitizeReleaseId(legacyIdentity?.commit ?? legacyIdentity?.version ?? `legacy-${Date.now()}`);
+    const legacyDir = join(layout.releasesRoot, legacyId);
+    try {
+      await access(legacyDir, fsConstants.F_OK);
+      const preservedId = `${legacyId}-${Date.now()}`;
+      await rename2(layout.libDir, join(layout.releasesRoot, preservedId));
+      await normalizeLegacyBundleShape(join(layout.releasesRoot, preservedId));
+      previousReleaseId = preservedId;
+    } catch {
+      await rename2(layout.libDir, legacyDir);
+      await normalizeLegacyBundleShape(legacyDir);
+      previousReleaseId = legacyId;
+    }
   }
-  const manifest = parsed;
-  const bundles = manifest.bundles;
-  if (typeof bundles !== "object" || bundles === null) {
-    throw new Error("update manifest has no bundles table");
+  const tempLink = `${layout.libDir}.new-${process.pid}`;
+  await rm3(tempLink, { force: true });
+  await symlink(join("beeline-releases", releaseId), tempLink);
+  await rename2(tempLink, layout.libDir);
+  await fsyncDir(dirname4(layout.libDir));
+  await installRecoveryLauncher(layout, releaseDir);
+  await writeBinForwarders(layout, releaseDir);
+  const state = await readUpdateState(layout);
+  await writeUpdateState(layout, {
+    ...state,
+    stagedReleaseId: void 0,
+    previousReleaseId: previousReleaseId && previousReleaseId !== releaseId ? previousReleaseId : state.previousReleaseId
+  });
+  if (!options.deferPruning)
+    await pruneHelperReleases(layout);
+}
+async function installRecoveryLauncher(layout, releaseDir) {
+  const bootstrap = join(releaseDir, "lib/beeline/recovery-cli.mjs");
+  if (await access(bootstrap).then(() => true, () => false)) {
+    const stable = resolve6(layout.libDir, "../beeline-bootstrap.mjs");
+    const temporary = `${stable}.${process.pid}.tmp`;
+    await copyFile(bootstrap, temporary);
+    await rename2(temporary, stable);
+    await replaceFile(resolve6(layout.libDir, "../beeline-node-path"), `${process.execPath}
+`, 384);
   }
-  const entry = bundles[platform];
-  if (typeof entry !== "object" || entry === null) {
-    throw new Error(`update manifest has no bundle for platform ${platform}`);
+}
+async function normalizeLegacyBundleShape(bundleDir) {
+  const innerLib = join(bundleDir, "lib", "beeline");
+  let anyFlat = false;
+  for (const name of LEGACY_FLAT_BUNDLE_FILES) {
+    try {
+      await access(join(bundleDir, name), fsConstants.F_OK);
+      anyFlat = true;
+      break;
+    } catch {
+    }
   }
-  const bundle = entry;
-  const file = typeof bundle.file === "string" ? bundle.file : "";
-  const sha256 = typeof bundle.sha256 === "string" ? bundle.sha256.toLowerCase() : "";
-  if (!file || !/^[a-z0-9][a-z0-9._-]*$/i.test(file)) {
-    throw new Error(`update manifest names an unusable bundle file: ${JSON.stringify(bundle.file)}`);
+  if (!anyFlat)
+    return;
+  await mkdir3(innerLib, { recursive: true });
+  for (const name of LEGACY_FLAT_BUNDLE_FILES) {
+    try {
+      await access(join(innerLib, name), fsConstants.F_OK);
+      continue;
+    } catch {
+    }
+    await rename2(join(bundleDir, name), join(innerLib, name)).catch(() => void 0);
   }
-  if (!/^[0-9a-f]{64}$/.test(sha256)) {
-    throw new Error(`update manifest carries no usable sha256 for ${platform}`);
+}
+async function writeBinForwarders(layout, activeBundleRoot) {
+  const entries = [
+    ...FORWARDER_TOOLS.map((tool) => [tool, tool]),
+    ...Object.entries(FORWARDER_ALIASES).map(([alias, tool]) => [alias, tool])
+  ];
+  for (const [name, tool] of entries) {
+    const target = join(activeBundleRoot, "bin", tool);
+    try {
+      await access(target, fsConstants.X_OK);
+    } catch {
+      continue;
+    }
+    const independent = await access(resolve6(layout.libDir, "../beeline-bootstrap.mjs")).then(() => true, () => false);
+    await replaceFile(join(layout.binDir, name), independent || tool !== "beeline" ? forwarderScript(tool) : forwarderScript("legacy-beeline").replace("/bin/legacy-beeline", "/bin/beeline"), 493);
   }
-  const sourceCommit = typeof bundle.commit === "string" && bundle.commit ? bundle.commit : typeof manifest.sourceCommit === "string" ? manifest.sourceCommit : void 0;
-  const version = typeof bundle.version === "string" && bundle.version ? bundle.version : typeof manifest.version === "string" ? manifest.version : void 0;
-  return {
-    schemaVersion: typeof manifest.schemaVersion === "number" ? manifest.schemaVersion : 1,
-    ...sourceCommit ? { sourceCommit } : {},
-    ...version ? { version } : {},
-    bundles,
-    bundle: {
-      file,
-      sha256,
-      ...typeof bundle.bytes === "number" ? { bytes: bundle.bytes } : {},
-      ...sourceCommit ? { commit: sourceCommit } : {},
-      ...version ? { version } : {},
-      ...typeof bundle.node === "string" ? { node: bundle.node } : {}
+}
+async function repairInstallForwarders(layout, opts = {}) {
+  assertInstallTestIsolation(layout);
+  if (await pathKind(layout.libDir) !== "symlink")
+    return false;
+  await installRecoveryLauncher(layout, layout.libDir);
+  const forwarderHealthy = async (name, tool) => {
+    let current;
+    try {
+      current = await readFile2(join(layout.binDir, name), "utf8");
+    } catch {
+      current = void 0;
     }
+    const independent = await access(resolve6(layout.libDir, "../beeline-bootstrap.mjs")).then(() => true, () => false);
+    const expected = independent || tool !== "beeline" ? forwarderScript(tool) : forwarderScript("legacy-beeline").replace("/bin/legacy-beeline", "/bin/beeline");
+    return current === expected;
   };
-}
-function compareBundleIdentity(installed, published) {
-  if (installed?.commit && published.commit) {
-    if (installed.commit === published.commit)
-      return { kind: "current" };
-    return { kind: "update-available", published };
-  }
-  if (installed?.version && published.version) {
-    const ordering = compareVersions(installed.version, published.version);
-    if (ordering > 0)
-      return { kind: "current" };
-    if (ordering < 0)
-      return { kind: "update-available", published };
-    if (installed.commit && published.commit)
-      return { kind: "current" };
-    return { kind: "current" };
+  let healthy = await forwarderHealthy("beeline", "beeline");
+  for (const [alias, tool] of Object.entries(FORWARDER_ALIASES)) {
+    if (!await forwarderHealthy(alias, tool))
+      healthy = false;
   }
-  const missing = [
-    ...installed?.commit || installed?.version ? [] : ["installed identity"],
-    ...published.commit || published.version ? [] : ["published identity"]
-  ];
-  return {
-    kind: "indeterminate",
-    reason: `cannot compare: ${missing.join(" and ")} unknown`
-  };
+  if (healthy)
+    return false;
+  await mkdir3(layout.binDir, { recursive: true });
+  await writeBinForwarders(layout, layout.libDir);
+  opts.logger?.(`[body] self-update: repaired <prefix>/bin forwarders to follow the active-bundle anchor (${layout.libDir})`);
+  return true;
 }
-function compareVersions(a, b) {
-  const parse = (value) => {
-    const parts = value.split(/[.+-]/).filter(Boolean);
-    if (parts.length === 0)
-      return void 0;
-    return parts.map((part) => /^\d+$/.test(part) ? Number(part) : part);
-  };
-  const left = parse(a);
-  const right = parse(b);
-  if (!left || !right)
-    return a === b ? 0 : a > b ? 1 : -1;
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index += 1) {
-    const l = left[index];
-    const r = right[index];
-    if (l === void 0)
-      return -1;
-    if (r === void 0)
-      return 1;
-    if (l === r)
+function describeIdentity(identity) {
+  if (!identity)
+    return "unknown";
+  const parts = [];
+  if (identity.version)
+    parts.push(identity.version);
+  if (identity.commit)
+    parts.push(identity.commit.slice(0, 12));
+  return parts.join(" ") || "unknown";
+}
+async function pruneHelperReleases(layout, loadedRelease) {
+  assertInstallTestIsolation(layout);
+  if (!await ordinaryDirectory(layout.releasesRoot))
+    return [];
+  const active = await activeReleaseId(layout);
+  if (!active)
+    return [];
+  const state = await readUpdateState(layout);
+  const candidates = [];
+  for (const entry of await readdir3(layout.releasesRoot, { withFileTypes: true })) {
+    if (entry.name.startsWith("."))
+      continue;
+    if (entry.isSymbolicLink()) {
+      if (![active, state.previousReleaseId, state.stagedReleaseId, loadedRelease].includes(entry.name))
+        await rm3(join(layout.releasesRoot, entry.name), { force: true });
       continue;
-    if (typeof l === "number" && typeof r === "number")
-      return l > r ? 1 : -1;
-    return String(l) > String(r) ? 1 : -1;
+    }
+    if (!entry.isDirectory())
+      continue;
+    const path = join(layout.releasesRoot, entry.name);
+    if (!await ordinaryDirectory(path))
+      continue;
+    candidates.push({
+      id: entry.name,
+      modified: (await lstat3(path)).mtimeMs,
+      bootable: await access(join(path, BUNDLE_ENTRYPOINT)).then(() => true, () => false)
+    });
   }
-  return 0;
+  const recordedPrevious = candidates.find((entry) => entry.id === state.previousReleaseId && entry.id !== active && entry.bootable)?.id;
+  const previous = recordedPrevious ?? candidates.filter((entry) => entry.bootable && entry.id !== active && entry.id !== state.stagedReleaseId).sort((a, b) => b.modified - a.modified)[0]?.id;
+  const keep = /* @__PURE__ */ new Set([active, previous, loadedRelease, state.stagedReleaseId]);
+  const removed = [];
+  for (const entry of candidates) {
+    if (keep.has(entry.id))
+      continue;
+    await removeStoragePath(join(layout.releasesRoot, entry.id));
+    removed.push(entry.id);
+  }
+  if (previous !== state.previousReleaseId)
+    await writeUpdateState(layout, { ...state, previousReleaseId: previous });
+  return removed;
 }
-var DEFAULT_UPDATE_MANIFEST_URL;
-var init_self_update_manifest = __esm({
-  "apps/body/dist/self-update-manifest.js"() {
+var LEGACY_FLAT_BUNDLE_FILES;
+var init_self_update_activate_release = __esm({
+  "apps/body/dist/self-update-activate-release.js"() {
     "use strict";
-    DEFAULT_UPDATE_MANIFEST_URL = "https://usebeeline.app/dl/manifest.json";
+    init_lifecycle_test_guard();
+    init_storage_filesystem();
+    init_self_update();
+    LEGACY_FLAT_BUNDLE_FILES = [
+      "beeline-cli.mjs",
+      "beeline-readonly-mcp.mjs",
+      "pi-mcp-adapter.mjs",
+      "bundle.json"
+    ];
   }
 });
 
 // apps/body/dist/self-update.js
 var self_update_exports = {};
 __export(self_update_exports, {
+  BUNDLE_ENTRYPOINT: () => BUNDLE_ENTRYPOINT,
+  CODEGRAPH_ENTRYPOINT: () => CODEGRAPH_ENTRYPOINT,
+  FORWARDER_ALIASES: () => FORWARDER_ALIASES,
+  FORWARDER_TOOLS: () => FORWARDER_TOOLS,
+  PI_MCP_ADAPTER_ENTRYPOINT: () => PI_MCP_ADAPTER_ENTRYPOINT,
+  RELEASES_SEGMENT: () => RELEASES_SEGMENT,
   STAGED_NODE_PATH_FILE: () => STAGED_NODE_PATH_FILE,
   SelfUpdateManager: () => SelfUpdateManager,
   activateRelease: () => activateRelease,
   activeReleaseId: () => activeReleaseId,
+  anchorLayout: () => anchorLayout,
   archiveUrlFor: () => archiveUrlFor,
   beelineInstallLayout: () => beelineInstallLayout,
+  bundleJsonCandidates: () => bundleJsonCandidates,
   defaultBeelineInstallLayout: () => defaultBeelineInstallLayout,
   describeIdentity: () => describeIdentity,
   discoveredBeelineInstallLayout: () => discoveredBeelineInstallLayout,
+  entrypointCandidates: () => entrypointCandidates,
+  fetchText: () => fetchText,
+  forwarderScript: () => forwarderScript,
+  fsyncDir: () => fsyncDir,
   hostPlatformKey: () => hostPlatformKey,
   nodeVersionAtLeast: () => nodeVersionAtLeast,
   normalizeLegacyBundleShape: () => normalizeLegacyBundleShape,
+  pathKind: () => pathKind,
   prepareLatestRelease: () => prepareLatestRelease,
   pruneHelperReleases: () => pruneHelperReleases,
   readBundleEngineMinimum: () => readBundleEngineMinimum,
+  readBundleJson: () => readBundleJson,
   readInstalledBundleIdentity: () => readInstalledBundleIdentity,
   readUpdateState: () => readUpdateState,
   releaseIdFromPath: () => releaseIdFromPath,
   repairInstallForwarders: () => repairInstallForwarders,
+  replaceFile: () => replaceFile,
+  requiredBundlePaths: () => requiredBundlePaths,
   resolveBundleEntrypoint: () => resolveBundleEntrypoint,
+  run: () => run,
   runningReleaseId: () => runningReleaseId,
+  sanitizeReleaseId: () => sanitizeReleaseId,
   stageRelease: () => stageRelease,
+  updateStatePath: () => updateStatePath,
   writeUpdateState: () => writeUpdateState
 });
-import { createHash as createHash3 } from "node:crypto";
-import { constants as fsConstants } from "node:fs";
-import { access, chmod as chmod2, copyFile, lstat as lstat3, mkdir as mkdir3, open, readFile as readFile2, readdir as readdir3, rename as rename2, rm as rm3, symlink, writeFile as writeFile2 } from "node:fs/promises";
-import { spawn as spawn2 } from "node:child_process";
+import { readFile as readFile3, mkdir as mkdir4, open, rename as rename3, lstat as lstat4, access as access2, writeFile as writeFile2, rm as rm4, chmod as chmod2 } from "node:fs/promises";
+import { join as join2, resolve as resolve7, dirname as dirname5 } from "node:path";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname4, join, resolve as resolve6 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { constants as fsConstants2 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
 function anchorLayout(rawLibDir) {
-  const libDir = resolve6(rawLibDir);
+  const libDir = resolve7(rawLibDir);
   const segments = libDir.split(/[/\\]/);
   const idx = segments.lastIndexOf(RELEASES_SEGMENT);
   if (idx >= 2 && segments[idx - 1] === "lib") {
@@ -488,9 +702,9 @@ function anchorLayout(rawLibDir) {
     // prefix's bin, NOT <prefix>/lib/bin — deriving it one level up was the
     // defect that made activateRelease write its stable forwarders where
     // nothing executed them, leaving stale raw wrappers in <prefix>/bin.
-    binDir: resolve6(libDir, "../../bin"),
+    binDir: resolve7(libDir, "../../bin"),
     libDir,
-    releasesRoot: resolve6(libDir, `../${RELEASES_SEGMENT}`)
+    releasesRoot: resolve7(libDir, `../${RELEASES_SEGMENT}`)
   };
 }
 function beelineInstallLayout(env = process.env) {
@@ -502,18 +716,18 @@ function beelineInstallLayout(env = process.env) {
 function releaseIdFromPath(path) {
   if (!path?.trim())
     return void 0;
-  const segments = resolve6(path.trim()).split(/[/\\]/);
+  const segments = resolve7(path.trim()).split(/[/\\]/);
   const idx = segments.lastIndexOf(RELEASES_SEGMENT);
   const id = idx >= 0 ? segments[idx + 1] : void 0;
   return id ? sanitizeReleaseId(id) : void 0;
 }
 function runningReleaseId(layout, env = process.env, invocationPath = process.argv[1]) {
-  const releasesRoot = resolve6(layout.releasesRoot);
-  const anchor = resolve6(layout.libDir);
+  const releasesRoot = resolve7(layout.releasesRoot);
+  const anchor = resolve7(layout.libDir);
   for (const raw of [env.BEELINE_LIB_DIR, invocationPath]) {
     if (!raw?.trim())
       continue;
-    const resolved = resolve6(raw.trim());
+    const resolved = resolve7(raw.trim());
     if (resolved !== anchor && !resolved.startsWith(`${releasesRoot}/`))
       continue;
     const id = releaseIdFromPath(resolved);
@@ -524,7 +738,7 @@ function runningReleaseId(layout, env = process.env, invocationPath = process.ar
 }
 function defaultBeelineInstallLayout(env = process.env) {
   const home2 = env.HOME?.trim() || homedir3();
-  return anchorLayout(resolve6(home2, ".local", "lib", "beeline"));
+  return anchorLayout(resolve7(home2, ".local", "lib", "beeline"));
 }
 function discoveredBeelineInstallLayout(env = process.env) {
   const explicitAnchor = env.BEELINE_INSTALL_LIB_DIR?.trim();
@@ -532,7 +746,7 @@ function discoveredBeelineInstallLayout(env = process.env) {
     return anchorLayout(explicitAnchor);
   const explicitBinDir = env.BEELINE_INSTALL_DIR?.trim();
   if (explicitBinDir)
-    return anchorLayout(resolve6(dirname4(resolve6(explicitBinDir)), "lib", "beeline"));
+    return anchorLayout(resolve7(dirname5(resolve7(explicitBinDir)), "lib", "beeline"));
   return defaultBeelineInstallLayout(env);
 }
 function hostPlatformKey() {
@@ -543,13 +757,13 @@ function hostPlatformKey() {
   return `${os}-${arch}`;
 }
 function bundleJsonCandidates(bundleDir) {
-  return [join(bundleDir, "lib", "beeline", "bundle.json"), join(bundleDir, "bundle.json")];
+  return [join2(bundleDir, "lib", "beeline", "bundle.json"), join2(bundleDir, "bundle.json")];
 }
 async function readBundleJson(bundleDir) {
   let raw;
   for (const candidate of bundleJsonCandidates(bundleDir)) {
     try {
-      raw = await readFile2(candidate, "utf8");
+      raw = await readFile3(candidate, "utf8");
       break;
     } catch {
     }
@@ -569,7 +783,7 @@ async function readBundleJson(bundleDir) {
 async function readBundleEngineMinimum(bundleDir) {
   for (const candidate of bundleJsonCandidates(bundleDir)) {
     try {
-      const parsed = JSON.parse(await readFile2(candidate, "utf8"));
+      const parsed = JSON.parse(await readFile3(candidate, "utf8"));
       const match = /^>=(\d+)\.(\d+)\.(\d+)$/.exec(parsed.node ?? "");
       if (match)
         return [Number(match[1]), Number(match[2]), Number(match[3])];
@@ -589,17 +803,17 @@ function nodeVersionAtLeast(version, minimum) {
   return true;
 }
 function updateStatePath(layout) {
-  return join(layout.releasesRoot, ".state", "update-state.json");
+  return join2(layout.releasesRoot, ".state", "update-state.json");
 }
 async function readUpdateState(layout) {
   try {
-    return JSON.parse(await readFile2(updateStatePath(layout), "utf8"));
+    return JSON.parse(await readFile3(updateStatePath(layout), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeUpdateState(layout, state) {
-  await mkdir3(join(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir4(join2(layout.releasesRoot, ".state"), { recursive: true });
   const path = updateStatePath(layout);
   const temporary = `${path}.${process.pid}.tmp`;
   const handle = await open(temporary, "w", 384);
@@ -610,8 +824,8 @@ async function writeUpdateState(layout, state) {
   } finally {
     await handle.close();
   }
-  await rename2(temporary, path);
-  await fsyncDir(dirname4(path));
+  await rename3(temporary, path);
+  await fsyncDir(dirname5(path));
 }
 async function readInstalledBundleIdentity(layout, _state = {}) {
   const fromDisk = await readBundleJson(layout.libDir);
@@ -625,7 +839,7 @@ function sanitizeReleaseId(id) {
 }
 async function pathKind(path) {
   try {
-    const info = await lstat3(path);
+    const info = await lstat4(path);
     if (info.isSymbolicLink())
       return "symlink";
     return info.isDirectory() ? "directory" : "missing";
@@ -688,12 +902,12 @@ function run(command2, args, _timeoutMs) {
   });
 }
 function entrypointCandidates(bundleDir) {
-  return [join(bundleDir, BUNDLE_ENTRYPOINT), join(bundleDir, "beeline-cli.mjs")];
+  return [join2(bundleDir, BUNDLE_ENTRYPOINT), join2(bundleDir, "beeline-cli.mjs")];
 }
 async function resolveBundleEntrypoint(bundleDir) {
   for (const candidate of entrypointCandidates(bundleDir)) {
     try {
-      await access(candidate, fsConstants.F_OK);
+      await access2(candidate, fsConstants2.F_OK);
       return candidate;
     } catch {
     }
@@ -717,17 +931,17 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
   });
   const log2 = opts.logger ?? ((line) => console.log(`[body] self-update: ${line}`));
   let releaseId = sanitizeReleaseId((published.commit ?? published.version ?? `release-${Date.now()}`) + (opts.force ? `-repair-${Date.now()}` : ""));
-  let releaseDir = join(layout.releasesRoot, releaseId);
-  let okMarker = join(releaseDir, ".stage-ok");
+  let releaseDir = join2(layout.releasesRoot, releaseId);
+  let okMarker = join2(releaseDir, ".stage-ok");
   let previouslyVerified = false;
   try {
-    const recorded = await readFile2(okMarker, "utf8");
+    const recorded = await readFile3(okMarker, "utf8");
     if (recorded.trim() === published.sha256 && !opts.force)
       return releaseId;
     releaseId = sanitizeReleaseId(`${releaseId}-${published.sha256.slice(0, 12)}`);
-    releaseDir = join(layout.releasesRoot, releaseId);
-    okMarker = join(releaseDir, ".stage-ok");
-    const matching = await readFile2(okMarker, "utf8").catch(() => "");
+    releaseDir = join2(layout.releasesRoot, releaseId);
+    okMarker = join2(releaseDir, ".stage-ok");
+    const matching = await readFile3(okMarker, "utf8").catch(() => "");
     if (matching.trim() === published.sha256 && !opts.force)
       return releaseId;
     previouslyVerified = Boolean(matching);
@@ -735,12 +949,12 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
   }
   if (await activeReleaseId(layout) === releaseId) {
     releaseId = sanitizeReleaseId(`${releaseId}-repair-${Date.now()}`);
-    releaseDir = join(layout.releasesRoot, releaseId);
-    okMarker = join(releaseDir, ".stage-ok");
+    releaseDir = join2(layout.releasesRoot, releaseId);
+    okMarker = join2(releaseDir, ".stage-ok");
     previouslyVerified = false;
   }
-  await mkdir3(releaseDir, { recursive: true });
-  const tempArchive = join(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
+  await mkdir4(releaseDir, { recursive: true });
+  const tempArchive = join2(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
   try {
     log2(`downloading ${published.file}`);
     const response = await fetchImpl(archiveUrlFor(manifestUrl, published.file), {
@@ -784,7 +998,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
       throw new Error(`extracting bundle failed: ${extract.stderr}`);
     for (const relative of requiredBundlePaths()) {
       try {
-        await access(join(releaseDir, relative), fsConstants.F_OK);
+        await access2(join2(releaseDir, relative), fsConstants2.F_OK);
       } catch {
         throw new Error(`staged bundle is missing ${relative}`);
       }
@@ -797,11 +1011,11 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
       if (!nodeVersionAtLeast(process.versions.node, engineMinimum)) {
         throw new Error(`staged bundle requires Node.js >=${engineMinimum.join(".")}, but this process is running Node.js ${process.versions.node} \u2014 install a satisfying Node runtime and retry`);
       }
-      await writeFile2(join(releaseDir, STAGED_NODE_PATH_FILE), `${process.execPath}
+      await writeFile2(join2(releaseDir, STAGED_NODE_PATH_FILE), `${process.execPath}
 `, "utf8");
     }
     if (opts.smokeTestCli !== false) {
-      const probe = await run(process.execPath, [join(releaseDir, BUNDLE_ENTRYPOINT), "--version"], Math.min(6e4, remaining()));
+      const probe = await run(process.execPath, [join2(releaseDir, BUNDLE_ENTRYPOINT), "--version"], Math.min(6e4, remaining()));
       if (probe.status !== 0) {
         throw new Error(`staged bundle failed its startup smoke test (--version exited ${probe.status})${probe.stderr ? `: ${probe.stderr.trim()}` : ""}`);
       }
@@ -812,10 +1026,10 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     return releaseId;
   } catch (error) {
     if (!previouslyVerified)
-      await rm3(releaseDir, { recursive: true, force: true });
+      await rm4(releaseDir, { recursive: true, force: true });
     throw error;
   } finally {
-    await rm3(tempArchive, { force: true });
+    await rm4(tempArchive, { force: true });
   }
 }
 function forwarderScript(tool) {
@@ -850,142 +1064,14 @@ async function replaceFile(path, contents, mode) {
   const temp = `${path}.new-${process.pid}`;
   await writeFile2(temp, contents, { mode });
   await chmod2(temp, mode);
-  await rename2(temp, path);
-}
-async function activateRelease(layout, releaseId, options = {}) {
-  assertInstallTestIsolation(layout);
-  let releaseDir = join(layout.releasesRoot, releaseId);
-  let previousReleaseId = await activeReleaseId(layout);
-  await access(join(releaseDir, BUNDLE_ENTRYPOINT), fsConstants.F_OK);
-  await mkdir3(layout.releasesRoot, { recursive: true });
-  await mkdir3(layout.binDir, { recursive: true });
-  const kind = await pathKind(layout.libDir);
-  if (kind === "directory") {
-    const legacyIdentity = await readBundleJson(layout.libDir);
-    const legacyId = sanitizeReleaseId(legacyIdentity?.commit ?? legacyIdentity?.version ?? `legacy-${Date.now()}`);
-    const legacyDir = join(layout.releasesRoot, legacyId);
-    try {
-      await access(legacyDir, fsConstants.F_OK);
-      const preservedId = `${legacyId}-${Date.now()}`;
-      await rename2(layout.libDir, join(layout.releasesRoot, preservedId));
-      await normalizeLegacyBundleShape(join(layout.releasesRoot, preservedId));
-      previousReleaseId = preservedId;
-    } catch {
-      await rename2(layout.libDir, legacyDir);
-      await normalizeLegacyBundleShape(legacyDir);
-      previousReleaseId = legacyId;
-    }
-  }
-  const tempLink = `${layout.libDir}.new-${process.pid}`;
-  await rm3(tempLink, { force: true });
-  await symlink(join("beeline-releases", releaseId), tempLink);
-  await rename2(tempLink, layout.libDir);
-  await fsyncDir(dirname4(layout.libDir));
-  await installRecoveryLauncher(layout, releaseDir);
-  await writeBinForwarders(layout, releaseDir);
-  const state = await readUpdateState(layout);
-  await writeUpdateState(layout, {
-    ...state,
-    stagedReleaseId: void 0,
-    previousReleaseId: previousReleaseId && previousReleaseId !== releaseId ? previousReleaseId : state.previousReleaseId
-  });
-  if (!options.deferPruning)
-    await pruneHelperReleases(layout);
-}
-async function installRecoveryLauncher(layout, releaseDir) {
-  const bootstrap = join(releaseDir, "lib/beeline/recovery-cli.mjs");
-  if (await access(bootstrap).then(() => true, () => false)) {
-    const stable = resolve6(layout.libDir, "../beeline-bootstrap.mjs");
-    const temporary = `${stable}.${process.pid}.tmp`;
-    await copyFile(bootstrap, temporary);
-    await rename2(temporary, stable);
-    await replaceFile(resolve6(layout.libDir, "../beeline-node-path"), `${process.execPath}
-`, 384);
-  }
-}
-async function normalizeLegacyBundleShape(bundleDir) {
-  const innerLib = join(bundleDir, "lib", "beeline");
-  let anyFlat = false;
-  for (const name of LEGACY_FLAT_BUNDLE_FILES) {
-    try {
-      await access(join(bundleDir, name), fsConstants.F_OK);
-      anyFlat = true;
-      break;
-    } catch {
-    }
-  }
-  if (!anyFlat)
-    return;
-  await mkdir3(innerLib, { recursive: true });
-  for (const name of LEGACY_FLAT_BUNDLE_FILES) {
-    try {
-      await access(join(innerLib, name), fsConstants.F_OK);
-      continue;
-    } catch {
-    }
-    await rename2(join(bundleDir, name), join(innerLib, name)).catch(() => void 0);
-  }
-}
-async function writeBinForwarders(layout, activeBundleRoot) {
-  const entries = [
-    ...FORWARDER_TOOLS.map((tool) => [tool, tool]),
-    ...Object.entries(FORWARDER_ALIASES).map(([alias, tool]) => [alias, tool])
-  ];
-  for (const [name, tool] of entries) {
-    const target = join(activeBundleRoot, "bin", tool);
-    try {
-      await access(target, fsConstants.X_OK);
-    } catch {
-      continue;
-    }
-    const independent = await access(resolve6(layout.libDir, "../beeline-bootstrap.mjs")).then(() => true, () => false);
-    await replaceFile(join(layout.binDir, name), independent || tool !== "beeline" ? forwarderScript(tool) : forwarderScript("legacy-beeline").replace("/bin/legacy-beeline", "/bin/beeline"), 493);
-  }
-}
-async function repairInstallForwarders(layout, opts = {}) {
-  assertInstallTestIsolation(layout);
-  if (await pathKind(layout.libDir) !== "symlink")
-    return false;
-  await installRecoveryLauncher(layout, layout.libDir);
-  const forwarderHealthy = async (name, tool) => {
-    let current;
-    try {
-      current = await readFile2(join(layout.binDir, name), "utf8");
-    } catch {
-      current = void 0;
-    }
-    const independent = await access(resolve6(layout.libDir, "../beeline-bootstrap.mjs")).then(() => true, () => false);
-    const expected = independent || tool !== "beeline" ? forwarderScript(tool) : forwarderScript("legacy-beeline").replace("/bin/legacy-beeline", "/bin/beeline");
-    return current === expected;
-  };
-  let healthy = await forwarderHealthy("beeline", "beeline");
-  for (const [alias, tool] of Object.entries(FORWARDER_ALIASES)) {
-    if (!await forwarderHealthy(alias, tool))
-      healthy = false;
-  }
-  if (healthy)
-    return false;
-  await mkdir3(layout.binDir, { recursive: true });
-  await writeBinForwarders(layout, layout.libDir);
-  opts.logger?.(`[body] self-update: repaired <prefix>/bin forwarders to follow the active-bundle anchor (${layout.libDir})`);
-  return true;
-}
-function describeIdentity(identity) {
-  if (!identity)
-    return "unknown";
-  const parts = [];
-  if (identity.version)
-    parts.push(identity.version);
-  if (identity.commit)
-    parts.push(identity.commit.slice(0, 12));
-  return parts.join(" ") || "unknown";
+  await rename3(temp, path);
 }
 async function prepareLatestRelease(layout, options = {}) {
   try {
     const manifestUrl = options.manifest?.url ?? resolveManifestUrl(options.env ?? process.env);
     const bundle = options.manifest?.bundle ?? parseUpdateManifest(await fetchText(manifestUrl, options.fetchImpl ?? fetch), hostPlatformKey()).bundle;
     const pending = (await readUpdateState(layout)).stagedReleaseId;
-    const pendingDigest = pending ? await readFile2(join(layout.releasesRoot, pending, ".stage-ok"), "utf8").catch(() => "") : "";
+    const pendingDigest = pending ? await readFile3(join2(layout.releasesRoot, pending, ".stage-ok"), "utf8").catch(() => "") : "";
     const releaseId = !options.force && pending && pendingDigest.trim() === bundle.sha256 ? pending : await stageRelease(layout, manifestUrl, bundle, {
       fetchImpl: options.fetchImpl,
       logger: options.logger,
@@ -1009,55 +1095,18 @@ async function prepareLatestRelease(layout, options = {}) {
     throw error;
   }
 }
-async function pruneHelperReleases(layout, loadedRelease) {
-  assertInstallTestIsolation(layout);
-  if (!await ordinaryDirectory(layout.releasesRoot))
-    return [];
-  const active = await activeReleaseId(layout);
-  if (!active)
-    return [];
-  const state = await readUpdateState(layout);
-  const candidates = [];
-  for (const entry of await readdir3(layout.releasesRoot, { withFileTypes: true })) {
-    if (entry.name.startsWith("."))
-      continue;
-    if (entry.isSymbolicLink()) {
-      if (![active, state.previousReleaseId, state.stagedReleaseId, loadedRelease].includes(entry.name))
-        await rm3(join(layout.releasesRoot, entry.name), { force: true });
-      continue;
-    }
-    if (!entry.isDirectory())
-      continue;
-    const path = join(layout.releasesRoot, entry.name);
-    if (!await ordinaryDirectory(path))
-      continue;
-    candidates.push({
-      id: entry.name,
-      modified: (await lstat3(path)).mtimeMs,
-      bootable: await access(join(path, BUNDLE_ENTRYPOINT)).then(() => true, () => false)
-    });
-  }
-  const recordedPrevious = candidates.find((entry) => entry.id === state.previousReleaseId && entry.id !== active && entry.bootable)?.id;
-  const previous = recordedPrevious ?? candidates.filter((entry) => entry.bootable && entry.id !== active && entry.id !== state.stagedReleaseId).sort((a, b) => b.modified - a.modified)[0]?.id;
-  const keep = /* @__PURE__ */ new Set([active, previous, loadedRelease, state.stagedReleaseId]);
-  const removed = [];
-  for (const entry of candidates) {
-    if (keep.has(entry.id))
-      continue;
-    await removeStoragePath(join(layout.releasesRoot, entry.id));
-    removed.push(entry.id);
-  }
-  if (previous !== state.previousReleaseId)
-    await writeUpdateState(layout, { ...state, previousReleaseId: previous });
-  return removed;
-}
-var RELEASES_SEGMENT, STAGED_NODE_PATH_FILE, BUNDLE_ENTRYPOINT, PI_MCP_ADAPTER_ENTRYPOINT, CODEGRAPH_ENTRYPOINT, FORWARDER_TOOLS, FORWARDER_ALIASES, LEGACY_FLAT_BUNDLE_FILES, SelfUpdateManager;
+var RELEASES_SEGMENT, STAGED_NODE_PATH_FILE, BUNDLE_ENTRYPOINT, PI_MCP_ADAPTER_ENTRYPOINT, CODEGRAPH_ENTRYPOINT, FORWARDER_TOOLS, FORWARDER_ALIASES, SelfUpdateManager;
 var init_self_update = __esm({
   "apps/body/dist/self-update.js"() {
     "use strict";
-    init_storage_filesystem();
     init_lifecycle_test_guard();
     init_self_update_manifest();
+    init_self_update_activate_release();
+    init_self_update_activate_release();
+    init_self_update_activate_release();
+    init_self_update_activate_release();
+    init_self_update_activate_release();
+    init_self_update_activate_release();
     RELEASES_SEGMENT = "beeline-releases";
     STAGED_NODE_PATH_FILE = ".node-path";
     BUNDLE_ENTRYPOINT = "lib/beeline/beeline-cli.mjs";
@@ -1073,12 +1122,6 @@ var init_self_update = __esm({
     FORWARDER_ALIASES = {
       usebeeline: "beeline"
     };
-    LEGACY_FLAT_BUNDLE_FILES = [
-      "beeline-cli.mjs",
-      "beeline-readonly-mcp.mjs",
-      "pi-mcp-adapter.mjs",
-      "bundle.json"
-    ];
     SelfUpdateManager = class {
       options;
       constructor(options) {
@@ -1108,9 +1151,9 @@ __export(managed_update_exports, {
   withInstallLock: () => withInstallLock
 });
 import { spawn as spawn3 } from "node:child_process";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 function withInstallLock(layout, work, options = {}) {
-  return withKernelLock(`beeline-install:${resolve7(layout.libDir)}`, work, options.waitMs);
+  return withKernelLock(`beeline-install:${resolve8(layout.libDir)}`, work, options.waitMs);
 }
 function versionAtLeast(actual, minimum) {
   const parse = (value) => /^v?(\d+)\.(\d+)\.(\d+)$/.exec(value)?.slice(1).map(Number);
@@ -1135,7 +1178,7 @@ async function runManagedUpdateWorker() {
 }
 async function prepareReleaseInWorker(env, deadlineAt, entrypoint) {
   const layout = beelineInstallLayout(env);
-  const bootstrap = entrypoint ?? resolve7(layout.libDir, "../beeline-bootstrap.mjs");
+  const bootstrap = entrypoint ?? resolve8(layout.libDir, "../beeline-bootstrap.mjs");
   return new Promise((done, reject) => {
     const child = spawn3(process.execPath, [bootstrap, "managed-update-worker"], {
       detached: true,
@@ -1193,7 +1236,6 @@ var init_managed_update = __esm({
       #interruptAt;
       #deadlineAt;
       #handingOff;
-      #notice;
       #completed = false;
       #draining = false;
       constructor(options) {
@@ -1205,10 +1247,7 @@ var init_managed_update = __esm({
       get pending() {
         return this.#preparing ?? this.#handingOff;
       }
-      notify(releaseKey, minimum) {
-        if (releaseKey && releaseKey === this.#notice)
-          return;
-        this.#notice = releaseKey;
+      notify(_releaseKey, minimum) {
         if (minimum && (!this.#minimum || !versionAtLeast(this.#minimum, minimum))) {
           this.#minimum = minimum;
           this.#handoffAt = this.now();
@@ -1227,7 +1266,7 @@ var init_managed_update = __esm({
         if (this.#minimum) {
           const identity = await readInstalledBundleIdentity({
             ...this.options.layout,
-            libDir: resolve7(this.options.layout.releasesRoot, releaseId)
+            libDir: resolve8(this.options.layout.releasesRoot, releaseId)
           });
           if (!identity?.version || !versionAtLeast(identity.version, this.#minimum)) {
             this.#prepared = void 0;
@@ -3407,9 +3446,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve11, reject) => {
+          return new Promise((resolve13, reject) => {
             this.close((err, data) => {
-              return err ? reject(err) : resolve11(data);
+              return err ? reject(err) : resolve13(data);
             });
           });
         }
@@ -3447,12 +3486,12 @@ var require_dispatcher_base = __commonJS({
           err = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve11, reject) => {
+          return new Promise((resolve13, reject) => {
             this.destroy(err, (err2, data) => {
               return err2 ? (
                 /* istanbul ignore next: should never error */
                 reject(err2)
-              ) : resolve11(data);
+              ) : resolve13(data);
             });
           });
         }
@@ -5719,8 +5758,8 @@ var require_util2 = __commonJS({
     function createDeferredPromise() {
       let res;
       let rej;
-      const promise = new Promise((resolve11, reject) => {
-        res = resolve11;
+      const promise = new Promise((resolve13, reject) => {
+        res = resolve13;
         rej = reject;
       });
       return { promise, resolve: res, reject: rej };
@@ -7966,12 +8005,12 @@ upgrade: ${upgrade}\r
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve11, reject) => {
+      const waitForDrain = () => new Promise((resolve13, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve11;
+          callback = resolve13;
         }
       });
       socket.on("close", onDrain).on("drain", onDrain);
@@ -8608,12 +8647,12 @@ var require_client_h2 = __commonJS({
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve11, reject) => {
+      const waitForDrain = () => new Promise((resolve13, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve11;
+          callback = resolve13;
         }
       });
       h2stream.on("close", onDrain).on("drain", onDrain);
@@ -9091,16 +9130,16 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       async [kClose]() {
-        return new Promise((resolve11) => {
+        return new Promise((resolve13) => {
           if (this[kSize]) {
-            this[kClosedResolve] = resolve11;
+            this[kClosedResolve] = resolve13;
           } else {
-            resolve11(null);
+            resolve13(null);
           }
         });
       }
       async [kDestroy](err) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve13) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request2 = requests[i];
@@ -9111,7 +9150,7 @@ var require_client = __commonJS({
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve11(null);
+            resolve13(null);
           };
           if (this[kHTTPContext]) {
             this[kHTTPContext].destroy(err, callback);
@@ -9162,7 +9201,7 @@ var require_client = __commonJS({
         });
       }
       try {
-        const socket = await new Promise((resolve11, reject) => {
+        const socket = await new Promise((resolve13, reject) => {
           client[kConnector]({
             host,
             hostname,
@@ -9174,7 +9213,7 @@ var require_client = __commonJS({
             if (err) {
               reject(err);
             } else {
-              resolve11(socket2);
+              resolve13(socket2);
             }
           });
         });
@@ -9510,8 +9549,8 @@ var require_pool_base = __commonJS({
         if (this[kQueue].isEmpty()) {
           await Promise.all(this[kClients].map((c) => c.close()));
         } else {
-          await new Promise((resolve11) => {
-            this[kClosedResolve] = resolve11;
+          await new Promise((resolve13) => {
+            this[kClosedResolve] = resolve13;
           });
         }
       }
@@ -10754,7 +10793,7 @@ var require_readable = __commonJS({
         if (this._readableState.closeEmitted) {
           return null;
         }
-        return await new Promise((resolve11, reject) => {
+        return await new Promise((resolve13, reject) => {
           if (this[kContentLength] > limit) {
             this.destroy(new AbortError());
           }
@@ -10767,7 +10806,7 @@ var require_readable = __commonJS({
             if (signal?.aborted) {
               reject(signal.reason ?? new AbortError());
             } else {
-              resolve11(null);
+              resolve13(null);
             }
           }).on("error", noop).on("data", function(chunk) {
             limit -= chunk.length;
@@ -10786,7 +10825,7 @@ var require_readable = __commonJS({
     }
     async function consume(stream, type) {
       assert(!stream[kConsume]);
-      return new Promise((resolve11, reject) => {
+      return new Promise((resolve13, reject) => {
         if (isUnusable(stream)) {
           const rState = stream._readableState;
           if (rState.destroyed && rState.closeEmitted === false) {
@@ -10803,7 +10842,7 @@ var require_readable = __commonJS({
             stream[kConsume] = {
               type,
               stream,
-              resolve: resolve11,
+              resolve: resolve13,
               reject,
               length: 0,
               body: []
@@ -10873,18 +10912,18 @@ var require_readable = __commonJS({
       return buffer;
     }
     function consumeEnd(consume2) {
-      const { type, body, resolve: resolve11, stream, length } = consume2;
+      const { type, body, resolve: resolve13, stream, length } = consume2;
       try {
         if (type === "text") {
-          resolve11(chunksDecode(body, length));
+          resolve13(chunksDecode(body, length));
         } else if (type === "json") {
-          resolve11(JSON.parse(chunksDecode(body, length)));
+          resolve13(JSON.parse(chunksDecode(body, length)));
         } else if (type === "arrayBuffer") {
-          resolve11(chunksConcat(body, length).buffer);
+          resolve13(chunksConcat(body, length).buffer);
         } else if (type === "blob") {
-          resolve11(new Blob(body, { type: stream[kContentType] }));
+          resolve13(new Blob(body, { type: stream[kContentType] }));
         } else if (type === "bytes") {
-          resolve11(chunksConcat(body, length));
+          resolve13(chunksConcat(body, length));
         }
         consumeFinish(consume2);
       } catch (err) {
@@ -11141,9 +11180,9 @@ var require_api_request = __commonJS({
     };
     function request2(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve13, reject) => {
           request2.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve11(data);
+            return err ? reject(err) : resolve13(data);
           });
         });
       }
@@ -11366,9 +11405,9 @@ var require_api_stream = __commonJS({
     };
     function stream(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve13, reject) => {
           stream.call(this, opts, factory, (err, data) => {
-            return err ? reject(err) : resolve11(data);
+            return err ? reject(err) : resolve13(data);
           });
         });
       }
@@ -11653,9 +11692,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve13, reject) => {
           upgrade.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve11(data);
+            return err ? reject(err) : resolve13(data);
           });
         });
       }
@@ -11747,9 +11786,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve11, reject) => {
+        return new Promise((resolve13, reject) => {
           connect.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve11(data);
+            return err ? reject(err) : resolve13(data);
           });
         });
       }
@@ -12976,16 +13015,16 @@ var require_dns = __commonJS({
       setRecords(origin, addresses) {
         const timestamp = Date.now();
         const records = { records: { 4: null, 6: null } };
-        for (const record of addresses) {
-          record.timestamp = timestamp;
-          if (typeof record.ttl === "number") {
-            record.ttl = Math.min(record.ttl, this.#maxTTL);
+        for (const record2 of addresses) {
+          record2.timestamp = timestamp;
+          if (typeof record2.ttl === "number") {
+            record2.ttl = Math.min(record2.ttl, this.#maxTTL);
           } else {
-            record.ttl = this.#maxTTL;
+            record2.ttl = this.#maxTTL;
           }
-          const familyRecords = records.records[record.family] ?? { ips: [] };
-          familyRecords.ips.push(record);
-          records.records[record.family] = familyRecords;
+          const familyRecords = records.records[record2.family] ?? { ips: [] };
+          familyRecords.ips.push(record2);
+          records.records[record2.family] = familyRecords;
         }
         this.#records.set(origin.hostname, records);
       }
@@ -15611,7 +15650,7 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url = requestCurrentURL(request2);
         const agent = fetchParams.controller.dispatcher;
-        return new Promise((resolve11, reject) => agent.dispatch(
+        return new Promise((resolve13, reject) => agent.dispatch(
           {
             path: url.pathname + url.search,
             origin: url.origin,
@@ -15687,7 +15726,7 @@ var require_fetch = __commonJS({
                 }
               }
               const onError = this.onError.bind(this);
-              resolve11({
+              resolve13({
                 status,
                 statusText,
                 headersList,
@@ -15733,7 +15772,7 @@ var require_fetch = __commonJS({
               for (let i = 0; i < rawHeaders.length; i += 2) {
                 headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
               }
-              resolve11({
+              resolve13({
                 status,
                 statusText: STATUS_CODES[status],
                 headersList,
@@ -19463,8 +19502,8 @@ var require_util8 = __commonJS({
       return true;
     }
     function delay(ms) {
-      return new Promise((resolve11) => {
-        setTimeout(resolve11, ms).unref();
+      return new Promise((resolve13) => {
+        setTimeout(resolve13, ms).unref();
       });
     }
     module.exports = {
@@ -19630,41 +19669,41 @@ var require_eventsource_stream = __commonJS({
         if (colonPosition === 0) {
           return;
         }
-        let field = "";
+        let field2 = "";
         let value = "";
         if (colonPosition !== -1) {
-          field = line.subarray(0, colonPosition).toString("utf8");
+          field2 = line.subarray(0, colonPosition).toString("utf8");
           let valueStart = colonPosition + 1;
           if (line[valueStart] === SPACE) {
             ++valueStart;
           }
           value = line.subarray(valueStart).toString("utf8");
         } else {
-          field = line.toString("utf8");
+          field2 = line.toString("utf8");
           value = "";
         }
-        switch (field) {
+        switch (field2) {
           case "data":
-            if (event[field] === void 0) {
-              event[field] = value;
+            if (event[field2] === void 0) {
+              event[field2] = value;
             } else {
-              event[field] += `
+              event[field2] += `
 ${value}`;
             }
             break;
           case "retry":
             if (isASCIINumber(value)) {
-              event[field] = value;
+              event[field2] = value;
             }
             break;
           case "id":
             if (isValidLastEventId(value)) {
-              event[field] = value;
+              event[field2] = value;
             }
             break;
           case "event":
             if (value.length > 0) {
-              event[field] = value;
+              event[field2] = value;
             }
             break;
         }
@@ -20147,9 +20186,9 @@ var require_undici = __commonJS({
 // apps/body/dist/filesystem-change.js
 import { watch as watch2 } from "node:fs";
 import { stat as stat2 } from "node:fs/promises";
-import { dirname as dirname5 } from "node:path";
+import { dirname as dirname6 } from "node:path";
 function waitForPathRemoval(path) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     let reading = false, dirty = false, ended = false;
     const finish = (error) => {
       if (ended)
@@ -20159,7 +20198,7 @@ function waitForPathRemoval(path) {
       if (error)
         reject(error);
       else
-        resolve11();
+        resolve13();
     };
     const inspect = async () => {
       dirty = true;
@@ -20185,7 +20224,7 @@ function waitForPathRemoval(path) {
         reading = false;
       }
     };
-    const watcher = watch2(dirname5(path), () => {
+    const watcher = watch2(dirname6(path), () => {
       void inspect();
     });
     watcher.once("error", finish);
@@ -20219,9 +20258,9 @@ __export(store_exports, {
 import { createHash as createHash4, randomUUID } from "node:crypto";
 import { chmodSync, mkdirSync, readFileSync as readFileSync3, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 function stateDir(env = process.env) {
-  return join2(env.XDG_STATE_HOME || join2(env.HOME || homedir4(), ".local/state"), "beeline-sessions");
+  return join3(env.XDG_STATE_HOME || join3(env.HOME || homedir4(), ".local/state"), "beeline-sessions");
 }
 function pidAlive(pid) {
   try {
@@ -20243,17 +20282,17 @@ function writePrivate(path, text) {
 }
 function readState(dir = stateDir()) {
   try {
-    const value = JSON.parse(readFileSync3(join2(dir, "state.json"), "utf8"));
+    const value = JSON.parse(readFileSync3(join3(dir, "state.json"), "utf8"));
     return Array.isArray(value.sessions) ? value : { sessions: [] };
   } catch {
     return { sessions: [] };
   }
 }
 function writeState(dir, state) {
-  writePrivate(join2(ensureDir(dir), "state.json"), JSON.stringify(state, null, 2) + "\n");
+  writePrivate(join3(ensureDir(dir), "state.json"), JSON.stringify(state, null, 2) + "\n");
 }
 async function withLock(dir, run2) {
-  const lock = join2(ensureDir(dir), "state.lock");
+  const lock = join3(ensureDir(dir), "state.lock");
   for (let attempt = 0; ; attempt++) {
     try {
       mkdirSync(lock);
@@ -20292,16 +20331,16 @@ function safe(value) {
   return value.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 120);
 }
 function inboxPath(dir, key) {
-  return join2(dir, "inbox", `${createHash4("sha256").update(key).digest("hex").slice(0, 24)}.txt`);
+  return join3(dir, "inbox", `${createHash4("sha256").update(key).digest("hex").slice(0, 24)}.txt`);
 }
 function queueInbox(dir, key, text) {
   adoptInboxText(dir, key);
   queueInboxOnce(dir, key, `local:${randomUUID()}`, text);
 }
 function adoptInboxText(dir, key) {
-  const folder = ensureDir(join2(dir, "deliveries", createHash4("sha256").update(key).digest("hex").slice(0, 24)));
+  const folder = ensureDir(join3(dir, "deliveries", createHash4("sha256").update(key).digest("hex").slice(0, 24)));
   try {
-    renameSync(inboxPath(dir, key), join2(folder, `${randomUUID()}.text.pending`));
+    renameSync(inboxPath(dir, key), join3(folder, `${randomUUID()}.text.pending`));
   } catch (error) {
     if (error.code !== "ENOENT")
       throw error;
@@ -20312,8 +20351,8 @@ function queueInboxOnce(dir, key, deliveryId, text) {
   const queuedAt = lastInboxOrder;
   if (!deliveryId || deliveryId.length > 256)
     throw new Error("Invalid inbox delivery identity");
-  const folder = ensureDir(join2(dir, "deliveries", createHash4("sha256").update(key).digest("hex").slice(0, 24)));
-  const stem = join2(folder, createHash4("sha256").update(deliveryId).digest("hex"));
+  const folder = ensureDir(join3(dir, "deliveries", createHash4("sha256").update(key).digest("hex").slice(0, 24)));
+  const stem = join3(folder, createHash4("sha256").update(deliveryId).digest("hex"));
   if (existsDelivery(stem + ".pending") || existsDelivery(stem + ".done"))
     return false;
   writePrivate(stem + ".pending", JSON.stringify({ id: deliveryId, text, queuedAt }));
@@ -20328,7 +20367,7 @@ function existsDelivery(path) {
   }
 }
 function takeDeliveries(dir, key) {
-  const folder = join2(dir, "deliveries", createHash4("sha256").update(key).digest("hex").slice(0, 24));
+  const folder = join3(dir, "deliveries", createHash4("sha256").update(key).digest("hex").slice(0, 24));
   let names;
   try {
     names = readdirSync(folder);
@@ -20337,7 +20376,7 @@ function takeDeliveries(dir, key) {
   }
   const pending = names.filter((name) => name.endsWith(".pending")).flatMap((name) => {
     try {
-      const contents = readFileSync3(join2(folder, name), "utf8");
+      const contents = readFileSync3(join3(folder, name), "utf8");
       const item = name.endsWith(".text.pending") ? { text: contents, queuedAt: 0 } : JSON.parse(contents);
       return typeof item.text === "string" ? [{ name, ...item }] : [];
     } catch {
@@ -20346,7 +20385,7 @@ function takeDeliveries(dir, key) {
   }).sort((a, b) => a.queuedAt - b.queuedAt || a.name.localeCompare(b.name));
   const text = [];
   for (const item of pending) {
-    const path = join2(folder, item.name), done = path.replace(/\.pending$/, ".done");
+    const path = join3(folder, item.name), done = path.replace(/\.pending$/, ".done");
     try {
       renameSync(path, done);
     } catch {
@@ -20362,15 +20401,15 @@ function takeInbox(dir, key) {
   return takeDeliveries(dir, key).join("\n\n");
 }
 function recordHookSession(dir, session2) {
-  writePrivate(join2(ensureDir(join2(dir, "hooks")), `${safe(session2.agent)}-${safe(session2.sessionId)}.json`), JSON.stringify(session2));
+  writePrivate(join3(ensureDir(join3(dir, "hooks")), `${safe(session2.agent)}-${safe(session2.sessionId)}.json`), JSON.stringify(session2));
 }
 function forgetHookSession(dir, agent, sessionId) {
-  rmSync(join2(dir, "hooks", `${safe(agent)}-${safe(sessionId)}.json`), { force: true });
+  rmSync(join3(dir, "hooks", `${safe(agent)}-${safe(sessionId)}.json`), { force: true });
 }
 function hookSessions(dir, now = Date.now(), alive = pidAlive) {
   let names;
   try {
-    names = readdirSync(join2(dir, "hooks"));
+    names = readdirSync(join3(dir, "hooks"));
   } catch {
     return [];
   }
@@ -20379,7 +20418,7 @@ function hookSessions(dir, now = Date.now(), alive = pidAlive) {
     if (!name.endsWith(".json"))
       continue;
     try {
-      const session2 = JSON.parse(readFileSync3(join2(dir, "hooks", name), "utf8"));
+      const session2 = JSON.parse(readFileSync3(join3(dir, "hooks", name), "utf8"));
       if (now - session2.seenAt <= HOOK_TTL_MS && (session2.pid === void 0 || alive(session2.pid)))
         found.push(session2);
     } catch {
@@ -20404,7 +20443,7 @@ function admitHeldMcpCompletion(url, body) {
   if (!["https:", "http:"].includes(target.protocol) || target.username || target.password || target.hash || target.search || target.pathname !== "/mcp/oauth/handoff" || !body || typeof body !== "object" || Object.getPrototypeOf(body) !== Object.prototype)
     throw new Error("Held MCP completion route unavailable");
   const fields = Object.getOwnPropertyDescriptors(body);
-  if (Object.getOwnPropertySymbols(body).length || Object.keys(fields).some((key) => !["state", "completionV1", "waitMs"].includes(key)) || Object.values(fields).some((field) => !("value" in field)) || fields.completionV1?.value !== true || typeof fields.state?.value !== "string" || !/^[A-Za-z0-9_-]{32,128}$/.test(fields.state.value) || !Number.isSafeInteger(fields.waitMs?.value) || fields.waitMs.value < 1 || fields.waitMs.value > 6e5)
+  if (Object.getOwnPropertySymbols(body).length || Object.keys(fields).some((key) => !["state", "completionV1", "waitMs"].includes(key)) || Object.values(fields).some((field2) => !("value" in field2)) || fields.completionV1?.value !== true || typeof fields.state?.value !== "string" || !/^[A-Za-z0-9_-]{32,128}$/.test(fields.state.value) || !Number.isSafeInteger(fields.waitMs?.value) || fields.waitMs.value < 1 || fields.waitMs.value > 6e5)
     throw new Error("Held MCP completion admission invalid");
 }
 async function request(url, body, headers, stream, cancellation, held = false) {
@@ -20636,10 +20675,47 @@ var init_beeline_api = __esm({
   }
 });
 
+// apps/body/dist/process-exit.js
+import { spawn as spawn5 } from "node:child_process";
+function waitForProcessExit(pid, signal) {
+  return new Promise((resolve13, reject) => {
+    const child = spawn5("/usr/bin/python3", ["-c", WAIT, String(pid)], { stdio: "ignore", signal });
+    child.once("error", reject);
+    child.once("close", (code) => code === 0 ? resolve13() : reject(new Error(`process exit observer failed (${code})`)));
+  });
+}
+var WAIT;
+var init_process_exit = __esm({
+  "apps/body/dist/process-exit.js"() {
+    "use strict";
+    WAIT = `import os,sys,select
+pid=int(sys.argv[1])
+try:
+ if hasattr(os,'pidfd_open'):
+  fd=os.pidfd_open(pid)
+  try: select.select([fd],[],[])
+  finally: os.close(fd)
+ else:
+  queue=select.kqueue()
+  try: queue.control([select.kevent(pid,filter=select.KQ_FILTER_PROC,flags=select.KQ_EV_ADD|select.KQ_EV_ONESHOT,fflags=select.KQ_NOTE_EXIT)],1)
+  finally: queue.close()
+except ProcessLookupError: pass
+`;
+  }
+});
+
+// packages/api-contract/dist/phone-types-room-live-delta.js
+var init_phone_types_room_live_delta = __esm({
+  "packages/api-contract/dist/phone-types-room-live-delta.js"() {
+    "use strict";
+  }
+});
+
 // packages/api-contract/dist/phone-types.js
 var init_phone_types = __esm({
   "packages/api-contract/dist/phone-types.js"() {
     "use strict";
+    init_phone_types_room_live_delta();
   }
 });
 
@@ -20650,21 +20726,12 @@ var init_model_choice = __esm({
   }
 });
 
-// packages/api-contract/dist/system-message-catalog.js
-function systemMessage(key, ...values) {
-  const entry = SYSTEM_MESSAGE_CATALOG[key];
-  if (values.length !== entry.variables.length)
-    throw new Error(`System message ${key} needs ${entry.variables.length} variables`);
-  let text = entry.parts[0];
-  for (let index = 0; index < values.length; index++)
-    text += `${values[index]}${entry.parts[index + 1]}`;
-  return text;
-}
-var SYSTEM_MESSAGE_CATALOG;
-var init_system_message_catalog = __esm({
-  "packages/api-contract/dist/system-message-catalog.js"() {
+// packages/api-contract/dist/system-message-catalog-away-auto-pause.js
+var SYSTEM_MESSAGE_AWAY_AUTO_PAUSE;
+var init_system_message_catalog_away_auto_pause = __esm({
+  "packages/api-contract/dist/system-message-catalog-away-auto-pause.js"() {
     "use strict";
-    SYSTEM_MESSAGE_CATALOG = {
+    SYSTEM_MESSAGE_AWAY_AUTO_PAUSE = {
       "away-auto-pause.warning": { parts: ["will pause schedules and subscriptions for"], variables: [] },
       "away-auto-pause.come-back": { parts: ["You have been away for 3 days. Come back within 1 day to keep them running. After they pause, ask your agent to resume."], variables: [] },
       "agent-command.agent-mention": {
@@ -21312,7 +21379,17 @@ var init_system_message_catalog = __esm({
       "daemon-service.instead-of": {
         parts: ["instead of ", ""],
         variables: ["input_from"]
-      },
+      }
+    };
+  }
+});
+
+// packages/api-contract/dist/system-message-catalog-daemon-service.js
+var SYSTEM_MESSAGE_DAEMON_SERVICE;
+var init_system_message_catalog_daemon_service = __esm({
+  "packages/api-contract/dist/system-message-catalog-daemon-service.js"() {
+    "use strict";
+    SYSTEM_MESSAGE_DAEMON_SERVICE = {
       "daemon-service.needs-a-connection-to": {
         parts: ["needs a connection to"],
         variables: []
@@ -21960,7 +22037,17 @@ var init_system_message_catalog = __esm({
       "vault-save-http.list-separator": {
         parts: [", "],
         variables: []
-      },
+      }
+    };
+  }
+});
+
+// packages/api-contract/dist/system-message-catalog-voice-service.js
+var SYSTEM_MESSAGE_VOICE_SERVICE;
+var init_system_message_catalog_voice_service = __esm({
+  "packages/api-contract/dist/system-message-catalog-voice-service.js"() {
+    "use strict";
+    SYSTEM_MESSAGE_VOICE_SERVICE = {
       "voice-service.voice-call": {
         parts: ["Voice call"],
         variables: []
@@ -22605,7 +22692,17 @@ var init_system_message_catalog = __esm({
       "turn-silence.the-helper-couldn-t-get-a-working-copy-of-check-the-repository-is": {
         parts: ["the helper couldn't get a working copy of ", ". Check the repository is reachable."],
         variables: ["classified_repo_the_repository"]
-      },
+      }
+    };
+  }
+});
+
+// packages/api-contract/dist/system-message-catalog-turn-silence.js
+var SYSTEM_MESSAGE_TURN_SILENCE;
+var init_system_message_catalog_turn_silence = __esm({
+  "packages/api-contract/dist/system-message-catalog-turn-silence.js"() {
+    "use strict";
+    SYSTEM_MESSAGE_TURN_SILENCE = {
       "turn-silence.the-helper-is-out-of-date-run-beeline-start-on-the-helper-s-machi": {
         parts: ["the helper is out of date. Run `beeline start` on the helper's machine."],
         variables: []
@@ -22812,6 +22909,33 @@ var init_system_message_catalog = __esm({
   }
 });
 
+// packages/api-contract/dist/system-message-catalog.js
+function systemMessage(key, ...values) {
+  const entry = SYSTEM_MESSAGE_CATALOG[key];
+  if (values.length !== entry.variables.length)
+    throw new Error(`System message ${key} needs ${entry.variables.length} variables`);
+  let text = entry.parts[0];
+  for (let index = 0; index < values.length; index++)
+    text += `${values[index]}${entry.parts[index + 1]}`;
+  return text;
+}
+var SYSTEM_MESSAGE_CATALOG;
+var init_system_message_catalog = __esm({
+  "packages/api-contract/dist/system-message-catalog.js"() {
+    "use strict";
+    init_system_message_catalog_away_auto_pause();
+    init_system_message_catalog_daemon_service();
+    init_system_message_catalog_voice_service();
+    init_system_message_catalog_turn_silence();
+    SYSTEM_MESSAGE_CATALOG = {
+      ...SYSTEM_MESSAGE_AWAY_AUTO_PAUSE,
+      ...SYSTEM_MESSAGE_DAEMON_SERVICE,
+      ...SYSTEM_MESSAGE_VOICE_SERVICE,
+      ...SYSTEM_MESSAGE_TURN_SILENCE
+    };
+  }
+});
+
 // packages/api-contract/dist/voice.js
 var init_voice = __esm({
   "packages/api-contract/dist/voice.js"() {
@@ -22852,20 +22976,6 @@ var init_artifacts = __esm({
   }
 });
 
-// packages/api-contract/dist/repository-onboarding.js
-var init_repository_onboarding = __esm({
-  "packages/api-contract/dist/repository-onboarding.js"() {
-    "use strict";
-  }
-});
-
-// packages/api-contract/dist/vault-save.js
-var init_vault_save = __esm({
-  "packages/api-contract/dist/vault-save.js"() {
-    "use strict";
-  }
-});
-
 // packages/api-contract/dist/agent-usage.js
 var USAGE_OLD_SECONDS, USAGE_WINDOW_LABELS;
 var init_agent_usage = __esm({
@@ -22885,52 +22995,6 @@ var init_agent_usage = __esm({
   }
 });
 
-// packages/api-contract/dist/system-events.js
-function isPerItemEventKind(value) {
-  return PER_ITEM_EVENT_KINDS.includes(value);
-}
-var SYSTEM_LINE_SEPARATOR, SERVER_EVENT_KINDS, PER_ITEM_EVENT_KINDS, SUBSCRIBABLE_EVENT_KINDS, AGENT_EVENT_SLUG_MAX_LENGTH, AGENT_KIND;
-var init_system_events = __esm({
-  "packages/api-contract/dist/system-events.js"() {
-    "use strict";
-    init_system_message_catalog();
-    SYSTEM_LINE_SEPARATOR = systemMessage("system-events.separator");
-    SERVER_EVENT_KINDS = [
-      "joined",
-      "left",
-      "schedule-ran",
-      "corner-opened",
-      "check-passed",
-      "check-failed",
-      "merged",
-      "grant-decided",
-      "squire-approval-decided",
-      "connector-offer-decided",
-      "turn-cancelled",
-      "choice-answered",
-      "choice-skipped",
-      "poll-closed",
-      "workflow-handoff",
-      "subscription-fired",
-      "computer-session-activity"
-    ];
-    PER_ITEM_EVENT_KINDS = [
-      "grant-decided",
-      "squire-approval-decided",
-      "connector-offer-decided",
-      "turn-cancelled",
-      "choice-answered",
-      "choice-skipped",
-      "poll-closed",
-      "subscription-fired",
-      "computer-session-activity"
-    ];
-    SUBSCRIBABLE_EVENT_KINDS = SERVER_EVENT_KINDS.filter((kind) => !isPerItemEventKind(kind) && kind !== "merged");
-    AGENT_EVENT_SLUG_MAX_LENGTH = 40;
-    AGENT_KIND = new RegExp(`^agent:[a-z0-9-]{1,${AGENT_EVENT_SLUG_MAX_LENGTH}}$`);
-  }
-});
-
 // packages/api-contract/dist/agent-sign-in.js
 var AGENT_SIGN_IN_ATTEMPT_TTL_MS, AGENT_SIGN_IN_SERVICE_LABELS;
 var init_agent_sign_in = __esm({
@@ -22950,15 +23014,6 @@ var init_agent_sign_in = __esm({
   }
 });
 
-// packages/api-contract/dist/agent-access.js
-var ACCESS_NOTICE_WINDOW_MS;
-var init_agent_access = __esm({
-  "packages/api-contract/dist/agent-access.js"() {
-    "use strict";
-    ACCESS_NOTICE_WINDOW_MS = 10 * 6e4;
-  }
-});
-
 // packages/api-contract/dist/agent-grants.js
 var AGENT_GRANT_KINDS, REQUESTABLE_AGENT_GRANT_KINDS, DECISION_LINE;
 var init_agent_grants = __esm({
@@ -23049,23 +23104,124 @@ var init_room_choices = __esm({
   }
 });
 
+// packages/api-contract/dist/repository-onboarding.js
+var init_repository_onboarding = __esm({
+  "packages/api-contract/dist/repository-onboarding.js"() {
+    "use strict";
+  }
+});
+
+// packages/api-contract/dist/vault-save.js
+var init_vault_save = __esm({
+  "packages/api-contract/dist/vault-save.js"() {
+    "use strict";
+  }
+});
+
+// packages/api-contract/dist/system-events.js
+function isPerItemEventKind(value) {
+  return PER_ITEM_EVENT_KINDS.includes(value);
+}
+var SYSTEM_LINE_SEPARATOR, SERVER_EVENT_KINDS, PER_ITEM_EVENT_KINDS, SUBSCRIBABLE_EVENT_KINDS, AGENT_EVENT_SLUG_MAX_LENGTH, AGENT_KIND;
+var init_system_events = __esm({
+  "packages/api-contract/dist/system-events.js"() {
+    "use strict";
+    init_system_message_catalog();
+    SYSTEM_LINE_SEPARATOR = systemMessage("system-events.separator");
+    SERVER_EVENT_KINDS = [
+      "joined",
+      "left",
+      "schedule-ran",
+      "corner-opened",
+      "check-passed",
+      "check-failed",
+      "merged",
+      "grant-decided",
+      "squire-approval-decided",
+      "connector-offer-decided",
+      "turn-cancelled",
+      "choice-answered",
+      "choice-skipped",
+      "poll-closed",
+      "workflow-handoff",
+      "subscription-fired",
+      "computer-session-activity"
+    ];
+    PER_ITEM_EVENT_KINDS = [
+      "grant-decided",
+      "squire-approval-decided",
+      "connector-offer-decided",
+      "turn-cancelled",
+      "choice-answered",
+      "choice-skipped",
+      "poll-closed",
+      "subscription-fired",
+      "computer-session-activity"
+    ];
+    SUBSCRIBABLE_EVENT_KINDS = SERVER_EVENT_KINDS.filter((kind) => !isPerItemEventKind(kind) && kind !== "merged");
+    AGENT_EVENT_SLUG_MAX_LENGTH = 40;
+    AGENT_KIND = new RegExp(`^agent:[a-z0-9-]{1,${AGENT_EVENT_SLUG_MAX_LENGTH}}$`);
+  }
+});
+
+// packages/api-contract/dist/phone-guards-read-choice-card.js
+var init_phone_guards_read_choice_card = __esm({
+  "packages/api-contract/dist/phone-guards-read-choice-card.js"() {
+    "use strict";
+    init_repository_onboarding();
+    init_vault_save();
+    init_system_events();
+    init_voice();
+    init_phone_types();
+    init_room_choices();
+    init_phone_guards();
+  }
+});
+
+// packages/api-contract/dist/agent-access.js
+var ACCESS_NOTICE_WINDOW_MS;
+var init_agent_access = __esm({
+  "packages/api-contract/dist/agent-access.js"() {
+    "use strict";
+    ACCESS_NOTICE_WINDOW_MS = 10 * 6e4;
+  }
+});
+
+// packages/api-contract/dist/phone-guards-read-corner-lifecycle.js
+var init_phone_guards_read_corner_lifecycle = __esm({
+  "packages/api-contract/dist/phone-guards-read-corner-lifecycle.js"() {
+    "use strict";
+    init_agent_access();
+    init_phone_types();
+    init_phone_guards();
+    init_phone_guards_read_choice_card();
+  }
+});
+
+// packages/api-contract/dist/phone-guards-read-agent-detail-view.js
+var init_phone_guards_read_agent_detail_view = __esm({
+  "packages/api-contract/dist/phone-guards-read-agent-detail-view.js"() {
+    "use strict";
+    init_agent_usage();
+    init_phone_guards();
+    init_phone_guards_read_corner_lifecycle();
+  }
+});
+
 // packages/api-contract/dist/phone-guards.js
 var CLOSED_VIEWER;
 var init_phone_guards = __esm({
   "packages/api-contract/dist/phone-guards.js"() {
     "use strict";
-    init_repository_onboarding();
-    init_vault_save();
     init_agent_usage();
-    init_system_events();
     init_agent_sign_in();
-    init_agent_access();
-    init_voice();
-    init_phone_types();
     init_agent_grants();
     init_connector_offers();
     init_workbench();
     init_room_choices();
+    init_phone_guards_read_choice_card();
+    init_phone_guards_read_corner_lifecycle();
+    init_phone_guards_read_agent_detail_view();
     CLOSED_VIEWER = {
       identity: { pubkey: "0".repeat(64), kind: "human", name: "" },
       role: "member",
@@ -23697,9 +23853,9 @@ var init_stream_frame = __esm({
 import { execFile as execFile3 } from "node:child_process";
 import { closeSync, fstatSync, openSync, readSync, readdirSync as readdirSync2, readlinkSync, statSync as statSync2 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { basename as basename3, join as join3 } from "node:path";
+import { basename as basename3, join as join4 } from "node:path";
 function codexHome(env = process.env) {
-  return env.CODEX_HOME || join3(env.HOME || homedir5(), ".codex");
+  return env.CODEX_HOME || join4(env.HOME || homedir5(), ".codex");
 }
 function turnEvent(line) {
   if (!line.includes("event_msg") || !(line.includes("task_") || line.includes("turn_")))
@@ -23763,14 +23919,14 @@ function scanCodex(proc = "/proc") {
       continue;
     let fds;
     try {
-      fds = readdirSync2(join3(proc, name, "fd"));
+      fds = readdirSync2(join4(proc, name, "fd"));
     } catch {
       continue;
     }
     for (const fd of fds) {
       let target;
       try {
-        target = readlinkSync(join3(proc, name, "fd", fd));
+        target = readlinkSync(join4(proc, name, "fd", fd));
       } catch {
         continue;
       }
@@ -23779,7 +23935,7 @@ function scanCodex(proc = "/proc") {
         continue;
       let cwd;
       try {
-        cwd = readlinkSync(join3(proc, name, "cwd"));
+        cwd = readlinkSync(join4(proc, name, "cwd"));
       } catch {
       }
       if (!found.some((s) => s.threadId === threadId))
@@ -23789,12 +23945,12 @@ function scanCodex(proc = "/proc") {
   return found;
 }
 function codexQueue(threadId, text, bin = "codex", timeoutMs = 3e4) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     execFile3(bin, ["queue", "--thread", threadId, "--message", text], { timeout: timeoutMs }, (error, _stdout, stderr) => {
       if (error)
         reject(new Error(String(stderr).trim() || error.message));
       else
-        resolve11();
+        resolve13();
     });
   });
 }
@@ -23812,12 +23968,12 @@ var init_codex = __esm({
 import { closeSync as closeSync2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync4, readSync as readSync2, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { homedir as homedir6 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function claudeConfigDir(env = process.env) {
-  return env.CLAUDE_CONFIG_DIR || join4(env.HOME || homedir6(), ".claude");
+  return env.CLAUDE_CONFIG_DIR || join5(env.HOME || homedir6(), ".claude");
 }
 function scanClaude(env = process.env, alive = pidAlive) {
-  const dir = join4(claudeConfigDir(env), "sessions");
+  const dir = join5(claudeConfigDir(env), "sessions");
   let names;
   try {
     names = readdirSync3(dir);
@@ -23829,7 +23985,7 @@ function scanClaude(env = process.env, alive = pidAlive) {
     if (!/^\d+\.json$/.test(name))
       continue;
     try {
-      const value = JSON.parse(readFileSync4(join4(dir, name), "utf8"));
+      const value = JSON.parse(readFileSync4(join5(dir, name), "utf8"));
       if (Number.isInteger(value.pid) && alive(value.pid))
         sessions.push(value);
     } catch {
@@ -23841,7 +23997,7 @@ function chosenName(session2) {
   return ["user", "peer", "hook"].includes(session2.nameSource ?? "") ? session2.name : void 0;
 }
 function postToClaude(socket, text, _timeoutMs = 5e3) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const connection = createConnection3(socket.path);
     connection.once("error", (error) => {
       reject(error);
@@ -23850,13 +24006,13 @@ function postToClaude(socket, text, _timeoutMs = 5e3) {
       if (socket.token)
         connection.write(JSON.stringify({ type: "auth", token: socket.token }) + "\n");
       connection.end(JSON.stringify({ type: "user", message: { role: "user", content: text } }) + "\n", () => {
-        resolve11();
+        resolve13();
       });
     });
   });
 }
 function claudeTranscript(sessionId, env = process.env) {
-  const root = join4(claudeConfigDir(env), "projects");
+  const root = join5(claudeConfigDir(env), "projects");
   let projects;
   try {
     projects = readdirSync3(root);
@@ -23864,7 +24020,7 @@ function claudeTranscript(sessionId, env = process.env) {
     return void 0;
   }
   for (const project of projects) {
-    const path = join4(root, project, `${sessionId}.jsonl`);
+    const path = join5(root, project, `${sessionId}.jsonl`);
     try {
       if (statSync3(path).isFile())
         return path;
@@ -23903,7 +24059,7 @@ function heldBy(mode, setting) {
 }
 function inboundSetting(env = process.env) {
   try {
-    const value = JSON.parse(readFileSync4(join4(claudeConfigDir(env), "settings.json"), "utf8"));
+    const value = JSON.parse(readFileSync4(join5(claudeConfigDir(env), "settings.json"), "utf8"));
     return typeof value.crossSessionInbound === "string" ? value.crossSessionInbound : void 0;
   } catch {
     return void 0;
@@ -23918,20 +24074,20 @@ var init_claude = __esm({
 
 // apps/body/dist/session-join/claude-mcp.js
 import { watch as watch3, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync as readdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { createInterface } from "node:readline";
 function hasClaudeMcp(dir, claudePid) {
   if (!claudePid)
     return false;
   let files;
   try {
-    files = readdirSync4(join5(dir, "claude-mcp"));
+    files = readdirSync4(join6(dir, "claude-mcp"));
   } catch {
     return false;
   }
   return files.some((file) => {
     try {
-      const entry = JSON.parse(readFileSync5(join5(dir, "claude-mcp", file), "utf8"));
+      const entry = JSON.parse(readFileSync5(join6(dir, "claude-mcp", file), "utf8"));
       return entry.claudePid === claudePid && pidAlive(entry.pid);
     } catch {
       return false;
@@ -23940,17 +24096,19 @@ function hasClaudeMcp(dir, claudePid) {
 }
 async function flushClaudeMcp(dir, session2, token, post = postToClaude) {
   if (!session2.messagingSocketPath)
-    return;
+    return false;
   const joined2 = readState(dir).sessions.find((s) => s.agent === "claude-code" && (s.pid === session2.pid || s.sessionId === session2.sessionId));
   if (!joined2)
-    return;
+    return false;
   const text = takeInbox(dir, joined2.key);
   if (!text)
-    return;
+    return false;
   try {
     await post({ path: session2.messagingSocketPath, token }, text);
+    return true;
   } catch {
     queueInbox(dir, joined2.key, text);
+    return false;
   }
 }
 function joinedClaude(dir, env, chain) {
@@ -23960,32 +24118,38 @@ function joinedClaude(dir, env, chain) {
     return void 0;
   return readState(dir).sessions.find((s) => s.agent === "claude-code" && (s.pid === session2.pid || s.sessionId === session2.sessionId));
 }
-async function runClaudeMcp(dir, env, rulesFor) {
+async function runClaudeMcp(dir, env, rulesFor, post = postToClaude) {
   const chain = ancestors(process.pid);
   let registration;
-  let flushing = false;
+  let flushing = false, dirty = false;
   const flush2 = async () => {
+    dirty = true;
     if (flushing || !env.CLAUDE_CODE_MESSAGING_TOKEN)
       return;
     flushing = true;
     try {
-      const live = scanClaude(env);
-      const session2 = chain.map((pid) => live.find((s) => s.pid === pid)).find(Boolean);
-      if (!session2)
-        return;
-      if (!registration) {
-        const folder = join5(dir, "claude-mcp");
-        mkdirSync2(folder, { recursive: true, mode: 448 });
-        registration = join5(folder, `${process.pid}.json`);
-        writeFileSync2(registration, JSON.stringify({ pid: process.pid, claudePid: session2.pid }), { mode: 384 });
+      while (dirty) {
+        dirty = false;
+        const live = scanClaude(env);
+        const session2 = chain.map((pid) => live.find((s) => s.pid === pid)).find(Boolean);
+        if (!session2)
+          return;
+        if (!registration) {
+          const folder = join6(dir, "claude-mcp");
+          mkdirSync2(folder, { recursive: true, mode: 448 });
+          registration = join6(folder, `${process.pid}.json`);
+          writeFileSync2(registration, JSON.stringify({ pid: process.pid, claudePid: session2.pid }), { mode: 384 });
+        }
+        if (!await flushClaudeMcp(dir, session2, env.CLAUDE_CODE_MESSAGING_TOKEN, post))
+          break;
       }
-      await flushClaudeMcp(dir, session2, env.CLAUDE_CODE_MESSAGING_TOKEN);
     } finally {
       flushing = false;
     }
   };
   const watcher = watch3(dir, { recursive: true }, (_event, name) => {
-    if (String(name ?? "").startsWith("inbox/"))
+    const path = String(name ?? "");
+    if (path === "state.json" || path.startsWith("inbox/"))
       void flush2().catch(() => void 0);
   });
   try {
@@ -24074,10 +24238,10 @@ var init_sessions = __esm({
 });
 
 // apps/body/dist/session-join/bridge.js
-import { spawn as spawn5 } from "node:child_process";
+import { execFileSync, spawn as spawn6 } from "node:child_process";
 import { chmodSync as chmodSync2, closeSync as closeSync3, existsSync as existsSync2, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync6, readdirSync as readdirSync5, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync3, watch as watch4 } from "node:fs";
 import { createConnection as createConnection4, createServer as createServer3 } from "node:net";
-import { join as join6 } from "node:path";
+import { basename as basename4, join as join7, resolve as resolve10 } from "node:path";
 import { createHash as createHash6 } from "node:crypto";
 function command(runner2, joined2, args) {
   const q = (v) => /^[A-Za-z0-9_./:@=-]+$/.test(v) ? v : `"${v.replace(/(["\\$`])/g, "\\$1")}"`;
@@ -24179,7 +24343,7 @@ async function acceptMemberDelivery(dir, key, runner2, raw) {
 }
 function log(dir, line) {
   try {
-    writeFileSync3(join6(dir, "bridge.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+    writeFileSync3(join7(dir, "bridge.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `, { flag: "a", mode: 384 });
   } catch {
   }
@@ -24205,7 +24369,7 @@ async function flush(dir, sources, deps = realDeps) {
   }
 }
 function serveTools(dir) {
-  const path = join6(dir, "bridge.sock");
+  const path = join7(dir, "bridge.sock");
   rmSync3(path, { force: true });
   const server = createServer3((connection) => {
     let buffer = "", taken = false;
@@ -24233,7 +24397,7 @@ function serveTools(dir) {
   server.unref();
 }
 function outboxDir(cwd) {
-  return join6(cwd, ".beeline", "outbox");
+  return join7(cwd, ".beeline", "outbox");
 }
 async function serveOutboxes(dir) {
   let served = 0;
@@ -24245,7 +24409,7 @@ async function serveOutboxes(dir) {
       continue;
     }
     for (const name of names.filter((n) => n.endsWith(".request.json"))) {
-      const path = join6(outboxDir(joined2.cwd), name);
+      const path = join7(outboxDir(joined2.cwd), name);
       const taking = `${path}.taking`;
       try {
         renameSync2(path, taking);
@@ -24271,19 +24435,19 @@ async function serveOutboxes(dir) {
 async function toolViaOutbox(cwd, name, args) {
   const dirPath = outboxDir(cwd);
   mkdirSync3(dirPath, { recursive: true });
-  writeFileSync3(join6(cwd, ".beeline", ".gitignore"), "*\n");
+  writeFileSync3(join7(cwd, ".beeline", ".gitignore"), "*\n");
   const id = `${Date.now()}-${process.pid}`;
-  const request2 = join6(dirPath, `${id}.request.json`), result = join6(dirPath, `${id}.result.json`);
+  const request2 = join7(dirPath, `${id}.request.json`), result = join7(dirPath, `${id}.result.json`);
   writeFileSync3(`${request2}.tmp`, JSON.stringify({ name, args }));
   renameSync2(`${request2}.tmp`, request2);
-  return new Promise((resolve11) => {
+  return new Promise((resolve13) => {
     let settled = false;
     const finish = (answer) => {
       if (settled)
         return;
       settled = true;
       watcher.close();
-      resolve11(answer);
+      resolve13(answer);
     };
     const inspect = () => {
       try {
@@ -24301,15 +24465,15 @@ async function toolViaOutbox(cwd, name, args) {
   });
 }
 function toolViaBridge(dir, key, name, args) {
-  return new Promise((resolve11) => {
-    const connection = createConnection4(join6(dir, "bridge.sock"));
+  return new Promise((resolve13) => {
+    const connection = createConnection4(join7(dir, "bridge.sock"));
     let text = "", sent = false, settled = false;
     const unknown = { ok: false, error: "Beeline tool result is awaiting confirmation" };
     const finish = (answer) => {
       if (settled)
         return;
       settled = true;
-      resolve11(answer);
+      resolve13(answer);
       connection.destroy();
     };
     connection.setEncoding("utf8");
@@ -24331,7 +24495,7 @@ function toolViaBridge(dir, key, name, args) {
   });
 }
 async function runBridge(dir, runner2) {
-  const pidFile = join6(dir, "bridge.pid");
+  const pidFile = join7(dir, "bridge.pid");
   try {
     const fd = openSync3(pidFile, "wx", 384);
     writeFileSync3(fd, String(process.pid));
@@ -24351,6 +24515,7 @@ async function runBridge(dir, runner2) {
     wake?.();
   };
   serveTools(dir);
+  writeFileSync3(join7(dir, "bridge-owner.json"), JSON.stringify({ pid: process.pid, digest: bundleDigest(runner2) }), { mode: 384 });
   const localWatch = watch4(dir, { recursive: true }, (_event, name) => {
     const path = String(name ?? "");
     if (path === "state.json" || path.startsWith("hooks/") || path.startsWith("inbox/") || path.startsWith("deliveries/"))
@@ -24364,7 +24529,7 @@ async function runBridge(dir, runner2) {
     for (const watcher of outboxWatches.values())
       watcher.close();
     rmSync3(pidFile, { force: true });
-    rmSync3(join6(dir, "bridge.sock"), { force: true });
+    rmSync3(join7(dir, "bridge.sock"), { force: true });
     process.exit(0);
   };
   process.once("SIGTERM", stop);
@@ -24435,7 +24600,7 @@ async function runBridge(dir, runner2) {
         const path = outboxDir(joined2.cwd);
         if (!outboxWatches.has(path)) {
           mkdirSync3(path, { recursive: true, mode: 448 });
-          const ignore = join6(joined2.cwd, ".beeline", ".gitignore");
+          const ignore = join7(joined2.cwd, ".beeline", ".gitignore");
           if (!existsSync2(ignore))
             writeFileSync3(ignore, "*\n", { mode: 384 });
           outboxWatches.set(path, watch4(path, (_event, name) => {
@@ -24447,8 +24612,8 @@ async function runBridge(dir, runner2) {
       await serveOutboxes(dir).catch((error) => log(dir, `outbox: ${String(error)}`));
       await flush(dir, sources).catch((error) => log(dir, `flush: ${String(error)}`));
       if (!localDirty)
-        await new Promise((resolve11) => {
-          wake = resolve11;
+        await new Promise((resolve13) => {
+          wake = resolve13;
         });
       wake = void 0;
     }
@@ -24462,30 +24627,101 @@ async function runBridge(dir, runner2) {
   }
   log(dir, `bridge ${process.pid} stopped: no joined sessions`);
   rmSync3(pidFile, { force: true });
-  rmSync3(join6(dir, "bridge.sock"), { force: true });
+  rmSync3(join7(dir, "bridge.sock"), { force: true });
   process.exit(0);
 }
 function bridgeRunning(dir) {
   try {
-    const holder = Number(readFileSync6(join6(dir, "bridge.pid"), "utf8"));
+    const holder = Number(readFileSync6(join7(dir, "bridge.pid"), "utf8"));
     return Boolean(holder) && pidAlive(holder);
   } catch {
     return false;
   }
 }
-function ensureBridge(dir, runner2, env = process.env) {
-  if (bridgeRunning(dir))
-    return;
-  const out = openSync3(join6(dir, "bridge.log"), "a", 384);
-  const child = spawn5(runner2.node, [runner2.bundle, "session", "bridge"], { detached: true, stdio: ["ignore", out, out], env });
-  child.unref();
-  closeSync3(out);
+function bundleDigest(runner2) {
+  return createHash6("sha256").update(readFileSync6(runner2.bundle)).digest("hex");
+}
+function bridgeOwner(dir) {
+  try {
+    return JSON.parse(readFileSync6(join7(dir, "bridge-owner.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function isBridgeProcess(pid) {
+  try {
+    if (process.platform === "linux") {
+      const args2 = readFileSync6(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean);
+      return args2.length === 4 && /^node(?:\.exe)?$/.test(basename4(args2[0])) && /^(?:beeline|usebeeline\.mjs|recovery-cli\.mjs)$/.test(basename4(args2[1])) && args2[2] === "session" && args2[3] === "bridge";
+    }
+    const args = execFileSync("ps", ["-ww", "-p", String(pid), "-o", "args="], { encoding: "utf8" }).trim();
+    return /(?:^|\/)node\s+.*\/(?:beeline|usebeeline\.mjs|recovery-cli\.mjs) session bridge$/.test(args);
+  } catch {
+    return false;
+  }
+}
+async function ensureBridge(dir, runner2, env = process.env) {
+  await withKernelLock(`beeline-session-bridge:${resolve10(dir)}`, async () => {
+    const digest = bundleDigest(runner2);
+    const pidFile = join7(dir, "bridge.pid");
+    if (bridgeRunning(dir)) {
+      const pid = Number(readFileSync6(pidFile, "utf8"));
+      if (!isBridgeProcess(pid))
+        throw new Error("Beeline bridge PID belongs to an unrecognized process; refusing takeover");
+      const owner = bridgeOwner(dir);
+      if (owner?.pid === pid && owner.digest === digest)
+        return;
+      log(dir, `replacing stale bridge ${pid}`);
+      await withLock(dir, async () => {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch (error) {
+          if (error.code !== "ESRCH")
+            throw error;
+        }
+        await waitForProcessExit(pid);
+      });
+      if (existsSync2(pidFile) && Number(readFileSync6(pidFile, "utf8")) === pid)
+        rmSync3(pidFile);
+    }
+    const out = openSync3(join7(dir, "bridge.log"), "a", 384);
+    const child = spawn6(runner2.node, [runner2.bundle, "session", "bridge"], { detached: true, stdio: ["ignore", out, out], env });
+    closeSync3(out);
+    child.unref();
+    await new Promise((done, fail) => {
+      const finish = (error) => {
+        watcher.close();
+        child.removeListener("error", failed);
+        child.removeListener("exit", exited);
+        if (error)
+          fail(error);
+        else
+          done();
+      };
+      const inspect = () => {
+        const owner = bridgeOwner(dir);
+        if (owner && owner.pid === child.pid && owner.digest === digest)
+          finish();
+      };
+      const failed = (error) => finish(error);
+      const exited = () => finish(new Error("Beeline bridge exited before readiness; see bridge.log"));
+      const watcher = watch4(dir, (_event, name) => {
+        if (String(name) === "bridge-owner.json")
+          inspect();
+      });
+      child.once("error", failed);
+      child.once("exit", exited);
+      inspect();
+    });
+  });
 }
 var realDeps;
 var init_bridge = __esm({
   "apps/body/dist/session-join/bridge.js"() {
     "use strict";
     init_agent_command();
+    init_kernel_lock();
+    init_process_exit();
     init_phone();
     init_beeline_api();
     init_stream_frame();
@@ -24735,7 +24971,7 @@ def register(ctx):
 import { spawnSync } from "node:child_process";
 import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync as renameSync3, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync4, chmodSync as chmodSync3 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname6, join as join7 } from "node:path";
+import { dirname as dirname7, join as join8 } from "node:path";
 function home(env) {
   return env.HOME || homedir7();
 }
@@ -24771,7 +25007,7 @@ function writeFile3(path, content, expected) {
   }
   if (before === content)
     return false;
-  mkdirSync4(dirname6(path), { recursive: true });
+  mkdirSync4(dirname7(path), { recursive: true });
   const backup = `${path}.bak-${NAME}`;
   if (before !== void 0 && !existsSync3(backup) && !before.includes(" session hook "))
     copyFileSync(path, backup);
@@ -24881,18 +25117,18 @@ function saveJson(path, value, remove) {
 function claudeCode(context) {
   const command2 = (event) => ({ hooks: [{ type: "command", command: hookCommand(context, "claude-code", event), timeout: 10 }] });
   const remove = Boolean(context.remove);
-  const path = context.env.CLAUDE_CONFIG_DIR ? join7(context.env.CLAUDE_CONFIG_DIR, ".claude.json") : join7(home(context.env), ".claude.json");
-  return [...mergeClaudeMcp(path, context), ...hooksFile(join7(claudeConfigDir(context.env), "settings.json"), "claude-code", [["SessionStart", command2("session-start")]], remove)];
+  const path = context.env.CLAUDE_CONFIG_DIR ? join8(context.env.CLAUDE_CONFIG_DIR, ".claude.json") : join8(home(context.env), ".claude.json");
+  return [...mergeClaudeMcp(path, context), ...hooksFile(join8(claudeConfigDir(context.env), "settings.json"), "claude-code", [["SessionStart", command2("session-start")]], remove)];
 }
 function codex(context) {
   const group = (event) => ({ matcher: "*", hooks: [{ type: "command", command: hookCommand(context, "codex", event), timeout: 10 }] });
-  const lines = hooksFile(join7(codexHome(context.env), "hooks.json"), "codex", [["SessionStart", group("session-start")]], Boolean(context.remove));
+  const lines = hooksFile(join8(codexHome(context.env), "hooks.json"), "codex", [["SessionStart", group("session-start")]], Boolean(context.remove));
   if (lines.length && !context.remove)
     lines.push("Codex asks once to trust Beeline\u2019s SessionStart hook if automatic trust is unavailable: open /hooks and trust only Beeline.");
   return lines;
 }
 function geminiHome(env) {
-  return env.GEMINI_CLI_HOME || join7(home(env), ".gemini");
+  return env.GEMINI_CLI_HOME || join8(home(env), ".gemini");
 }
 function gemini(context) {
   const group = (event, timeout) => ({ matcher: "*", hooks: [{
@@ -24901,7 +25137,7 @@ function gemini(context) {
     command: hookCommand(context, "gemini", event),
     timeout
   }] });
-  return hooksFile(join7(geminiHome(context.env), "settings.json"), "gemini", [
+  return hooksFile(join8(geminiHome(context.env), "settings.json"), "gemini", [
     ["SessionStart", group("session-start", 1e4)],
     ["BeforeAgent", group("user-prompt-submit", 1e4)],
     ["AfterTool", group("post-tool-use", 1e4)],
@@ -24910,9 +25146,9 @@ function gemini(context) {
   ], Boolean(context.remove));
 }
 function antigravity(context) {
-  const dir = join7(home(context.env), ".gemini/config");
+  const dir = join8(home(context.env), ".gemini/config");
   const lines = [];
-  const hooksPath = join7(dir, "hooks.json");
+  const hooksPath = join8(dir, "hooks.json");
   const hooks = readJson(hooksPath);
   if (context.remove)
     delete hooks[NAME];
@@ -24928,13 +25164,13 @@ function antigravity(context) {
     };
   }
   lines.push(...saveJson(hooksPath, hooks, Boolean(context.remove)));
-  const sidecar = join7(dir, "sidecars", NAME, "sidecar.json");
-  const configPath = join7(dir, "config.json");
+  const sidecar = join8(dir, "sidecars", NAME, "sidecar.json");
+  const configPath = join8(dir, "config.json");
   const config = readJson(configPath);
   const sidecars = object2(config, "sidecars");
   if (context.remove) {
     delete sidecars[NAME];
-    rmSync4(dirname6(sidecar), { recursive: true, force: true });
+    rmSync4(dirname7(sidecar), { recursive: true, force: true });
   } else {
     if (writeJson(sidecar, {
       command: context.node,
@@ -24961,31 +25197,31 @@ function pluginFile(path, content, remove) {
   return writeFile3(path, content) ? [`updated ${path}`] : [];
 }
 function opencode(context) {
-  return pluginFile(join7(home(context.env), ".config/opencode/plugins", `${NAME}.ts`), fill(OPENCODE_PLUGIN, context.node, context.bundle), Boolean(context.remove));
+  return pluginFile(join8(home(context.env), ".config/opencode/plugins", `${NAME}.ts`), fill(OPENCODE_PLUGIN, context.node, context.bundle), Boolean(context.remove));
 }
 function piHome(env) {
-  return env.PI_CODING_AGENT_DIR || join7(home(env), ".pi/agent");
+  return env.PI_CODING_AGENT_DIR || join8(home(env), ".pi/agent");
 }
 function pi(context) {
-  return pluginFile(join7(piHome(context.env), "extensions", `${NAME}.ts`), fill(PI_EXTENSION, context.node, context.bundle), Boolean(context.remove));
+  return pluginFile(join8(piHome(context.env), "extensions", `${NAME}.ts`), fill(PI_EXTENSION, context.node, context.bundle), Boolean(context.remove));
 }
 function hermesRoot(env) {
-  const base = env.HERMES_HOME ? env.HERMES_HOME.replace(/^~(?=\/|$)/, home(env)) : join7(home(env), `.hermes${env.HERMES_DATA_DIR_SUFFIX ?? ""}`);
+  const base = env.HERMES_HOME ? env.HERMES_HOME.replace(/^~(?=\/|$)/, home(env)) : join8(home(env), `.hermes${env.HERMES_DATA_DIR_SUFFIX ?? ""}`);
   let active = "";
   try {
-    active = readFileSync7(join7(base, "active_profile"), "utf8").trim();
+    active = readFileSync7(join8(base, "active_profile"), "utf8").trim();
   } catch {
   }
-  if (active && active !== "default" && active !== "." && active !== ".." && !/[/\\]/.test(active) && existsSync3(join7(base, "profiles", active)))
-    return join7(base, "profiles", active);
+  if (active && active !== "default" && active !== "." && active !== ".." && !/[/\\]/.test(active) && existsSync3(join8(base, "profiles", active)))
+    return join8(base, "profiles", active);
   return base;
 }
 function hermes(context) {
-  const dir = join7(hermesRoot(context.env), "plugins", NAME);
+  const dir = join8(hermesRoot(context.env), "plugins", NAME);
   const remove = Boolean(context.remove);
   const lines = [
-    ...pluginFile(join7(dir, "__init__.py"), fill(HERMES_PLUGIN, context.node, context.bundle), remove),
-    ...pluginFile(join7(dir, "plugin.yaml"), HERMES_MANIFEST, remove)
+    ...pluginFile(join8(dir, "__init__.py"), fill(HERMES_PLUGIN, context.node, context.bundle), remove),
+    ...pluginFile(join8(dir, "plugin.yaml"), HERMES_MANIFEST, remove)
   ];
   if (remove)
     rmSync4(dir, { recursive: true, force: true });
@@ -24995,7 +25231,7 @@ function hermes(context) {
   return lines;
 }
 function zcodeIn(homeDir, context) {
-  const native = join7(homeDir, ".zcode/cli/config.json"), fallback = join7(homeDir, ".agents/mcp.json");
+  const native = join8(homeDir, ".zcode/cli/config.json"), fallback = join8(homeDir, ".agents/mcp.json");
   const servers = (value, isNative) => isNative ? object2(object2(value, "mcp"), "servers") : object2(value, "mcpServers");
   const remove = Boolean(context.remove);
   const toFallback = !remove && !Object.keys(servers(readJson(native), true)).some((key) => key !== NAME) && Object.keys(servers(readJson(fallback), false)).length > 0;
@@ -25045,11 +25281,11 @@ var init_setup = __esm({
 
 // apps/body/dist/session-join/claude-inbound.js
 import { existsSync as existsSync4, readFileSync as readFileSync8, rmSync as rmSync5 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function assertClaudePolicy(env) {
   const paths = [
     env.CLAUDE_CODE_MANAGED_SETTINGS_PATH,
-    join8(claudeConfigDir(env), "managed-settings.json"),
+    join9(claudeConfigDir(env), "managed-settings.json"),
     process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : "/etc/claude-code/managed-settings.json"
   ];
   for (const path of paths) {
@@ -25064,8 +25300,8 @@ async function acceptClaudeInbound(env) {
   const dir = stateDir(env);
   await withLock(dir, () => {
     assertClaudePolicy(env);
-    const path = join8(claudeConfigDir(env), "settings.json");
-    const saved = join8(dir, "claude-inbound.json");
+    const path = join9(claudeConfigDir(env), "settings.json");
+    const saved = join9(dir, "claude-inbound.json");
     const value = readJson(path);
     if (!existsSync4(saved))
       writeFile3(saved, JSON.stringify({ present: Object.hasOwn(value, "crossSessionInbound"), value: value.crossSessionInbound }));
@@ -25079,12 +25315,12 @@ async function restoreClaudeInbound(env) {
   await withLock(dir, () => {
     if (readState(dir).sessions.length)
       return;
-    const saved = join8(dir, "claude-inbound.json");
+    const saved = join9(dir, "claude-inbound.json");
     if (!existsSync4(saved))
       return;
     assertClaudePolicy(env);
     const old = JSON.parse(readFileSync8(saved, "utf8"));
-    const path = join8(claudeConfigDir(env), "settings.json");
+    const path = join9(claudeConfigDir(env), "settings.json");
     const value = readJson(path);
     if (value.crossSessionInbound === "accept") {
       if (old.present)
@@ -25106,10 +25342,10 @@ var init_claude_inbound = __esm({
 });
 
 // apps/body/dist/session-join/codex-trust.js
-import { spawn as spawn6 } from "node:child_process";
-import { join as join9 } from "node:path";
+import { spawn as spawn7 } from "node:child_process";
+import { join as join10 } from "node:path";
 function beelineTrustEdits(hooks, context) {
-  const path = join9(codexHome(context.env), "hooks.json");
+  const path = join10(codexHome(context.env), "hooks.json");
   const expected = hookCommand(context, "codex", "session-start");
   const own2 = hooks.filter((h) => h.sourcePath === path && h.source === "user" && !h.isManaged && h.pluginId === null && h.eventName === "sessionStart" && h.handlerType === "command" && h.command === expected && h.matcher === "*" && h.timeoutSec === 10 && h.key.startsWith(path) && /^:session_start:\d+:\d+$/.test(h.key.slice(path.length)) && /^sha256:[0-9a-f]{64}$/.test(h.currentHash));
   if (own2.length !== 1)
@@ -25118,7 +25354,7 @@ function beelineTrustEdits(hooks, context) {
   return [{ keyPath: `hooks.state.${JSON.stringify(hook.key)}.trusted_hash`, value: hook.currentHash, mergeStrategy: "replace" }];
 }
 async function trustCodexHook(context, bin, cwd) {
-  const child = spawn6(bin, ["app-server", "--stdio"], { env: context.env, cwd, stdio: ["pipe", "pipe", "ignore"] });
+  const child = spawn7(bin, ["app-server", "--stdio"], { env: context.env, cwd, stdio: ["pipe", "pipe", "ignore"] });
   let id = 0, buffer = "";
   const pending = /* @__PURE__ */ new Map();
   const fail = () => {
@@ -25156,9 +25392,9 @@ async function trustCodexHook(context, bin, cwd) {
       }
     }
   });
-  const request2 = (method, params) => new Promise((resolve11, reject) => {
+  const request2 = (method, params) => new Promise((resolve13, reject) => {
     const key = ++id;
-    pending.set(key, { resolve: resolve11, reject: () => reject(new Error("Codex hook trust unavailable")) });
+    pending.set(key, { resolve: resolve13, reject: () => reject(new Error("Codex hook trust unavailable")) });
     child.stdin.write(JSON.stringify({ id: key, method, params }) + "\n");
   });
   try {
@@ -25339,7 +25575,7 @@ var init_pull_apps = __esm({
     "use strict";
     init_store();
     init_beeline_api();
-    agentapi = (sessionId, text) => new Promise((resolve11, reject) => execFile4("agentapi", ["send-message", sessionId, text], { timeout: 3e4 }, (error) => error ? reject(error) : resolve11()));
+    agentapi = (sessionId, text) => new Promise((resolve13, reject) => execFile4("agentapi", ["send-message", sessionId, text], { timeout: 3e4 }, (error) => error ? reject(error) : resolve13()));
   }
 });
 
@@ -25349,9 +25585,9 @@ __export(command_exports, {
   findOwnSession: () => findOwnSession,
   runSessionCommand: () => runSessionCommand
 });
-import { spawn as spawn7, spawnSync as spawnSync2 } from "node:child_process";
+import { spawn as spawn8, spawnSync as spawnSync2 } from "node:child_process";
 import { closeSync as closeSync4, copyFileSync as copyFileSync2, existsSync as existsSync5, fsyncSync, mkdirSync as mkdirSync5, openSync as openSync4, readFileSync as readFileSync9, readdirSync as readdirSync6, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { delimiter, dirname as dirname7, join as join10, resolve as resolve9 } from "node:path";
+import { delimiter, dirname as dirname8, join as join11, resolve as resolve11 } from "node:path";
 import { createHash as createHash7, randomUUID as randomUUID2 } from "node:crypto";
 function writePending(file, pending) {
   const temporary = file + "." + randomUUID2() + ".tmp";
@@ -25365,7 +25601,7 @@ function writePending(file, pending) {
     }
     renameSync4(temporary, file);
     if (process.platform !== "win32") {
-      const directory = openSync4(dirname7(file), "r");
+      const directory = openSync4(dirname8(file), "r");
       try {
         fsyncSync(directory);
       } finally {
@@ -25379,14 +25615,14 @@ function writePending(file, pending) {
 function existingPending(dir, own2, server) {
   let names;
   try {
-    names = readdirSync6(join10(dir, "pending"));
+    names = readdirSync6(join11(dir, "pending"));
   } catch {
     return;
   }
   if (names.length > 256)
     throw new Error("Too many pending Beeline sign-ins");
   return names.filter((name) => /^[a-f0-9]{24}\.json$/.test(name)).flatMap((name) => {
-    const file = join10(dir, "pending", name);
+    const file = join11(dir, "pending", name);
     try {
       const pending = JSON.parse(readFileSync9(file, "utf8"));
       return pending.agent === own2.agent && pending.cwd === own2.cwd && pending.server === server && (!pending.sessionId || !own2.sessionId || pending.sessionId === own2.sessionId) ? [{ file, pending }] : [];
@@ -25411,7 +25647,7 @@ function words(args, valued) {
 }
 function which(bin, env) {
   for (const dir of (env.PATH ?? "").split(delimiter)) {
-    const path = join10(dir, bin);
+    const path = join11(dir, bin);
     if (dir && existsSync5(path))
       return path;
   }
@@ -25420,8 +25656,8 @@ function which(bin, env) {
 function runner(dir, env) {
   if (env.BEELINE_SESSION_BUNDLE)
     return { node: process.execPath, bundle: env.BEELINE_SESSION_BUNDLE };
-  const bundle = join10(dir, "usebeeline.mjs");
-  const running = resolve9(process.argv[1] ?? "");
+  const bundle = join11(dir, "usebeeline.mjs");
+  const running = resolve11(process.argv[1] ?? "");
   if (running !== bundle && running.endsWith(".mjs")) {
     mkdirSync5(dir, { recursive: true, mode: 448 });
     copyFileSync2(running, bundle);
@@ -25474,6 +25710,7 @@ async function joinCommand(args, env) {
   const server = serverUrl(args, env);
   const existing = readState(dir).sessions.find((s) => s.key === key && s.server === server);
   if (existing) {
+    let connected = false;
     try {
       await accessToken(dir, key);
       await updateState(dir, (state) => {
@@ -25483,10 +25720,13 @@ async function joinCommand(args, env) {
           s.pid = own2.pid ?? s.pid;
         }
       });
-      ensureBridge(dir, run2, env);
+      connected = true;
+    } catch {
+    }
+    if (connected) {
+      await ensureBridge(dir, run2, env);
       console.log(`This ${agentLabel(own2.agent)} session is on Beeline as @${existing.handle ?? existing.name}. Tags in its Rooms arrive here.`);
       return;
-    } catch {
     }
   }
   const taken = new Set(readState(dir).sessions.filter((s) => s.key !== key).map((s) => s.name));
@@ -25511,14 +25751,14 @@ async function joinCommand(args, env) {
     startedAt: Date.now(),
     claudeInboundFallback: own2.claudeInboundFallback
   };
-  mkdirSync5(join10(dir, "pending"), { recursive: true, mode: 448 });
-  const file = join10(dir, "pending", `${createHash7("sha256").update(signIn.state).digest("hex").slice(0, 24)}.json`);
+  mkdirSync5(join11(dir, "pending"), { recursive: true, mode: 448 });
+  const file = join11(dir, "pending", `${createHash7("sha256").update(signIn.state).digest("hex").slice(0, 24)}.json`);
   if (!resume)
     writePending(file, pending);
   if (!resume && previous && previous.file !== file)
     rmSync6(previous.file, { force: true });
-  const out = join10(dir, "bridge.log");
-  const child = spawn7(run2.node, [run2.bundle, "session", "finish-join", file], { detached: true, stdio: "ignore", env: { ...env, BEELINE_SESSION_BUNDLE: run2.bundle } });
+  const out = join11(dir, "bridge.log");
+  const child = spawn8(run2.node, [run2.bundle, "session", "finish-join", file], { detached: true, stdio: "ignore", env: { ...env, BEELINE_SESSION_BUNDLE: run2.bundle } });
   child.unref();
   console.log([
     `Show your person this link. They open it on any device (a phone works) and sign in with GitHub or Google:`,
@@ -25595,7 +25835,7 @@ async function finishJoinOwned(file, env) {
         changes.splice(prompt, 1);
       changes.push("Trusted only Beeline\u2019s SessionStart hook, pinned to its current Codex hash.");
     }
-    ensureBridge(dir, run2, env);
+    await ensureBridge(dir, run2, env);
     const rooms = me.rooms.map((r) => r.name).slice(0, 5).join(", ");
     await announce(joined2, `Beeline: you joined as @${joined2.handle ?? joined2.name}${rooms ? ` in ${rooms}` : ""}. When someone tags you there, the message arrives here with the command that answers it.${changes.length ? `
 (${changes.join("; ")})` : ""}
@@ -25643,7 +25883,7 @@ function own(args, env) {
 }
 async function ownTool(dir, joined2, name, args) {
   let bridged = await toolViaBridge(dir, joined2.key, name, args);
-  if (!bridged && existsSync5(join10(dir, "bridge.pid")) && process.cwd().startsWith(joined2.cwd))
+  if (!bridged && existsSync5(join11(dir, "bridge.pid")) && process.cwd().startsWith(joined2.cwd))
     bridged = await toolViaOutbox(joined2.cwd, name, args);
   if (bridged) {
     if (!bridged.ok)
@@ -25689,7 +25929,7 @@ async function session(args, env) {
       if (out)
         process.stdout.write(out + "\n");
       if (event === "session-start" && readState(dir).sessions.length)
-        ensureBridge(dir, runner(dir, env), env);
+        await ensureBridge(dir, runner(dir, env), env);
     } catch {
     }
     return;
@@ -25752,14 +25992,14 @@ async function session(args, env) {
   throw new Error("Usage: usebeeline join | usebeeline session reply|read|tool|status|leave");
 }
 function readStdin(_limitMs) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve13) => {
     let text = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       text += chunk;
     });
     process.stdin.on("end", () => {
-      resolve11(text);
+      resolve13(text);
     });
   });
 }
@@ -25797,19 +26037,19 @@ var init_command = __esm({
     init_setup();
     init_store();
     init_kernel_lock();
-    finisherKey = (file) => "beeline-session-sign-in:" + resolve9(file);
+    finisherKey = (file) => "beeline-session-sign-in:" + resolve11(file);
     VALUED = ["--as", "--room", "--reply-to", "--server", "--name", "--session", "--state", "--limit"];
   }
 });
 
 // apps/body/dist/recovery-cli.js
-import { spawn as spawn8 } from "node:child_process";
-import { readFile as readFile4, readdir as readdir5, stat as stat3, unlink } from "node:fs/promises";
-import { resolve as resolve10 } from "node:path";
+import { spawn as spawn9 } from "node:child_process";
+import { readFile as readFile5, readdir as readdir5, stat as stat3, unlink } from "node:fs/promises";
+import { resolve as resolve12 } from "node:path";
 
 // apps/body/dist/recovery.js
-import { readFile as readFile3, readdir as readdir4, stat } from "node:fs/promises";
-import { resolve as resolve8 } from "node:path";
+import { readFile as readFile4, readdir as readdir4, stat } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
 
 // apps/body/dist/machine-control.js
 import { watch } from "node:fs";
@@ -26170,8 +26410,8 @@ async function prepareMachineRelease(layout, options = {}) {
     return withInstallLock(layout, () => prepareLatestRelease(layout, { ...options, deadlineAt }), {
       waitMs: Math.max(0, deadlineAt - Date.now())
     });
-  const stable = resolve8(layout.libDir, "../beeline-bootstrap.mjs");
-  const entrypoint = env.BEELINE_RECOVERY_ENTRY || await readFile3(stable).then(() => stable, () => process.argv[1]);
+  const stable = resolve9(layout.libDir, "../beeline-bootstrap.mjs");
+  const entrypoint = env.BEELINE_RECOVERY_ENTRY || await readFile4(stable).then(() => stable, () => process.argv[1]);
   return prepareReleaseInWorker({ ...env, ...options?.force ? { BEELINE_FORCE_REPAIR: "1" } : {} }, deadlineAt, entrypoint);
 }
 async function convergeMachine(options = {}) {
@@ -26179,9 +26419,9 @@ async function convergeMachine(options = {}) {
   assertLifecycleTestIsolation(env, Boolean(options.run));
   const layout = options.layout ?? beelineInstallLayout(env) ?? discoveredBeelineInstallLayout(env);
   const deadlineAt = options.deadlineAt ?? Date.now() + (options.timeoutMs ?? 6e5);
-  const stateRoot = env.XDG_STATE_HOME || resolve8(env.HOME || "", ".local/state");
-  const root = resolve8(stateRoot, "beeline/agents");
-  const configured = await Promise.all((await readdir4(root).catch(() => [])).filter((id) => /^[0-9a-f]{64}$/i.test(id)).map(async (id) => await stat(resolve8(root, id, "runtime.json")).then(() => true, () => false) && !await stat(resolve8(root, id, "stopped")).then(() => true, () => false) ? id : void 0));
+  const stateRoot = env.XDG_STATE_HOME || resolve9(env.HOME || "", ".local/state");
+  const root = resolve9(stateRoot, "beeline/agents");
+  const configured = await Promise.all((await readdir4(root).catch(() => [])).filter((id) => /^[0-9a-f]{64}$/i.test(id)).map(async (id) => await stat(resolve9(root, id, "runtime.json")).then(() => true, () => false) && !await stat(resolve9(root, id, "stopped")).then(() => true, () => false) ? id : void 0));
   const required = /* @__PURE__ */ new Set([
     ...configured.filter((id) => Boolean(id)),
     ...options.agentIds ?? []
@@ -26202,7 +26442,7 @@ async function convergeMachine(options = {}) {
   let expectedRelease = options.releaseId;
   const targetIdentity = options.releaseId ? await readInstalledBundleIdentity({
     ...layout,
-    libDir: resolve8(layout.releasesRoot, options.releaseId)
+    libDir: resolve9(layout.releasesRoot, options.releaseId)
   }) : void 0;
   const request2 = options.releaseId && hasControl ? {
     operation: "update",
@@ -26239,8 +26479,8 @@ async function bootstrapMachine(env = process.env) {
   for (const id of [state.stagedReleaseId, active]) {
     if (!id || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id))
       continue;
-    const digest = await readFile3(resolve8(layout.releasesRoot, id, ".stage-ok"), "utf8").catch(() => "");
-    if (/^[0-9a-f]{64}$/i.test(digest.trim()) && await resolveBundleEntrypoint(resolve8(layout.releasesRoot, id))) {
+    const digest = await readFile4(resolve9(layout.releasesRoot, id, ".stage-ok"), "utf8").catch(() => "");
+    if (/^[0-9a-f]{64}$/i.test(digest.trim()) && await resolveBundleEntrypoint(resolve9(layout.releasesRoot, id))) {
       releaseId = id;
       break;
     }
@@ -26256,7 +26496,7 @@ async function bootstrapMachine(env = process.env) {
     await withInstallLock(layout, () => activateRelease(layout, releaseId, { deferPruning: true }), {
       waitMs: Math.max(0, bootDeadlineAt - Date.now())
     });
-  const entry = await resolveBundleEntrypoint(resolve8(layout.releasesRoot, releaseId));
+  const entry = await resolveBundleEntrypoint(resolve9(layout.releasesRoot, releaseId));
   if (!entry)
     throw new Error(`selected release ${releaseId} has no body entry`);
   return entry;
@@ -26322,18 +26562,18 @@ async function main() {
       if (args[i] === "--manifest-url" && !args[++i])
         throw new Error("--manifest-url requires a URL");
     }
-    const stateRoot2 = process.env.XDG_STATE_HOME || resolve10(process.env.HOME || "", ".local/state");
+    const stateRoot2 = process.env.XDG_STATE_HOME || resolve12(process.env.HOME || "", ".local/state");
     if (args.includes("--status")) {
       const [native, helper] = await Promise.all([
         nativeHelperStatus(),
         requestMachine(stateRoot2, { operation: "status" }, () => true, 2e3).catch(() => void 0)
       ]);
-      const root = resolve10(stateRoot2, "beeline/agents");
+      const root = resolve12(stateRoot2, "beeline/agents");
       const agents = await Promise.all((await readdir5(root).catch(() => [])).filter((id) => /^[0-9a-f]{64}$/.test(id)).map(async (id) => ({
         agentId: id,
-        enabled: !await stat3(resolve10(root, id, "stopped")).then(() => true, () => false),
+        enabled: !await stat3(resolve12(root, id, "stopped")).then(() => true, () => false),
         ...helper?.agents[id] ?? { state: "not hosted" },
-        validRecord: await readFile4(resolve10(root, id, "runtime.json"), "utf8").then((raw) => Boolean(JSON.parse(raw).agent)).catch(() => false)
+        validRecord: await readFile5(resolve12(root, id, "runtime.json"), "utf8").then((raw) => Boolean(JSON.parse(raw).agent)).catch(() => false)
       })));
       console.log(JSON.stringify({
         native,
@@ -26382,7 +26622,7 @@ async function main() {
     console.log(`[beeline] executing release ${status.loadedRelease}; helper ${status.pid}; every enabled agent serving`);
     return;
   }
-  const stateRoot = process.env.XDG_STATE_HOME || resolve10(process.env.HOME || "", ".local/state");
+  const stateRoot = process.env.XDG_STATE_HOME || resolve12(process.env.HOME || "", ".local/state");
   let selectedRelease;
   if (command2 === "start") {
     for (let i = 1; i < args.length; i++) {
@@ -26397,13 +26637,13 @@ async function main() {
     const requested = agentFlag >= 0 ? args[agentFlag + 1] : args[1] && !args[1].startsWith("--") ? args[1] : void 0;
     if (agentFlag >= 0 && !requested)
       throw new Error("--agent requires an agent public key");
-    const agentRoot = resolve10(stateRoot, "beeline/agents");
+    const agentRoot = resolve12(stateRoot, "beeline/agents");
     const ids = (await readdir5(agentRoot).catch(() => [])).filter((id) => /^[0-9a-f]{64}$/.test(id));
     const selected = requested ? ids.filter((id) => id.startsWith(requested)) : args.includes("--all") ? ids : [];
     if (requested && selected.length !== 1)
       throw new Error(`no unique paired agent matches ${requested}`);
     for (const id of selected)
-      await unlink(resolve10(agentRoot, id, "stopped")).catch((error) => {
+      await unlink(resolve12(agentRoot, id, "stopped")).catch((error) => {
         if (error.code !== "ENOENT")
           throw error;
       });
@@ -26427,7 +26667,7 @@ async function main() {
   const entry = await resolveBundleEntrypoint(layout.libDir);
   if (!entry)
     throw new Error("no installed Beeline body; run npx usebeeline connect");
-  const child = spawn8(process.execPath, [entry, ...args], {
+  const child = spawn9(process.execPath, [entry, ...args], {
     env: {
       ...process.env,
       BEELINE_LIB_DIR: layout.libDir,
@@ -26445,7 +26685,7 @@ async function convergeDependencies(layout, _deadlineAt) {
   if (!entry)
     throw new Error("dependency phase has no selected body");
   await new Promise((done, reject) => {
-    const child = spawn8(process.execPath, [entry, "converge-dependencies"], {
+    const child = spawn9(process.execPath, [entry, "converge-dependencies"], {
       env: { ...process.env, BEELINE_LIB_DIR: layout.libDir, BEELINE_INTERNAL_RECOVERY: "1" },
       stdio: "inherit"
     });