opencode-supertask 0.1.22 → 0.1.24

package/dist/cli/index.js

@@ -17095,26 +17095,26 @@ var require_CronDate = __commonJS({
        * @param {CronDate | Date | number | string} [timestamp] - The timestamp to initialize the CronDate with.
        * @param {string} [tz] - The timezone to use for the CronDate.
        */
-      constructor(timestamp, tz) {
+      constructor(timestamp2, tz) {
         const dateOpts = { zone: tz };
-        if (!timestamp) {
+        if (!timestamp2) {
           this.#date = luxon_1.DateTime.local();
-        } else if (timestamp instanceof _CronDate) {
-          this.#date = timestamp.#date;
-          this.#dstStart = timestamp.#dstStart;
-          this.#dstEnd = timestamp.#dstEnd;
-        } else if (timestamp instanceof Date) {
-          this.#date = luxon_1.DateTime.fromJSDate(timestamp, dateOpts);
-        } else if (typeof timestamp === "number") {
-          this.#date = luxon_1.DateTime.fromMillis(timestamp, dateOpts);
+        } else if (timestamp2 instanceof _CronDate) {
+          this.#date = timestamp2.#date;
+          this.#dstStart = timestamp2.#dstStart;
+          this.#dstEnd = timestamp2.#dstEnd;
+        } else if (timestamp2 instanceof Date) {
+          this.#date = luxon_1.DateTime.fromJSDate(timestamp2, dateOpts);
+        } else if (typeof timestamp2 === "number") {
+          this.#date = luxon_1.DateTime.fromMillis(timestamp2, dateOpts);
         } else {
-          this.#date = luxon_1.DateTime.fromISO(timestamp, dateOpts);
-          this.#date.isValid || (this.#date = luxon_1.DateTime.fromRFC2822(timestamp, dateOpts));
-          this.#date.isValid || (this.#date = luxon_1.DateTime.fromSQL(timestamp, dateOpts));
-          this.#date.isValid || (this.#date = luxon_1.DateTime.fromFormat(timestamp, "EEE, d MMM yyyy HH:mm:ss", dateOpts));
+          this.#date = luxon_1.DateTime.fromISO(timestamp2, dateOpts);
+          this.#date.isValid || (this.#date = luxon_1.DateTime.fromRFC2822(timestamp2, dateOpts));
+          this.#date.isValid || (this.#date = luxon_1.DateTime.fromSQL(timestamp2, dateOpts));
+          this.#date.isValid || (this.#date = luxon_1.DateTime.fromFormat(timestamp2, "EEE, d MMM yyyy HH:mm:ss", dateOpts));
         }
         if (!this.#date.isValid) {
-          throw new Error(`CronDate: unhandled timestamp: ${timestamp}`);
+          throw new Error(`CronDate: unhandled timestamp: ${timestamp2}`);
         }
         if (tz && tz !== this.#date.zoneName) {
           this.#date = this.#date.setZone(tz);
@@ -19172,6 +19172,412 @@ var init_task_template_service = __esm({
   }
 });
 
+// src/core/process-control.ts
+import { spawnSync } from "child_process";
+import { basename } from "path";
+function isSafePid(pid) {
+  return Number.isInteger(pid) && pid > 1 && pid !== process.pid;
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+function inspectUnixProcess(pid) {
+  const result = spawnSync("ps", ["-o", "pgid=", "-o", "command=", "-p", String(pid)], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) return null;
+  const match2 = result.stdout.trim().match(/^(\d+)\s+(.+)$/s);
+  if (!match2) return null;
+  return { processGroupId: Number(match2[1]), command: match2[2] };
+}
+function commandMatches(command, expectedExecutable) {
+  const expectedName = basename(expectedExecutable).trim().toLowerCase();
+  if (!expectedName) return false;
+  return command.toLowerCase().includes(expectedName);
+}
+function signalSpawnedProcessTree(pid, signal) {
+  if (!isSafePid(pid)) return false;
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+      return true;
+    } catch {
+    }
+  }
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function signalRecordedProcessTree(pid, signal, expectedExecutable) {
+  if (!isSafePid(pid)) return false;
+  if (process.platform === "win32") {
+    const list = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (list.status !== 0 || !commandMatches(list.stdout, expectedExecutable)) return false;
+    const args = ["/PID", String(pid), "/T"];
+    if (signal === "SIGKILL") args.push("/F");
+    return spawnSync("taskkill", args, { stdio: "ignore" }).status === 0;
+  }
+  const info = inspectUnixProcess(pid);
+  if (!info || !commandMatches(info.command, expectedExecutable)) return false;
+  try {
+    if (info.processGroupId === pid) process.kill(-pid, signal);
+    else process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_process_control = __esm({
+  "src/core/process-control.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/services/database-maintenance.service.ts
+import { Database as Database3 } from "bun:sqlite";
+import { randomUUID } from "crypto";
+import {
+  chmodSync,
+  constants,
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { basename as basename2, dirname as dirname2, resolve } from "path";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function normalizedPath(path) {
+  return path === ":memory:" ? path : resolve(path);
+}
+function safeUnlink(path) {
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    const code = error instanceof Error && "code" in error ? error.code : void 0;
+    if (code !== "ENOENT") throw error;
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var REQUIRED_TABLES, DatabaseMaintenanceConflictError, DatabaseMaintenanceService;
+var init_database_maintenance_service = __esm({
+  "src/core/services/database-maintenance.service.ts"() {
+    "use strict";
+    init_db2();
+    init_process_control();
+    REQUIRED_TABLES = ["gateway_lock", "tasks", "task_runs", "task_templates"];
+    DatabaseMaintenanceConflictError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "DatabaseMaintenanceConflictError";
+      }
+    };
+    DatabaseMaintenanceService = class {
+      static check() {
+        return this.inspect(getSqlite(), DB_FILE_PATH);
+      }
+      static backup(outputPath) {
+        const sqlite2 = getSqlite();
+        try {
+          sqlite2.query("PRAGMA wal_checkpoint(PASSIVE)").get();
+        } catch {
+        }
+        return this.writeSnapshot(sqlite2, outputPath ?? this.createBackupPath("backup"));
+      }
+      static clear(options = {}) {
+        const sqlite2 = getSqlite();
+        this.assertGatewaySafe(sqlite2, options.allowCurrentGateway ?? false);
+        this.assertNoRunningWork(sqlite2);
+        sqlite2.exec("BEGIN IMMEDIATE");
+        let backup = null;
+        try {
+          this.assertGatewaySafe(sqlite2, options.allowCurrentGateway ?? false);
+          this.assertNoRunningWork(sqlite2);
+          const before = this.readCounts(sqlite2);
+          backup = this.writeSnapshot(sqlite2, this.createBackupPath("pre-clear"));
+          sqlite2.exec("DELETE FROM task_runs");
+          sqlite2.exec("DELETE FROM tasks");
+          sqlite2.exec("DELETE FROM task_templates");
+          sqlite2.exec("COMMIT");
+          return {
+            backupPath: backup.path,
+            deleted: before,
+            check: this.inspect(sqlite2, DB_FILE_PATH)
+          };
+        } catch (error) {
+          if (sqlite2.inTransaction) sqlite2.exec("ROLLBACK");
+          if (error instanceof DatabaseMaintenanceConflictError) throw error;
+          const backupHint = backup ? `\uFF1B\u4E8B\u52A1\u5DF2\u56DE\u6EDA\uFF0C\u5907\u4EFD\u4FDD\u7559\u5728 ${backup.path}` : "";
+          throw new Error(`\u6E05\u7A7A\u6570\u636E\u5E93\u5931\u8D25${backupHint}\uFF1A${errorMessage(error)}`);
+        }
+      }
+      static restore(sourcePath) {
+        if (DB_FILE_PATH === ":memory:") {
+          throw new Error("\u5185\u5B58\u6570\u636E\u5E93\u4E0D\u652F\u6301 restore");
+        }
+        const source = normalizedPath(sourcePath);
+        const livePath = normalizedPath(DB_FILE_PATH);
+        if (source === livePath) throw new Error("\u6062\u590D\u6765\u6E90\u4E0D\u80FD\u662F\u5F53\u524D\u6570\u636E\u5E93\u6587\u4EF6");
+        const current = getSqlite();
+        this.assertGatewaySafe(current, false);
+        this.assertNoRunningWork(current);
+        if (!existsSync2(source) || !statSync(source).isFile()) {
+          throw new Error(`\u5907\u4EFD\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${source}`);
+        }
+        let sourceCheck;
+        try {
+          sourceCheck = this.inspectFile(source);
+        } catch (error) {
+          throw new Error(`\u5907\u4EFD\u6587\u4EF6\u65E0\u6548\uFF1A${errorMessage(error)}`);
+        }
+        if (!sourceCheck.ok) {
+          throw new Error(`\u5907\u4EFD\u6587\u4EF6\u6821\u9A8C\u5931\u8D25\uFF1A${sourceCheck.integrityMessages.join("; ") || "schema/foreign key error"}`);
+        }
+        const stagePath = `${livePath}.restore-${process.pid}-${randomUUID()}.tmp`;
+        const rollbackPath = `${livePath}.rollback-${process.pid}-${randomUUID()}.tmp`;
+        let safetyBackup = null;
+        let liveMoved = false;
+        try {
+          copyFileSync(source, stagePath, constants.COPYFILE_EXCL);
+          chmodSync(stagePath, 384);
+          const staged = new Database3(stagePath);
+          try {
+            const stagedCheck = this.inspect(staged, stagePath);
+            if (!stagedCheck.ok) throw new Error("\u6682\u5B58\u6062\u590D\u6587\u4EF6\u6821\u9A8C\u5931\u8D25");
+            const now = Date.now();
+            staged.query(
+              "INSERT OR REPLACE INTO gateway_lock (id, pid, acquired_at, heartbeat_at, ready_at) VALUES (1, ?, ?, ?, NULL)"
+            ).run(process.pid, now, now);
+          } finally {
+            staged.close();
+          }
+          const sqlite2 = getSqlite();
+          sqlite2.exec("BEGIN IMMEDIATE");
+          try {
+            this.assertGatewaySafe(sqlite2, false);
+            this.assertNoRunningWork(sqlite2);
+            safetyBackup = this.writeSnapshot(sqlite2, this.createBackupPath("pre-restore"));
+            const now = Date.now();
+            sqlite2.query(
+              "INSERT OR REPLACE INTO gateway_lock (id, pid, acquired_at, heartbeat_at, ready_at) VALUES (1, ?, ?, ?, NULL)"
+            ).run(process.pid, now, now);
+            sqlite2.exec("COMMIT");
+          } catch (error) {
+            if (sqlite2.inTransaction) sqlite2.exec("ROLLBACK");
+            throw error;
+          }
+          const checkpoint = sqlite2.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
+          if (checkpoint && checkpoint.busy !== 0) {
+            throw new DatabaseMaintenanceConflictError("\u6570\u636E\u5E93\u4ECD\u88AB\u5176\u4ED6\u8FDE\u63A5\u5360\u7528\uFF0C\u65E0\u6CD5\u5B89\u5168\u6062\u590D");
+          }
+          closeDb();
+          safeUnlink(`${livePath}-wal`);
+          safeUnlink(`${livePath}-shm`);
+          renameSync(livePath, rollbackPath);
+          liveMoved = true;
+          renameSync(stagePath, livePath);
+          const restored = getSqlite();
+          restored.exec("BEGIN IMMEDIATE");
+          let recoveredRunningTasks = 0;
+          let closedRunningRuns = 0;
+          try {
+            recoveredRunningTasks = this.scalar(
+              restored,
+              "SELECT COUNT(*) AS count FROM tasks WHERE status = 'running'"
+            );
+            closedRunningRuns = this.scalar(
+              restored,
+              "SELECT COUNT(*) AS count FROM task_runs WHERE status = 'running'"
+            );
+            const finishedAt = Math.floor(Date.now() / 1e3);
+            restored.query(`
+                    UPDATE task_runs
+                    SET status = 'failed', finished_at = ?,
+                        log = CASE
+                            WHEN log IS NULL OR log = '' THEN '\u6570\u636E\u5E93\u6062\u590D\u65F6\u5173\u95ED\u9057\u7559\u8FD0\u884C\u8BB0\u5F55'
+                            ELSE log || '
+\u6570\u636E\u5E93\u6062\u590D\u65F6\u5173\u95ED\u9057\u7559\u8FD0\u884C\u8BB0\u5F55'
+                        END
+                    WHERE status = 'running'
+                `).run(finishedAt);
+            restored.exec(`
+                    UPDATE tasks
+                    SET status = 'pending', started_at = NULL, finished_at = NULL
+                    WHERE status = 'running'
+                `);
+            restored.query("DELETE FROM gateway_lock WHERE pid = ?").run(process.pid);
+            restored.exec("COMMIT");
+          } catch (error) {
+            if (restored.inTransaction) restored.exec("ROLLBACK");
+            throw error;
+          }
+          const check = this.inspect(restored, livePath);
+          if (!check.ok) throw new Error("\u6062\u590D\u540E\u7684\u6570\u636E\u5E93\u672A\u901A\u8FC7\u5B8C\u6574\u6027\u6821\u9A8C");
+          safeUnlink(rollbackPath);
+          return {
+            sourcePath: source,
+            safetyBackupPath: safetyBackup.path,
+            recoveredRunningTasks,
+            closedRunningRuns,
+            check
+          };
+        } catch (error) {
+          closeDb();
+          safeUnlink(`${livePath}-wal`);
+          safeUnlink(`${livePath}-shm`);
+          safeUnlink(stagePath);
+          safeUnlink(`${stagePath}-journal`);
+          safeUnlink(`${stagePath}-wal`);
+          safeUnlink(`${stagePath}-shm`);
+          if (liveMoved && existsSync2(rollbackPath)) {
+            safeUnlink(livePath);
+            renameSync(rollbackPath, livePath);
+            try {
+              const original = getSqlite();
+              original.query("DELETE FROM gateway_lock WHERE pid = ?").run(process.pid);
+            } catch {
+            }
+          } else if (existsSync2(rollbackPath)) {
+            safeUnlink(rollbackPath);
+          } else {
+            try {
+              getSqlite().query("DELETE FROM gateway_lock WHERE pid = ?").run(process.pid);
+            } catch {
+            }
+          }
+          const backupHint = safetyBackup ? `\uFF1B\u5F53\u524D\u5E93\u5B89\u5168\u5907\u4EFD\uFF1A${safetyBackup.path}` : "";
+          throw new Error(`\u6062\u590D\u6570\u636E\u5E93\u5931\u8D25\uFF0C\u5DF2\u5C1D\u8BD5\u56DE\u6EDA${backupHint}\uFF1A${errorMessage(error)}`);
+        }
+      }
+      static inspectFile(path) {
+        let sqlite2;
+        try {
+          sqlite2 = new Database3(path, { readonly: true, strict: true });
+        } catch (error) {
+          throw new Error(`\u65E0\u6CD5\u6253\u5F00\u5907\u4EFD\u6587\u4EF6\uFF1A${errorMessage(error)}`);
+        }
+        try {
+          return this.inspect(sqlite2, path);
+        } finally {
+          sqlite2.close();
+        }
+      }
+      static inspect(sqlite2, path) {
+        const tableRows = sqlite2.query(
+          "SELECT name FROM sqlite_master WHERE type = 'table'"
+        ).all();
+        const tableNames = new Set(tableRows.map((row) => row.name));
+        const missingTables = REQUIRED_TABLES.filter((table) => !tableNames.has(table));
+        const integrityRows = sqlite2.query("PRAGMA integrity_check").all();
+        const integrityMessages = integrityRows.map((row) => row.integrity_check);
+        const foreignKeyViolations = sqlite2.query("PRAGMA foreign_key_check").all().length;
+        const journal = sqlite2.query("PRAGMA journal_mode").get();
+        const counts = missingTables.length === 0 ? this.readCounts(sqlite2) : { tasks: 0, taskRuns: 0, taskTemplates: 0 };
+        const runningTasks = missingTables.includes("tasks") ? 0 : this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM tasks WHERE status = 'running'");
+        const runningRuns = missingTables.includes("task_runs") ? 0 : this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM task_runs WHERE status = 'running'");
+        const sizeBytes = path === ":memory:" || !existsSync2(path) ? sqlite2.serialize().byteLength : statSync(path).size;
+        return {
+          ok: integrityMessages.length === 1 && integrityMessages[0] === "ok" && foreignKeyViolations === 0 && missingTables.length === 0,
+          path: normalizedPath(path),
+          sizeBytes,
+          journalMode: journal?.journal_mode ?? "unknown",
+          integrityMessages,
+          foreignKeyViolations,
+          missingTables,
+          counts,
+          runningTasks,
+          runningRuns
+        };
+      }
+      static writeSnapshot(sqlite2, outputPath) {
+        const liveCheck = this.inspect(sqlite2, DB_FILE_PATH);
+        if (!liveCheck.ok) throw new Error("\u5F53\u524D\u6570\u636E\u5E93\u672A\u901A\u8FC7\u5B8C\u6574\u6027\u6821\u9A8C\uFF0C\u5DF2\u62D2\u7EDD\u521B\u5EFA\u5907\u4EFD");
+        const output = normalizedPath(outputPath);
+        if (DB_FILE_PATH !== ":memory:" && output === normalizedPath(DB_FILE_PATH)) {
+          throw new Error("\u5907\u4EFD\u8DEF\u5F84\u4E0D\u80FD\u8986\u76D6\u5F53\u524D\u6570\u636E\u5E93");
+        }
+        if (existsSync2(output)) throw new Error(`\u5907\u4EFD\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1A${output}`);
+        mkdirSync2(dirname2(output), { recursive: true });
+        const temporary = `${output}.tmp-${process.pid}-${randomUUID()}`;
+        try {
+          writeFileSync(temporary, sqlite2.serialize(), { flag: "wx", mode: 384 });
+          const standalone = new Database3(temporary, { readwrite: true, create: false });
+          try {
+            standalone.query("PRAGMA journal_mode = DELETE").get();
+          } finally {
+            standalone.close();
+          }
+          safeUnlink(`${temporary}-wal`);
+          safeUnlink(`${temporary}-shm`);
+          const check = this.inspectFile(temporary);
+          if (!check.ok) throw new Error("\u65B0\u5907\u4EFD\u672A\u901A\u8FC7\u5B8C\u6574\u6027\u6821\u9A8C");
+          renameSync(temporary, output);
+          const finalCheck = { ...check, path: output, sizeBytes: statSync(output).size };
+          return { path: output, sizeBytes: finalCheck.sizeBytes, check: finalCheck };
+        } catch (error) {
+          safeUnlink(temporary);
+          safeUnlink(`${temporary}-wal`);
+          safeUnlink(`${temporary}-shm`);
+          throw error;
+        }
+      }
+      static createBackupPath(kind) {
+        const directory = DB_FILE_PATH === ":memory:" ? tmpdir() : dirname2(normalizedPath(DB_FILE_PATH));
+        const base = DB_FILE_PATH === ":memory:" ? "supertask-memory" : basename2(DB_FILE_PATH, ".db");
+        return resolve(directory, `${base}.${kind}-${timestamp()}-${randomUUID().slice(0, 8)}.db`);
+      }
+      static readCounts(sqlite2) {
+        return {
+          tasks: this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM tasks"),
+          taskRuns: this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM task_runs"),
+          taskTemplates: this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM task_templates")
+        };
+      }
+      static scalar(sqlite2, statement) {
+        const row = sqlite2.query(statement).get();
+        return Number(row?.count ?? 0);
+      }
+      static assertGatewaySafe(sqlite2, allowCurrentGateway) {
+        const lock = sqlite2.query("SELECT pid FROM gateway_lock WHERE id = 1").get();
+        if (!lock || !isProcessAlive(lock.pid)) return;
+        if (allowCurrentGateway && lock.pid === process.pid) return;
+        throw new DatabaseMaintenanceConflictError(
+          `Gateway PID ${lock.pid} \u4ECD\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148\u6267\u884C pm2 stop supertask-gateway`
+        );
+      }
+      static assertNoRunningWork(sqlite2) {
+        const runningTasks = this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM tasks WHERE status = 'running'");
+        const runningRuns = this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM task_runs WHERE status = 'running'");
+        if (runningTasks > 0 || runningRuns > 0) {
+          throw new DatabaseMaintenanceConflictError(
+            `\u5B58\u5728\u8FD0\u884C\u4E2D\u4EFB\u52A1\uFF08tasks=${runningTasks}, task_runs=${runningRuns}\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u5371\u9669\u64CD\u4F5C`
+          );
+        }
+      }
+    };
+  }
+});
+
 // src/gateway/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -19181,7 +19587,7 @@ __export(config_exports, {
   loadConfig: () => loadConfig,
   validateConfig: () => validateConfig
 });
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 function getConfigPath() {
@@ -19261,7 +19667,7 @@ function validateConfig(input) {
   };
 }
 function loadConfig(path = getConfigPath()) {
-  if (!existsSync2(path)) return validateConfig({ configVersion: 2 });
+  if (!existsSync3(path)) return validateConfig({ configVersion: 2 });
   try {
     return validateConfig(JSON.parse(readFileSync(path, "utf-8")));
   } catch (error) {
@@ -19315,12 +19721,12 @@ __export(pm2_exports, {
   uninstall: () => uninstall,
   upgrade: () => upgrade
 });
-import { execSync, spawnSync } from "child_process";
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { execSync, spawnSync as spawnSync2 } from "child_process";
+import { chmodSync as chmodSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname2, isAbsolute, join as join3 } from "path";
+import { dirname as dirname3, isAbsolute, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { Database as Database3 } from "bun:sqlite";
+import { Database as Database4 } from "bun:sqlite";
 function getPackageVersion() {
   const envVersion = process.env.npm_package_version;
   if (envVersion) return envVersion;
@@ -19335,14 +19741,14 @@ function getPackageVersion() {
 function resolveGatewayEntry() {
   const override = process.env.SUPERTASK_GATEWAY_ENTRY;
   if (override) {
-    if (!existsSync3(override)) throw new Error(`[supertask] Gateway entry not found: ${override}`);
+    if (!existsSync4(override)) throw new Error(`[supertask] Gateway entry not found: ${override}`);
     return override;
   }
   const candidates = [
     join3(__dirname, "../gateway/index.js"),
     join3(__dirname, "../gateway/index.ts")
   ];
-  const entry = candidates.find((candidate) => existsSync3(candidate));
+  const entry = candidates.find((candidate) => existsSync4(candidate));
   if (!entry) throw new Error(`[supertask] Gateway entry not found. Checked: ${candidates.join(", ")}`);
   return entry;
 }
@@ -19352,7 +19758,7 @@ function versionFile() {
 function getRunningVersion() {
   try {
     const path = versionFile();
-    if (!existsSync3(path)) return null;
+    if (!existsSync4(path)) return null;
     return readFileSync2(path, "utf-8").trim() || null;
   } catch {
     return null;
@@ -19360,8 +19766,8 @@ function getRunningVersion() {
 }
 function writeRunningVersion(version2) {
   const path = versionFile();
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync(path, version2, "utf-8");
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync2(path, version2, "utf-8");
 }
 function pm2Bin() {
   return process.env.SUPERTASK_PM2_BIN ?? (process.platform === "win32" ? "pm2.cmd" : "pm2");
@@ -19372,7 +19778,7 @@ function xmlEscape(value) {
 function resolvePm2Bin() {
   const configured = pm2Bin();
   if (isAbsolute(configured)) return configured;
-  const result = spawnSync("which", [configured], { encoding: "utf8" });
+  const result = spawnSync2("which", [configured], { encoding: "utf8" });
   const resolved = result.status === 0 ? result.stdout.trim().split("\n")[0] : "";
   if (!resolved) throw new Error(`[supertask] \u65E0\u6CD5\u89E3\u6790 pm2 \u53EF\u6267\u884C\u6587\u4EF6: ${configured}`);
   return resolved;
@@ -19427,14 +19833,14 @@ function installMacLaunchAgent() {
   </dict>
 </plist>
 `;
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync(path, plist, { mode: 384 });
-  chmodSync(path, 384);
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync2(path, plist, { mode: 384 });
+  chmodSync2(path, 384);
   const domain = `gui/${process.getuid()}`;
-  spawnSync(launchctlBin(), ["bootout", `${domain}/${MAC_LAUNCH_AGENT_LABEL}`], {
+  spawnSync2(launchctlBin(), ["bootout", `${domain}/${MAC_LAUNCH_AGENT_LABEL}`], {
     stdio: "ignore"
   });
-  const loaded = spawnSync(launchctlBin(), ["bootstrap", domain, path], {
+  const loaded = spawnSync2(launchctlBin(), ["bootstrap", domain, path], {
     encoding: "utf8"
   });
   if (loaded.status !== 0) {
@@ -19444,7 +19850,7 @@ function installMacLaunchAgent() {
   return path;
 }
 function isPm2Installed() {
-  const result = spawnSync(pm2Bin(), ["--version"], {
+  const result = spawnSync2(pm2Bin(), ["--version"], {
     stdio: "ignore",
     shell: process.platform === "win32"
   });
@@ -19465,7 +19871,7 @@ function installPm2() {
   }
 }
 function pm2Exec(args) {
-  const result = spawnSync(pm2Bin(), args, {
+  const result = spawnSync2(pm2Bin(), args, {
     stdio: ["pipe", "pipe", "pipe"],
     encoding: "utf-8",
     env: process.env,
@@ -19501,10 +19907,10 @@ function databasePath() {
 }
 function isGatewayReady(expectedPid) {
   const path = databasePath();
-  if (!existsSync3(path)) return false;
+  if (!existsSync4(path)) return false;
   let database = null;
   try {
-    database = new Database3(path, { readonly: true });
+    database = new Database4(path, { readonly: true });
     const row = database.query(
       "SELECT pid, heartbeat_at, ready_at FROM gateway_lock WHERE id = 1"
     ).get();
@@ -19656,7 +20062,7 @@ var init_pm2 = __esm({
   "src/daemon/pm2.ts"() {
     "use strict";
     init_config();
-    __dirname = dirname2(fileURLToPath2(import.meta.url));
+    __dirname = dirname3(fileURLToPath2(import.meta.url));
     PROCESS_NAME = "supertask-gateway";
     MAC_LAUNCH_AGENT_LABEL = "com.supertask.pm2-resurrect";
     GATEWAY_LOCK_STALE_MS = 3e4;
@@ -19867,80 +20273,6 @@ var init_health = __esm({
   }
 });
 
-// src/core/process-control.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { basename } from "path";
-function isSafePid(pid) {
-  return Number.isInteger(pid) && pid > 1 && pid !== process.pid;
-}
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error instanceof Error && "code" in error && error.code === "EPERM";
-  }
-}
-function inspectUnixProcess(pid) {
-  const result = spawnSync2("ps", ["-o", "pgid=", "-o", "command=", "-p", String(pid)], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  if (result.status !== 0) return null;
-  const match2 = result.stdout.trim().match(/^(\d+)\s+(.+)$/s);
-  if (!match2) return null;
-  return { processGroupId: Number(match2[1]), command: match2[2] };
-}
-function commandMatches(command, expectedExecutable) {
-  const expectedName = basename(expectedExecutable).trim().toLowerCase();
-  if (!expectedName) return false;
-  return command.toLowerCase().includes(expectedName);
-}
-function signalSpawnedProcessTree(pid, signal) {
-  if (!isSafePid(pid)) return false;
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-pid, signal);
-      return true;
-    } catch {
-    }
-  }
-  try {
-    process.kill(pid, signal);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function signalRecordedProcessTree(pid, signal, expectedExecutable) {
-  if (!isSafePid(pid)) return false;
-  if (process.platform === "win32") {
-    const list = spawnSync2("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    if (list.status !== 0 || !commandMatches(list.stdout, expectedExecutable)) return false;
-    const args = ["/PID", String(pid), "/T"];
-    if (signal === "SIGKILL") args.push("/F");
-    return spawnSync2("taskkill", args, { stdio: "ignore" }).status === 0;
-  }
-  const info = inspectUnixProcess(pid);
-  if (!info || !commandMatches(info.command, expectedExecutable)) return false;
-  try {
-    if (info.processGroupId === pid) process.kill(-pid, signal);
-    else process.kill(pid, signal);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var init_process_control = __esm({
-  "src/core/process-control.ts"() {
-    "use strict";
-  }
-});
-
 // src/worker/index.ts
 import { spawn } from "child_process";
 var DEFAULT_MAX_OUTPUT_CHARS, FORBIDDEN_AGENT, WorkerEngine;
@@ -20213,14 +20545,14 @@ ${output}` : ""}`;
         if (entry.child.exitCode !== null || entry.child.signalCode !== null) {
           return Promise.resolve();
         }
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           const timeout = setTimeout(() => {
             this.signalEntry(entry, "SIGKILL");
-            resolve();
+            resolve2();
           }, 5e3);
           entry.child.once("close", () => {
             clearTimeout(timeout);
-            resolve();
+            resolve2();
           });
           this.signalEntry(entry, "SIGTERM");
         });
@@ -22922,8 +23254,8 @@ __export(web_exports, {
   dashboardApp: () => dashboardApp,
   default: () => web_default
 });
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, renameSync } from "fs";
-import { dirname as dirname3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, renameSync as renameSync2 } from "fs";
+import { dirname as dirname4 } from "path";
 function parsePositiveInteger(value) {
   if (!/^\d+$/.test(value)) return null;
   const parsed = Number(value);
@@ -22973,7 +23305,7 @@ function esc(s) {
 }
 function readCurrentConfig() {
   const configPath = getConfigPath();
-  if (!existsSync4(configPath)) return {};
+  if (!existsSync5(configPath)) return {};
   try {
     return JSON.parse(readFileSync3(configPath, "utf-8"));
   } catch {
@@ -22982,11 +23314,11 @@ function readCurrentConfig() {
 }
 function writeConfig(cfg) {
   const configPath = getConfigPath();
-  const dir = dirname3(configPath);
-  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+  const dir = dirname4(configPath);
+  if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true });
   const tempPath = `${configPath}.${process.pid}.tmp`;
-  writeFileSync2(tempPath, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
-  renameSync(tempPath, configPath);
+  writeFileSync3(tempPath, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+  renameSync2(tempPath, configPath);
 }
 function renderLayout(title, activeTab, body) {
   return `<!DOCTYPE html><html><head><meta charset="UTF-8"><title>${title} - SuperTask</title>${SHARED_STYLES}
@@ -23003,12 +23335,12 @@ async function triggerTmpl(id){if(!confirm('\u7ACB\u5373\u89E6\u53D1\u4E00\u6B21
 function toggleLog(id){const el=document.getElementById('log-'+id);el.style.display=el.style.display==='none'?'block':'none';}
 
 async function clearDatabase(){
-  if(!confirm('\u786E\u5B9A\u6E05\u7A7A\u6240\u6709\u4EFB\u52A1\u6570\u636E\uFF1F\u6B64\u64CD\u4F5C\u4E0D\u53EF\u6062\u590D\uFF01'))return;
-  if(!confirm('\u518D\u6B21\u786E\u8BA4\uFF1A\u5C06\u5220\u9664\u6240\u6709\u4EFB\u52A1\u3001\u6267\u884C\u8BB0\u5F55\u548C\u8C03\u5EA6\u6A21\u677F\u3002'))return;
+  if(!confirm('\u786E\u5B9A\u6E05\u7A7A\u6240\u6709\u4EFB\u52A1\u6570\u636E\uFF1F\u7CFB\u7EDF\u4F1A\u5148\u81EA\u52A8\u521B\u5EFA\u5907\u4EFD\u3002'))return;
+  if(!confirm('\u518D\u6B21\u786E\u8BA4\uFF1A\u5C06\u4E8B\u52A1\u6027\u5220\u9664\u6240\u6709\u4EFB\u52A1\u3001\u6267\u884C\u8BB0\u5F55\u548C\u8C03\u5EA6\u6A21\u677F\u3002'))return;
   try{
-    const r=await fetch('/api/database/clear',{method:'POST'});
+    const r=await fetch('/api/database/clear',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({confirmation:'CLEAR'})});
     const d=await r.json();
-    if(d.success){alert('\u6570\u636E\u5E93\u5DF2\u6E05\u7A7A');location.reload();}
+    if(d.success){alert('\u6570\u636E\u5E93\u5DF2\u6E05\u7A7A\uFF0C\u81EA\u52A8\u5907\u4EFD\uFF1A'+d.backupPath);location.reload();}
     else{alert('\u6E05\u7A7A\u5931\u8D25: '+d.error);}
   }catch(e){alert('\u6E05\u7A7A\u5931\u8D25: '+e.message);}
 }
@@ -23069,6 +23401,7 @@ var init_web = __esm({
     init_task_service();
     init_task_run_service();
     init_task_template_service();
+    init_database_maintenance_service();
     init_drizzle_orm();
     init_db2();
     init_config();
@@ -23377,7 +23710,7 @@ var init_web = __esm({
       const stats = await TaskService.stats({});
       const runningRuns = await TaskRunService.getAllRunningRuns();
       const templates = await TaskTemplateService.list(100);
-      const configExists = existsSync4(configPath);
+      const configExists = existsSync5(configPath);
       let runRows = "";
       if (runningRuns.length > 0) {
         for (const run of runningRuns) {
@@ -23451,7 +23784,7 @@ var init_web = __esm({
 
       <div class="card mt16" style="border-color:var(--red)">
         <h3 style="margin:0 0 12px;font-size:14px;color:var(--red)">\u5371\u9669\u64CD\u4F5C</h3>
-        <p class="sm mu" style="margin:0 0 12px">\u6E05\u7A7A\u6240\u6709\u4EFB\u52A1\u6570\u636E\uFF08tasks + task_runs + task_templates\uFF09\uFF0C\u4E0D\u53EF\u6062\u590D\u3002</p>
+        <p class="sm mu" style="margin:0 0 12px">\u81EA\u52A8\u5907\u4EFD\u540E\u4E8B\u52A1\u6027\u6E05\u7A7A tasks\u3001task_runs \u548C task_templates\uFF1B\u5B58\u5728\u8FD0\u884C\u4E2D\u4EFB\u52A1\u65F6\u4F1A\u62D2\u7EDD\u6267\u884C\u3002</p>
         <button class="btn btn-danger" style="border-color:var(--red);color:var(--red);padding:6px 16px" onclick="clearDatabase()">\u6E05\u7A7A\u6570\u636E\u5E93</button>
       </div>`;
       return c.html(renderLayout("\u7CFB\u7EDF\u72B6\u6001", "system", body));
@@ -23556,14 +23889,16 @@ var init_web = __esm({
       }
     });
     app.post("/api/database/clear", async (c) => {
+      const body = await c.req.json().catch(() => ({}));
+      if (body.confirmation !== "CLEAR") {
+        return c.json({ success: false, error: "confirmation must be CLEAR" }, 400);
+      }
       try {
-        const { tasks: tasks3, taskRuns: taskRuns4, taskTemplates: taskTemplates4 } = schema_exports;
-        await db.delete(taskRuns4);
-        await db.delete(taskTemplates4);
-        await db.delete(tasks3);
-        return c.json({ success: true });
+        const result = DatabaseMaintenanceService.clear({ allowCurrentGateway: true });
+        return c.json({ success: true, ...result });
       } catch (err) {
-        return c.json({ success: false, error: err instanceof Error ? err.message : String(err) }, 500);
+        const status = err instanceof DatabaseMaintenanceConflictError ? 409 : 500;
+        return c.json({ success: false, error: err instanceof Error ? err.message : String(err) }, status);
       }
     });
     dashboardApp = app;
@@ -23762,13 +24097,13 @@ __export(update_exports, {
   resolveInstalledPlugin: () => resolveInstalledPlugin
 });
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4, readdirSync } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
 function pluginAt(packageDir) {
   const packageJson = join4(packageDir, "package.json");
   const gatewayEntry = join4(packageDir, "dist/gateway/index.js");
-  if (!existsSync5(packageJson) || !existsSync5(gatewayEntry)) return null;
+  if (!existsSync6(packageJson) || !existsSync6(gatewayEntry)) return null;
   try {
     const pkg = JSON.parse(readFileSync4(packageJson, "utf8"));
     if (pkg.name !== PACKAGE_NAME || typeof pkg.version !== "string") return null;
@@ -23793,6 +24128,11 @@ function compareVersions(left, right) {
 function cacheRoot() {
   return process.env.SUPERTASK_OPENCODE_CACHE_DIR ?? join4(homedir4(), ".cache/opencode/packages");
 }
+function installedPlugins() {
+  const root = cacheRoot();
+  const packageDirs = existsSync6(root) ? readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && (entry.name === PACKAGE_NAME || entry.name.startsWith(`${PACKAGE_NAME}@`))).map((entry) => join4(root, entry.name, "node_modules", PACKAGE_NAME)) : [];
+  return packageDirs.map(pluginAt).filter((plugin) => plugin !== null);
+}
 function resolveInstalledPlugin() {
   const override = process.env.SUPERTASK_PLUGIN_PACKAGE_DIR;
   if (override) {
@@ -23800,9 +24140,7 @@ function resolveInstalledPlugin() {
     if (!plugin) throw new Error(`[supertask] \u5B89\u88C5\u5305\u65E0\u6548\u6216\u7F3A\u5C11 Gateway \u6784\u5EFA\u4EA7\u7269: ${override}`);
     return plugin;
   }
-  const root = cacheRoot();
-  const packageDirs = existsSync5(root) ? readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && (entry.name === PACKAGE_NAME || entry.name.startsWith(`${PACKAGE_NAME}@`))).map((entry) => join4(root, entry.name, "node_modules", PACKAGE_NAME)) : [];
-  const installed = packageDirs.map(pluginAt).filter((plugin) => plugin !== null).sort((left, right) => compareVersions(right.version, left.version));
+  const installed = installedPlugins().sort((left, right) => compareVersions(right.version, left.version));
   if (!installed[0]) {
     throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u7F13\u5B58\u4E2D\u627E\u4E0D\u5230\u53EF\u8FD0\u884C\u7684 ${PACKAGE_NAME}`);
   }
@@ -23811,10 +24149,52 @@ function resolveInstalledPlugin() {
 function opencodeBin() {
   return process.env.SUPERTASK_OPENCODE_BIN ?? "opencode";
 }
+function npmBin() {
+  return process.env.SUPERTASK_NPM_BIN ?? "npm";
+}
+function latestVersion() {
+  const result = spawnSync3(npmBin(), [
+    "view",
+    PACKAGE_NAME,
+    "dist-tags.latest",
+    "--json"
+  ], {
+    encoding: "utf8",
+    env: process.env,
+    timeout: 3e4
+  });
+  const output = `${result.stdout ?? ""}`.trim();
+  if (result.error) {
+    throw new Error(`[supertask] \u67E5\u8BE2 npm latest \u5931\u8D25: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    const detail = `${result.stderr ?? ""}`.trim();
+    throw new Error(`[supertask] \u67E5\u8BE2 npm latest \u5931\u8D25: ${detail || `\u9000\u51FA\u7801 ${result.status}`}`);
+  }
+  let version2;
+  try {
+    version2 = JSON.parse(output);
+  } catch {
+    throw new Error(`[supertask] npm latest \u8FD4\u56DE\u65E0\u6CD5\u89E3\u6790: ${output || "(empty)"}`);
+  }
+  if (typeof version2 !== "string" || versionParts(version2) === null) {
+    throw new Error(`[supertask] npm latest \u7248\u672C\u65E0\u6548: ${String(version2)}`);
+  }
+  return version2;
+}
+function resolveInstalledVersion(expectedVersion) {
+  const override = process.env.SUPERTASK_PLUGIN_PACKAGE_DIR;
+  const installed = override ? [pluginAt(override)].filter((plugin) => plugin !== null) : installedPlugins();
+  const matched = installed.find((plugin) => plugin.version === expectedVersion);
+  if (matched) return matched;
+  const actual = installed.length > 0 ? installed.map((plugin) => plugin.version).join(", ") : "\u672A\u627E\u5230\u53EF\u8FD0\u884C\u7F13\u5B58";
+  throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u7F13\u5B58\u7248\u672C\u4E0D\u5339\u914D\uFF1A\u671F\u671B ${expectedVersion}\uFF0C\u5B9E\u9645 ${actual}`);
+}
 function installLatestPlugin() {
+  const version2 = latestVersion();
   const result = spawnSync3(opencodeBin(), [
     "plugin",
-    `${PACKAGE_NAME}@latest`,
+    `${PACKAGE_NAME}@${version2}`,
     "--global",
     "--force"
   ], {
@@ -23829,7 +24209,7 @@ function installLatestPlugin() {
   if (result.status !== 0) {
     throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u66F4\u65B0\u5931\u8D25: ${output || `\u9000\u51FA\u7801 ${result.status}`}`);
   }
-  return resolveInstalledPlugin();
+  return resolveInstalledVersion(version2);
 }
 var PACKAGE_NAME;
 var init_update2 = __esm({
@@ -23859,6 +24239,7 @@ var {
 // src/cli/index.ts
 init_task_service();
 init_task_template_service();
+init_database_maintenance_service();
 init_db2();
 
 // src/core/duration.ts
@@ -24107,15 +24488,35 @@ program2.command("template").description("\u7BA1\u7406\u4EFB\u52A1\u8C03\u5EA6\u
     console.log(JSON.stringify({ deleted, id: parseInt(options.id) }));
   }))
 );
+var databaseCommand = new Command("db").description("\u6570\u636E\u5E93\u68C0\u67E5\u3001\u5907\u4EFD\u3001\u6E05\u7A7A\u4E0E\u6062\u590D");
+databaseCommand.command("check").description("\u68C0\u67E5\u6570\u636E\u5E93\u5B8C\u6574\u6027\u3001\u5916\u952E\u548C\u4E1A\u52A1\u8868\u7EDF\u8BA1").action(async () => withDb(async () => {
+  console.log(JSON.stringify(DatabaseMaintenanceService.check(), null, 2));
+}));
+databaseCommand.command("backup").description("\u521B\u5EFA\u7ECF\u8FC7\u5B8C\u6574\u6027\u6821\u9A8C\u7684\u4E00\u81F4\u6027\u5907\u4EFD").option("-o, --output <path>", "\u5907\u4EFD\u6587\u4EF6\u8DEF\u5F84\uFF08\u9ED8\u8BA4\u5199\u5165\u6570\u636E\u5E93\u76EE\u5F55\uFF09").action(async (options) => withDb(async () => {
+  console.log(JSON.stringify(DatabaseMaintenanceService.backup(options.output), null, 2));
+}));
+databaseCommand.command("clear").description("\u5907\u4EFD\u540E\u4E8B\u52A1\u6027\u6E05\u7A7A\u4EFB\u52A1\u3001\u6267\u884C\u8BB0\u5F55\u548C\u8C03\u5EA6\u6A21\u677F").option("--confirm <word>", "\u5371\u9669\u64CD\u4F5C\u786E\u8BA4\uFF0C\u5FC5\u987B\u586B\u5199 CLEAR").action(async (options) => withDb(async () => {
+  if (options.confirm !== "CLEAR") {
+    throw new Error("\u6E05\u7A7A\u6570\u636E\u5E93\u5FC5\u987B\u663E\u5F0F\u4F20\u5165 --confirm CLEAR");
+  }
+  console.log(JSON.stringify(DatabaseMaintenanceService.clear(), null, 2));
+}));
+databaseCommand.command("restore").description("\u81EA\u52A8\u5907\u4EFD\u5F53\u524D\u5E93\u540E\uFF0C\u4ECE\u6307\u5B9A\u5907\u4EFD\u6062\u590D\u6570\u636E\u5E93").requiredOption("--from <path>", "\u8981\u6062\u590D\u7684 SQLite \u5907\u4EFD\u6587\u4EF6").option("--confirm <word>", "\u5371\u9669\u64CD\u4F5C\u786E\u8BA4\uFF0C\u5FC5\u987B\u586B\u5199 RESTORE").action(async (options) => withDb(async () => {
+  if (options.confirm !== "RESTORE") {
+    throw new Error("\u6062\u590D\u6570\u636E\u5E93\u5FC5\u987B\u663E\u5F0F\u4F20\u5165 --confirm RESTORE");
+  }
+  console.log(JSON.stringify(DatabaseMaintenanceService.restore(options.from), null, 2));
+}));
+program2.addCommand(databaseCommand);
 program2.command("init").description("Initialize SuperTask (create config + run migrations)").action(async () => withDb(async () => {
-  const { existsSync: existsSync6, mkdirSync: mkdirSync4, writeFileSync: writeFileSync3 } = await import("fs");
-  const { dirname: dirname4 } = await import("path");
+  const { existsSync: existsSync7, mkdirSync: mkdirSync5, writeFileSync: writeFileSync4 } = await import("fs");
+  const { dirname: dirname5 } = await import("path");
   const { getConfigPath: getConfigPath2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const configPath = getConfigPath2();
-  if (!existsSync6(configPath)) {
-    const dir = dirname4(configPath);
-    if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
-    writeFileSync3(configPath, JSON.stringify({
+  if (!existsSync7(configPath)) {
+    const dir = dirname5(configPath);
+    if (!existsSync7(dir)) mkdirSync5(dir, { recursive: true });
+    writeFileSync4(configPath, JSON.stringify({
       configVersion: 2,
       worker: { maxConcurrency: 2 },
       scheduler: { enabled: true }
@@ -24180,7 +24581,7 @@ program2.command("upgrade").description("Update OpenCode plugin cache and restar
     installed = installLatestPlugin2();
   } catch (err) {
     console.error(err instanceof Error ? err.message : String(err));
-    console.error("Try manually: opencode plugin opencode-supertask@latest --global --force");
+    console.error("Try manually: query npm dist-tags.latest, then install that exact version with opencode plugin.");
     process.exit(1);
   }
   try {