abtars 0.2.0 → 0.2.1-alpha.10

package/bundle/abtars-cli.js

@@ -2,24 +2,27 @@
  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-PPSB2ZIN.js";
+} from "./chunk-VREI2GUO.js";
+import {
+  rollback
+} from "./chunk-EZZBO2QK.js";
 import {
-  RETENTION,
   acquireLock,
-  activate,
+  atomicSwap,
+  cleanStaleStaging,
+  configSnapshot,
   emptyManifest,
   hashFile,
-  inspectLock,
+  healthProbe,
   packagePaths,
-  pruneReleases,
-  readCurrent,
   readManifest,
-  releaseExists,
-  writeManifest
-} from "./chunk-HXJRZWKA.js";
+  readSentinel,
+  writeManifest,
+  writeSentinel
+} from "./chunk-JRK3UFBS.js";
 import {
   restart
-} from "./chunk-XOCP5BMO.js";
+} from "./chunk-URAQLQ2U.js";
 import {
   init_log_and_swallow,
   logAndSwallow
@@ -301,122 +304,210 @@ async function uninstall(opts) {
 
 // src/cli/commands/backup.ts
 init_paths();
-import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, statSync, renameSync, unlinkSync as unlinkSync3, copyFileSync } from "node:fs";
-import { join as join4, dirname } from "node:path";
+import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, statSync, unlinkSync as unlinkSync3, renameSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join4, dirname, basename } from "node:path";
 import { spawnSync } from "node:child_process";
-var AB_SAVE = ["config", "secret", "tasks", "logo", "workspace", "skills/custom", "skills/self"];
+import { createCipheriv, hkdfSync, randomBytes } from "node:crypto";
 var DEFAULT_PRUNE_DAYS = 7;
-async function backup(outputDir, pruneDays) {
+var ABTARS_EXCLUDE = [
+  "releases",
+  "current",
+  "bin",
+  "app",
+  "logs",
+  "node_modules",
+  "overflow",
+  "browser-socket",
+  "bridge.lock",
+  "watchdog.lock",
+  "browse-spawn.sock",
+  "manifest.json",
+  "*.sock"
+];
+var ABMIND_EXCLUDE = [
+  "memory/memory.db",
+  "lib",
+  "node_modules",
+  "backups",
+  "*.sock",
+  "*.db-wal",
+  "*.db-shm"
+];
+var CONFIG_DIRS = ["config", "secret", "tasks", "skills", "core", "agents"];
+async function backup(opts = {}) {
   const abHome = abtarsHome();
+  const abmindHome = process.env["ABMIND_HOME"] ?? join4(dirname(abHome), ".abmind");
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const destDir = outputDir ?? join4(dirname(abHome), ".backup-abtars");
+  const destDir = opts.outputDir ?? join4(dirname(abHome), ".backup-abtars");
   mkdirSync(destDir, { recursive: true });
-  const abmindPaths = [
-    join4(dirname(abHome), ".abmind", "lib", "node_modules", "abmind", "dist", "cli", "abmind-backup.js"),
-    join4(dirname(abHome), "workspace", "ab", "abmind", "dist", "cli", "abmind-backup.js")
-  ];
-  const abmindBin = abmindPaths.find((p) => existsSync3(p));
-  let abmResult;
-  if (abmindBin) {
-    abmResult = spawnSync("node", [abmindBin], { encoding: "utf-8", env: { ...process.env } });
+  const isConfig = opts.config === true;
+  const prefix = isConfig ? `abtars-config-${date}` : `abtars-${date}`;
+  const zipExcludes = [];
+  if (isConfig) {
   } else {
-    abmResult = spawnSync("abmind", ["backup"], { encoding: "utf-8", env: { ...process.env } });
-  }
-  if (abmResult.status !== 0) {
-    process.stderr.write(`\u26A0\uFE0F abmind backup failed: ${abmResult.stderr || abmResult.stdout}
-`);
-    return 1;
-  }
-  const abmindBackupsDir = join4(dirname(abHome), ".abmind", "backups");
-  let abmFile;
-  if (existsSync3(abmindBackupsDir)) {
-    const abmFiles = readdirSync2(abmindBackupsDir).filter((f) => f.endsWith(".abm")).sort().reverse();
-    if (abmFiles.length > 0) abmFile = abmFiles[0];
-  }
-  if (abmFile) {
-    const src = join4(abmindBackupsDir, abmFile);
-    const dest = join4(destDir, `abmind-${date}.abm`);
-    renameSync(src, dest);
-    const size = (statSync(dest).size / 1024).toFixed(0);
-    process.stdout.write(`\u2713 abmind-${date}.abm (${size}KB, encrypted)
-`);
-  } else {
-    process.stderr.write(`\u26A0\uFE0F abmind backup produced no .abm file
-`);
-  }
-  const files = [];
-  for (const dir of AB_SAVE) {
-    const abs = join4(abHome, dir);
-    if (existsSync3(abs)) collectDir(abs, dir, files);
-  }
-  if (files.length === 0) {
-    process.stderr.write("Nothing to zip from abtars.\n");
-    return 1;
-  }
-  const tmpDir = join4(process.env["TMPDIR"] ?? "/tmp", `abtars-backup-${Date.now()}`);
-  mkdirSync(tmpDir, { recursive: true });
-  for (const f of files) {
-    const dest = join4(tmpDir, f.zipPath);
-    mkdirSync(dirname(dest), { recursive: true });
-    copyFileSync(f.absPath, dest);
+    for (const ex of ABTARS_EXCLUDE) {
+      zipExcludes.push(`${ex}/*`, ex);
+    }
+    zipExcludes.push("*.db-wal", "*.db-shm", "*.sock");
   }
-  const zipPath = join4(destDir, `abtars-${date}.zip`);
   const has7z = spawnSync("which", ["7z"], { encoding: "utf-8" }).status === 0;
+  const zipExt = has7z ? ".7z" : ".zip";
+  let zipPath = join4(destDir, prefix + zipExt);
   let zipOk;
-  if (has7z) {
-    const r = spawnSync("7z", ["a", zipPath.replace(/\.zip$/, ".7z"), "."], { cwd: tmpDir, encoding: "utf-8" });
-    zipOk = r.status === 0;
+  if (isConfig) {
+    const existingDirs = CONFIG_DIRS.filter((d) => existsSync3(join4(abHome, d)));
+    if (existingDirs.length === 0) {
+      process.stderr.write("Nothing to backup \u2014 no config dirs found\n");
+      return 1;
+    }
+    if (has7z) {
+      const r = spawnSync("7z", ["a", zipPath, ...existingDirs], { cwd: abHome, encoding: "utf-8" });
+      zipOk = r.status === 0;
+    } else {
+      const r = spawnSync("zip", ["-qr", zipPath, ...existingDirs], { cwd: abHome, encoding: "utf-8" });
+      zipOk = r.status === 0;
+    }
   } else {
-    const r = spawnSync("zip", ["-r", zipPath, "."], { cwd: tmpDir, encoding: "utf-8" });
-    zipOk = r.status === 0;
+    if (has7z) {
+      const excludeArgs = ABTARS_EXCLUDE.flatMap((ex) => ["-xr!" + ex]);
+      excludeArgs.push("-xr!*.db-wal", "-xr!*.db-shm", "-xr!*.sock");
+      const r = spawnSync("7z", ["a", zipPath, ".", ...excludeArgs], { cwd: abHome, encoding: "utf-8" });
+      zipOk = r.status === 0;
+    } else {
+      const excludeArgs = ABTARS_EXCLUDE.flatMap((ex) => ["-x", `${ex}/*`, "-x", ex]);
+      excludeArgs.push("-x", "*.db-wal", "-x", "*.db-shm", "-x", "*.sock");
+      const r = spawnSync("zip", ["-qr", zipPath, ".", ...excludeArgs], { cwd: abHome, encoding: "utf-8" });
+      zipOk = r.status === 0;
+    }
+    if (zipOk && existsSync3(abmindHome)) {
+      if (has7z) {
+        const excludeArgs = ABMIND_EXCLUDE.flatMap((ex) => ["-xr!" + ex]);
+        const r = spawnSync("7z", ["a", zipPath, ".", ...excludeArgs], { cwd: abmindHome, encoding: "utf-8" });
+        zipOk = r.status === 0;
+      } else {
+        const excludeArgs = ABMIND_EXCLUDE.flatMap((ex) => ["-x", `${ex}/*`, "-x", ex]);
+        const r = spawnSync("zip", ["-qr", zipPath, "-g", ".", ...excludeArgs], { cwd: abmindHome, encoding: "utf-8" });
+        zipOk = r.status === 0;
+      }
+    }
+    const dbPath = join4(abmindHome, "memory", "memory.db");
+    if (zipOk && existsSync3(dbPath)) {
+      const tmpDb = join4(process.env["TMPDIR"] ?? "/tmp", `abtars-backup-memory-${Date.now()}.db`);
+      const sqliteResult = spawnSync("sqlite3", [dbPath, `.backup '${tmpDb}'`], { encoding: "utf-8" });
+      if (sqliteResult.status === 0 && existsSync3(tmpDb)) {
+        if (has7z) {
+          spawnSync("7z", ["a", zipPath, tmpDb], { encoding: "utf-8" });
+        } else {
+          spawnSync("zip", ["-qj", zipPath, tmpDb], { encoding: "utf-8" });
+        }
+        try {
+          unlinkSync3(tmpDb);
+        } catch {
+        }
+      }
+    }
   }
-  spawnSync("rm", ["-rf", tmpDir]);
   if (!zipOk) {
-    process.stderr.write(`\u26A0\uFE0F zip/7z failed
-`);
+    process.stderr.write("Backup zip failed\n");
     return 1;
   }
-  const actualZip = has7z ? zipPath.replace(/\.zip$/, ".7z") : zipPath;
-  const sizeMb = (statSync(actualZip).size / 1024 / 1024).toFixed(1);
-  process.stdout.write(`\u2713 ${actualZip.split("/").pop()} (${sizeMb}MB, ${files.length} files)
+  if (!isConfig) {
+    const actual = statSync(zipPath).size;
+    if (actual < 1e5) {
+      process.stderr.write(`\u26A0\uFE0F Backup suspiciously small (${actual} bytes)
 `);
-  const maxAge = (pruneDays ?? DEFAULT_PRUNE_DAYS) * 864e5;
-  const now = Date.now();
-  for (const f of readdirSync2(destDir)) {
-    if (!(f.startsWith("abtars-") || f.startsWith("abmind-"))) continue;
-    if (!(f.endsWith(".zip") || f.endsWith(".7z") || f.endsWith(".abm"))) continue;
-    const fPath = join4(destDir, f);
-    try {
-      if (now - statSync(fPath).mtimeMs > maxAge) {
-        unlinkSync3(fPath);
-        process.stdout.write(`  \u{1F5D1} pruned ${f}
+    }
+  }
+  const zipSize = (statSync(zipPath).size / 1024 / 1024).toFixed(1);
+  process.stdout.write(`\u2713 ${basename(zipPath)} (${zipSize}MB)
+`);
+  if (opts.encrypt) {
+    const encPath = zipPath + ".enc";
+    const ok = encryptFile(zipPath, encPath, abmindHome);
+    if (!ok) return 1;
+    unlinkSync3(zipPath);
+    zipPath = encPath;
+    process.stdout.write(`\u2713 encrypted \u2192 ${basename(encPath)}
+`);
+  }
+  if (!isConfig) {
+    const abmResult = runAbmindBackup(abHome, abmindHome);
+    if (abmResult) {
+      const dest = join4(destDir, `abmind-${date}.abm`);
+      renameSync(abmResult, dest);
+      const size = (statSync(dest).size / 1024).toFixed(0);
+      process.stdout.write(`\u2713 abmind-${date}.abm (${size}KB, encrypted)
 `);
+    } else {
+      process.stderr.write("\u26A0\uFE0F abmind backup failed or produced no .abm\n");
+    }
+  }
+  const pruneDays = opts.pruneDays ?? DEFAULT_PRUNE_DAYS;
+  if (pruneDays > 0) {
+    const maxAge = pruneDays * 864e5;
+    const now = Date.now();
+    for (const f of readdirSync2(destDir)) {
+      if (!(f.startsWith("abtars-") || f.startsWith("abmind-"))) continue;
+      if (!(f.endsWith(".zip") || f.endsWith(".7z") || f.endsWith(".abm") || f.endsWith(".enc"))) continue;
+      const fPath = join4(destDir, f);
+      try {
+        if (now - statSync(fPath).mtimeMs > maxAge) {
+          unlinkSync3(fPath);
+          process.stdout.write(`  \u{1F5D1} pruned ${f}
+`);
+        }
+      } catch {
       }
-    } catch {
     }
   }
   return 0;
 }
-function collectDir(dir, prefix, out) {
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const abs = join4(dir, entry.name);
-    const rel = `${prefix}/${entry.name}`;
-    if (entry.isDirectory()) {
-      collectDir(abs, rel, out);
-    } else if (entry.isFile()) {
-      out.push({ absPath: abs, zipPath: rel });
-    }
+function runAbmindBackup(abHome, abmindHome) {
+  const abmindPaths = [
+    join4(dirname(abHome), "workspace", "ab", "abmind", "dist", "cli", "abmind-backup.js"),
+    join4(abmindHome, "lib", "node_modules", "abmind", "dist", "cli", "abmind-backup.js")
+  ];
+  const abmindBin = abmindPaths.find((p) => existsSync3(p));
+  let result;
+  if (abmindBin) {
+    result = spawnSync("node", [abmindBin], { encoding: "utf-8", env: { ...process.env } });
+  } else {
+    result = spawnSync("abmind", ["backup"], { encoding: "utf-8", env: { ...process.env } });
+  }
+  if (result.status !== 0) return null;
+  const backupsDir = join4(abmindHome, "backups");
+  if (!existsSync3(backupsDir)) return null;
+  const abmFiles = readdirSync2(backupsDir).filter((f) => f.endsWith(".abm")).sort().reverse();
+  return abmFiles[0] ? join4(backupsDir, abmFiles[0]) : null;
+}
+function encryptFile(inputPath, outputPath, abmindHome) {
+  const keyPath = join4(abmindHome, "secret", "abmind.key");
+  if (!existsSync3(keyPath)) {
+    process.stderr.write(`\u26A0\uFE0F --encrypt requires ${keyPath}
+`);
+    return false;
   }
+  const master = Buffer.from(readFileSync2(keyPath, "utf-8").trim(), "hex");
+  const key = Buffer.from(hkdfSync("sha256", master, "", "abtars-backup-v1", 32));
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const input = readFileSync2(inputPath);
+  const encrypted = Buffer.concat([cipher.update(input), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const out = Buffer.concat([iv, encrypted, tag]);
+  writeFileSync(outputPath, out);
+  return true;
 }
 
 // src/cli/commands/onboard.ts
 init_log_and_swallow();
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname as dirname2, join as join6 } from "node:path";
+import { homedir as homedir2 } from "node:os";
 import { fileURLToPath } from "node:url";
 
 // src/components/hints.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync, renameSync as renameSync2 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync as renameSync2 } from "node:fs";
 import { join as join5 } from "node:path";
 function manifestPath() {
   const home = process.env["ABTARS_HOME"] ?? join5(process.env["HOME"] ?? "", ".abtars");
@@ -426,7 +517,7 @@ function readManifest2() {
   const path = manifestPath();
   if (!existsSync4(path)) return {};
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync3(path, "utf-8"));
   } catch {
     return {};
   }
@@ -434,7 +525,7 @@ function readManifest2() {
 function writeManifestAtomic(data) {
   const path = manifestPath();
   const tmp = path + ".tmp";
-  writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  writeFileSync2(tmp, JSON.stringify(data, null, 2) + "\n");
   renameSync2(tmp, path);
 }
 function showHintOnce(id, text) {
@@ -487,7 +578,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-ODLDL2DB.js");
+  const { packagePaths: pp, readManifest: rm3 } = await import("./deploy-lib-import-PJXUADPS.js");
   const mfPaths = pp("abtars");
   const mf = await rm3(mfPaths.manifest);
   const installMode = mf?.installMode ?? "supervised";
@@ -753,7 +844,7 @@ function validateNonInteractive(opts) {
   }
   return {
     installMode: "supervised",
-    userName: "",
+    userName: opts.userName ?? "",
     passphrase: "",
     telegramToken: opts.telegramToken ?? "",
     telegramChatId: opts.telegramChatId ?? "",
@@ -818,7 +909,10 @@ function mergeEnvContent(existing, answers) {
     "WAKE_TIME",
     "HEARTBEAT_INTERVAL_SEC",
     "EMBEDDING_ENABLED",
-    "TRUST_MODE"
+    "TRUST_MODE",
+    "TELEGRAM_ENABLED",
+    "DISCORD_ENABLED",
+    "IRC_ENABLED"
   ]);
   const keptLines = [];
   for (const line of existing.split("\n")) {
@@ -843,6 +937,9 @@ function mergeEnvContent(existing, answers) {
   newBlock.push(`EMBEDDING_ENABLED=${answers.embeddingEnabled ? "true" : "false"}`);
   newBlock.push(`SECURITY_MODE=${answers.securityMode}`);
   newBlock.push(`TRUST_MODE=${answers.trustMode ? "true" : "false"}`);
+  newBlock.push(`TELEGRAM_ENABLED=${answers.telegramToken ? "true" : "false"}`);
+  newBlock.push(`DISCORD_ENABLED=${answers.discordBotToken ? "true" : "false"}`);
+  newBlock.push(`IRC_ENABLED=false`);
   return [...keptLines, ...newBlock, ""].join("\n");
 }
 async function onboard(opts) {
@@ -917,7 +1014,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-ODLDL2DB.js");
+  const { writeManifest: writeManifest2 } = await import("./deploy-lib-import-PJXUADPS.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}
@@ -974,6 +1071,15 @@ async function onboard(opts) {
     await writeFile(usersPath, JSON.stringify(users, null, 2) + "\n", { mode: 384 });
     process.stdout.write(`\u2713 users.json \u2192 ${usersPath}
 `);
+    try {
+      const manifestPath2 = join6(homedir2(), ".abmind", "manifest.json");
+      const manifest2 = JSON.parse((await import("node:fs")).readFileSync(manifestPath2, "utf-8"));
+      if (manifest2.encryptionUser && manifest2.encryptionUser !== answers.userName) {
+        process.stdout.write(`\u26A0\uFE0F  abmind encryption uses name '${manifest2.encryptionUser}' but you entered '${answers.userName}'. Backup restore will need the encryption name ('${manifest2.encryptionUser}').
+`);
+      }
+    } catch {
+    }
   }
   if (answers.userName) {
     const abmindHome = process.env["ABMIND_HOME"] ?? join6(dirname2(paths.home), ".abmind");
@@ -1039,8 +1145,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: existsSync9 } = await import("node:fs");
+  const hasRelease = existsSync9(join6(paths.home, "current"));
   if (!hasRelease) {
     process.stdout.write(`
 Next: run 'abtars update' to stage the release, then start the bridge.
@@ -1060,9 +1166,9 @@ Next: start the bridge
   return 0;
 }
 async function seedDefaultTasks(chatId, abtarsHome4) {
-  const { existsSync: existsSync8 } = await import("node:fs");
-  const tasksJson = join6(abtarsHome4, "state", "tasks.json");
-  if (existsSync8(tasksJson)) {
+  const { existsSync: existsSync9 } = await import("node:fs");
+  const tasksJson = join6(abtarsHome4, "tasks", "tasks.json");
+  if (existsSync9(tasksJson)) {
     process.stdout.write(`\u2022 tasks.json exists \u2014 skipping default-task seed
 `);
     return;
@@ -1075,7 +1181,7 @@ async function seedDefaultTasks(chatId, abtarsHome4) {
   ];
   let templatePath = null;
   for (const p of candidates) {
-    if (existsSync8(p)) {
+    if (existsSync9(p)) {
       templatePath = p;
       break;
     }
@@ -1131,95 +1237,13 @@ async function seedDefaultTasks(chatId, abtarsHome4) {
   }
 }
 
-// src/cli/commands/rollback.ts
-import { hostname } from "node:os";
-async function rollback(opts) {
-  const paths = packagePaths("abtars");
-  const manifest = await readManifest(paths.manifest);
-  if (!manifest || !manifest.version) {
-    process.stderr.write(`No active release; nothing to roll back.
-`);
-    return 2;
-  }
-  if (manifest.priorReleases.length === 0 && opts.to === void 0) {
-    process.stderr.write(`No prior releases recorded; nothing to roll back to.
-`);
-    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}`);
-  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]
-    });
-    process.stdout.write(`\u2713 manifest updated
-`);
-    process.stdout.write(`
-Rollback complete: ${target}
-`);
-    void emptyManifest;
-    void hostname;
-    return 0;
-  } finally {
-    await release();
-  }
-}
-
 // src/cli/commands/status.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import { join as join7 } 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})
@@ -1228,6 +1252,8 @@ Run 'abtars install' to set up.
     );
     return 1;
   }
+  const appExists = existsSync5(paths.app);
+  const appPrevExists = existsSync5(paths.appPrev);
   const lines = [
     `abtars status`,
     `  home:          ${paths.home}`,
@@ -1237,66 +1263,60 @@ 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(readFileSync4(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 {
+    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, mkdirSync as mkdirSync2 } 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 join10 } from "node:path";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "node:fs";
+import { copyFile as copyFile2, mkdir as mkdir4, chmod, readdir } from "node:fs/promises";
+import { rmSync as rmSync2, 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 existsSync6 } 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";
 var LocalBuildError = class extends Error {
@@ -1368,29 +1388,29 @@ async function readPackageVersion(repoRoot) {
 }
 function makeLocalBuildSource(opts = {}) {
   const repoRoot = opts.repoRoot ?? process.cwd();
-  const isNpmPackage = !existsSync5(join8(repoRoot, ".git"));
+  const isNpmPackage = !existsSync6(join8(repoRoot, ".git"));
   return {
     name: "local",
     async prepare(ctx) {
       if (isNpmPackage) {
         const bundleDir = join8(repoRoot, "bundle");
-        if (!existsSync5(bundleDir)) {
+        if (!existsSync6(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 });
+        if (existsSync6(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 });
+        if (existsSync6(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 });
+        if (existsSync6(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"));
+        if (existsSync6(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");
         process.stdout.write(`\u2713 staged ${version2} (from npm package)
 `);
@@ -1402,41 +1422,17 @@ 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(join8(repoRoot, "bundle"), join8(stagedPath, "bundle"), { recursive: true });
+      const coreSkillsSrc = join8(repoRoot, "core", "skills");
+      if (existsSync6(coreSkillsSrc)) {
+        await cp(coreSkillsSrc, join8(stagedPath, "core", "skills"), { recursive: true });
       }
+      await writeFile2(join8(stagedPath, "package.json"), JSON.stringify({ type: "module", name: "abtars", version }, null, 2) + "\n");
+      await copyFile(join8(repoRoot, "install-manifest.json"), join8(stagedPath, "install-manifest.json"));
       const packageLockHash = await hashFile(join8(repoRoot, "package-lock.json"));
       return { version, stagedPath, commit, branch, packageLockHash, source: "local" };
     }
@@ -1445,7 +1441,7 @@ 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 existsSync7, readFileSync as readFileSync5, unlinkSync as unlinkSync4 } from "node:fs";
 import { mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
 import { join as join9 } from "node:path";
 var TIMEOUT_MS = 6e4;
@@ -1457,7 +1453,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(readFileSync5(join9(home, "app", "package.json"), "utf-8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -1472,14 +1468,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);
       run("tar", ["-xzf", tgzPath, "--strip-components=1"], stagedPath);
-      if (existsSync6(tgzPath)) unlinkSync4(tgzPath);
+      if (existsSync7(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" };
     }
@@ -1489,7 +1485,7 @@ function makeNpmSource(packageName) {
 // src/cli/commands/update.ts
 function readJsonField2(file, field) {
   try {
-    return JSON.parse(readFileSync5(file, "utf-8"))[field];
+    return JSON.parse(readFileSync6(file, "utf-8"))[field];
   } catch {
     return void 0;
   }
@@ -1502,42 +1498,66 @@ Use --source local (default) or --source npm.
     return 2;
   }
   const paths = packagePaths("abtars");
-  if (!existsSync7(paths.releases) && existsSync7(join10(paths.home, "current"))) {
-    process.stdout.write("Migrating old layout \u2192 releases/...\n");
-    mkdirSync2(paths.releases, { recursive: true });
+  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 (existsSync8(paths.appStaging) && existsSync8(paths.app)) {
+        rmSync2(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 && !existsSync8(join10(repoRoot, ".git"))) {
       const { realpathSync } = await import("node:fs");
       const scriptPath = realpathSync(process.argv[1] ?? "");
+      const { dirname: dirname3 } = await import("node:path");
       const candidate = join10(dirname3(scriptPath), "..");
-      if (existsSync7(join10(candidate, "bundle"))) repoRoot = candidate;
+      if (existsSync8(join10(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");
       try {
         const pkg = JSON.parse(readFileSync6(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;
-        writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+        const { writeFileSync: writeFileSync3 } = await import("node:fs");
+        writeFileSync3(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 });
         process.stdout.write(`\u2713 external deps installed
@@ -1547,288 +1567,293 @@ 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 = join10(staged.stagedPath, "bundle", "abtars.js");
+    if (!existsSync8(entryPoint)) {
+      process.stderr.write(`\u274C Entry point not found: ${entryPoint}
+`);
+      return 1;
     }
+    configSnapshot(paths.config);
+    process.stdout.write(`\u2713 config snapshot (3-slot rotation)
+`);
     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);
+    atomicSwap(paths.app, paths.appPrev, paths.appStaging);
+    process.stdout.write(`\u2713 atomic swap: app.staging/ \u2192 app/
+`);
+    await postSwapHousekeeping(paths, repoRoot, staged);
     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,
+      installMode: prior?.installMode ?? "supervised",
+      repoRoot: opts.fromLocal && existsSync8(join10(repoRoot, ".git")) ? repoRoot : prior?.repoRoot ?? 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 { loadManifest } = await import("./install-manifest-QRWID3KZ.js");
-    const sourceRoot = staged.stagedPath;
-    const installManifest = loadManifest(sourceRoot);
-    const repoScripts = join10(sourceRoot, "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);
-      if (isExecutable(name)) {
-        await copyFile2(join10(repoScripts, name), join10(paths.home, name));
-        await chmod(join10(paths.home, 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 (!existsSync8(paths.appPrev1)) {
+      process.stderr.write(`\u274C No app.prev.1/ to roll back to. Manual intervention required.
 `);
-    const { writeWrapper } = await import("./install-RSLOS3Q5.js");
-    await mkdir4(paths.bin, { recursive: true });
-    for (const name of installManifest.cliWrappers) {
-      await writeWrapper(paths.bin, name, paths.current, false);
+      process.stderr.write(`   Check: ~/.abtars/logs/bridge.log
+`);
+      return 2;
+    }
+    const brokenDir = join10(paths.home, "app.broken");
+    rmSync2(brokenDir, { recursive: true, force: true });
+    const { renameSync: renameSync3 } = await import("node:fs");
+    renameSync3(paths.app, brokenDir);
+    renameSync3(paths.appPrev1, paths.app);
+    if (prior) {
+      await writeManifest(paths.manifest, prior);
     }
-    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 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.
 `);
+      rmSync2(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"],
+    join10(repoRoot, "..", "abmind"),
+    join10(process.env["HOME"] ?? "", "abmind")
+  ].filter(Boolean);
+  for (const src of candidates) {
+    const distDir = join10(src, "dist");
+    if (existsSync8(distDir)) {
+      const dest = join10(stagedPath, "node_modules", "abmind");
+      mkdirSync2(dest, { recursive: true });
+      cpSync(distDir, join10(dest, "dist"), { recursive: true });
+      if (existsSync8(join10(src, "package.json"))) cpSync(join10(src, "package.json"), join10(dest, "package.json"));
+      if (existsSync8(join10(src, "prompts"))) cpSync(join10(src, "prompts"), join10(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 = 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) => 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(join10(repoScripts, name), join10(destScripts, name));
+    if (isExecutable(name)) await chmod(join10(destScripts, name), 493);
+  }
+  process.stdout.write(`\u2713 scripts refreshed (${scriptFiles.length} files)
+`);
+  const { writeWrapper } = await import("./install-6H3APAIJ.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 = join10(paths.app, "core", "skills");
+  const skillsCoreDst = join10(paths.home, "skills", "core");
+  if (existsSync8(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)
+`);
+  }
+  for (const d of ["custom", "downloaded", "self"]) {
+    await mkdir4(join10(paths.home, "skills", d), { recursive: true });
+  }
+  const releaseConfig = join10(paths.app, "config");
+  const destConfig = join10(paths.home, "config");
+  if (existsSync8(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 (!existsSync8(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 = join10(releaseConfig, "transport.default.json");
+    if (existsSync8(defaultTransport)) cpSync(defaultTransport, join10(destConfig, "transport.default.json"));
+  }
+  const transportJson = join10(paths.home, "config", "transport.json");
+  if (existsSync8(transportJson)) {
+    try {
+      const tc = JSON.parse(readFileSync6(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: writeFileSync3 } = await import("node:fs");
+        writeFileSync3(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 = join10(paths.home, "scripts", "doctor.sh");
+  if (existsSync8(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 = join10(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 = join10(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 (!existsSync8(join10(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(join10(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
@@ -1865,8 +1890,8 @@ Usage:
   abtars uninstall [--yes]
   abtars update  [--source local|npm|github] [--from-local]
   abtars rollback [--to <version>]
-  abtars backup
-  abtars restore <file.zip|.7z>
+  abtars backup [--config] [--encrypt] [--output <dir>] [--prune-days N]
+  abtars restore <file.zip|.7z|.abm|.enc> [--config] [--passphrase <p>]
   abtars doctor [<args passed to doctor.sh>...]
   abtars onboard [--non-interactive --accept-risk --telegram-token ... --telegram-chat-id ...]
   abtars restart [--cold]
@@ -1879,6 +1904,20 @@ Usage:
   );
 }
 async function main(argv) {
+  if (argv[0] === "--version" || argv[0] === "-v" || argv[0] === "version") {
+    const { readFileSync: readFileSync7 } = await import("node:fs");
+    const { join: join11, dirname: dirname3 } = await import("node:path");
+    const { fileURLToPath: fileURLToPath2 } = await import("node:url");
+    const here = dirname3(fileURLToPath2(import.meta.url));
+    try {
+      const pkg = JSON.parse(readFileSync7(join11(here, "..", "package.json"), "utf-8"));
+      process.stdout.write(`${pkg.version}
+`);
+    } catch {
+      process.stdout.write("unknown\n");
+    }
+    return 0;
+  }
   const { command, flags } = parseArgs(argv);
   try {
     switch (command) {
@@ -1898,14 +1937,20 @@ 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({ to: typeof flags.get("to") === "string" ? Number(flags.get("to")) : void 0 });
       case "backup":
-        return await backup(typeof flags.get("output") === "string" ? flags.get("output") : void 0);
+        return await backup({
+          config: flags.get("config") === true,
+          encrypt: flags.get("encrypt") === true,
+          outputDir: typeof flags.get("output") === "string" ? flags.get("output") : void 0,
+          pruneDays: typeof flags.get("prune-days") === "string" ? Number(flags.get("prune-days")) : void 0
+        });
       case "restore": {
-        const { restore } = await import("./restore-ROJF22R2.js");
-        return await restore(argv[1] ?? "");
+        const { restore } = await import("./restore-UH2UE2K5.js");
+        return await restore(argv[1] ?? "", {
+          config: flags.get("config") === true,
+          passphrase: typeof flags.get("passphrase") === "string" ? flags.get("passphrase") : void 0
+        });
       }
       case "doctor":
         return await doctor(argv.slice(1).filter((a) => a !== ""));
@@ -1918,6 +1963,7 @@ async function main(argv) {
           defaultProvider: typeof flags.get("default-provider") === "string" ? flags.get("default-provider") : void 0,
           defaultModel: typeof flags.get("default-model") === "string" ? flags.get("default-model") : void 0,
           discordA2aChannel: typeof flags.get("discord-a2a-channel") === "string" ? flags.get("discord-a2a-channel") : void 0,
+          userName: typeof flags.get("user-name") === "string" ? flags.get("user-name") : void 0,
           force: flags.get("force") === true
         });
       case "status":
@@ -1927,7 +1973,7 @@ async function main(argv) {
       case "stop":
         return await stop({ force: flags.get("force") === true });
       case "start": {
-        const { start: startCmd } = await import("./start-4IWBKLWO.js");
+        const { start: startCmd } = await import("./start-CBVKNEAT.js");
         return await startCmd();
       }
       case "daemon": {
@@ -1946,10 +1992,6 @@ async function main(argv) {
         const { configShow } = await import("./config-show-ZTXX27FW.js");
         return await configShow();
       }
-      case "passwd": {
-        const { passwd } = await import("./passwd-QSHZJ2CG.js");
-        return await passwd();
-      }
       case "":
       case "help":
       case "--help":