usebeeline 0.1.57 → 0.1.59

package/dist/usebeeline.mjs

@@ -126,6 +126,152 @@ var init_lifecycle_test_guard = __esm({
   }
 });
 
+// apps/body/dist/trusty-squire-storage.js
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute, resolve as resolve4 } from "node:path";
+function trustySquireLegacyStorePaths(operatorHome = homedir2(), env = process.env) {
+  const roots = /* @__PURE__ */ new Set([resolve4(operatorHome, ".config")]);
+  const xdgConfig = env.XDG_CONFIG_HOME?.trim();
+  if (xdgConfig && isAbsolute(xdgConfig))
+    roots.add(resolve4(xdgConfig));
+  return [...roots].map((root) => resolve4(root, "trusty-squire"));
+}
+var init_trusty_squire_storage = __esm({
+  "apps/body/dist/trusty-squire-storage.js"() {
+    "use strict";
+  }
+});
+
+// apps/body/dist/storage-filesystem.js
+import { chmod, lstat as lstat2, readdir as readdir2, realpath, rm as rm2 } from "node:fs/promises";
+import { resolve as resolve5, sep } from "node:path";
+import { spawn } from "node:child_process";
+function canonicalStoragePath(path) {
+  const absolute = resolve5(path);
+  return process.platform === "darwin" ? absolute.replace(/^\/(var|tmp|etc)(?=\/|$)/, "/private/$1") : absolute;
+}
+async function ordinaryDirectory(path) {
+  const info = await lstat2(path).catch(() => void 0);
+  return Boolean(info?.isDirectory() && canonicalStoragePath(await realpath(path)) === canonicalStoragePath(path));
+}
+async function storageTree(root) {
+  if (process.platform === "darwin") {
+    const tree2 = /* @__PURE__ */ new Map();
+    const visit = async (path) => {
+      const info = await lstat2(path);
+      tree2.set(path, {
+        dev: info.dev,
+        ino: info.ino,
+        blocks: info.blocks * 512,
+        links: info.nlink,
+        directory: info.isDirectory(),
+        lastUsed: Math.max(info.atimeMs, info.mtimeMs)
+      });
+      if (info.isDirectory() && !isSquirePath(path))
+        for (const name of await readdir2(path))
+          await visit(resolve5(path, name));
+    };
+    await visit(root);
+    return tree2;
+  }
+  const child = spawn("/usr/bin/python3", ["-c", TREE_INVENTORY, root], { stdio: ["ignore", "pipe", "pipe"] });
+  const tree = /* @__PURE__ */ new Map();
+  let pending = "", stderr = "";
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr = (stderr + chunk).slice(-8192);
+  });
+  const completed = new Promise((done, fail) => {
+    child.once("error", fail);
+    child.once("close", (code) => code === 0 ? done() : fail(new Error(`storage inventory failed (${code}): ${stderr}`)));
+  });
+  void completed.catch(() => void 0);
+  const add = (line) => {
+    const [path, dev, ino, blocks, links, directory, lastUsed] = JSON.parse(line);
+    tree.set(path, { dev, ino, blocks, links, directory, lastUsed });
+  };
+  child.stdout.setEncoding("utf8");
+  for await (const chunk of child.stdout) {
+    pending += chunk;
+    let newline;
+    while ((newline = pending.indexOf("\n")) >= 0) {
+      add(pending.slice(0, newline));
+      pending = pending.slice(newline + 1);
+    }
+  }
+  await completed;
+  if (pending)
+    add(pending);
+  return tree;
+}
+function isSquirePath(path) {
+  const absolute = resolve5(path);
+  return absolute.split(sep).some((part, index, parts) => [".trusty-squire", "squire-host-config"].includes(part) || part === "trusty-squire" && parts[index - 1] !== "skills") || trustySquireLegacyStorePaths().some((root) => absolute === root || absolute.startsWith(`${root}${sep}`));
+}
+async function removeStoragePath(root, knownTree) {
+  const original = knownTree ?? await storageTree(root);
+  let index = removalIndexes.get(original);
+  if (!index) {
+    index = {
+      excluded: [...original.keys()].filter(isSquirePath),
+      directories: [...original].filter(([, item]) => item.directory).map(([path]) => path).sort()
+    };
+    removalIndexes.set(original, index);
+  }
+  const { excluded, directories } = index;
+  if (excluded.some((path) => path === root || path.startsWith(`${root}/`)))
+    throw new Error("refusing removal of Trusty Squire storage");
+  if (isSquirePath(root))
+    throw new Error("refusing removal of Trusty Squire storage");
+  const prefix = `${root}/`;
+  let low = 0, high = directories.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (directories[middle] < prefix)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  const ownedDirectories = original.get(root)?.directory ? [root] : [];
+  for (let cursor = low; cursor < directories.length && directories[cursor].startsWith(prefix); cursor++)
+    ownedDirectories.push(directories[cursor]);
+  for (const path of ownedDirectories) {
+    const info = await lstat2(path).catch((error) => {
+      if (error.code === "ENOENT")
+        return void 0;
+      throw error;
+    });
+    if (!info)
+      continue;
+    if (info.isDirectory() && process.getuid?.() === info.uid && (info.mode & 448) !== 448)
+      await chmod(path, info.mode | 448);
+  }
+  await rm2(root, { recursive: true, force: true, maxRetries: 3 });
+}
+var TREE_INVENTORY, removalIndexes;
+var init_storage_filesystem = __esm({
+  "apps/body/dist/storage-filesystem.js"() {
+    "use strict";
+    init_trusty_squire_storage();
+    TREE_INVENTORY = String.raw`
+import os, sys, json, stat
+root=sys.argv[1]
+def visit(path):
+    s=os.lstat(path)
+    directory=stat.S_ISDIR(s.st_mode)
+    print(json.dumps([path,s.st_dev,s.st_ino,s.st_blocks*512,s.st_nlink,directory,max(s.st_atime_ns,s.st_mtime_ns)/1000000]))
+    if directory and not (os.path.basename(path) in ['.trusty-squire','squire-host-config'] or (os.path.basename(path)=='trusty-squire' and os.path.basename(os.path.dirname(path))!='skills')):
+        fd=os.open(path,os.O_RDONLY|os.O_DIRECTORY|os.O_NOATIME|os.O_NOFOLLOW)
+        try: names=os.listdir(fd)
+        finally: os.close(fd)
+        for name in names: visit(os.path.join(path,name))
+visit(root)
+
+`;
+    removalIndexes = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // apps/body/dist/self-update-manifest.js
 function resolveManifestUrl(env = process.env) {
   const override = env.BEELINE_UPDATE_MANIFEST_URL?.trim();
@@ -252,6 +398,7 @@ __export(self_update_exports, {
   nodeVersionAtLeast: () => nodeVersionAtLeast,
   normalizeLegacyBundleShape: () => normalizeLegacyBundleShape,
   prepareLatestRelease: () => prepareLatestRelease,
+  pruneHelperReleases: () => pruneHelperReleases,
   readBundleEngineMinimum: () => readBundleEngineMinimum,
   readInstalledBundleIdentity: () => readInstalledBundleIdentity,
   readUpdateState: () => readUpdateState,
@@ -264,12 +411,12 @@ __export(self_update_exports, {
 });
 import { createHash as createHash3 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
-import { access, chmod, copyFile, lstat as lstat2, mkdir as mkdir3, open, readFile as readFile2, rename, rm as rm2, symlink, writeFile as writeFile2 } from "node:fs/promises";
-import { spawn } from "node:child_process";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname4, join, resolve as resolve4 } from "node:path";
+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 { homedir as homedir3 } from "node:os";
+import { dirname as dirname4, join, resolve as resolve6 } from "node:path";
 function anchorLayout(rawLibDir) {
-  const libDir = resolve4(rawLibDir);
+  const libDir = resolve6(rawLibDir);
   const segments = libDir.split(/[/\\]/);
   const idx = segments.lastIndexOf(RELEASES_SEGMENT);
   if (idx >= 2 && segments[idx - 1] === "lib") {
@@ -285,9 +432,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: resolve4(libDir, "../../bin"),
+    binDir: resolve6(libDir, "../../bin"),
     libDir,
-    releasesRoot: resolve4(libDir, `../${RELEASES_SEGMENT}`)
+    releasesRoot: resolve6(libDir, `../${RELEASES_SEGMENT}`)
   };
 }
 function beelineInstallLayout(env = process.env) {
@@ -299,18 +446,18 @@ function beelineInstallLayout(env = process.env) {
 function releaseIdFromPath(path) {
   if (!path?.trim())
     return void 0;
-  const segments = resolve4(path.trim()).split(/[/\\]/);
+  const segments = resolve6(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 = resolve4(layout.releasesRoot);
-  const anchor = resolve4(layout.libDir);
+  const releasesRoot = resolve6(layout.releasesRoot);
+  const anchor = resolve6(layout.libDir);
   for (const raw of [env.BEELINE_LIB_DIR, invocationPath]) {
     if (!raw?.trim())
       continue;
-    const resolved = resolve4(raw.trim());
+    const resolved = resolve6(raw.trim());
     if (resolved !== anchor && !resolved.startsWith(`${releasesRoot}/`))
       continue;
     const id = releaseIdFromPath(resolved);
@@ -320,8 +467,8 @@ function runningReleaseId(layout, env = process.env, invocationPath = process.ar
   return void 0;
 }
 function defaultBeelineInstallLayout(env = process.env) {
-  const home = env.HOME?.trim() || homedir2();
-  return anchorLayout(resolve4(home, ".local", "lib", "beeline"));
+  const home = env.HOME?.trim() || homedir3();
+  return anchorLayout(resolve6(home, ".local", "lib", "beeline"));
 }
 function discoveredBeelineInstallLayout(env = process.env) {
   const explicitAnchor = env.BEELINE_INSTALL_LIB_DIR?.trim();
@@ -329,7 +476,7 @@ function discoveredBeelineInstallLayout(env = process.env) {
     return anchorLayout(explicitAnchor);
   const explicitBinDir = env.BEELINE_INSTALL_DIR?.trim();
   if (explicitBinDir)
-    return anchorLayout(resolve4(dirname4(resolve4(explicitBinDir)), "lib", "beeline"));
+    return anchorLayout(resolve6(dirname4(resolve6(explicitBinDir)), "lib", "beeline"));
   return defaultBeelineInstallLayout(env);
 }
 function hostPlatformKey() {
@@ -407,7 +554,7 @@ async function writeUpdateState(layout, state) {
   } finally {
     await handle.close();
   }
-  await rename(temporary, path);
+  await rename2(temporary, path);
   await fsyncDir(dirname4(path));
 }
 async function readInstalledBundleIdentity(layout, _state = {}) {
@@ -422,7 +569,7 @@ function sanitizeReleaseId(id) {
 }
 async function pathKind(path) {
   try {
-    const info = await lstat2(path);
+    const info = await lstat3(path);
     if (info.isSymbolicLink())
       return "symlink";
     return info.isDirectory() ? "directory" : "missing";
@@ -470,7 +617,7 @@ async function fetchText(url, fetchImpl) {
 }
 function run(command, args, timeoutMs) {
   return new Promise((resolveRun) => {
-    const child = spawn(command, args, { stdio: ["ignore", "ignore", "pipe"] });
+    const child = spawn2(command, args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
@@ -566,7 +713,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     }
     await writeFile2(tempArchive, Buffer.concat(chunks), { mode: 384 });
     const entries = (await new Promise((resolveList, rejectList) => {
-      const child = spawn("tar", ["-tzf", tempArchive], { stdio: ["ignore", "pipe", "inherit"] });
+      const child = spawn2("tar", ["-tzf", tempArchive], { stdio: ["ignore", "pipe", "inherit"] });
       const timer = setTimeout(() => child.kill("SIGKILL"), Math.min(3e4, remaining()));
       let out = "";
       child.stdout?.on("data", (chunk) => {
@@ -619,10 +766,10 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     return releaseId;
   } catch (error) {
     if (!previouslyVerified)
-      await rm2(releaseDir, { recursive: true, force: true });
+      await rm3(releaseDir, { recursive: true, force: true });
     throw error;
   } finally {
-    await rm2(tempArchive, { force: true });
+    await rm3(tempArchive, { force: true });
   }
 }
 function forwarderScript(tool) {
@@ -656,12 +803,13 @@ function forwarderScript(tool) {
 async function replaceFile(path, contents, mode) {
   const temp = `${path}.new-${process.pid}`;
   await writeFile2(temp, contents, { mode });
-  await chmod(temp, mode);
-  await rename(temp, path);
+  await chmod2(temp, mode);
+  await rename2(temp, path);
 }
-async function activateRelease(layout, releaseId) {
+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 });
@@ -673,29 +821,39 @@ async function activateRelease(layout, releaseId) {
     try {
       await access(legacyDir, fsConstants.F_OK);
       const preservedId = `${legacyId}-${Date.now()}`;
-      await rename(layout.libDir, join(layout.releasesRoot, preservedId));
+      await rename2(layout.libDir, join(layout.releasesRoot, preservedId));
       await normalizeLegacyBundleShape(join(layout.releasesRoot, preservedId));
+      previousReleaseId = preservedId;
     } catch {
-      await rename(layout.libDir, legacyDir);
+      await rename2(layout.libDir, legacyDir);
       await normalizeLegacyBundleShape(legacyDir);
+      previousReleaseId = legacyId;
     }
   }
   const tempLink = `${layout.libDir}.new-${process.pid}`;
-  await rm2(tempLink, { force: true });
+  await rm3(tempLink, { force: true });
   await symlink(join("beeline-releases", releaseId), tempLink);
-  await rename(tempLink, layout.libDir);
+  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 = resolve4(layout.libDir, "../beeline-bootstrap.mjs");
+    const stable = resolve6(layout.libDir, "../beeline-bootstrap.mjs");
     const temporary = `${stable}.${process.pid}.tmp`;
     await copyFile(bootstrap, temporary);
-    await rename(temporary, stable);
-    await replaceFile(resolve4(layout.libDir, "../beeline-node-path"), `${process.execPath}
+    await rename2(temporary, stable);
+    await replaceFile(resolve6(layout.libDir, "../beeline-node-path"), `${process.execPath}
 `, 384);
   }
 }
@@ -719,7 +877,7 @@ async function normalizeLegacyBundleShape(bundleDir) {
       continue;
     } catch {
     }
-    await rename(join(bundleDir, name), join(innerLib, name)).catch(() => void 0);
+    await rename2(join(bundleDir, name), join(innerLib, name)).catch(() => void 0);
   }
 }
 async function writeBinForwarders(layout, activeBundleRoot) {
@@ -734,7 +892,7 @@ async function writeBinForwarders(layout, activeBundleRoot) {
     } catch {
       continue;
     }
-    const independent = await access(resolve4(layout.libDir, "../beeline-bootstrap.mjs")).then(() => true, () => false);
+    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);
   }
 }
@@ -750,7 +908,7 @@ async function repairInstallForwarders(layout, opts = {}) {
     } catch {
       current = void 0;
     }
-    const independent = await access(resolve4(layout.libDir, "../beeline-bootstrap.mjs")).then(() => true, () => false);
+    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;
   };
@@ -789,6 +947,7 @@ async function prepareLatestRelease(layout, options = {}) {
       deadlineAt: options.deadlineAt
     });
     await writeUpdateState(layout, {
+      ...await readUpdateState(layout),
       lastCheckAt: Date.now(),
       lastCheckResult: "verified",
       stagedReleaseId: releaseId
@@ -804,10 +963,53 @@ 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 init_self_update = __esm({
   "apps/body/dist/self-update.js"() {
     "use strict";
+    init_storage_filesystem();
     init_lifecycle_test_guard();
     init_self_update_manifest();
     RELEASES_SEGMENT = "beeline-releases";
@@ -859,10 +1061,10 @@ __export(managed_update_exports, {
   versionAtLeast: () => versionAtLeast,
   withInstallLock: () => withInstallLock
 });
-import { spawn as spawn2 } from "node:child_process";
-import { resolve as resolve5 } from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+import { resolve as resolve7 } from "node:path";
 function withInstallLock(layout, work, options = {}) {
-  return withKernelLock(`beeline-install:${resolve5(layout.libDir)}`, work, options.waitMs);
+  return withKernelLock(`beeline-install:${resolve7(layout.libDir)}`, work, options.waitMs);
 }
 function versionAtLeast(actual, minimum) {
   const parse = (value) => /^v?(\d+)\.(\d+)\.(\d+)$/.exec(value)?.slice(1).map(Number);
@@ -887,9 +1089,9 @@ async function runManagedUpdateWorker() {
 }
 async function prepareReleaseInWorker(env, deadlineAt, entrypoint) {
   const layout = beelineInstallLayout(env);
-  const bootstrap = entrypoint ?? resolve5(layout.libDir, "../beeline-bootstrap.mjs");
+  const bootstrap = entrypoint ?? resolve7(layout.libDir, "../beeline-bootstrap.mjs");
   return new Promise((done, reject) => {
-    const child = spawn2(process.execPath, [bootstrap, "managed-update-worker"], {
+    const child = spawn3(process.execPath, [bootstrap, "managed-update-worker"], {
       detached: true,
       env: {
         ...env,
@@ -993,7 +1195,7 @@ var init_managed_update = __esm({
         if (this.#minimum) {
           const identity = await readInstalledBundleIdentity({
             ...this.options.layout,
-            libDir: resolve5(this.options.layout.releasesRoot, releaseId)
+            libDir: resolve7(this.options.layout.releasesRoot, releaseId)
           });
           if (!identity?.version || !versionAtLeast(identity.version, this.#minimum)) {
             this.#prepared = void 0;
@@ -1075,13 +1277,13 @@ var init_managed_update = __esm({
 });
 
 // apps/body/dist/recovery-cli.js
-import { spawn as spawn3 } from "node:child_process";
-import { readFile as readFile4, readdir as readdir3, stat as stat2, unlink } from "node:fs/promises";
-import { resolve as resolve7 } from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+import { readFile as readFile4, readdir as readdir5, stat as stat2, unlink } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
 
 // apps/body/dist/recovery.js
-import { readFile as readFile3, readdir as readdir2, stat } from "node:fs/promises";
-import { resolve as resolve6 } from "node:path";
+import { readFile as readFile3, readdir as readdir4, stat } from "node:fs/promises";
+import { resolve as resolve8 } from "node:path";
 
 // apps/body/dist/machine-control.js
 import { watch } from "node:fs";
@@ -1193,7 +1395,7 @@ async function requestMachine(stateRoot, request, accept, timeoutMs = 6e5) {
 init_kernel_lock();
 init_lifecycle_test_guard();
 import { execFile } from "node:child_process";
-import { mkdir as mkdir2, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { mkdir as mkdir2, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { resolve as resolve3 } from "node:path";
 import { promisify } from "node:util";
@@ -1215,9 +1417,7 @@ Environment=PATH=%h/.local/bin:/usr/local/bin:/usr/bin:/bin
 ExecStart=%h/.local/bin/beeline helper-bootstrap
 ExecReload=/bin/kill -HUP $MAINPID
 Restart=always
-RestartSec=5s
-RestartSteps=5
-RestartMaxDelaySec=60s
+RestartSec=1s
 WatchdogSec=180s
 CPUWeight=1000
 IOWeight=1000
@@ -1449,7 +1649,7 @@ async function prepareMachineRelease(layout, options = {}) {
     return withInstallLock(layout, () => prepareLatestRelease(layout, { ...options, deadlineAt }), {
       waitMs: Math.max(0, deadlineAt - Date.now())
     });
-  const stable = resolve6(layout.libDir, "../beeline-bootstrap.mjs");
+  const stable = resolve8(layout.libDir, "../beeline-bootstrap.mjs");
   const entrypoint = env.BEELINE_RECOVERY_ENTRY || await readFile3(stable).then(() => stable, () => process.argv[1]);
   return prepareReleaseInWorker({ ...env, ...options?.force ? { BEELINE_FORCE_REPAIR: "1" } : {} }, deadlineAt, entrypoint);
 }
@@ -1458,9 +1658,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 || resolve6(env.HOME || "", ".local/state");
-  const root = resolve6(stateRoot, "beeline/agents");
-  const configured = await Promise.all((await readdir2(root).catch(() => [])).filter((id) => /^[0-9a-f]{64}$/i.test(id)).map(async (id) => await stat(resolve6(root, id, "runtime.json")).then(() => true, () => false) && !await stat(resolve6(root, id, "stopped")).then(() => true, () => false) ? id : void 0));
+  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 required = /* @__PURE__ */ new Set([
     ...configured.filter((id) => Boolean(id)),
     ...options.agentIds ?? []
@@ -1481,7 +1681,7 @@ async function convergeMachine(options = {}) {
   let expectedRelease = options.releaseId;
   const targetIdentity = options.releaseId ? await readInstalledBundleIdentity({
     ...layout,
-    libDir: resolve6(layout.releasesRoot, options.releaseId)
+    libDir: resolve8(layout.releasesRoot, options.releaseId)
   }) : void 0;
   const request = options.releaseId && hasControl ? {
     operation: "update",
@@ -1512,33 +1712,32 @@ async function bootstrapMachine(env = process.env) {
   if (!pid || ![Number(env.BEELINE_BOOT_LAUNCHER_PID), Number(env.BEELINE_BOOT_LAUNCHER_PARENT_PID)].includes(pid))
     throw new Error("helper bootstrap requires native service ownership; run beeline start");
   const layout = beelineInstallLayout(env) ?? discoveredBeelineInstallLayout(env);
+  const state = await readUpdateState(layout);
+  const active = await activeReleaseId(layout);
   let releaseId;
-  try {
+  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))) {
+      releaseId = id;
+      break;
+    }
+  }
+  if (!releaseId) {
     if (env.BEELINE_UPDATE_DISABLE === "1")
-      throw new Error("automatic release selection disabled by BEELINE_UPDATE_DISABLE");
-    const prepared = await prepareMachineRelease(layout, {
+      throw new Error("automatic release selection disabled; no verified runnable release");
+    releaseId = (await prepareMachineRelease(layout, {
       env,
       deadlineAt: Date.now() + 18e4,
       logger: (line) => console.error(line)
-    });
-    releaseId = prepared.releaseId;
-    await withInstallLock(layout, () => activateRelease(layout, releaseId), {
-      waitMs: Math.max(0, bootDeadlineAt - Date.now())
-    });
-  } catch (error) {
-    const state = await readUpdateState(layout);
-    const candidates = [state.stagedReleaseId, await activeReleaseId(layout)];
-    const verified = await Promise.all(candidates.map(async (id) => id && /^[0-9a-f]{64}$/i.test((await readFile3(resolve6(layout.releasesRoot, id, ".stage-ok"), "utf8").catch(() => "")).trim()) ? id : void 0));
-    const candidate = verified.find(Boolean);
-    if (!candidate)
-      throw new Error(`startup release selection failed; no verified runnable release: ${String(error)}`);
-    releaseId = candidate;
-    console.error(`[beeline] serving verified ${releaseId}; release freshness unconfirmed: ${String(error)}`);
-    await withInstallLock(layout, () => activateRelease(layout, releaseId), {
+    })).releaseId;
+  }
+  if (releaseId !== active)
+    await withInstallLock(layout, () => activateRelease(layout, releaseId, { deferPruning: true }), {
       waitMs: Math.max(0, bootDeadlineAt - Date.now())
     });
-  }
-  const entry = await resolveBundleEntrypoint(resolve6(layout.releasesRoot, releaseId));
+  const entry = await resolveBundleEntrypoint(resolve8(layout.releasesRoot, releaseId));
   if (!entry)
     throw new Error(`selected release ${releaseId} has no body entry`);
   return entry;
@@ -1599,18 +1798,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 || resolve7(process.env.HOME || "", ".local/state");
+    const stateRoot2 = process.env.XDG_STATE_HOME || resolve9(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 = resolve7(stateRoot2, "beeline/agents");
-      const agents = await Promise.all((await readdir3(root).catch(() => [])).filter((id) => /^[0-9a-f]{64}$/.test(id)).map(async (id) => ({
+      const root = resolve9(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 stat2(resolve7(root, id, "stopped")).then(() => true, () => false),
+        enabled: !await stat2(resolve9(root, id, "stopped")).then(() => true, () => false),
         ...helper?.agents[id] ?? { state: "not hosted" },
-        validRecord: await readFile4(resolve7(root, id, "runtime.json"), "utf8").then((raw) => Boolean(JSON.parse(raw).agent)).catch(() => false)
+        validRecord: await readFile4(resolve9(root, id, "runtime.json"), "utf8").then((raw) => Boolean(JSON.parse(raw).agent)).catch(() => false)
       })));
       console.log(JSON.stringify({
         native,
@@ -1660,7 +1859,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 || resolve7(process.env.HOME || "", ".local/state");
+  const stateRoot = process.env.XDG_STATE_HOME || resolve9(process.env.HOME || "", ".local/state");
   let selectedRelease;
   if (command === "start") {
     for (let i = 1; i < args.length; i++) {
@@ -1675,13 +1874,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 = resolve7(stateRoot, "beeline/agents");
-    const ids = (await readdir3(agentRoot).catch(() => [])).filter((id) => /^[0-9a-f]{64}$/.test(id));
+    const agentRoot = resolve9(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(resolve7(agentRoot, id, "stopped")).catch((error) => {
+      await unlink(resolve9(agentRoot, id, "stopped")).catch((error) => {
         if (error.code !== "ENOENT")
           throw error;
       });
@@ -1705,7 +1904,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 = spawn3(process.execPath, [entry, ...args], {
+  const child = spawn4(process.execPath, [entry, ...args], {
     env: {
       ...process.env,
       BEELINE_LIB_DIR: layout.libDir,
@@ -1723,7 +1922,7 @@ async function convergeDependencies(layout, deadlineAt) {
   if (!entry)
     throw new Error("dependency phase has no selected body");
   await new Promise((done, reject) => {
-    const child = spawn3(process.execPath, [entry, "converge-dependencies"], {
+    const child = spawn4(process.execPath, [entry, "converge-dependencies"], {
       env: { ...process.env, BEELINE_LIB_DIR: layout.libDir, BEELINE_INTERNAL_RECOVERY: "1" },
       stdio: "inherit"
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usebeeline",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "description": "Connect an AI coding agent to Beeline with one command.",
   "homepage": "https://usebeeline.app",
   "bugs": {