abtars 0.1.0-alpha.1

package/bundle/abtars-cli.js

@@ -0,0 +1,1438 @@
+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 {
+  showHintOnce,
+  update
+} from "./chunk-5R2ANXQ7.js";
+import {
+  install
+} from "./chunk-XREWVCUO.js";
+import {
+  acquireLock,
+  activate,
+  emptyManifest,
+  inspectLock,
+  packagePaths,
+  readCurrent,
+  readManifest,
+  releaseExists,
+  writeManifest
+} from "./chunk-265TPOPC.js";
+import {
+  restart
+} from "./chunk-ZXPXCDA6.js";
+import {
+  init_log_and_swallow,
+  logAndSwallow
+} from "./chunk-FMWKEPM7.js";
+import "./chunk-BUUVFUPO.js";
+import {
+  abtarsHome,
+  init_paths
+} from "./chunk-X76UX47U.js";
+import {
+  __require
+} from "./chunk-NWDBD4PA.js";
+
+// src/cli/commands/doctor.ts
+import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+async function pathExists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function doctor(args = []) {
+  const paths = packagePaths("abtars");
+  const installed = join(paths.home, "scripts", "doctor.sh");
+  const repo = join(process.cwd(), "scripts", "doctor.sh");
+  const candidate = await pathExists(installed) ? installed : await pathExists(repo) ? repo : null;
+  if (candidate === null) {
+    process.stderr.write(
+      `doctor.sh not found (looked in ${installed} and ${repo}).
+Run from an abtars checkout or after 'abtars install'.
+`
+    );
+    return 2;
+  }
+  return new Promise((resolve) => {
+    const child = spawn(candidate, [...args], { stdio: "inherit", env: process.env });
+    child.on("exit", (code) => resolve(code ?? 1));
+    child.on("error", (err) => {
+      process.stderr.write(`doctor.sh spawn failed: ${err.message}
+`);
+      resolve(1);
+    });
+  });
+}
+
+// src/cli/commands/uninstall.ts
+import { existsSync as existsSync2, readdirSync, unlinkSync as unlinkSync2, readlinkSync, rmSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { createInterface } from "node:readline";
+
+// src/cli/commands/stop.ts
+init_log_and_swallow();
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join as join2 } from "node:path";
+import { homedir } from "node:os";
+function abtarsHome2() {
+  return process.env["ABTARS_HOME"] ?? join2(process.env["HOME"] ?? "", ".abtars");
+}
+function readJsonField(file, field) {
+  try {
+    const data = JSON.parse(readFileSync(file, "utf-8"));
+    return data[field];
+  } catch {
+    return void 0;
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pidLooksLike(pid, needles) {
+  try {
+    const cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf-8");
+    return needles.some((n) => cmdline.includes(n));
+  } catch {
+    return true;
+  }
+}
+async function killGracefully(pid, needles) {
+  if (!pidAlive(pid)) return "not-running";
+  if (!pidLooksLike(pid, needles)) return "stale";
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return "not-running";
+  }
+  for (let i = 0; i < 10; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (!pidAlive(pid)) return "killed";
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  await new Promise((r) => setTimeout(r, 500));
+  return pidAlive(pid) ? "not-running" : "forced";
+}
+function removeLock(path) {
+  try {
+    if (existsSync(path)) unlinkSync(path);
+  } catch (err) {
+    logAndSwallow("stop", "op", err);
+  }
+}
+async function stop(opts) {
+  const home = abtarsHome2();
+  const manifestPath = join2(home, "manifest.json");
+  const watchdogLock = join2(home, "watchdog.lock");
+  const bridgeLock = join2(home, "bridge.lock");
+  const force = opts.force ?? false;
+  const installMode = readJsonField(manifestPath, "installMode");
+  if (installMode === "supervised-daemon" && !force) {
+    process.stderr.write(`Bridge runs under supervised-daemon \u2014 use supervisor stop (supervisor will respawn if you kill the process directly).
+`);
+    if (process.platform === "darwin") {
+      process.stderr.write(`  sudo -k launchctl bootout system/com.abtars.daemon
+`);
+    } else {
+      process.stderr.write(`  sudo -k systemctl stop abtars
+`);
+    }
+    process.stderr.write(`
+Use 'abtars stop --force' to kill the process anyway (supervisor will respawn).
+`);
+    return 1;
+  }
+  if (force && process.platform === "darwin") {
+    try {
+      execFileSync("launchctl", ["bootout", `gui/${process.getuid()}`, join2(homedir(), "Library", "LaunchAgents", "com.abtars.watchdog.plist")], { timeout: 5e3 });
+    } catch {
+    }
+  }
+  const wdPid = readJsonField(watchdogLock, "pid");
+  let wdResult = "not-running";
+  let wdPidActual;
+  if (wdPid && wdPid > 0) {
+    wdPidActual = wdPid;
+    wdResult = await killGracefully(wdPid, ["watchdog.sh"]);
+    if (wdResult === "killed" || wdResult === "forced") {
+      removeLock(watchdogLock);
+    } else if (wdResult === "stale") {
+      process.stdout.write(`\u26A0\uFE0F watchdog.lock PID ${wdPid} is not watchdog.sh \u2014 stale lock, removing
+`);
+      removeLock(watchdogLock);
+    }
+  }
+  const brPid = readJsonField(bridgeLock, "pid");
+  let brResult = "not-running";
+  let brPidActual;
+  if (brPid && brPid > 0) {
+    brPidActual = brPid;
+    brResult = await killGracefully(brPid, ["abtars", "main.js", "bundle"]);
+    if (brResult === "killed" || brResult === "forced") {
+      removeLock(bridgeLock);
+    } else if (brResult === "stale") {
+      process.stdout.write(`\u26A0\uFE0F bridge.lock PID ${brPid} is not abtars \u2014 stale lock, removing
+`);
+      removeLock(bridgeLock);
+    }
+  }
+  const wdMsg = formatResult("Watchdog", wdResult, wdPidActual);
+  const brMsg = formatResult("Bridge", brResult, brPidActual);
+  if (wdResult === "not-running" && brResult === "not-running") {
+    process.stdout.write(`Nothing to stop \u2014 neither watchdog nor bridge running.
+`);
+    return 0;
+  }
+  process.stdout.write(`\u{1F6D1} ${wdMsg}
+   ${brMsg}
+`);
+  if (force && process.platform === "darwin") {
+    process.stdout.write(`   LaunchAgent unloaded. To restart: launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.abtars.watchdog.plist
+`);
+  }
+  const allDown = (wdResult === "not-running" || wdResult === "killed" || wdResult === "forced" || wdResult === "stale") && (brResult === "not-running" || brResult === "killed" || brResult === "forced" || brResult === "stale");
+  return allDown ? 0 : 1;
+}
+function formatResult(label, result, pid) {
+  switch (result) {
+    case "killed":
+      return `${label} stopped (PID ${pid}, SIGTERM)`;
+    case "forced":
+      return `${label} stopped (PID ${pid}, SIGKILL)`;
+    case "stale":
+      return `${label} lock was stale (PID ${pid} not ours)`;
+    case "not-running":
+      return `${label} was not running`;
+    case "gone":
+      return `${label} kill failed \u2014 PID ${pid} still alive`;
+  }
+}
+
+// src/cli/commands/uninstall.ts
+function abtarsHome3() {
+  return process.env["ABTARS_HOME"] ?? join3(process.env["HOME"] ?? "", ".abtars");
+}
+function binDir() {
+  return join3(process.env["HOME"] ?? "", ".local", "bin");
+}
+async function confirm() {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question("\u26A0\uFE0F  This will DELETE ~/.abtars/ entirely. Type 'uninstall' to confirm: ", (answer) => {
+      rl.close();
+      resolve(answer.trim() === "uninstall");
+    });
+  });
+}
+function removeSymlinks() {
+  const dir = binDir();
+  if (!existsSync2(dir)) return [];
+  const home = abtarsHome3();
+  const removed = [];
+  for (const entry of readdirSync(dir)) {
+    if (!entry.startsWith("abtars")) continue;
+    const full = join3(dir, entry);
+    try {
+      const target = readlinkSync(full);
+      if (target.includes(home) || target.includes(".abtars")) {
+        unlinkSync2(full);
+        removed.push(entry);
+      }
+    } catch {
+    }
+  }
+  return removed;
+}
+function unloadLaunchd() {
+  if (process.platform !== "darwin") return;
+  const plist = join3(process.env["HOME"] ?? "", "Library", "LaunchAgents", "com.abtars.watchdog.plist");
+  if (!existsSync2(plist)) return;
+  try {
+    const { execSync } = __require("node:child_process");
+    execSync(`launchctl bootout gui/$(id -u) "${plist}" 2>/dev/null`, { stdio: "ignore" });
+    unlinkSync2(plist);
+  } catch {
+  }
+}
+async function uninstall(opts) {
+  const home = abtarsHome3();
+  if (!existsSync2(home)) {
+    process.stdout.write("Nothing to uninstall \u2014 ~/.abtars/ does not exist.\n");
+    return 0;
+  }
+  if (!opts.yes) {
+    const confirmed = await confirm();
+    if (!confirmed) {
+      process.stdout.write("Aborted.\n");
+      return 1;
+    }
+  }
+  await stop({ force: true });
+  unloadLaunchd();
+  const removed = removeSymlinks();
+  rmSync(home, { recursive: true, force: true });
+  process.stdout.write(`
+\u2713 Uninstalled abtars
+`);
+  process.stdout.write(`  Removed: ${home}/
+`);
+  if (removed.length > 0) {
+    process.stdout.write(`  Symlinks removed: ${removed.join(", ")}
+`);
+  }
+  process.stdout.write(`
+  Source repo (~/abtars/) is untouched.
+`);
+  return 0;
+}
+
+// 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 { spawnSync } from "node:child_process";
+var AB_SAVE = ["config", "secret", "tasks", "logo", "workspace", "skills/custom", "skills/self"];
+var DEFAULT_PRUNE_DAYS = 7;
+async function backup(outputDir, pruneDays) {
+  const abHome = abtarsHome();
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const destDir = 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 } });
+  } 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);
+  }
+  const zipPath = join4(destDir, `abtars-${date}.zip`);
+  const has7z = spawnSync("which", ["7z"], { encoding: "utf-8" }).status === 0;
+  let zipOk;
+  if (has7z) {
+    const r = spawnSync("7z", ["a", zipPath.replace(/\.zip$/, ".7z"), "."], { cwd: tmpDir, encoding: "utf-8" });
+    zipOk = r.status === 0;
+  } else {
+    const r = spawnSync("zip", ["-r", zipPath, "."], { cwd: tmpDir, encoding: "utf-8" });
+    zipOk = r.status === 0;
+  }
+  spawnSync("rm", ["-rf", tmpDir]);
+  if (!zipOk) {
+    process.stderr.write(`\u26A0\uFE0F zip/7z failed
+`);
+    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)
+`);
+  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}
+`);
+      }
+    } 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 });
+    }
+  }
+}
+
+// src/cli/commands/onboard.ts
+init_log_and_swallow();
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+var VALID_PROVIDERS = ["openrouter", "anthropic", "openai", "ollama", "kiro", "gemini"];
+var PROVIDER_TRANSPORT_NAME = {
+  openrouter: "openrouter",
+  anthropic: "anthropic",
+  openai: "openai",
+  ollama: "ollama",
+  kiro: "kiro",
+  gemini: "gemini"
+};
+var DEFAULT_MODELS = {
+  openrouter: "google/gemini-2.5-flash",
+  anthropic: "claude-sonnet-4-5-20250929",
+  openai: "gpt-4o",
+  ollama: "kimi-k2.5:cloud",
+  kiro: "claude-sonnet-4.6",
+  gemini: "gemini-2.5-flash"
+};
+var API_PROVIDERS = /* @__PURE__ */ new Set(["openrouter", "anthropic", "openai", "ollama"]);
+var PROVIDER_ENDPOINT = {
+  openrouter: "https://openrouter.ai/api/v1",
+  anthropic: "https://api.anthropic.com/v1",
+  openai: "https://api.openai.com/v1",
+  ollama: "http://localhost:11434/v1"
+};
+var PROVIDER_API_KEY_ENV = {
+  openrouter: "OPENROUTER_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  ollama: "OLLAMA_API_KEY",
+  kiro: "KIRO_API_KEY",
+  gemini: "GEMINI_API_KEY"
+};
+async function runInteractive(existing) {
+  const { intro, outro, text, select, confirm: confirm2, isCancel, cancel } = await import("./dist-MTMKARCP.js");
+  intro("abtars onboard \u2014 first-time setup");
+  const noteEmpty = "press Enter to skip";
+  const { packagePaths: pp, readManifest: rm } = await import("./deploy-lib-import-32ZFKHWP.js");
+  const mfPaths = pp("abtars");
+  const mf = await rm(mfPaths.manifest);
+  const installMode = mf?.installMode ?? "supervised";
+  const userName = await text({
+    message: "Your name",
+    placeholder: "your name",
+    initialValue: existing?.userName ?? ""
+  });
+  if (isCancel(userName)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const passphrase = "";
+  const securityMode = await select({
+    message: "Security mode \u2014 restrict agent file/command access?",
+    options: [
+      { value: "guardrails", label: "guardrails \u2014 path guard + command blocklist (recommended)" },
+      { value: "off", label: "off \u2014 no restrictions (legacy)" }
+    ],
+    initialValue: existing?.securityMode ?? "guardrails"
+  });
+  if (isCancel(securityMode)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const trustMode = await confirm2({
+    message: "Trust mode \u2014 auto-approve agent permission requests? (recommended for personal use)",
+    initialValue: true
+  });
+  if (isCancel(trustMode)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const telegramToken = await text({
+    message: `Telegram bot token (@BotFather \u2192 /mybots \u2192 API Token, ${noteEmpty})`,
+    placeholder: "123456789:ABCdefGHI...",
+    initialValue: existing?.telegramToken,
+    validate: (v) => !v || v.trim() === "" || v.includes(":") ? void 0 : 'expected format "<id>:<secret>" or empty'
+  });
+  if (isCancel(telegramToken)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  let detectedChatId = existing?.telegramChatId ?? "";
+  if (telegramToken && telegramToken.trim() && !detectedChatId) {
+    const botUrl = `https://api.telegram.org/bot${telegramToken.trim()}`;
+    try {
+      await fetch(`${botUrl}/deleteWebhook?drop_pending_updates=true`);
+    } 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);
+        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({
+    message: `Your Telegram user ID (${noteEmpty})`,
+    placeholder: "123456789",
+    initialValue: detectedChatId,
+    validate: (v) => !v || v.trim() === "" || /^-?\d+$/.test(v.trim()) ? void 0 : "expected numeric user ID or empty"
+  });
+  if (isCancel(telegramChatId)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const discordBotToken = await text({
+    message: `Discord bot token (${noteEmpty})`,
+    placeholder: "MTIzNDU2...",
+    initialValue: existing?.discordBotToken
+  });
+  if (isCancel(discordBotToken)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const discordAppId = await text({
+    message: `Discord app ID (${noteEmpty})`,
+    placeholder: "987654321098765432",
+    initialValue: existing?.discordAppId,
+    validate: (v) => !v || v.trim() === "" || /^\d{10,20}$/.test(v.trim()) ? void 0 : "expected Discord snowflake or empty"
+  });
+  if (isCancel(discordAppId)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const discordA2aChannel = await text({
+    message: `Discord allowed channel ID (${noteEmpty})`,
+    placeholder: "987654321098765432",
+    initialValue: existing?.discordA2aChannel,
+    validate: (v) => !v || v.trim() === "" || /^\d{10,20}$/.test(v.trim()) ? void 0 : "expected Discord snowflake or empty"
+  });
+  if (isCancel(discordA2aChannel)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const defaultProvider = await select({
+    message: "Default transport provider",
+    options: [
+      { value: "openrouter", label: "openrouter \u2014 many models via API key" },
+      { value: "anthropic", label: "anthropic \u2014 Claude API (direct)" },
+      { value: "openai", label: "openai \u2014 GPT API (direct)" },
+      { value: "ollama", label: "ollama \u2014 local/cloud Ollama endpoint" },
+      { value: "kiro", label: "kiro \u2014 Kiro CLI (free or paid; tier via model)" },
+      { value: "gemini", label: "gemini \u2014 Gemini CLI (free or paid; tier via model)" }
+    ],
+    initialValue: existing?.defaultProvider ?? "kiro"
+  });
+  if (isCancel(defaultProvider)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const defaultModel = await text({
+    message: `Default model (for ${defaultProvider})`,
+    placeholder: DEFAULT_MODELS[defaultProvider],
+    initialValue: existing?.defaultModel ?? DEFAULT_MODELS[defaultProvider]
+  });
+  if (isCancel(defaultModel)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const apiKeyEnv = PROVIDER_API_KEY_ENV[defaultProvider];
+  let providerApiKey = existing?.providerApiKey ?? "";
+  {
+    const v = await text({
+      message: `${apiKeyEnv} (${noteEmpty})`,
+      placeholder: existing?.providerApiKey ? "(keep existing)" : "sk-or-v1-... or leave blank",
+      initialValue: existing?.providerApiKey
+    });
+    if (isCancel(v)) {
+      cancel("Cancelled.");
+      return null;
+    }
+    providerApiKey = String(v ?? "").trim() || existing?.providerApiKey || "";
+  }
+  const modelStr = String(defaultModel).trim() || DEFAULT_MODELS[defaultProvider];
+  if (API_PROVIDERS.has(defaultProvider) && providerApiKey) {
+    const check = await confirm2({ message: "Check availability (GET /v1/models)?", initialValue: true });
+    if (isCancel(check)) {
+      cancel("Cancelled.");
+      return null;
+    }
+    if (check) {
+      const endpoint = PROVIDER_ENDPOINT[defaultProvider] ?? "";
+      const result = await checkModelAvailability(endpoint, providerApiKey, modelStr);
+      process.stdout.write(result.ok ? `\u2713 ${modelStr} available on ${defaultProvider}
+` : `\u26A0\uFE0F  ${result.message}
+`);
+    }
+  }
+  const hailMary = await text({
+    message: `Ultimate fallback model \u2014 hailMary (${noteEmpty}; uses same provider + key as above)`,
+    placeholder: "google/gemini-2.5-flash",
+    initialValue: existing?.hailMaryModel ?? "google/gemini-2.5-flash"
+  });
+  if (isCancel(hailMary)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const hailMaryModel = String(hailMary ?? "").trim();
+  if (hailMaryModel && API_PROVIDERS.has(defaultProvider) && providerApiKey) {
+    const check = await confirm2({ message: `Check hailMary availability (${hailMaryModel})?`, initialValue: true });
+    if (isCancel(check)) {
+      cancel("Cancelled.");
+      return null;
+    }
+    if (check) {
+      const endpoint = PROVIDER_ENDPOINT[defaultProvider] ?? "";
+      const result = await checkModelAvailability(endpoint, providerApiKey, hailMaryModel);
+      process.stdout.write(result.ok ? `\u2713 ${hailMaryModel} available
+` : `\u26A0\uFE0F  ${result.message}
+`);
+    }
+  }
+  const bedTime = await text({
+    message: `Bed time HH:MM \u2014 daily sleep trigger (${noteEmpty} for default 0:30)`,
+    placeholder: "0:30",
+    initialValue: existing?.bedTime,
+    validate: (v) => !v || /^\d{1,2}:\d{2}$/.test(v.trim()) ? void 0 : "expected H:MM format"
+  });
+  if (isCancel(bedTime)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const wakeTime = await text({
+    message: `Wake time HH:MM (${noteEmpty} for default 7:00)`,
+    placeholder: "7:00",
+    initialValue: existing?.wakeTime,
+    validate: (v) => !v || /^\d{1,2}:\d{2}$/.test(v.trim()) ? void 0 : "expected H:MM format"
+  });
+  if (isCancel(wakeTime)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const groqApiKey = await text({
+    message: `GROQ_API_KEY for voice-note transcription (${noteEmpty})`,
+    placeholder: existing?.groqApiKey ? "(keep existing)" : "gsk_...",
+    initialValue: existing?.groqApiKey
+  });
+  if (isCancel(groqApiKey)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const embeddingEnabled = false;
+  const mask = (s) => s ? s.length > 8 ? `${s.slice(0, 4)}\u2026${s.slice(-4)}` : "***" : "(skipped)";
+  const lines = [
+    "",
+    "\u2500\u2500 Summary \u2500\u2500",
+    `  Deployment mode:     ${installMode}`,
+    `  Your name:           ${String(userName ?? "") || "(skipped)"}`,
+    `  Telegram token:      ${mask(String(telegramToken ?? ""))}`,
+    `  Telegram chat ID:    ${String(telegramChatId ?? "") || "(skipped)"}`,
+    `  Discord bot token:   ${mask(String(discordBotToken ?? ""))}`,
+    `  Discord app ID:      ${String(discordAppId ?? "") || "(skipped)"}`,
+    `  Discord channel ID:  ${String(discordA2aChannel ?? "") || "(skipped)"}`,
+    `  Provider:            ${defaultProvider}`,
+    `  Default model:       ${modelStr}`,
+    `  ${apiKeyEnv}:        ${mask(providerApiKey)}`,
+    `  hailMary model:      ${hailMaryModel || "(skipped)"}`,
+    `  Bed time:            ${String(bedTime ?? "") || "(default 0:30)"}`,
+    `  Wake time:           ${String(wakeTime ?? "") || "(default 7:00)"}`,
+    `  GROQ_API_KEY:        ${mask(String(groqApiKey ?? ""))}`,
+    `  Embeddings:          ${embeddingEnabled ? "enabled" : "disabled"}`,
+    `  Trust mode:          ${trustMode ? "true (auto-approve)" : "false (prompt user)"}`,
+    ""
+  ];
+  process.stdout.write(lines.join("\n"));
+  const ok = await confirm2({ message: "Looks good? Write config?", initialValue: true });
+  if (isCancel(ok) || !ok) {
+    cancel("Cancelled \u2014 no files written.");
+    return null;
+  }
+  outro("Writing config\u2026");
+  return {
+    installMode,
+    userName: String(userName ?? "").trim(),
+    passphrase: String(passphrase ?? ""),
+    telegramToken: String(telegramToken ?? "").trim(),
+    telegramChatId: String(telegramChatId ?? "").trim(),
+    discordBotToken: String(discordBotToken ?? "").trim(),
+    discordAppId: String(discordAppId ?? "").trim(),
+    discordA2aChannel: String(discordA2aChannel ?? "").trim(),
+    defaultProvider,
+    defaultModel: modelStr,
+    providerApiKey,
+    hailMaryModel,
+    bedTime: String(bedTime ?? "").trim(),
+    wakeTime: String(wakeTime ?? "").trim(),
+    groqApiKey: String(groqApiKey ?? "").trim() || existing?.groqApiKey || "",
+    embeddingEnabled: false,
+    securityMode: String(securityMode ?? "guardrails"),
+    trustMode: trustMode === true
+  };
+}
+async function checkModelAvailability(endpoint, apiKey, model) {
+  try {
+    const res = await fetch(`${endpoint}/models`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) return { ok: false, message: `provider returned ${res.status}` };
+    const json = await res.json();
+    const ids = (json.data ?? []).map((m) => m.id);
+    return ids.includes(model) ? { ok: true, message: "available" } : { ok: false, message: `"${model}" not found in provider's model list` };
+  } catch (err) {
+    return { ok: false, message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+function validateNonInteractive(opts) {
+  if (!opts.acceptRisk) {
+    return "--non-interactive requires --accept-risk (you are bypassing safety prompts)";
+  }
+  const provider = opts.defaultProvider ?? "openrouter";
+  if (!VALID_PROVIDERS.includes(provider)) {
+    return `--default-provider must be one of: ${VALID_PROVIDERS.join(", ")}`;
+  }
+  return {
+    installMode: "supervised",
+    userName: "",
+    passphrase: "",
+    telegramToken: opts.telegramToken ?? "",
+    telegramChatId: opts.telegramChatId ?? "",
+    discordBotToken: "",
+    discordAppId: "",
+    discordA2aChannel: opts.discordA2aChannel ?? "",
+    defaultProvider: provider,
+    defaultModel: opts.defaultModel ?? DEFAULT_MODELS[provider],
+    providerApiKey: "",
+    hailMaryModel: "",
+    bedTime: "",
+    wakeTime: "",
+    groqApiKey: "",
+    embeddingEnabled: false,
+    securityMode: "guardrails",
+    trustMode: true
+  };
+}
+async function readExisting(envPath) {
+  try {
+    const content = await readFile(envPath, "utf-8");
+    const kv = /* @__PURE__ */ new Map();
+    for (const line of content.split("\n")) {
+      const m = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+      if (m && m[1] !== void 0 && m[2] !== void 0) kv.set(m[1], m[2]);
+    }
+    const provider = kv.get("DEFAULT_PROVIDER") ?? "openrouter";
+    if (!VALID_PROVIDERS.includes(provider)) return null;
+    const apiKeyEnv = PROVIDER_API_KEY_ENV[provider];
+    return {
+      installMode: "simple",
+      userName: kv.get("USER_DISPLAY_NAME") ?? "",
+      passphrase: "",
+      telegramToken: kv.get("TELEGRAM_BOT_TOKEN") ?? "",
+      telegramChatId: kv.get("MAIN_CHAT_ID") ?? "",
+      discordBotToken: kv.get("DISCORD_BOT_TOKEN") ?? "",
+      discordAppId: kv.get("DISCORD_APP_ID") ?? "",
+      discordA2aChannel: kv.get("DISCORD_A2A_CHANNEL_ID") ?? "",
+      defaultProvider: provider,
+      defaultModel: kv.get("DEFAULT_MODEL") ?? DEFAULT_MODELS[provider],
+      providerApiKey: apiKeyEnv ? kv.get(apiKeyEnv) ?? "" : "",
+      hailMaryModel: "",
+      bedTime: kv.get("BED_TIME") ?? "",
+      wakeTime: kv.get("WAKE_TIME") ?? "",
+      groqApiKey: kv.get("GROQ_API_KEY") ?? "",
+      embeddingEnabled: kv.get("EMBEDDING_ENABLED") === "true",
+      securityMode: kv.get("SECURITY_MODE") ?? "guardrails",
+      trustMode: kv.get("TRUST_MODE") === "true"
+    };
+  } catch {
+    return null;
+  }
+}
+function mergeEnvContent(existing, answers) {
+  const owned = /* @__PURE__ */ new Set([
+    "MAIN_CHAT_ID",
+    "DISCORD_APP_ID",
+    "DISCORD_A2A_CHANNEL_ID",
+    "DEFAULT_PROVIDER",
+    "DEFAULT_MODEL",
+    "BED_TIME",
+    "WAKE_TIME",
+    "HEARTBEAT_INTERVAL_SEC",
+    "EMBEDDING_ENABLED",
+    "TRUST_MODE"
+  ]);
+  const keptLines = [];
+  for (const line of existing.split("\n")) {
+    const m = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+    if (m && m[1] !== void 0 && owned.has(m[1])) continue;
+    keptLines.push(line);
+  }
+  while (keptLines.length > 0 && keptLines[keptLines.length - 1] === "") keptLines.pop();
+  const newBlock = [
+    "",
+    "# --- abtars onboard-managed ---",
+    `DEFAULT_PROVIDER=${answers.defaultProvider}`,
+    `DEFAULT_MODEL=${answers.defaultModel}`
+  ];
+  if (answers.telegramChatId) newBlock.push(`MAIN_CHAT_ID=${answers.telegramChatId}`);
+  else if (answers.discordA2aChannel) newBlock.push(`MAIN_CHAT_ID=${answers.discordA2aChannel}`);
+  if (answers.discordAppId) newBlock.push(`DISCORD_APP_ID=${answers.discordAppId}`);
+  if (answers.discordA2aChannel) newBlock.push(`DISCORD_A2A_CHANNEL_ID=${answers.discordA2aChannel}`);
+  if (answers.bedTime) newBlock.push(`BED_TIME=${answers.bedTime}`);
+  if (answers.wakeTime) newBlock.push(`WAKE_TIME=${answers.wakeTime}`);
+  newBlock.push(`HEARTBEAT_INTERVAL_SEC=300`);
+  newBlock.push(`EMBEDDING_ENABLED=${answers.embeddingEnabled ? "true" : "false"}`);
+  newBlock.push(`SECURITY_MODE=${answers.securityMode}`);
+  newBlock.push(`TRUST_MODE=${answers.trustMode ? "true" : "false"}`);
+  return [...keptLines, ...newBlock, ""].join("\n");
+}
+async function onboard(opts) {
+  const paths = packagePaths("abtars");
+  const { initInstallLog, logInstall, logInstallHeader } = await import("./install-log-IAPHYKD4.js");
+  initInstallLog(paths.home);
+  logInstallHeader("onboard");
+  const _origWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk, ...args) => {
+    if (typeof chunk === "string" && (chunk.startsWith("\u2713") || chunk.startsWith("\u26A0") || chunk.startsWith("\u2022"))) logInstall(chunk.trimEnd());
+    return _origWrite(chunk, ...args);
+  };
+  const manifest = await readManifest(paths.manifest);
+  if (!manifest) {
+    process.stderr.write(
+      `Not installed yet. Run 'abtars install' first.
+(Manifest not found at ${paths.manifest}.)
+`
+    );
+    return 2;
+  }
+  const envPath = join5(paths.config, ".env");
+  const existing = await readExisting(envPath);
+  const secretDir = join5(paths.home, "secret");
+  const { existsSync: secretExists } = await import("node:fs");
+  const hasSecretToken = secretExists(join5(secretDir, "TELEGRAM_BOT_TOKEN")) || secretExists(join5(secretDir, "DISCORD_BOT_TOKEN"));
+  const hasUserConfig = existing !== null && (existing.telegramToken || existing.discordBotToken || hasSecretToken);
+  if (hasUserConfig && !opts.force) {
+    showHintOnce("onboard-reoffer", "Re-running onboard overwrites config. Use --force to confirm, or edit ~/.abtars/config/.env directly.");
+    if (opts.nonInteractive) {
+      process.stderr.write(`config/.env already configured. Re-run with --force to overwrite.
+`);
+      return 3;
+    }
+  }
+  let answers;
+  if (opts.nonInteractive) {
+    const result = validateNonInteractive(opts);
+    if (typeof result === "string") {
+      process.stderr.write(`error: ${result}
+`);
+      return 4;
+    }
+    answers = result;
+  } else {
+    answers = await runInteractive(existing);
+    if (answers === null) return 1;
+  }
+  let currentContent = "";
+  try {
+    currentContent = await readFile(envPath, "utf-8");
+  } catch {
+    currentContent = "";
+  }
+  const next = mergeEnvContent(currentContent, answers);
+  await writeFile(envPath, next, { mode: 384 });
+  process.stdout.write(`
+\u2713 Wrote ${envPath}
+`);
+  const secretDirPath = join5(paths.home, "secret");
+  await mkdir(secretDirPath, { recursive: true });
+  const secrets = [];
+  if (answers.telegramToken) secrets.push(["TELEGRAM_BOT_TOKEN", answers.telegramToken]);
+  if (answers.discordBotToken) secrets.push(["DISCORD_BOT_TOKEN", answers.discordBotToken]);
+  if (answers.providerApiKey) {
+    const providerKeyName = PROVIDER_API_KEY_ENV[answers.defaultProvider];
+    if (providerKeyName) secrets.push([providerKeyName, answers.providerApiKey]);
+  }
+  if (answers.groqApiKey) secrets.push(["GROQ_API_KEY", answers.groqApiKey]);
+  for (const [name, value] of secrets) {
+    await writeFile(join5(secretDirPath, name), value, { mode: 384 });
+  }
+  if (secrets.length > 0) process.stdout.write(`\u2713 ${secrets.length} secrets \u2192 ${secretDirPath}
+`);
+  const { writeManifest: writeManifest2 } = await import("./deploy-lib-import-32ZFKHWP.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}
+`);
+  {
+    const transportPath = join5(paths.config, "transport.json");
+    let tc = {};
+    try {
+      tc = JSON.parse(await readFile(transportPath, "utf-8"));
+    } catch (err) {
+      logAndSwallow("onboard", "op", err);
+    }
+    if (!tc["providers"]) {
+      tc["providers"] = {
+        "kiro": { "transport": "acp", "cli": "kiro-cli" },
+        "ollama": { "transport": "api", "endpoint": "http://localhost:11434/v1" },
+        "openrouter": { "transport": "api", "endpoint": "https://openrouter.ai/api/v1", "apiKeyEnv": "OPENROUTER_API_KEY" }
+      };
+    }
+    if (!tc["agents"]) {
+      const provName = PROVIDER_TRANSPORT_NAME[answers.defaultProvider] ?? answers.defaultProvider;
+      tc["agents"] = {
+        "professor": { "model": answers.defaultModel, "provider": provName },
+        "dreamy": { "model": answers.defaultModel, "provider": provName },
+        "browsie": { "model": answers.defaultModel, "provider": provName },
+        "coding": { "model": answers.defaultModel, "provider": provName }
+      };
+    }
+    if (answers.hailMaryModel) {
+      const provName = PROVIDER_TRANSPORT_NAME[answers.defaultProvider] ?? answers.defaultProvider;
+      tc["hailMary"] = { model: answers.hailMaryModel, provider: provName };
+    }
+    await writeFile(transportPath, JSON.stringify(tc, null, 2) + "\n", { mode: 384 });
+    process.stdout.write(`\u2713 transport.json \u2192 ${transportPath}
+`);
+  }
+  {
+    const usersPath = join5(paths.config, "users.json");
+    const userId = answers.userName.toLowerCase().replace(/[^a-z0-9]/g, "") || "user";
+    const platforms = {};
+    if (answers.telegramChatId) platforms["telegram"] = parseInt(answers.telegramChatId, 10) || answers.telegramChatId;
+    if (answers.discordAppId) platforms["discord"] = answers.discordAppId;
+    const users = {
+      users: [{
+        userId,
+        displayName: answers.userName || userId,
+        role: "master",
+        maxClass: 3,
+        tools: ["all"],
+        platforms,
+        allowedChats: []
+      }]
+    };
+    await writeFile(usersPath, JSON.stringify(users, null, 2) + "\n", { mode: 384 });
+    process.stdout.write(`\u2713 users.json \u2192 ${usersPath}
+`);
+  }
+  if (answers.userName) {
+    const abmindHome = process.env["ABMIND_HOME"] ?? join5(dirname2(paths.home), ".abmind");
+    const profileDir = join5(abmindHome, "memory", "core");
+    const { existsSync: profileExists } = await import("node:fs");
+    if (profileExists(profileDir)) {
+      const profilePath = join5(profileDir, "user_profile.md");
+      if (!profileExists(profilePath)) {
+        await writeFile(profilePath, `# User Profile
+
+Name: ${answers.userName}
+`, { mode: 384 });
+        process.stdout.write(`\u2713 user_profile.md \u2192 ${profilePath}
+`);
+      }
+    }
+  }
+  if (answers.passphrase && answers.userName) {
+    try {
+      const { deriveFromPassphrase, writeKeyVerify } = await import("abmind");
+      const { writeToKeyring } = await import("abmind");
+      const key = deriveFromPassphrase(answers.passphrase, answers.userName);
+      writeKeyVerify(key);
+      const stored = writeToKeyring(answers.passphrase);
+      process.stdout.write(`\u2713 Encryption key derived from passphrase${stored ? " (stored in keyring)" : ""}
+`);
+    } catch (err) {
+      process.stdout.write(`\u26A0 Key init failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  }
+  if (answers.telegramChatId) {
+    await seedDefaultTasks(answers.telegramChatId, paths.home);
+  }
+  const agentsDir = join5(paths.home, "agents");
+  const agentRulesPath = join5(agentsDir, "default.md");
+  const { existsSync: agentRulesExists } = await import("node:fs");
+  if (!agentRulesExists(agentRulesPath)) {
+    await mkdir(agentsDir, { recursive: true });
+    const bundledPath = join5(dirname2(fileURLToPath(import.meta.url)), "agents", "default.md");
+    const fallbackPath = join5(dirname2(fileURLToPath(import.meta.url)), "..", "..", "agents", "default.md");
+    let content = "# Agent-to-Agent API\n\n<!-- See docs for configuration -->\n";
+    try {
+      content = await readFile(bundledPath, "utf-8");
+    } catch {
+      try {
+        content = await readFile(fallbackPath, "utf-8");
+      } catch {
+      }
+    }
+    await writeFile(agentRulesPath, content);
+    process.stdout.write(`\u2713 agents/default.md \u2192 ${agentRulesPath}
+`);
+  }
+  process.stdout.write(`
+\u{1F4A1} To edit providers, agents, hailMary, fallback chains \u2014 edit:
+   ${join5(paths.config, "transport.json")}
+   Docs: https://aksika.github.io/abtars/
+`);
+  if (opts.nonInteractive) {
+    process.stdout.write(`
+Next: 'abtars update' to build, then start the bridge.
+`);
+    return 0;
+  }
+  const { existsSync: existsSync4 } = await import("node:fs");
+  const inRepo = existsSync4(join5(process.cwd(), ".git")) && existsSync4(join5(process.cwd(), "package.json"));
+  if (!inRepo) {
+    process.stdout.write(`
+Next: cd into the abtars repo and run 'abtars update' to build and activate.
+`);
+    return 0;
+  }
+  process.stdout.write(`
+\u2500\u2500 Running 'abtars update' \u2500\u2500
+`);
+  const { update: update2 } = await import("./update-QCW5LXRN.js");
+  const updRc = await update2({ source: "local", fromLocal: true, allowAbmindMismatch: false });
+  if (updRc !== 0) {
+    process.stderr.write(`
+\u26A0\uFE0F  'abtars update' exited with code ${updRc}. Fix and re-run manually.
+`);
+    return updRc;
+  }
+  try {
+    const { spawnSync: spawnSync2 } = await import("node:child_process");
+    const which = spawnSync2("which", ["abmind"], { encoding: "utf-8" });
+    if (which.status === 0) {
+      process.stdout.write(`
+\u2500\u2500 Running 'abmind install' \u2500\u2500
+`);
+      const r = spawnSync2("abmind", ["install"], { stdio: "inherit" });
+      if (r.status !== 0) process.stdout.write(`\u26A0 abmind install exited with code ${r.status}
+`);
+    } else {
+      process.stdout.write(`
+\u2139\uFE0F  abmind not installed. Run 'npm install -g abmind && abmind install' later to enable persistent memory.
+`);
+    }
+  } catch {
+  }
+  const { confirm: confirm2 } = await import("./dist-MTMKARCP.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 run = await confirm2({ message: `Enable and start the watchdog service?`, initialValue: true });
+    if (run === 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)
+`);
+    }
+  }
+  process.stdout.write(`
+\u2713 Onboarding complete.
+`);
+  return 0;
+}
+async function seedDefaultTasks(chatId, abtarsHome4) {
+  const { existsSync: existsSync4 } = await import("node:fs");
+  const tasksJson = join5(abtarsHome4, "state", "tasks.json");
+  if (existsSync4(tasksJson)) {
+    process.stdout.write(`\u2022 tasks.json exists \u2014 skipping default-task seed
+`);
+    return;
+  }
+  const { fileURLToPath: fileURLToPath2 } = await import("node:url");
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  const candidates = [
+    join5(here, "..", "..", "..", "tasks.default.json"),
+    join5(here, "..", "..", "tasks.default.json")
+  ];
+  let templatePath = null;
+  for (const p of candidates) {
+    if (existsSync4(p)) {
+      templatePath = p;
+      break;
+    }
+  }
+  if (!templatePath) {
+    process.stdout.write(`\u2022 tasks.default.json not found \u2014 skipping default-task seed
+`);
+    return;
+  }
+  let template;
+  try {
+    const raw = await readFile(templatePath, "utf-8");
+    template = JSON.parse(raw);
+  } catch (err) {
+    process.stdout.write(`\u2022 Failed to read tasks.default.json: ${err instanceof Error ? err.message : String(err)}
+`);
+    return;
+  }
+  const { spawnSync: spawnSync2 } = await import("node:child_process");
+  let seeded = 0;
+  for (const entry of template) {
+    const args = [
+      "add",
+      "--schedule",
+      entry.schedule,
+      "--message",
+      entry.message,
+      "--chat-id",
+      chatId,
+      "--type",
+      entry.type,
+      "--executor",
+      entry.executor
+    ];
+    if (entry.id) args.push("--id", entry.id);
+    if (entry.title) args.push("--title", entry.title);
+    if (entry.maxRunsPerDay) args.push("--max-runs-per-day", String(entry.maxRunsPerDay));
+    const result = spawnSync2("abtars-task", args, {
+      encoding: "utf-8",
+      env: { ...process.env, ABTARS_HOME: abtarsHome4 }
+    });
+    if (result.status === 0) {
+      seeded++;
+    } else {
+      const err = result.error?.message ?? result.stderr?.trim() ?? result.stdout?.trim() ?? `exit ${result.status}`;
+      process.stdout.write(`  \u26A0\uFE0F failed to seed task "${entry.message.slice(0, 40)}": ${err}
+`);
+    }
+  }
+  if (seeded > 0) {
+    process.stdout.write(`\u2713 seeded ${seeded} default task${seeded === 1 ? "" : "s"}
+`);
+  }
+}
+
+// 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
+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})
+Run 'abtars install' to set up.
+`
+    );
+    return 1;
+  }
+  const lines = [
+    `abtars status`,
+    `  home:          ${paths.home}`,
+    `  version:       ${manifest.version || "(unset \u2014 run update)"}`,
+    `  commit:        ${manifest.commit ?? "(unknown)"}`,
+    `  branch:        ${manifest.branch ?? "(unknown)"}`,
+    `  source:        ${manifest.source}`,
+    `  activated:     ${manifest.activatedAt}`,
+    `  current ->:    ${current ?? "(missing)"}`,
+    `  host:          ${manifest.host}`,
+    `  prior:         ${manifest.priorReleases.length > 0 ? manifest.priorReleases.map((r) => r.version).join(", ") : "(none)"}`
+  ];
+  if (lock.held) {
+    lines.push(
+      `  lock:          HELD by pid ${lock.content.pid} (${lock.content.cmd})${lock.stale ? " \u2014 STALE" : ""}`
+    );
+  } else {
+    lines.push(`  lock:          not held`);
+  }
+  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.
+`
+    );
+    return 1;
+  }
+  return 0;
+}
+
+// src/cli/abtars.ts
+process.umask(63);
+function parseArgs(argv) {
+  const command = argv[0] ?? "";
+  const flags = /* @__PURE__ */ new Map();
+  for (let i = 1; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === void 0) continue;
+    if (a.startsWith("--")) {
+      const eqIdx = a.indexOf("=");
+      if (eqIdx > 2) {
+        flags.set(a.slice(2, eqIdx), a.slice(eqIdx + 1));
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("--")) {
+          flags.set(a.slice(2), next);
+          i++;
+        } else {
+          flags.set(a.slice(2), true);
+        }
+      }
+    }
+  }
+  return { command, flags };
+}
+function printUsage() {
+  process.stdout.write(
+    `abtars \u2014 install/update CLI (#158)
+
+Usage:
+  abtars install [--force] [--mode=simple|supervised|supervised-daemon] [--restore <backup.zip>]
+  abtars uninstall [--yes]
+  abtars update  [--source local|npm|github] [--from-local]
+  abtars rollback [--to <version>]
+  abtars backup
+  abtars restore <file.zip|.7z>
+  abtars doctor [<args passed to doctor.sh>...]
+  abtars onboard [--non-interactive --accept-risk --telegram-token ... --telegram-chat-id ...]
+  abtars restart [--cold]
+  abtars start
+  abtars stop [--force]
+  abtars status
+  abtars logs
+  abtars config
+`
+  );
+}
+async function main(argv) {
+  const { command, flags } = parseArgs(argv);
+  try {
+    switch (command) {
+      case "install":
+        return await install({
+          restore: typeof flags.get("restore") === "string" ? flags.get("restore") : void 0,
+          force: flags.get("force") === true,
+          dryRun: flags.get("dry-run") === true,
+          mode: flags.get("mode") === "simple" ? "simple" : flags.get("mode") === "supervised" ? "supervised" : flags.get("mode") === "supervised-daemon" ? "supervised-daemon" : void 0
+        });
+      case "uninstall":
+        return await uninstall({ yes: flags.get("yes") === true });
+      case "update":
+        return await update({
+          source: flags.get("source") ?? "local",
+          fromLocal: flags.get("from-local") === true,
+          allowAbmindMismatch: flags.get("allow-abmind-mismatch") === true
+        });
+      case "rollback":
+        return await rollback({
+          to: typeof flags.get("to") === "string" ? flags.get("to") : void 0
+        });
+      case "backup":
+        return await backup(typeof flags.get("output") === "string" ? flags.get("output") : void 0);
+      case "restore": {
+        const { restore } = await import("./restore-ZE3SEPSS.js");
+        return await restore(argv[1] ?? "");
+      }
+      case "doctor":
+        return await doctor(argv.slice(1).filter((a) => a !== ""));
+      case "onboard":
+        return await onboard({
+          nonInteractive: flags.get("non-interactive") === true,
+          acceptRisk: flags.get("accept-risk") === true,
+          telegramToken: typeof flags.get("telegram-token") === "string" ? flags.get("telegram-token") : void 0,
+          telegramChatId: typeof flags.get("telegram-chat-id") === "string" ? flags.get("telegram-chat-id") : void 0,
+          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,
+          force: flags.get("force") === true
+        });
+      case "status":
+        return await status();
+      case "restart":
+        return await restart({ cold: flags.get("cold") === true });
+      case "stop":
+        return await stop({ force: flags.get("force") === true });
+      case "start": {
+        const { start: startCmd } = await import("./start-FH3GRMJ4.js");
+        return await startCmd();
+      }
+      case "logs": {
+        const { logs } = await import("./logs-ZNYXX5PA.js");
+        return await logs();
+      }
+      case "config": {
+        const { configShow } = await import("./config-show-ERTATR6E.js");
+        return await configShow();
+      }
+      case "passwd": {
+        const { passwd } = await import("./passwd-RRFV4CC5.js");
+        return await passwd();
+      }
+      case "":
+      case "help":
+      case "--help":
+      case "-h":
+        printUsage();
+        return 0;
+      default:
+        process.stderr.write(`unknown subcommand: ${command}
+
+`);
+        printUsage();
+        return 2;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`error: ${msg}
+`);
+    return 1;
+  }
+}
+var isDirectRun = typeof process.argv[1] === "string" && (process.argv[1].endsWith("abtars.js") || process.argv[1].endsWith("abtars-cli.js") || process.argv[1].endsWith("abtars") || process.argv[1].endsWith("abtars.ts"));
+if (isDirectRun && process.env["VITEST"] === void 0) {
+  void main(process.argv.slice(2)).then((code) => process.exit(code));
+}
+export {
+  main
+};
+//# sourceMappingURL=abtars-cli.js.map