abtars 0.2.1-alpha.4 → 0.2.1-alpha.6

package/bundle/abtars-cli.js

@@ -2,21 +2,21 @@
  import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
 import {
   install
-} from "./chunk-RJJWPMUZ.js";
+} from "./chunk-4BUOO6WI.js";
 import {
-  RETENTION,
   acquireLock,
-  activate,
+  atomicSwap,
+  cleanStaleStaging,
+  configSnapshot,
   emptyManifest,
   hashFile,
-  inspectLock,
+  healthProbe,
   packagePaths,
-  pruneReleases,
-  readCurrent,
   readManifest,
-  releaseExists,
-  writeManifest
-} from "./chunk-RVERPUHT.js";
+  readSentinel,
+  writeManifest,
+  writeSentinel
+} from "./chunk-RSWUPUNA.js";
 import {
   restart
 } from "./chunk-URAQLQ2U.js";
@@ -488,7 +488,7 @@ async function runInteractive(existing) {
   const { intro, outro, text, select, confirm: confirm2, isCancel, cancel } = await import("./dist-J3T4XVKX.js");
   intro("abtars onboard \u2014 first-time setup");
   const noteEmpty = "press Enter to skip";
-  const { packagePaths: pp, readManifest: rm3 } = await import("./deploy-lib-import-HCMZCKZD.js");
+  const { packagePaths: pp, readManifest: rm3 } = await import("./deploy-lib-import-SBKXDD3F.js");
   const mfPaths = pp("abtars");
   const mf = await rm3(mfPaths.manifest);
   const installMode = mf?.installMode ?? "supervised";
@@ -924,7 +924,7 @@ async function onboard(opts) {
   }
   if (secrets.length > 0) process.stdout.write(`\u2713 ${secrets.length} secrets \u2192 ${secretDirPath}
 `);
-  const { writeManifest: writeManifest2 } = await import("./deploy-lib-import-HCMZCKZD.js");
+  const { writeManifest: writeManifest2 } = await import("./deploy-lib-import-SBKXDD3F.js");
   const mf = await readManifest(paths.manifest);
   if (mf) await writeManifest2(paths.manifest, { ...mf, installMode: answers.installMode });
   process.stdout.write(`\u2713 install mode: ${answers.installMode}
@@ -1055,8 +1055,8 @@ Next: 'abtars update' to build, then start the bridge.
 `);
     return 0;
   }
-  const { existsSync: existsSync8 } = await import("node:fs");
-  const hasRelease = existsSync8(join6(paths.home, "current"));
+  const { existsSync: existsSync10 } = await import("node:fs");
+  const hasRelease = existsSync10(join6(paths.home, "current"));
   if (!hasRelease) {
     process.stdout.write(`
 Next: run 'abtars update' to stage the release, then start the bridge.
@@ -1076,9 +1076,9 @@ Next: start the bridge
   return 0;
 }
 async function seedDefaultTasks(chatId, abtarsHome4) {
-  const { existsSync: existsSync8 } = await import("node:fs");
+  const { existsSync: existsSync10 } = await import("node:fs");
   const tasksJson = join6(abtarsHome4, "tasks", "tasks.json");
-  if (existsSync8(tasksJson)) {
+  if (existsSync10(tasksJson)) {
     process.stdout.write(`\u2022 tasks.json exists \u2014 skipping default-task seed
 `);
     return;
@@ -1091,7 +1091,7 @@ async function seedDefaultTasks(chatId, abtarsHome4) {
   ];
   let templatePath = null;
   for (const p of candidates) {
-    if (existsSync8(p)) {
+    if (existsSync10(p)) {
       templatePath = p;
       break;
     }
@@ -1148,80 +1148,59 @@ async function seedDefaultTasks(chatId, abtarsHome4) {
 }
 
 // src/cli/commands/rollback.ts
-import { hostname } from "node:os";
-async function rollback(opts) {
+import { existsSync as existsSync5, renameSync as renameSync3, rmSync as rmSync2 } from "node:fs";
+import { join as join7 } from "node:path";
+async function rollback() {
   const paths = packagePaths("abtars");
   const manifest = await readManifest(paths.manifest);
-  if (!manifest || !manifest.version) {
-    process.stderr.write(`No active release; nothing to roll back.
+  if (!existsSync5(paths.appPrev)) {
+    process.stderr.write(`Nothing to roll back to (no app.prev/ found).
 `);
     return 2;
   }
-  if (manifest.priorReleases.length === 0 && opts.to === void 0) {
-    process.stderr.write(`No prior releases recorded; nothing to roll back to.
+  if (!manifest?.version) {
+    process.stderr.write(`No active release in manifest; nothing to roll back.
 `);
     return 2;
   }
-  const target = opts.to ?? manifest.priorReleases[0].version;
-  if (target === manifest.version) {
-    process.stdout.write(`Already at ${target}; no-op.
-`);
-    return 0;
-  }
-  if (!await releaseExists(paths.releases, target)) {
-    const available = [manifest.version, ...manifest.priorReleases.map((r) => r.version)];
-    process.stderr.write(
-      `Target release '${target}' does not exist in ${paths.releases}.
-Available: ${available.join(", ")}
-If pruned, rebuild from the target's git SHA with 'abtars update' instead.
-`
-    );
-    return 2;
-  }
-  const targetRecord = target === manifest.version ? {
-    version: manifest.version,
-    commit: manifest.commit,
-    activatedAt: manifest.activatedAt,
-    packageLockHash: manifest.packageLockHash
-  } : manifest.priorReleases.find((r) => r.version === target) ?? null;
-  if (manifest.packageLockHash && targetRecord?.packageLockHash && manifest.packageLockHash !== targetRecord.packageLockHash) {
-    process.stderr.write(
-      `v${manifest.version} pinned different deps than v${target} (package-lock hashes differ).
-Rollback via symlink is unsafe. Instead:
-  git checkout ${targetRecord.commit ?? "<commit-from-manifest>"}
-  abtars update --from-local
-This rebuilds node_modules/ to match the target release.
-`
-    );
-    return 3;
-  }
-  const release = await acquireLock(paths.lock, `rollback --to ${target}`);
+  const release = await acquireLock(paths.lock, "rollback");
   try {
-    await activate(paths.current, target);
-    process.stdout.write(`\u2713 current -> releases/${target}
-`);
-    const newPrior = {
-      version: manifest.version,
-      commit: manifest.commit,
-      activatedAt: manifest.activatedAt,
-      packageLockHash: manifest.packageLockHash
-    };
-    const remainingPriors = manifest.priorReleases.filter((r) => r.version !== target);
-    await writeManifest(paths.manifest, {
-      ...manifest,
-      version: target,
-      commit: targetRecord?.commit ?? null,
-      packageLockHash: targetRecord?.packageLockHash ?? null,
-      activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      priorReleases: [newPrior, ...remainingPriors]
+    const brokenDir = join7(paths.home, "app.broken");
+    rmSync2(brokenDir, { recursive: true, force: true });
+    renameSync3(paths.app, brokenDir);
+    renameSync3(paths.appPrev, paths.app);
+    rmSync2(brokenDir, { recursive: true, force: true });
+    process.stdout.write(`\u2713 rolled back: app.prev/ \u2192 app/
+`);
+    if (manifest.previousVersion) {
+      await writeManifest(paths.manifest, {
+        ...manifest,
+        version: manifest.previousVersion,
+        commit: manifest.previousCommit,
+        activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        previousVersion: manifest.version,
+        previousCommit: manifest.commit
+      });
+      process.stdout.write(`\u2713 manifest: ${manifest.version} \u2192 ${manifest.previousVersion}
+`);
+    }
+    const restartTs = Date.now();
+    const { restart: restart2 } = await import("./abtars-restart.js");
+    process.stdout.write(`\u267B\uFE0F Restarting bridge...
+`);
+    await restart2({ cold: true }).catch(() => {
     });
-    process.stdout.write(`\u2713 manifest updated
+    const health = await healthProbe(paths.home, restartTs, 6e4);
+    if (health.healthy) {
+      process.stdout.write(`\u2713 Bridge healthy (PID ${health.pid})
 `);
+    } else {
+      process.stderr.write(`\u26A0\uFE0F Bridge may not have started. Check logs.
+`);
+    }
     process.stdout.write(`
-Rollback complete: ${target}
+Rollback complete.
 `);
-    void emptyManifest;
-    void hostname;
     return 0;
   } finally {
     await release();
@@ -1229,13 +1208,12 @@ Rollback complete: ${target}
 }
 
 // src/cli/commands/status.ts
+import { existsSync as existsSync6 } from "node:fs";
 import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 async function status() {
   const paths = packagePaths("abtars");
   const manifest = await readManifest(paths.manifest);
-  const current = await readCurrent(paths.current);
-  const lock = await inspectLock(paths.lock);
   if (!manifest) {
     process.stdout.write(
       `abtars: not installed (no manifest at ${paths.manifest})
@@ -1244,6 +1222,8 @@ Run 'abtars install' to set up.
     );
     return 1;
   }
+  const appExists = existsSync6(paths.app);
+  const appPrevExists = existsSync6(paths.appPrev);
   const lines = [
     `abtars status`,
     `  home:          ${paths.home}`,
@@ -1253,68 +1233,62 @@ Run 'abtars install' to set up.
     `  source:        ${manifest.source}`,
     `  mode:          ${manifest.installMode ?? "supervised"}`,
     `  activated:     ${manifest.activatedAt}`,
-    `  current ->:    ${current ?? "(missing)"}`,
-    `  host:          ${manifest.host}`,
-    `  prior:         ${manifest.priorReleases.length > 0 ? manifest.priorReleases.map((r) => r.version).join(", ") : "(none)"}`
+    `  app/:          ${appExists ? "\u2713 present" : "\u2717 missing"}`,
+    `  app.prev/:     ${appPrevExists ? "\u2713 present" : "\u25CB none"}`,
+    `  previous:      ${manifest.previousVersion ?? "(none)"}`,
+    `  host:          ${manifest.host}`
   ];
-  if (lock.held) {
-    const alive = (() => {
-      try {
-        process.kill(lock.content.pid, 0);
-        return true;
-      } catch {
-        return false;
-      }
-    })();
-    lines.push(
-      `  bridge:        ${alive ? "\u25CF running" : "\u2717 dead"} (pid ${lock.content.pid})${lock.stale ? " \u2014 STALE" : ""}`
-    );
-  } else {
-    try {
-      const bridgeLock = JSON.parse(readFileSync3(join7(paths.home, "bridge.lock"), "utf-8"));
-      if (bridgeLock.pid) {
-        const alive = (() => {
-          try {
-            process.kill(bridgeLock.pid, 0);
-            return true;
-          } catch {
-            return false;
-          }
-        })();
-        lines.push(`  bridge:        ${alive ? "\u25CF running" : "\u2717 dead"} (pid ${bridgeLock.pid})`);
-      } else {
-        lines.push(`  bridge:        \u25CB stopped`);
-      }
-    } catch {
+  try {
+    const bridgeLock = JSON.parse(readFileSync3(join8(paths.home, "bridge.lock"), "utf-8"));
+    if (bridgeLock.pid) {
+      const alive = (() => {
+        try {
+          process.kill(bridgeLock.pid, 0);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+      lines.push(`  bridge:        ${alive ? "\u25CF running" : "\u2717 dead"} (pid ${bridgeLock.pid})`);
+    } else {
       lines.push(`  bridge:        \u25CB stopped`);
     }
+  } catch {
+    lines.push(`  bridge:        \u25CB stopped`);
   }
   process.stdout.write(`${lines.join("\n")}
 `);
-  if (current !== null && manifest.version !== "" && current !== manifest.version) {
-    process.stderr.write(
-      `
-Warning: current symlink points at '${current}' but manifest says '${manifest.version}'.
-Re-run 'abtars update' or 'abtars rollback' to reconcile.
-`
-    );
+  const sentinel = readSentinel(paths.home);
+  if (sentinel?.status === "pending") {
+    const age = Date.now() - new Date(sentinel.startedAt).getTime();
+    if (age > 5 * 6e4) {
+      process.stderr.write(`
+\u26A0\uFE0F Last update (${sentinel.version}) may have failed \u2014 bridge never confirmed boot.
+`);
+      return 1;
+    }
+  }
+  if (!appExists) {
+    process.stderr.write(`
+\u26A0\uFE0F app/ directory missing. Run 'abtars update' to deploy.
+`);
     return 1;
   }
   return 0;
 }
 
 // src/cli/commands/update.ts
-init_log_and_swallow();
-import { hostname as hostname2 } from "node:os";
-import { join as join10, dirname as dirname3 } from "node:path";
-import { readFileSync as readFileSync5, existsSync as existsSync7 } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir4, chmod, readdir, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join as join11 } from "node:path";
+import { readFileSync as readFileSync5, existsSync as existsSync9 } from "node:fs";
+import { copyFile as copyFile2, mkdir as mkdir4, chmod, readdir } from "node:fs/promises";
+import { rmSync as rmSync3, cpSync, readdirSync as readdirSync3, mkdirSync as mkdirSync2 } from "node:fs";
 
 // src/cli/update-sources/local.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { copyFile, cp, mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var LocalBuildError = class extends Error {
   constructor(message, hint) {
     super(hint ? `${message}
@@ -1376,7 +1350,7 @@ ${upstream} is ahead by ${behind} commit${behind === 1 ? "" : "s"}.`,
   return { commit, branch };
 }
 async function readPackageVersion(repoRoot) {
-  const pkg = JSON.parse(await readFile2(join8(repoRoot, "package.json"), "utf-8"));
+  const pkg = JSON.parse(await readFile2(join9(repoRoot, "package.json"), "utf-8"));
   if (typeof pkg.version !== "string") {
     throw new LocalBuildError("package.json has no version field.");
   }
@@ -1384,30 +1358,30 @@ async function readPackageVersion(repoRoot) {
 }
 function makeLocalBuildSource(opts = {}) {
   const repoRoot = opts.repoRoot ?? process.cwd();
-  const isNpmPackage = !existsSync5(join8(repoRoot, ".git"));
+  const isNpmPackage = !existsSync7(join9(repoRoot, ".git"));
   return {
     name: "local",
     async prepare(ctx) {
       if (isNpmPackage) {
-        const bundleDir = join8(repoRoot, "bundle");
-        if (!existsSync5(bundleDir)) {
+        const bundleDir = join9(repoRoot, "bundle");
+        if (!existsSync7(bundleDir)) {
           throw new Error(`No bundle/ found at ${repoRoot}. Run from the abtars npm package or a git checkout.`);
         }
         const pkgVersion2 = await readPackageVersion(repoRoot);
         const version2 = pkgVersion2;
-        const stagedPath2 = join8(ctx.releasesDir, version2);
+        const stagedPath2 = ctx.stagingDir;
         await rm(stagedPath2, { recursive: true, force: true });
         await mkdir2(stagedPath2, { recursive: true });
-        await cp(bundleDir, join8(stagedPath2, "bundle"), { recursive: true });
-        const coreDir = join8(repoRoot, "core");
-        if (existsSync5(coreDir)) await cp(coreDir, join8(stagedPath2, "core"), { recursive: true });
-        const scriptsSrc = join8(repoRoot, "scripts");
-        if (existsSync5(scriptsSrc)) await cp(scriptsSrc, join8(stagedPath2, "scripts"), { recursive: true });
-        const configSrc = join8(repoRoot, "config");
-        if (existsSync5(configSrc)) await cp(configSrc, join8(stagedPath2, "config"), { recursive: true });
-        const manifestSrc = join8(repoRoot, "install-manifest.json");
-        if (existsSync5(manifestSrc)) await copyFile(manifestSrc, join8(stagedPath2, "install-manifest.json"));
-        await writeFile2(join8(stagedPath2, "package.json"), JSON.stringify({ type: "module", name: "abtars", version: version2 }, null, 2) + "\n");
+        await cp(bundleDir, join9(stagedPath2, "bundle"), { recursive: true });
+        const coreDir = join9(repoRoot, "core");
+        if (existsSync7(coreDir)) await cp(coreDir, join9(stagedPath2, "core"), { recursive: true });
+        const scriptsSrc = join9(repoRoot, "scripts");
+        if (existsSync7(scriptsSrc)) await cp(scriptsSrc, join9(stagedPath2, "scripts"), { recursive: true });
+        const configSrc = join9(repoRoot, "config");
+        if (existsSync7(configSrc)) await cp(configSrc, join9(stagedPath2, "config"), { recursive: true });
+        const manifestSrc = join9(repoRoot, "install-manifest.json");
+        if (existsSync7(manifestSrc)) await copyFile(manifestSrc, join9(stagedPath2, "install-manifest.json"));
+        await writeFile2(join9(stagedPath2, "package.json"), JSON.stringify({ type: "module", name: "abtars", version: version2 }, null, 2) + "\n");
         process.stdout.write(`\u2713 staged ${version2} (from npm package)
 `);
         return { version: version2, stagedPath: stagedPath2, commit: null, branch: null, packageLockHash: null, source: "local" };
@@ -1418,42 +1392,18 @@ function makeLocalBuildSource(opts = {}) {
       if (opts.skipInstall !== true) {
         runCmd("npm", ["install", "--no-audit", "--no-fund"], repoRoot);
       }
-      const useBundle = process.env["AGENTBRIDGE_BUILD_MODE"] !== "tsc";
-      if (useBundle) {
-        runCmd("npm", ["run", "bundle"], repoRoot);
-        const stagedPath2 = join8(ctx.releasesDir, version);
-        await rm(stagedPath2, { recursive: true, force: true });
-        await mkdir2(stagedPath2, { recursive: true });
-        await cp(join8(repoRoot, "bundle"), join8(stagedPath2, "bundle"), { recursive: true });
-        const coreSkillsSrc = join8(repoRoot, "core", "skills");
-        if (existsSync5(coreSkillsSrc)) {
-          await cp(coreSkillsSrc, join8(stagedPath2, "core", "skills"), { recursive: true });
-        }
-        await writeFile2(join8(stagedPath2, "package.json"), JSON.stringify({ type: "module", name: "abtars", version }, null, 2) + "\n");
-        await copyFile(join8(repoRoot, "install-manifest.json"), join8(stagedPath2, "install-manifest.json"));
-        const packageLockHash2 = await hashFile(join8(repoRoot, "package-lock.json"));
-        return { version, stagedPath: stagedPath2, commit, branch, packageLockHash: packageLockHash2, source: "local" };
-      }
-      runCmd("npm", ["run", "build"], repoRoot);
-      const stagedPath = join8(ctx.releasesDir, version);
+      runCmd("npm", ["run", "bundle"], repoRoot);
+      const stagedPath = ctx.stagingDir;
       await rm(stagedPath, { recursive: true, force: true });
       await mkdir2(stagedPath, { recursive: true });
-      await cp(join8(repoRoot, "dist"), join8(stagedPath, "dist"), { recursive: true });
-      await copyFile(join8(repoRoot, "install-manifest.json"), join8(stagedPath, "install-manifest.json"));
-      await rm(ctx.nodeModulesDir, { recursive: true, force: true });
-      await mkdir2(ctx.nodeModulesDir, { recursive: true });
-      const rsyncResult = spawnSync2(
-        "rsync",
-        ["-aL", "--quiet", `${join8(repoRoot, "node_modules")}/`, `${ctx.nodeModulesDir}/`],
-        { stdio: "inherit" }
-      );
-      if (rsyncResult.status !== 0) {
-        throw new LocalBuildError(
-          `rsync of node_modules failed (status ${rsyncResult.status ?? -1})`,
-          `Ensure rsync is installed. Falling back to node cp would re-create symlinks.`
-        );
+      await cp(join9(repoRoot, "bundle"), join9(stagedPath, "bundle"), { recursive: true });
+      const coreSkillsSrc = join9(repoRoot, "core", "skills");
+      if (existsSync7(coreSkillsSrc)) {
+        await cp(coreSkillsSrc, join9(stagedPath, "core", "skills"), { recursive: true });
       }
-      const packageLockHash = await hashFile(join8(repoRoot, "package-lock.json"));
+      await writeFile2(join9(stagedPath, "package.json"), JSON.stringify({ type: "module", name: "abtars", version }, null, 2) + "\n");
+      await copyFile(join9(repoRoot, "install-manifest.json"), join9(stagedPath, "install-manifest.json"));
+      const packageLockHash = await hashFile(join9(repoRoot, "package-lock.json"));
       return { version, stagedPath, commit, branch, packageLockHash, source: "local" };
     }
   };
@@ -1461,9 +1411,9 @@ function makeLocalBuildSource(opts = {}) {
 
 // src/cli/update-sources/npm.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync4, unlinkSync as unlinkSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4, unlinkSync as unlinkSync4 } from "node:fs";
 import { mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var TIMEOUT_MS = 6e4;
 function run(cmd, args, cwd) {
   const r = spawnSync3(cmd, args, { cwd, encoding: "utf-8", timeout: TIMEOUT_MS });
@@ -1473,7 +1423,7 @@ function run(cmd, args, cwd) {
 }
 function readLocalVersion(home) {
   try {
-    const pkg = JSON.parse(readFileSync4(join9(home, "current", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync4(join10(home, "app", "package.json"), "utf-8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -1488,14 +1438,14 @@ function makeNpmSource(packageName) {
       if (latest === current) {
         throw new Error(`Already at latest version (${latest}). Nothing to update.`);
       }
-      const stagedPath = join9(ctx.releasesDir, latest);
+      const stagedPath = ctx.stagingDir;
       await rm2(stagedPath, { recursive: true, force: true });
       await mkdir3(stagedPath, { recursive: true });
       run("npm", ["pack", `${packageName}@${latest}`, "--pack-destination", stagedPath], stagedPath);
       const tgzName = `${packageName}-${latest}.tgz`.replace("@", "").replace("/", "-");
-      const tgzPath = join9(stagedPath, tgzName);
+      const tgzPath = join10(stagedPath, tgzName);
       run("tar", ["-xzf", tgzPath, "--strip-components=1"], stagedPath);
-      if (existsSync6(tgzPath)) unlinkSync4(tgzPath);
+      if (existsSync8(tgzPath)) unlinkSync4(tgzPath);
       run("npm", ["install", "--omit=dev", "--no-audit", "--no-fund"], stagedPath);
       return { version: latest, stagedPath, commit: null, branch: null, packageLockHash: null, source: "npm" };
     }
@@ -1518,37 +1468,65 @@ Use --source local (default) or --source npm.
     return 2;
   }
   const paths = packagePaths("abtars");
+  const sentinel = readSentinel(paths.home);
+  if (sentinel?.status === "pending") {
+    const age = Date.now() - new Date(sentinel.startedAt).getTime();
+    if (age > 5 * 6e4) {
+      process.stderr.write(`\u26A0\uFE0F Previous update (${sentinel.version}) never completed successfully. Proceeding...
+`);
+    }
+  }
+  if (opts.check) {
+    return checkForUpdates(paths.home, opts);
+  }
   const release = await acquireLock(paths.lock, `update --source ${opts.source}`);
   try {
+    cleanStaleStaging(paths.appStaging);
+    const cleanupHandler = () => {
+      if (existsSync9(paths.appStaging) && existsSync9(paths.app)) {
+        rmSync3(paths.appStaging, { recursive: true, force: true });
+      }
+    };
+    process.on("SIGHUP", () => {
+      cleanupHandler();
+      process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+      cleanupHandler();
+      process.exit(143);
+    });
     let repoRoot = opts.repoRoot ?? process.cwd();
-    if (!opts.repoRoot && !existsSync7(join10(repoRoot, ".git"))) {
+    if (!opts.repoRoot && !existsSync9(join11(repoRoot, ".git"))) {
       const { realpathSync } = await import("node:fs");
       const scriptPath = realpathSync(process.argv[1] ?? "");
-      const candidate = join10(dirname3(scriptPath), "..");
-      if (existsSync7(join10(candidate, "bundle"))) repoRoot = candidate;
+      const { dirname: dirname3 } = await import("node:path");
+      const candidate = join11(dirname3(scriptPath), "..");
+      if (existsSync9(join11(candidate, "bundle"))) repoRoot = candidate;
     }
     const source = opts.source === "npm" ? makeNpmSource("abtars") : makeLocalBuildSource({ repoRoot, allowStale: opts.fromLocal });
     if (opts.fromLocal) {
       showHintOnce("update-from-local", "Building from working copy (--from-local). To sync with remote first: git pull && abtars update");
     }
-    process.stdout.write(`Building from local checkout (${process.cwd()})...
+    if (opts.dryRun) {
+      return printDryRun(paths, repoRoot, opts);
+    }
+    process.stdout.write(`Building from local checkout (${repoRoot})...
 `);
     const staged = await source.prepare({
-      releasesDir: paths.releases,
-      nodeModulesDir: paths.nodeModules,
+      stagingDir: paths.appStaging,
       home: paths.home,
       allowStale: opts.fromLocal
     });
-    process.stdout.write(`\u2713 staged ${staged.version} at ${staged.stagedPath}
+    process.stdout.write(`\u2713 staged ${staged.version}
 `);
     {
-      const pkgPath = join10(staged.stagedPath, "package.json");
-      const { readFileSync: readFileSync6, writeFileSync: writeFileSync2 } = await import("node:fs");
+      const pkgPath = join11(staged.stagedPath, "package.json");
       try {
-        const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         const externals = { patchright: "^1.59.4", "rettiwt-api": "^4.1.3" };
         pkg.dependencies = { ...pkg.dependencies, ...externals };
         if (pkg.dependencies?.abmind?.startsWith("file:")) delete pkg.dependencies.abmind;
+        const { writeFileSync: writeFileSync2 } = await import("node:fs");
         writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
         const { execSync } = await import("node:child_process");
         execSync("npm install --omit=dev --ignore-scripts 2>/dev/null", { cwd: staged.stagedPath, timeout: 6e4 });
@@ -1559,283 +1537,291 @@ Use --source local (default) or --source npm.
 `);
       }
     }
-    {
-      const { existsSync: existsSync8, unlinkSync: unlinkSync5, symlinkSync } = await import("node:fs");
-      const mainLink = join10(staged.stagedPath, "main.js");
-      try {
-        unlinkSync5(mainLink);
-      } catch (err) {
-        logAndSwallow("update", "op", err);
-      }
-      const entry = existsSync8(join10(staged.stagedPath, "bundle", "abtars.js")) ? "bundle/abtars.js" : "dist/main.js";
-      symlinkSync(entry, mainLink);
-    }
-    const { existsSync: ex2, symlinkSync: sl2, mkdirSync: mk2, unlinkSync: ul2 } = await import("node:fs");
-    const { dirname: dn2 } = await import("node:path");
-    await activate(paths.current, staged.version);
-    process.stdout.write(`\u2713 current -> releases/${staged.version}
-`);
-    const globalModules = join10(dn2(process.execPath), "..", "lib", "node_modules");
-    const abmindHome = process.env["ABMIND_HOME"] ?? join10(process.env["HOME"] ?? "", ".abmind");
-    const links = [];
-    const globalAbmind = join10(globalModules, "abmind");
-    const homeAbmind = join10(process.env["HOME"] ?? "", "abmind");
-    const localAbmind = join10(paths.home, "current", "node_modules", "abmind");
-    if (ex2(globalAbmind)) links.push({ name: "abmind", target: globalAbmind });
-    else if (ex2(homeAbmind)) links.push({ name: "abmind", target: homeAbmind });
-    else if (ex2(localAbmind)) links.push({ name: "abmind", target: localAbmind });
-    const bsq3 = join10(abmindHome, "lib", "node_modules", "better-sqlite3");
-    if (ex2(bsq3)) links.push({ name: "better-sqlite3", target: bsq3 });
-    if (links.length > 0) {
-      const bundleNm = join10(paths.home, "current", "bundle", "node_modules");
-      const rootNm = join10(paths.home, "current", "node_modules");
-      for (const dir of [bundleNm, rootNm]) {
-        mk2(dir, { recursive: true });
-        for (const { name, target } of links) {
-          const dest = join10(dir, name);
-          try {
-            if (ex2(dest)) ul2(dest);
-          } catch {
-          }
-          try {
-            sl2(target, dest);
-          } catch {
-          }
-        }
-      }
+    await copyAbmind(staged.stagedPath, repoRoot);
+    const entryPoint = join11(staged.stagedPath, "bundle", "abtars.js");
+    if (!existsSync9(entryPoint)) {
+      process.stderr.write(`\u274C Entry point not found: ${entryPoint}
+`);
+      return 1;
     }
+    configSnapshot(paths.config);
+    process.stdout.write(`\u2713 config snapshot (3-slot rotation)
+`);
+    atomicSwap(paths.app, paths.appPrev, paths.appStaging);
+    process.stdout.write(`\u2713 atomic swap: app.staging/ \u2192 app/
+`);
+    await postSwapHousekeeping(paths, repoRoot, staged);
     const prior = await readManifest(paths.manifest);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const newPriorReleases = prior?.version ? [
-      {
-        version: prior.version,
-        commit: prior.commit,
-        activatedAt: prior.activatedAt,
-        packageLockHash: prior.packageLockHash
-      },
-      ...prior.priorReleases ?? []
-    ].slice(0, RETENTION - 1) : prior?.priorReleases ?? [];
+    const sentinelData = {
+      version: staged.version,
+      previousVersion: prior?.version ?? null,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending"
+    };
+    writeSentinel(paths.home, sentinelData);
     await writeManifest(paths.manifest, {
-      ...prior ?? emptyManifest("abtars", hostname2()),
+      ...prior ?? emptyManifest("abtars", hostname()),
       version: staged.version,
       commit: staged.commit,
       branch: staged.branch,
       packageLockHash: staged.packageLockHash,
-      activatedAt: now,
+      activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       source: "local",
-      priorReleases: newPriorReleases
+      previousVersion: prior?.version ?? null,
+      previousCommit: prior?.commit ?? null
     });
     process.stdout.write(`\u2713 manifest updated
 `);
-    const pruned = await pruneReleases(
-      paths.releases,
-      [staged.version, ...newPriorReleases.map((r) => r.version)],
-      staged.version,
-      RETENTION
-    );
-    if (pruned.length > 0) {
-      process.stdout.write(`\u2713 pruned ${pruned.length} old release${pruned.length === 1 ? "" : "s"}: ${pruned.join(", ")}
+    const restartTimestamp = Date.now();
+    const restarted = await restartBridge(paths);
+    if (!restarted) {
+      process.stdout.write(`\u26A0\uFE0F Could not restart bridge. Start manually.
 `);
+      return 0;
     }
-    process.stdout.write(`
-Update complete: ${staged.version}
+    process.stdout.write(`Waiting for bridge health...
 `);
-    const transportJson = join10(paths.home, "config", "transport.json");
-    if (existsSync7(transportJson)) {
-      try {
-        const tc = JSON.parse(readFileSync5(transportJson, "utf-8"));
-        let cleared = false;
-        for (const agent of Object.values(tc.agents ?? {})) {
-          if (agent.demoted) {
-            delete agent.demoted;
-            delete agent.demotedReason;
-            delete agent.demotedModel;
-            cleared = true;
-          }
-          for (const fb of agent.fallbacks ?? []) {
-            if (fb.demoted) {
-              delete fb.demoted;
-              delete fb.demotedReason;
-              delete fb.demotedModel;
-              cleared = true;
-            }
-          }
-        }
-        if (cleared) {
-          const { writeFileSync: wfs } = await import("node:fs");
-          wfs(transportJson, JSON.stringify(tc, null, 2) + "\n");
-        }
-      } catch {
-      }
-    }
-    const installManifestPath = join10(repoRoot, "install-manifest.json");
-    const installManifest = JSON.parse(await readFile3(installManifestPath, "utf-8"));
-    const repoScripts = join10(repoRoot, "scripts");
-    const destScripts = join10(paths.home, "scripts");
-    await mkdir4(destScripts, { recursive: true });
-    const allScriptFiles = await readdir(repoScripts).catch(() => []);
-    const matchesInclude = (name) => installManifest.scripts.include.some((pattern) => {
-      const ext = pattern.replace("*", "");
-      return name.endsWith(ext);
-    });
-    const scriptFiles = allScriptFiles.filter(matchesInclude);
-    const home = process.env["HOME"] ?? "";
-    let serviceChanged = false;
-    const installMode = (await readManifest(paths.manifest))?.installMode ?? "supervised";
-    const isExecutable = (name) => {
-      const ext = installManifest.scripts.executable.replace("*", "");
-      return name.endsWith(ext);
-    };
-    for (const name of scriptFiles) {
-      await copyFile2(join10(repoScripts, name), join10(destScripts, name));
-      if (isExecutable(name)) await chmod(join10(destScripts, name), 493);
-      const macService = installManifest.services.supervised.macos;
-      if (macService && name === macService.plist && process.platform === "darwin" && home && installMode === "supervised") {
-        const launchAgentsDir = join10(home, "Library", "LaunchAgents");
-        await mkdir4(launchAgentsDir, { recursive: true });
-        const dst = join10(launchAgentsDir, name);
-        const oldContent = await readFile3(dst, "utf-8").catch(() => "");
-        let templated = await readFile3(join10(repoScripts, name), "utf-8");
-        for (const ph of macService.placeholders) templated = templated.replaceAll(ph, home);
-        await writeFile3(dst, templated);
-        if (oldContent !== templated) serviceChanged = true;
-      }
-      const linuxService = installManifest.services.supervised.linux;
-      if (linuxService?.units.includes(name) && process.platform === "linux" && home && installMode === "supervised") {
-        const systemdDir = join10(home, ".config", "systemd", "user");
-        await mkdir4(systemdDir, { recursive: true });
-        const dst = join10(systemdDir, name);
-        const oldContent = await readFile3(dst, "utf-8").catch(() => "");
-        await copyFile2(join10(repoScripts, name), dst);
-        const newContent = await readFile3(dst, "utf-8").catch(() => "");
-        if (oldContent !== newContent) serviceChanged = true;
-      }
+    const health = await healthProbe(paths.home, restartTimestamp, 6e4);
+    if (health.healthy) {
+      writeSentinel(paths.home, { ...sentinelData, status: "success" });
+      process.stdout.write(`\u2713 Bridge healthy (PID ${health.pid}, tick at ${new Date(health.heartbeat).toISOString()})
+`);
+      return 0;
     }
-    process.stdout.write(`\u2713 scripts refreshed (${scriptFiles.length} files)
+    process.stderr.write(`\u274C Bridge unhealthy after 60s. Auto-rolling back...
+`);
+    if (!existsSync9(paths.appPrev)) {
+      process.stderr.write(`\u274C No app.prev/ to roll back to. Manual intervention required.
+`);
+      process.stderr.write(`   Check: ~/.abtars/logs/bridge.log
 `);
-    const { writeWrapper } = await import("./install-GEXWJYJC.js");
-    await mkdir4(paths.bin, { recursive: true });
-    for (const name of installManifest.cliWrappers) {
-      await writeWrapper(paths.bin, name, paths.current, false);
+      return 2;
     }
-    process.stdout.write(`\u2713 wrappers refreshed (${installManifest.cliWrappers.length} files)
-`);
-    const { rmSync: rmSync2, cpSync, readdirSync: readdirSync3 } = await import("node:fs");
-    const skillsCoreSrc = join10(staged.stagedPath, "core", "skills");
-    const skillsCoreDst = join10(paths.home, "skills", "core");
-    if (existsSync7(skillsCoreSrc)) {
-      rmSync2(skillsCoreDst, { recursive: true, force: true });
-      cpSync(skillsCoreSrc, skillsCoreDst, { recursive: true });
-      const files = readdirSync3(skillsCoreDst, { recursive: true });
-      const count = files.filter((f) => f.endsWith("SKILL.md")).length;
-      process.stdout.write(`\u2713 skills/core synced (${count} skills)
+    const brokenDir = join11(paths.home, "app.broken");
+    rmSync3(brokenDir, { recursive: true, force: true });
+    const { renameSync: renameSync4 } = await import("node:fs");
+    renameSync4(paths.app, brokenDir);
+    renameSync4(paths.appPrev, paths.app);
+    if (prior) {
+      await writeManifest(paths.manifest, prior);
+    }
+    const rollbackTs = Date.now();
+    await restartBridge(paths);
+    const rollbackHealth = await healthProbe(paths.home, rollbackTs, 3e4);
+    if (rollbackHealth.healthy) {
+      process.stderr.write(`\u26A0\uFE0F Rolled back to previous version. Investigate ${brokenDir} for the failure.
 `);
+      rmSync3(brokenDir, { recursive: true, force: true });
+      return 1;
     }
-    for (const d of ["custom", "downloaded", "self"]) {
-      await mkdir4(join10(paths.home, "skills", d), { recursive: true });
+    process.stderr.write(`\u274C Rollback also failed. Manual intervention required.
+`);
+    process.stderr.write(`   Check: ~/.abtars/logs/bridge.log
+`);
+    process.stderr.write(`   Broken version preserved at: ${brokenDir}
+`);
+    return 2;
+  } finally {
+    await release();
+  }
+}
+async function copyAbmind(stagedPath, repoRoot) {
+  const candidates = [
+    process.env["ABMIND_REPO"],
+    join11(repoRoot, "..", "abmind"),
+    join11(process.env["HOME"] ?? "", "abmind")
+  ].filter(Boolean);
+  for (const src of candidates) {
+    const distDir = join11(src, "dist");
+    if (existsSync9(distDir)) {
+      const dest = join11(stagedPath, "node_modules", "abmind");
+      mkdirSync2(dest, { recursive: true });
+      cpSync(distDir, join11(dest, "dist"), { recursive: true });
+      if (existsSync9(join11(src, "package.json"))) cpSync(join11(src, "package.json"), join11(dest, "package.json"));
+      if (existsSync9(join11(src, "prompts"))) cpSync(join11(src, "prompts"), join11(dest, "prompts"), { recursive: true });
+      process.stdout.write(`\u2713 abmind copied from ${src}
+`);
+      return;
     }
-    for (const stale of ["memory", "ops", "tools", "coding"]) {
-      const p = join10(paths.home, "skills", stale);
-      if (existsSync7(p)) {
-        rmSync2(p, { recursive: true, force: true });
+  }
+  process.stdout.write(`\u26A0 abmind source not found (checked: ${candidates.join(", ")}). Bridge may fail to start.
+`);
+}
+async function postSwapHousekeeping(paths, repoRoot, _staged) {
+  const { loadManifest } = await import("./install-manifest-QRWID3KZ.js");
+  const installManifest = loadManifest(paths.app);
+  const repoScripts = join11(repoRoot, "scripts");
+  const destScripts = join11(paths.home, "scripts");
+  await mkdir4(destScripts, { recursive: true });
+  const allScriptFiles = await readdir(repoScripts).catch(() => []);
+  const matchesInclude = (name) => installManifest.scripts.include.some((pattern) => name.endsWith(pattern.replace("*", "")));
+  const scriptFiles = allScriptFiles.filter(matchesInclude);
+  const isExecutable = (name) => name.endsWith(installManifest.scripts.executable.replace("*", ""));
+  for (const name of scriptFiles) {
+    await copyFile2(join11(repoScripts, name), join11(destScripts, name));
+    if (isExecutable(name)) await chmod(join11(destScripts, name), 493);
+  }
+  process.stdout.write(`\u2713 scripts refreshed (${scriptFiles.length} files)
+`);
+  const { writeWrapper } = await import("./install-SH4UVUXQ.js");
+  await mkdir4(paths.bin, { recursive: true });
+  for (const name of installManifest.cliWrappers) {
+    await writeWrapper(paths.bin, name, paths.app, false);
+  }
+  process.stdout.write(`\u2713 wrappers refreshed (${installManifest.cliWrappers.length} files)
+`);
+  const skillsCoreSrc = join11(paths.app, "core", "skills");
+  const skillsCoreDst = join11(paths.home, "skills", "core");
+  if (existsSync9(skillsCoreSrc)) {
+    rmSync3(skillsCoreDst, { recursive: true, force: true });
+    cpSync(skillsCoreSrc, skillsCoreDst, { recursive: true });
+    const files = readdirSync3(skillsCoreDst, { recursive: true });
+    const count = files.filter((f) => f.endsWith("SKILL.md")).length;
+    process.stdout.write(`\u2713 skills/core synced (${count} skills)
+`);
+  }
+  for (const d of ["custom", "downloaded", "self"]) {
+    await mkdir4(join11(paths.home, "skills", d), { recursive: true });
+  }
+  const releaseConfig = join11(paths.app, "config");
+  const destConfig = join11(paths.home, "config");
+  if (existsSync9(releaseConfig)) {
+    for (const f of readdirSync3(releaseConfig)) {
+      const src = join11(releaseConfig, f);
+      if (f.endsWith(".example")) {
+        cpSync(src, join11(destConfig, f));
+        const target = join11(destConfig, f.replace(".example", ""));
+        if (!existsSync9(target)) cpSync(src, target);
       }
     }
-    const releaseConfig = join10(staged.stagedPath, "config");
-    const destConfig = join10(paths.home, "config");
-    if (existsSync7(releaseConfig)) {
-      for (const f of readdirSync3(releaseConfig)) {
-        const src = join10(releaseConfig, f);
-        if (f.endsWith(".example")) {
-          cpSync(src, join10(destConfig, f));
-          const target = join10(destConfig, f.replace(".example", ""));
-          if (!existsSync7(target)) cpSync(src, target);
+    const defaultTransport = join11(releaseConfig, "transport.default.json");
+    if (existsSync9(defaultTransport)) cpSync(defaultTransport, join11(destConfig, "transport.default.json"));
+  }
+  const transportJson = join11(paths.home, "config", "transport.json");
+  if (existsSync9(transportJson)) {
+    try {
+      const tc = JSON.parse(readFileSync5(transportJson, "utf-8"));
+      let cleared = false;
+      for (const agent of Object.values(tc.agents ?? {})) {
+        if (agent.demoted) {
+          delete agent.demoted;
+          delete agent.demotedReason;
+          delete agent.demotedModel;
+          cleared = true;
+        }
+        for (const fb of agent.fallbacks ?? []) {
+          if (fb.demoted) {
+            delete fb.demoted;
+            delete fb.demotedReason;
+            delete fb.demotedModel;
+            cleared = true;
+          }
         }
       }
-      const defaultTransport = join10(releaseConfig, "transport.default.json");
-      if (existsSync7(defaultTransport)) cpSync(defaultTransport, join10(destConfig, "transport.default.json"));
-    }
-    const coreSrc = join10(staged.stagedPath, "core");
-    const coreDst = join10(paths.home, "core");
-    if (existsSync7(coreSrc)) {
-      await mkdir4(coreDst, { recursive: true });
-      cpSync(coreSrc, coreDst, { recursive: true });
-    }
-    if (serviceChanged) {
-      if (process.platform === "darwin") {
-        process.stdout.write(`\u26A0\uFE0F  LaunchAgent plist updated \u2014 reload with: launchctl bootout gui/$(id -u)/com.abtars.watchdog && launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.abtars.watchdog.plist
-`);
-      } else {
-        process.stdout.write(`\u26A0\uFE0F  systemd service updated \u2014 reload with: systemctl --user daemon-reload && systemctl --user restart abtars-watchdog
-`);
+      if (cleared) {
+        const { writeFileSync: writeFileSync2 } = await import("node:fs");
+        writeFileSync2(transportJson, JSON.stringify(tc, null, 2) + "\n");
       }
+    } catch {
     }
-    void hashFile;
-    const { ensureInstallInvariants } = await import("./ensure-invariants-BJIEOSJ2.js");
-    const invariantResults = await ensureInstallInvariants(process.cwd(), paths.home);
-    if (invariantResults.length > 0) {
-      process.stdout.write(`\u2713 invariants: ${invariantResults.join(", ")}
+  }
+  const doctorPath = join11(paths.home, "scripts", "doctor.sh");
+  if (existsSync9(doctorPath)) {
+    process.stdout.write("\n\u{1FA7A} Health check...\n");
+    try {
+      const { execSync } = await import("node:child_process");
+      execSync(`bash "${doctorPath}" --fix`, { stdio: "inherit", timeout: 3e4 });
+    } catch (err) {
+      process.stderr.write(`\u26A0\uFE0F doctor --fix failed: ${err instanceof Error ? err.message : String(err)}
 `);
     }
-    const doctorPath = join10(paths.home, "scripts", "doctor.sh");
-    if (existsSync7(doctorPath)) {
-      process.stdout.write("\n\u{1FA7A} Health check...\n");
+  }
+  const { ensureInstallInvariants } = await import("./ensure-invariants-BJIEOSJ2.js");
+  const invariantResults = await ensureInstallInvariants(process.cwd(), paths.home);
+  if (invariantResults.length > 0) {
+    process.stdout.write(`\u2713 invariants: ${invariantResults.join(", ")}
+`);
+  }
+  void hashFile;
+}
+async function restartBridge(paths) {
+  const manifest = await readManifest(paths.manifest);
+  const mode = manifest?.installMode;
+  if (!mode) {
+    process.stderr.write("\u274C installMode not set in manifest.json. Run 'abtars install' first.\n");
+    return false;
+  }
+  if (mode === "supervised-daemon" || mode === "supervised") {
+    process.stdout.write("\n\u267B\uFE0F Restarting bridge via watchdog...\n");
+    const wdLock = join11(paths.home, "watchdog.lock");
+    const wdPid = readJsonField2(wdLock, "pid");
+    if (wdPid && wdPid > 0) {
       try {
-        const { execSync } = await import("node:child_process");
-        execSync(`bash "${doctorPath}" --fix`, { stdio: "inherit", timeout: 3e4 });
-      } catch (err) {
-        process.stderr.write(`\u26A0\uFE0F doctor --fix failed: ${err instanceof Error ? err.message : String(err)}
+        process.kill(wdPid, "SIGUSR1");
+        process.stdout.write(`  USR1 sent to watchdog (PID ${wdPid})
+`);
+        return true;
+      } catch {
+        process.stdout.write(`\u26A0\uFE0F Could not signal watchdog (PID ${wdPid}).
 `);
       }
     }
-    const manifestForRestart = await readManifest(paths.manifest);
-    const restartMode = manifestForRestart?.installMode;
-    if (!restartMode) {
-      process.stderr.write("\u274C installMode not set in manifest.json. Run 'abtars install' first.\n");
-      return 1;
-    }
-    if (restartMode === "supervised-daemon" || restartMode === "supervised") {
-      process.stdout.write("\nRestarting bridge via watchdog...\n");
-      const wdLock = join10(paths.home, "watchdog.lock");
-      const wdPid = readJsonField2(wdLock, "pid");
-      if (wdPid && wdPid > 0) {
-        try {
-          process.kill(wdPid, "SIGUSR1");
-          process.stdout.write(`\u267B\uFE0F USR1 sent to watchdog (PID ${wdPid}) \u2014 bridge will restart
+    const { restart: restart3 } = await import("./abtars-restart.js");
+    await restart3({ cold: true }).catch((err) => {
+      process.stderr.write(`\u26A0\uFE0F Restart failed: ${err instanceof Error ? err.message : String(err)}
 `);
-        } catch {
-          process.stdout.write(`\u26A0\uFE0F Could not signal watchdog (PID ${wdPid}). Restart manually:
-`);
-          if (process.platform === "darwin") {
-            process.stdout.write(`  launchctl kickstart -k gui/$(id -u)/com.abtars.watchdog
-`);
-          } else {
-            process.stdout.write(`  systemctl --user restart abtars-watchdog
+    });
+    return true;
+  }
+  process.stdout.write("\n\u267B\uFE0F Restarting bridge...\n");
+  const { restart: restart2 } = await import("./abtars-restart.js");
+  await restart2({ cold: true }).catch((err) => {
+    process.stderr.write(`\u26A0\uFE0F Restart failed: ${err instanceof Error ? err.message : String(err)}
 `);
-          }
-        }
-      } else {
-        process.stdout.write(`\u26A0\uFE0F Watchdog not running. Cold restart...
+  });
+  return true;
+}
+function printDryRun(paths, repoRoot, opts) {
+  const { spawnSync: spawnSync4 } = __require("node:child_process");
+  const commit = spawnSync4("git", ["rev-parse", "--short", "HEAD"], { cwd: repoRoot, encoding: "utf-8" }).stdout?.trim() ?? "?";
+  const branch = spawnSync4("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: repoRoot, encoding: "utf-8" }).stdout?.trim() ?? "?";
+  const wdLock = join11(paths.home, "watchdog.lock");
+  const wdPid = readJsonField2(wdLock, "pid");
+  process.stdout.write(`
+Dry run \u2014 no changes will be made.
+  Source:       ${opts.source} (commit ${commit} on ${branch})
+  Staging to:   ${paths.appStaging}
+  Swap:         app/ \u2192 app.prev/, app.staging/ \u2192 app/
+  Config snap:  config/ \u2192 config/.pre-update/ (3-slot rotation)
+  Restart:      ${wdPid ? `USR1 to watchdog (PID ${wdPid})` : "cold restart"}
+  Health:       poll bridge.lock for 60s
+  On failure:   auto-rollback (swap app/ \u2194 app.prev/)
 `);
-        const { restart: restart2 } = await import("./abtars-restart.js");
-        await restart2({ cold: true }).catch((err) => {
-          process.stderr.write(`\u26A0\uFE0F Restart failed: ${err instanceof Error ? err.message : String(err)}
+  return 0;
+}
+async function checkForUpdates(home, opts) {
+  const repoRoot = opts.repoRoot ?? process.cwd();
+  if (!existsSync9(join11(repoRoot, ".git"))) {
+    process.stderr.write("Not a git repository. --check requires a git checkout.\n");
+    return 2;
+  }
+  const { spawnSync: spawnSync4 } = await import("node:child_process");
+  spawnSync4("git", ["fetch", "--quiet"], { cwd: repoRoot });
+  const result = spawnSync4("git", ["rev-list", "--count", "HEAD..origin/dev"], { cwd: repoRoot, encoding: "utf-8" });
+  const ahead = parseInt(result.stdout?.trim() ?? "0", 10);
+  const manifest = await readManifest(join11(home, "manifest.json"));
+  process.stdout.write(`Current: ${manifest?.version ?? "unknown"} (deployed ${manifest?.activatedAt ?? "never"})
 `);
-        });
-      }
-    } else {
-      process.stdout.write("\nRestarting bridge...\n");
-      const { restart: restart2 } = await import("./abtars-restart.js");
-      await restart2({ cold: true }).catch((err) => {
-        process.stderr.write(`\u26A0\uFE0F Restart failed: ${err instanceof Error ? err.message : String(err)}
+  if (ahead === 0) {
+    process.stdout.write(`Remote:  up to date
 `);
-      });
-    }
-    const { printHealthSummary } = await import("./health-check-RJ2SUJYL.js");
-    printHealthSummary(paths.home);
     return 0;
-  } finally {
-    await release();
   }
+  process.stdout.write(`Remote:  dev is ${ahead} commit${ahead === 1 ? "" : "s"} ahead
+`);
+  process.stdout.write(`Action:  run 'abtars update' to apply
+`);
+  return 2;
 }
 
 // src/cli/abtars.ts
@@ -1905,9 +1891,7 @@ async function main(argv) {
           allowAbmindMismatch: flags.get("allow-abmind-mismatch") === true
         });
       case "rollback":
-        return await rollback({
-          to: typeof flags.get("to") === "string" ? flags.get("to") : void 0
-        });
+        return await rollback();
       case "backup":
         return await backup(typeof flags.get("output") === "string" ? flags.get("output") : void 0);
       case "restore": {