abtars 0.1.0-alpha.24 → 0.1.0-alpha.26

package/bundle/abtars-cli.js

@@ -538,20 +538,36 @@ async function runInteractive(existing) {
       await fetch(`${botUrl}/deleteWebhook`);
     } catch {
     }
-    process.stdout.write("\nSend /start to your bot on Telegram now... (waiting 30s)\n");
     try {
-      const res = await fetch(`${botUrl}/getUpdates?timeout=30&allowed_updates=["message"]`);
-      const data = await res.json();
-      const id = data.result?.find((u) => u.message?.chat?.id)?.message?.chat?.id;
-      if (id) {
-        detectedChatId = String(id);
+      const quick = await fetch(`${botUrl}/getUpdates?timeout=2&allowed_updates=${encodeURIComponent('["message"]')}`);
+      const qData = await quick.json();
+      const qId = qData.result?.find((u) => u.message?.chat?.id)?.message?.chat?.id;
+      if (qId) {
+        detectedChatId = String(qId);
         process.stdout.write(`\u2713 Detected your chat ID: ${detectedChatId}
 `);
-      } else {
-        process.stdout.write("\u26A0 No message received \u2014 enter manually below.\n");
       }
     } catch {
-      process.stdout.write("\u26A0 Could not reach Telegram API \u2014 enter manually below.\n");
+    }
+    if (!detectedChatId) {
+      process.stdout.write("\n\u2192 Send /start to your bot on Telegram, then press Enter here.\n");
+      await new Promise((resolve) => {
+        process.stdin.once("data", () => resolve());
+      });
+      try {
+        const res = await fetch(`${botUrl}/getUpdates?timeout=10&allowed_updates=${encodeURIComponent('["message"]')}`);
+        const data = await res.json();
+        const id = data.result?.find((u) => u.message?.chat?.id)?.message?.chat?.id;
+        if (id) {
+          detectedChatId = String(id);
+          process.stdout.write(`\u2713 Detected your chat ID: ${detectedChatId}
+`);
+        } else {
+          process.stdout.write("\u26A0 No message received \u2014 enter manually below.\n");
+        }
+      } catch {
+        process.stdout.write("\u26A0 Could not reach Telegram API \u2014 enter manually below.\n");
+      }
     }
   }
   const telegramChatId = await text({
@@ -1069,40 +1085,15 @@ Next: run 'abtars update' to stage the release, then start the bridge.
 `);
     return 0;
   }
-  const { confirm: confirm2 } = await import("./dist-J3T4XVKX.js");
-  const startCmds = [];
-  if (answers.installMode === "simple") {
-    startCmds.push("abtars start");
-  } else {
-    if (process.platform === "darwin") {
-      startCmds.push(`launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.abtars.watchdog.plist`);
-    } else if (process.platform === "linux") {
-      startCmds.push(`systemctl --user daemon-reload`);
-      startCmds.push(`systemctl --user enable --now abtars-watchdog`);
-    }
-  }
   process.stdout.write(`
-\u2500\u2500 Start the bridge \u2500\u2500
-`);
-  const { spawn: spawn2 } = await import("node:child_process");
-  if (startCmds.length > 0) {
-    for (const cmd of startCmds) process.stdout.write(`  \u2192 ${cmd}
-`);
-    const run2 = await confirm2({ message: `Enable and start the watchdog service?`, initialValue: true });
-    if (run2 === true) {
-      for (const cmd of startCmds) {
-        await new Promise((resolve) => {
-          const child = spawn2("bash", ["-lc", cmd], { stdio: "inherit" });
-          child.on("exit", () => resolve());
-        });
-      }
-    } else {
-      process.stdout.write(`  \u2192 skipped (run manually)
+\u2713 Onboarding complete.
 `);
-    }
-  }
   process.stdout.write(`
-\u2713 Onboarding complete.
+Next: start the bridge
+`);
+  process.stdout.write(`  Daemon mode:  sudo $(which abtars) daemon install
+`);
+  process.stdout.write(`  Manual mode:  abtars start
 `);
   return 0;
 }
@@ -1260,6 +1251,8 @@ Rollback complete: ${target}
 }
 
 // src/cli/commands/status.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 async function status() {
   const paths = packagePaths("abtars");
   const manifest = await readManifest(paths.manifest);
@@ -1299,7 +1292,24 @@ Run 'abtars install' to set up.
       `  bridge:        ${alive ? "\u25CF running" : "\u2717 dead"} (pid ${lock.content.pid})${lock.stale ? " \u2014 STALE" : ""}`
     );
   } else {
-    lines.push(`  bridge:        \u25CB stopped`);
+    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 {
+      lines.push(`  bridge:        \u25CB stopped`);
+    }
   }
   process.stdout.write(`${lines.join("\n")}
 `);
@@ -1318,15 +1328,15 @@ Re-run 'abtars update' or 'abtars rollback' to reconcile.
 // src/cli/commands/update.ts
 init_log_and_swallow();
 import { hostname as hostname2 } from "node:os";
-import { join as join9, dirname as dirname3 } from "node:path";
-import { readFileSync as readFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "node:fs";
+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";
 
 // src/cli/update-sources/local.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
 import { copyFile, cp, mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 var LocalBuildError = class extends Error {
   constructor(message, hint) {
     super(hint ? `${message}
@@ -1388,7 +1398,7 @@ ${upstream} is ahead by ${behind} commit${behind === 1 ? "" : "s"}.`,
   return { commit, branch };
 }
 async function readPackageVersion(repoRoot) {
-  const pkg = JSON.parse(await readFile2(join7(repoRoot, "package.json"), "utf-8"));
+  const pkg = JSON.parse(await readFile2(join8(repoRoot, "package.json"), "utf-8"));
   if (typeof pkg.version !== "string") {
     throw new LocalBuildError("package.json has no version field.");
   }
@@ -1396,30 +1406,30 @@ async function readPackageVersion(repoRoot) {
 }
 function makeLocalBuildSource(opts = {}) {
   const repoRoot = opts.repoRoot ?? process.cwd();
-  const isNpmPackage = !existsSync5(join7(repoRoot, ".git"));
+  const isNpmPackage = !existsSync5(join8(repoRoot, ".git"));
   return {
     name: "local",
     async prepare(ctx) {
       if (isNpmPackage) {
-        const bundleDir = join7(repoRoot, "bundle");
+        const bundleDir = join8(repoRoot, "bundle");
         if (!existsSync5(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 = join7(ctx.releasesDir, version2);
+        const stagedPath2 = join8(ctx.releasesDir, version2);
         await rm(stagedPath2, { recursive: true, force: true });
         await mkdir2(stagedPath2, { recursive: true });
-        await cp(bundleDir, join7(stagedPath2, "bundle"), { recursive: true });
-        const coreDir = join7(repoRoot, "core");
-        if (existsSync5(coreDir)) await cp(coreDir, join7(stagedPath2, "core"), { recursive: true });
-        const scriptsSrc = join7(repoRoot, "scripts");
-        if (existsSync5(scriptsSrc)) await cp(scriptsSrc, join7(stagedPath2, "scripts"), { recursive: true });
-        const configSrc = join7(repoRoot, "config");
-        if (existsSync5(configSrc)) await cp(configSrc, join7(stagedPath2, "config"), { recursive: true });
-        const manifestSrc = join7(repoRoot, "install-manifest.json");
-        if (existsSync5(manifestSrc)) await copyFile(manifestSrc, join7(stagedPath2, "install-manifest.json"));
-        await writeFile2(join7(stagedPath2, "package.json"), JSON.stringify({ type: "module", name: "abtars", version: version2 }, null, 2) + "\n");
+        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");
         process.stdout.write(`\u2713 staged ${version2} (from npm package)
 `);
         return { version: version2, stagedPath: stagedPath2, commit: null, branch: null, packageLockHash: null, source: "local" };
@@ -1433,30 +1443,30 @@ function makeLocalBuildSource(opts = {}) {
       const useBundle = process.env["AGENTBRIDGE_BUILD_MODE"] !== "tsc";
       if (useBundle) {
         runCmd("npm", ["run", "bundle"], repoRoot);
-        const stagedPath2 = join7(ctx.releasesDir, version);
+        const stagedPath2 = join8(ctx.releasesDir, version);
         await rm(stagedPath2, { recursive: true, force: true });
         await mkdir2(stagedPath2, { recursive: true });
-        await cp(join7(repoRoot, "bundle"), join7(stagedPath2, "bundle"), { recursive: true });
-        const coreSkillsSrc = join7(repoRoot, "core", "skills");
+        await cp(join8(repoRoot, "bundle"), join8(stagedPath2, "bundle"), { recursive: true });
+        const coreSkillsSrc = join8(repoRoot, "core", "skills");
         if (existsSync5(coreSkillsSrc)) {
-          await cp(coreSkillsSrc, join7(stagedPath2, "core", "skills"), { recursive: true });
+          await cp(coreSkillsSrc, join8(stagedPath2, "core", "skills"), { recursive: true });
         }
-        await writeFile2(join7(stagedPath2, "package.json"), JSON.stringify({ type: "module", name: "abtars", version }, null, 2) + "\n");
-        await copyFile(join7(repoRoot, "install-manifest.json"), join7(stagedPath2, "install-manifest.json"));
-        const packageLockHash2 = await hashFile(join7(repoRoot, "package-lock.json"));
+        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 = join7(ctx.releasesDir, version);
+      const stagedPath = join8(ctx.releasesDir, version);
       await rm(stagedPath, { recursive: true, force: true });
       await mkdir2(stagedPath, { recursive: true });
-      await cp(join7(repoRoot, "dist"), join7(stagedPath, "dist"), { recursive: true });
-      await copyFile(join7(repoRoot, "install-manifest.json"), join7(stagedPath, "install-manifest.json"));
+      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", `${join7(repoRoot, "node_modules")}/`, `${ctx.nodeModulesDir}/`],
+        ["-aL", "--quiet", `${join8(repoRoot, "node_modules")}/`, `${ctx.nodeModulesDir}/`],
         { stdio: "inherit" }
       );
       if (rsyncResult.status !== 0) {
@@ -1465,7 +1475,7 @@ function makeLocalBuildSource(opts = {}) {
           `Ensure rsync is installed. Falling back to node cp would re-create symlinks.`
         );
       }
-      const packageLockHash = await hashFile(join7(repoRoot, "package-lock.json"));
+      const packageLockHash = await hashFile(join8(repoRoot, "package-lock.json"));
       return { version, stagedPath, commit, branch, packageLockHash, source: "local" };
     }
   };
@@ -1473,9 +1483,9 @@ function makeLocalBuildSource(opts = {}) {
 
 // src/cli/update-sources/npm.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync3, unlinkSync as unlinkSync4 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4, unlinkSync as unlinkSync4 } from "node:fs";
 import { mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var TIMEOUT_MS = 6e4;
 function run(cmd, args, cwd) {
   const r = spawnSync3(cmd, args, { cwd, encoding: "utf-8", timeout: TIMEOUT_MS });
@@ -1485,7 +1495,7 @@ function run(cmd, args, cwd) {
 }
 function readLocalVersion(home) {
   try {
-    const pkg = JSON.parse(readFileSync3(join8(home, "current", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync4(join9(home, "current", "package.json"), "utf-8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -1500,12 +1510,12 @@ function makeNpmSource(packageName) {
       if (latest === current) {
         throw new Error(`Already at latest version (${latest}). Nothing to update.`);
       }
-      const stagedPath = join8(ctx.releasesDir, latest);
+      const stagedPath = join9(ctx.releasesDir, latest);
       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 = join8(stagedPath, tgzName);
+      const tgzPath = join9(stagedPath, tgzName);
       run("tar", ["-xzf", tgzPath, "--strip-components=1"], stagedPath);
       if (existsSync6(tgzPath)) unlinkSync4(tgzPath);
       run("npm", ["install", "--omit=dev", "--no-audit", "--no-fund"], stagedPath);
@@ -1517,7 +1527,7 @@ function makeNpmSource(packageName) {
 // src/cli/commands/update.ts
 function readJsonField2(file, field) {
   try {
-    return JSON.parse(readFileSync4(file, "utf-8"))[field];
+    return JSON.parse(readFileSync5(file, "utf-8"))[field];
   } catch {
     return void 0;
   }
@@ -1530,18 +1540,18 @@ Use --source local (default) or --source npm.
     return 2;
   }
   const paths = packagePaths("abtars");
-  if (!existsSync7(paths.releases) && existsSync7(join9(paths.home, "current"))) {
+  if (!existsSync7(paths.releases) && existsSync7(join10(paths.home, "current"))) {
     process.stdout.write("Migrating old layout \u2192 releases/...\n");
     mkdirSync2(paths.releases, { recursive: true });
   }
   const release = await acquireLock(paths.lock, `update --source ${opts.source}`);
   try {
     let repoRoot = opts.repoRoot ?? process.cwd();
-    if (!opts.repoRoot && !existsSync7(join9(repoRoot, ".git"))) {
+    if (!opts.repoRoot && !existsSync7(join10(repoRoot, ".git"))) {
       const { realpathSync } = await import("node:fs");
       const scriptPath = realpathSync(process.argv[1] ?? "");
-      const candidate = join9(dirname3(scriptPath), "..");
-      if (existsSync7(join9(candidate, "bundle"))) repoRoot = candidate;
+      const candidate = join10(dirname3(scriptPath), "..");
+      if (existsSync7(join10(candidate, "bundle"))) repoRoot = candidate;
     }
     const source = opts.source === "npm" ? makeNpmSource("abtars") : makeLocalBuildSource({ repoRoot, allowStale: opts.fromLocal });
     if (opts.fromLocal) {
@@ -1558,10 +1568,10 @@ Use --source local (default) or --source npm.
     process.stdout.write(`\u2713 staged ${staged.version} at ${staged.stagedPath}
 `);
     {
-      const pkgPath = join9(staged.stagedPath, "package.json");
-      const { readFileSync: readFileSync5, writeFileSync: writeFileSync2 } = await import("node:fs");
+      const pkgPath = join10(staged.stagedPath, "package.json");
+      const { readFileSync: readFileSync6, writeFileSync: writeFileSync2 } = await import("node:fs");
       try {
-        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
         const externals = { patchright: "^1.59.4", "rettiwt-api": "^4.1.3" };
         pkg.dependencies = { ...pkg.dependencies, ...externals };
         writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
@@ -1576,13 +1586,13 @@ Use --source local (default) or --source npm.
     }
     {
       const { existsSync: existsSync8, unlinkSync: unlinkSync5, symlinkSync } = await import("node:fs");
-      const mainLink = join9(staged.stagedPath, "main.js");
+      const mainLink = join10(staged.stagedPath, "main.js");
       try {
         unlinkSync5(mainLink);
       } catch (err) {
         logAndSwallow("update", "op", err);
       }
-      const entry = existsSync8(join9(staged.stagedPath, "bundle", "abtars.js")) ? "bundle/abtars.js" : "dist/main.js";
+      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");
@@ -1590,18 +1600,18 @@ Use --source local (default) or --source npm.
     await activate(paths.current, staged.version);
     process.stdout.write(`\u2713 current -> releases/${staged.version}
 `);
-    const globalModules = join9(dn2(process.execPath), "..", "lib", "node_modules");
-    const abmindHome = process.env["ABMIND_HOME"] ?? join9(process.env["HOME"] ?? "", ".abmind");
+    const globalModules = join10(dn2(process.execPath), "..", "lib", "node_modules");
+    const abmindHome = process.env["ABMIND_HOME"] ?? join10(process.env["HOME"] ?? "", ".abmind");
     const links = [];
-    const globalAbmind = join9(globalModules, "abmind");
+    const globalAbmind = join10(globalModules, "abmind");
     if (ex2(globalAbmind)) links.push({ name: "abmind", target: globalAbmind });
-    const bsq3 = join9(abmindHome, "lib", "node_modules", "better-sqlite3");
+    const bsq3 = join10(abmindHome, "lib", "node_modules", "better-sqlite3");
     if (ex2(bsq3)) links.push({ name: "better-sqlite3", target: bsq3 });
     if (links.length > 0) {
-      const newNm = join9(paths.home, "current", "node_modules");
+      const newNm = join10(paths.home, "current", "node_modules");
       mk2(newNm, { recursive: true });
       for (const { name, target } of links) {
-        const dest = join9(newNm, name);
+        const dest = join10(newNm, name);
         try {
           if (ex2(dest)) ul2(dest);
         } catch {
@@ -1648,10 +1658,10 @@ Use --source local (default) or --source npm.
     process.stdout.write(`
 Update complete: ${staged.version}
 `);
-    const transportJson = join9(paths.home, "config", "transport.json");
+    const transportJson = join10(paths.home, "config", "transport.json");
     if (existsSync7(transportJson)) {
       try {
-        const tc = JSON.parse(readFileSync4(transportJson, "utf-8"));
+        const tc = JSON.parse(readFileSync5(transportJson, "utf-8"));
         let cleared = false;
         for (const agent of Object.values(tc.agents ?? {})) {
           if (agent.demoted) {
@@ -1679,8 +1689,8 @@ Update complete: ${staged.version}
     const { loadManifest } = await import("./install-manifest-QRWID3KZ.js");
     const sourceRoot = staged.stagedPath;
     const installManifest = loadManifest(sourceRoot);
-    const repoScripts = join9(sourceRoot, "scripts");
-    const destScripts = join9(paths.home, "scripts");
+    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) => {
@@ -1696,30 +1706,30 @@ Update complete: ${staged.version}
       return name.endsWith(ext);
     };
     for (const name of scriptFiles) {
-      await copyFile2(join9(repoScripts, name), join9(destScripts, name));
-      if (isExecutable(name)) await chmod(join9(destScripts, name), 493);
+      await copyFile2(join10(repoScripts, name), join10(destScripts, name));
+      if (isExecutable(name)) await chmod(join10(destScripts, name), 493);
       if (isExecutable(name)) {
-        await copyFile2(join9(repoScripts, name), join9(paths.home, name));
-        await chmod(join9(paths.home, name), 493);
+        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 = join9(home, "Library", "LaunchAgents");
+        const launchAgentsDir = join10(home, "Library", "LaunchAgents");
         await mkdir4(launchAgentsDir, { recursive: true });
-        const dst = join9(launchAgentsDir, name);
+        const dst = join10(launchAgentsDir, name);
         const oldContent = await readFile3(dst, "utf-8").catch(() => "");
-        let templated = await readFile3(join9(repoScripts, name), "utf-8");
+        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 = join9(home, ".config", "systemd", "user");
+        const systemdDir = join10(home, ".config", "systemd", "user");
         await mkdir4(systemdDir, { recursive: true });
-        const dst = join9(systemdDir, name);
+        const dst = join10(systemdDir, name);
         const oldContent = await readFile3(dst, "utf-8").catch(() => "");
-        await copyFile2(join9(repoScripts, name), dst);
+        await copyFile2(join10(repoScripts, name), dst);
         const newContent = await readFile3(dst, "utf-8").catch(() => "");
         if (oldContent !== newContent) serviceChanged = true;
       }
@@ -1734,8 +1744,8 @@ Update complete: ${staged.version}
     process.stdout.write(`\u2713 wrappers refreshed (${installManifest.cliWrappers.length} files)
 `);
     const { rmSync: rmSync2, cpSync, readdirSync: readdirSync3 } = await import("node:fs");
-    const skillsCoreSrc = join9(staged.stagedPath, "core", "skills");
-    const skillsCoreDst = join9(paths.home, "skills", "core");
+    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 });
@@ -1745,30 +1755,30 @@ Update complete: ${staged.version}
 `);
     }
     for (const d of ["custom", "downloaded", "self"]) {
-      await mkdir4(join9(paths.home, "skills", d), { recursive: true });
+      await mkdir4(join10(paths.home, "skills", d), { recursive: true });
     }
     for (const stale of ["memory", "ops", "tools", "coding"]) {
-      const p = join9(paths.home, "skills", stale);
+      const p = join10(paths.home, "skills", stale);
       if (existsSync7(p)) {
         rmSync2(p, { recursive: true, force: true });
       }
     }
-    const releaseConfig = join9(staged.stagedPath, "config");
-    const destConfig = join9(paths.home, "config");
+    const releaseConfig = join10(staged.stagedPath, "config");
+    const destConfig = join10(paths.home, "config");
     if (existsSync7(releaseConfig)) {
       for (const f of readdirSync3(releaseConfig)) {
-        const src = join9(releaseConfig, f);
+        const src = join10(releaseConfig, f);
         if (f.endsWith(".example")) {
-          cpSync(src, join9(destConfig, f));
-          const target = join9(destConfig, f.replace(".example", ""));
+          cpSync(src, join10(destConfig, f));
+          const target = join10(destConfig, f.replace(".example", ""));
           if (!existsSync7(target)) cpSync(src, target);
         }
       }
-      const defaultTransport = join9(releaseConfig, "transport.default.json");
-      if (existsSync7(defaultTransport)) cpSync(defaultTransport, join9(destConfig, "transport.default.json"));
+      const defaultTransport = join10(releaseConfig, "transport.default.json");
+      if (existsSync7(defaultTransport)) cpSync(defaultTransport, join10(destConfig, "transport.default.json"));
     }
-    const coreSrc = join9(staged.stagedPath, "core");
-    const coreDst = join9(paths.home, "core");
+    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 });
@@ -1789,7 +1799,7 @@ Update complete: ${staged.version}
       process.stdout.write(`\u2713 invariants: ${invariantResults.join(", ")}
 `);
     }
-    const doctorPath = join9(paths.home, "scripts", "doctor.sh");
+    const doctorPath = join10(paths.home, "scripts", "doctor.sh");
     if (existsSync7(doctorPath)) {
       process.stdout.write("\n\u{1FA7A} Health check...\n");
       try {
@@ -1808,7 +1818,7 @@ Update complete: ${staged.version}
     }
     if (restartMode === "supervised-daemon" || restartMode === "supervised") {
       process.stdout.write("\nRestarting bridge via watchdog...\n");
-      const wdLock = join9(paths.home, "watchdog.lock");
+      const wdLock = join10(paths.home, "watchdog.lock");
       const wdPid = readJsonField2(wdLock, "pid");
       if (wdPid && wdPid > 0) {
         try {