opencode-supertask 0.1.25 → 0.1.27

package/dist/web/index.js

@@ -16521,7 +16521,9 @@ var tasks = sqliteTable("tasks", {
 }, (table) => [
   index("tasks_queue_idx").on(table.status, table.retryAfter, table.urgency, table.importance, table.createdAt, table.id),
   index("tasks_batch_status_idx").on(table.batchId, table.status),
-  index("tasks_template_status_idx").on(table.templateId, table.status)
+  index("tasks_template_status_idx").on(table.templateId, table.status),
+  index("tasks_depends_on_status_idx").on(table.dependsOn, table.status),
+  index("tasks_cleanup_idx").on(table.finishedAt, table.id, table.status)
 ]);
 var TASK_CATEGORIES = [
   "translate",
@@ -16544,7 +16546,8 @@ var taskRuns = sqliteTable("task_runs", {
   lockedBy: text("locked_by"),
   heartbeatAt: integer("heartbeat_at"),
   workerPid: integer("worker_pid"),
-  childPid: integer("child_pid")
+  childPid: integer("child_pid"),
+  launchProtocol: text("launch_protocol")
 }, (table) => [
   index("task_runs_task_started_idx").on(table.taskId, table.startedAt, table.id),
   index("task_runs_status_heartbeat_idx").on(table.status, table.heartbeatAt)
@@ -16574,7 +16577,13 @@ var taskTemplates = sqliteTable("task_templates", {
   createdAt: integer("created_at").default(0),
   updatedAt: integer("updated_at").default(0)
 }, (table) => [
-  index("task_templates_due_idx").on(table.enabled, table.nextRunAt, table.id)
+  index("task_templates_due_idx").on(table.enabled, table.nextRunAt, table.id),
+  index("task_templates_retention_idx").on(
+    table.scheduleType,
+    table.enabled,
+    table.lastRunAt,
+    table.id
+  )
 ]);
 
 // src/core/db/index.ts
@@ -16599,36 +16608,47 @@ function getMigrationsFolder() {
   }
   return join(__dirname, "../../drizzle");
 }
-function initDb() {
-  const dataDir = dirname(DB_FILE_PATH);
-  if (!existsSync(dataDir)) {
-    mkdirSync(dataDir, { recursive: true });
-  }
-  _sqlite = new Database2(DB_FILE_PATH);
-  _sqlite.exec("PRAGMA journal_mode = WAL;");
-  _sqlite.exec("PRAGMA busy_timeout = 5000;");
-  _sqlite.exec(`
+function ensureGatewayLock(sqliteDb) {
+  sqliteDb.exec(`
         CREATE TABLE IF NOT EXISTS gateway_lock (
             id INTEGER PRIMARY KEY CHECK (id = 1),
             pid INTEGER NOT NULL,
             acquired_at INTEGER NOT NULL,
             heartbeat_at INTEGER NOT NULL,
-            ready_at INTEGER
+            ready_at INTEGER,
+            version TEXT
         );
     `);
-  const gatewayLockColumns = _sqlite.query("PRAGMA table_info(gateway_lock)").all();
-  if (!gatewayLockColumns.some((column) => column.name === "ready_at")) {
-    _sqlite.exec("ALTER TABLE gateway_lock ADD COLUMN ready_at INTEGER;");
+  const columns = sqliteDb.query("PRAGMA table_info(gateway_lock)").all();
+  if (!columns.some((column) => column.name === "ready_at")) {
+    sqliteDb.exec("ALTER TABLE gateway_lock ADD COLUMN ready_at INTEGER;");
+  }
+  if (!columns.some((column) => column.name === "version")) {
+    sqliteDb.exec("ALTER TABLE gateway_lock ADD COLUMN version TEXT;");
   }
-  _db = drizzle(_sqlite, { schema: schema_exports });
+}
+function migrateSqliteDatabase(sqliteDb) {
+  ensureGatewayLock(sqliteDb);
+  const drizzleDb = drizzle(sqliteDb, { schema: schema_exports });
+  migrate(drizzleDb, { migrationsFolder: getMigrationsFolder() });
+  sqliteDb.exec("PRAGMA foreign_keys = ON;");
+  const violations = sqliteDb.query("PRAGMA foreign_key_check;").all();
+  if (violations.length > 0) {
+    throw new Error(`\u68C0\u6D4B\u5230 ${violations.length} \u6761\u5B64\u7ACB\u5173\u8054\u8BB0\u5F55\uFF0C\u8BF7\u5148\u4FEE\u590D\u6570\u636E\u518D\u542F\u52A8`);
+  }
+  return drizzleDb;
+}
+function initDb() {
+  const dataDir = dirname(DB_FILE_PATH);
+  if (!existsSync(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  _sqlite = new Database2(DB_FILE_PATH);
+  _sqlite.exec("PRAGMA journal_mode = WAL;");
+  _sqlite.exec("PRAGMA busy_timeout = 5000;");
   if (!_migrationRan) {
     try {
-      migrate(_db, { migrationsFolder: getMigrationsFolder() });
-      _sqlite.exec("PRAGMA foreign_keys = ON;");
-      const violations = _sqlite.query("PRAGMA foreign_key_check;").all();
-      if (violations.length > 0) {
-        throw new Error(`\u68C0\u6D4B\u5230 ${violations.length} \u6761\u5B64\u7ACB\u5173\u8054\u8BB0\u5F55\uFF0C\u8BF7\u5148\u4FEE\u590D\u6570\u636E\u518D\u542F\u52A8`);
-      }
+      _db = migrateSqliteDatabase(_sqlite);
       _migrationRan = true;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -16639,6 +16659,8 @@ function initDb() {
       console.error(`[supertask] migration failed: ${msg}`);
       throw new Error(`[supertask] DB migration failed: ${msg}`);
     }
+  } else {
+    _db = drizzle(_sqlite, { schema: schema_exports });
   }
   return _db;
 }
@@ -16650,14 +16672,6 @@ function getSqlite() {
   if (!_sqlite) initDb();
   return _sqlite;
 }
-function closeDb() {
-  if (_sqlite) {
-    _sqlite.close();
-    _sqlite = null;
-    _db = null;
-    _migrationRan = false;
-  }
-}
 var db = new Proxy({}, {
   get(_, prop) {
     const target = getDb();
@@ -16683,6 +16697,58 @@ function computeBackoff(retryCount, baseMs = 3e4, maxMs = MAX_BACKOFF_MS) {
 
 // src/core/services/task.service.ts
 var { tasks: tasks2, taskRuns: taskRuns2 } = schema_exports;
+var cleanupInvocation = 0;
+var TaskDeletionConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TaskDeletionConflictError";
+  }
+};
+function hasNoExecutableDependents() {
+  return sql`NOT EXISTS (
+        SELECT 1 FROM tasks AS dependent_task
+        WHERE dependent_task.depends_on = ${tasks2.id}
+          AND dependent_task.status IN ('pending', 'running', 'failed', 'dead_letter')
+    )`;
+}
+function hasViableDependency() {
+  return or(
+    isNull(tasks2.dependsOn),
+    sql`EXISTS (
+            SELECT 1 FROM tasks AS dependency_task
+            WHERE dependency_task.id = ${tasks2.dependsOn}
+              AND dependency_task.cwd IS ${tasks2.cwd}
+              AND (
+                  dependency_task.status IN ('pending', 'running', 'done')
+                  OR (
+                      dependency_task.status = 'failed'
+                      AND dependency_task.retry_count <= dependency_task.max_retries
+                  )
+              )
+        )`
+  );
+}
+function blockedDependentsOf(prerequisiteId) {
+  return sql`${tasks2.id} IN (
+        WITH RECURSIVE blocked_task(id) AS (
+            SELECT direct_dependent.id
+            FROM tasks AS direct_dependent
+            WHERE direct_dependent.depends_on = ${prerequisiteId}
+              AND direct_dependent.status IN ('pending', 'failed')
+              AND EXISTS (
+                  SELECT 1 FROM tasks AS prerequisite
+                  WHERE prerequisite.id = ${prerequisiteId}
+                    AND prerequisite.status IN ('dead_letter', 'cancelled')
+              )
+            UNION
+            SELECT descendant.id
+            FROM tasks AS descendant
+            INNER JOIN blocked_task ON descendant.depends_on = blocked_task.id
+            WHERE descendant.status IN ('pending', 'failed')
+        )
+        SELECT id FROM blocked_task
+    )`;
+}
 var TaskService = class {
   static buildScopeWhere(scope) {
     const conditions = [];
@@ -16693,8 +16759,28 @@ var TaskService = class {
   }
   static async add(data) {
     this.validateNewTask(data);
-    const result = await db.insert(tasks2).values(data).returning();
-    return result[0];
+    return db.transaction((tx) => {
+      if (data.dependsOn != null) {
+        const dependency = tx.select({
+          id: tasks2.id,
+          cwd: tasks2.cwd,
+          status: tasks2.status,
+          retryCount: tasks2.retryCount,
+          maxRetries: tasks2.maxRetries
+        }).from(tasks2).where(eq(tasks2.id, data.dependsOn)).get();
+        if (!dependency) {
+          throw new Error(`dependsOn \u6307\u5411\u7684\u4EFB\u52A1 #${data.dependsOn} \u4E0D\u5B58\u5728`);
+        }
+        if ((dependency.cwd ?? null) !== (data.cwd ?? null)) {
+          throw new Error("dependsOn \u5FC5\u987B\u6307\u5411\u540C\u4E00 cwd \u7684\u4EFB\u52A1");
+        }
+        const dependencyIsRecoverable = dependency.status === "pending" || dependency.status === "running" || dependency.status === "done" || dependency.status === "failed" && (dependency.retryCount ?? 0) <= (dependency.maxRetries ?? 3);
+        if (!dependencyIsRecoverable) {
+          throw new Error(`dependsOn \u6307\u5411\u7684\u4EFB\u52A1 #${data.dependsOn} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`);
+        }
+      }
+      return tx.insert(tasks2).values(data).returning().get();
+    }, { behavior: "immediate" });
   }
   static validateNewTask(data) {
     if (!data.name.trim()) throw new Error("name \u4E0D\u80FD\u4E3A\u7A7A");
@@ -16746,23 +16832,54 @@ var TaskService = class {
     if (batchFilter) {
       conditions.push(batchFilter);
     }
-    const allTasks = await db.select().from(tasks2).where(and(...conditions)).orderBy(
+    const result = await db.select().from(tasks2).where(and(
+      ...conditions,
+      or(
+        isNull(tasks2.dependsOn),
+        sql`EXISTS (
+                        SELECT 1 FROM tasks AS dependency_task
+                        WHERE dependency_task.id = ${tasks2.dependsOn}
+                          AND dependency_task.status = 'done'
+                          AND dependency_task.cwd IS ${tasks2.cwd}
+                    )`
+      ),
+      or(
+        isNull(tasks2.batchId),
+        sql`NOT EXISTS (
+                        SELECT 1 FROM tasks AS running_batch_task
+                        WHERE running_batch_task.batch_id = ${tasks2.batchId}
+                          AND (
+                              running_batch_task.status = 'running'
+                              OR EXISTS (
+                                  SELECT 1 FROM task_runs AS running_batch_run
+                                  WHERE running_batch_run.task_id = running_batch_task.id
+                                    AND running_batch_run.status = 'running'
+                              )
+                          )
+                        )`
+      ),
+      sql`NOT EXISTS (
+                    SELECT 1 FROM task_runs AS candidate_active_run
+                    WHERE candidate_active_run.task_id = ${tasks2.id}
+                      AND candidate_active_run.status = 'running'
+                )`
+    )).orderBy(
       desc(tasks2.urgency),
       desc(tasks2.importance),
       asc(tasks2.createdAt),
       asc(tasks2.id)
-    );
-    for (const task of allTasks) {
-      if (task.dependsOn) {
-        const depTask = await this.getById(task.dependsOn, scope);
-        if (depTask && depTask.status === "done") {
-          return task;
-        }
-        continue;
-      }
-      return task;
-    }
-    return null;
+    ).limit(1);
+    return result[0] ?? null;
+  }
+  static async countRunning() {
+    return db.transaction((tx) => {
+      const runningTasks = tx.select({ count: sql`count(*)` }).from(tasks2).where(eq(tasks2.status, "running")).get();
+      const runsWithoutRunningTask = tx.select({ count: sql`count(DISTINCT ${taskRuns2.taskId})` }).from(taskRuns2).innerJoin(tasks2, eq(tasks2.id, taskRuns2.taskId)).where(and(
+        eq(taskRuns2.status, "running"),
+        sql`${tasks2.status} <> 'running'`
+      )).get();
+      return Number(runningTasks?.count ?? 0) + Number(runsWithoutRunningTask?.count ?? 0);
+    }, { behavior: "deferred" });
   }
   static async start(id, scope = {}) {
     const conditions = [
@@ -16798,27 +16915,202 @@ var TaskService = class {
     return result[0] || null;
   }
   static async fail(id, log, scope = {}, options) {
-    const current = await this.getById(id, scope);
-    if (!current || current.status !== "running") return null;
-    const newRetryCount = (current.retryCount ?? 0) + 1;
-    const maxRetries = current.maxRetries ?? 3;
-    const isDeadLetter = options?.setDeadLetter ?? newRetryCount > maxRetries;
-    const conditions = [
-      eq(tasks2.id, id),
-      eq(tasks2.status, "running"),
-      ...this.buildScopeWhere(scope)
-    ];
+    return db.transaction((tx) => {
+      const current = tx.select().from(tasks2).where(and(
+        eq(tasks2.id, id),
+        eq(tasks2.status, "running"),
+        ...this.buildScopeWhere(scope)
+      )).get();
+      if (!current) return null;
+      const newRetryCount = (current.retryCount ?? 0) + 1;
+      const maxRetries = current.maxRetries ?? 3;
+      const isDeadLetter = options?.setDeadLetter ?? newRetryCount > maxRetries;
+      const failed = tx.update(tasks2).set({
+        status: isDeadLetter ? "dead_letter" : "failed",
+        finishedAt: /* @__PURE__ */ new Date(),
+        resultLog: log,
+        retryCount: newRetryCount,
+        retryAfter: isDeadLetter ? null : options?.retryAfterMs ?? Date.now() + computeBackoff(
+          newRetryCount,
+          current.retryBackoffMs ?? 3e4
+        )
+      }).where(and(eq(tasks2.id, id), eq(tasks2.status, "running"))).returning().get();
+      if (failed?.status === "dead_letter") {
+        tx.update(tasks2).set({
+          status: "dead_letter",
+          finishedAt: /* @__PURE__ */ new Date(),
+          retryAfter: null,
+          resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${id} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+        }).where(blockedDependentsOf(id)).run();
+      }
+      return failed ?? null;
+    }, { behavior: "immediate" });
+  }
+  static async completeRun(taskId, runId, log) {
+    return db.transaction((tx) => {
+      const currentTask = tx.select().from(tasks2).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).get();
+      const currentRun = tx.select({ id: taskRuns2.id }).from(taskRuns2).where(and(
+        eq(taskRuns2.id, runId),
+        eq(taskRuns2.taskId, taskId),
+        eq(taskRuns2.status, "running")
+      )).get();
+      if (!currentTask || !currentRun) return null;
+      const finishedAt = /* @__PURE__ */ new Date();
+      const completed = tx.update(tasks2).set({
+        status: "done",
+        finishedAt,
+        resultLog: log,
+        retryAfter: null
+      }).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).returning().get();
+      if (!completed) return null;
+      tx.update(taskRuns2).set({ status: "done", finishedAt, log }).where(and(eq(taskRuns2.id, runId), eq(taskRuns2.status, "running"))).run();
+      return completed;
+    }, { behavior: "immediate" });
+  }
+  static async failRun(taskId, runId, log, options) {
+    const failed = db.transaction((tx) => {
+      const currentTask = tx.select().from(tasks2).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).get();
+      const currentRun = tx.select({ id: taskRuns2.id }).from(taskRuns2).where(and(
+        eq(taskRuns2.id, runId),
+        eq(taskRuns2.taskId, taskId),
+        eq(taskRuns2.status, "running")
+      )).get();
+      if (!currentTask || !currentRun) return null;
+      const newRetryCount = (currentTask.retryCount ?? 0) + 1;
+      const maxRetries = currentTask.maxRetries ?? 3;
+      const isDeadLetter = options?.setDeadLetter ?? newRetryCount > maxRetries;
+      const finishedAt = /* @__PURE__ */ new Date();
+      const retryAfter = isDeadLetter ? null : options?.retryAfterMs ?? Date.now() + computeBackoff(
+        newRetryCount,
+        currentTask.retryBackoffMs ?? 3e4
+      );
+      const failed2 = tx.update(tasks2).set({
+        status: isDeadLetter ? "dead_letter" : "failed",
+        finishedAt,
+        resultLog: log,
+        retryCount: newRetryCount,
+        retryAfter
+      }).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).returning().get();
+      if (!failed2) return null;
+      tx.update(taskRuns2).set({ status: "failed", finishedAt, log }).where(and(eq(taskRuns2.id, runId), eq(taskRuns2.status, "running"))).run();
+      if (failed2.status === "dead_letter") {
+        tx.update(tasks2).set({
+          status: "dead_letter",
+          finishedAt,
+          retryAfter: null,
+          resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${taskId} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+        }).where(blockedDependentsOf(taskId)).run();
+      }
+      return failed2;
+    }, { behavior: "immediate" });
+    return failed;
+  }
+  static async recoverRun(taskId, runId, log) {
+    const recovery = db.transaction((tx) => {
+      const currentTask = tx.select().from(tasks2).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).get();
+      const currentRun = tx.select({ id: taskRuns2.id }).from(taskRuns2).where(and(
+        eq(taskRuns2.id, runId),
+        eq(taskRuns2.taskId, taskId),
+        eq(taskRuns2.status, "running")
+      )).get();
+      if (!currentRun) return null;
+      const finishedAt = /* @__PURE__ */ new Date();
+      tx.update(taskRuns2).set({ status: "failed", finishedAt, log }).where(and(eq(taskRuns2.id, runId), eq(taskRuns2.status, "running"))).run();
+      if (!currentTask) return null;
+      const retryCount = (currentTask.retryCount ?? 0) + 1;
+      const maxRetries = currentTask.maxRetries ?? 3;
+      const isDeadLetter = retryCount > maxRetries;
+      const recoveryStatus = isDeadLetter ? "dead_letter" : "pending";
+      const retryAfterMs = isDeadLetter ? null : Date.now() + computeBackoff(
+        retryCount,
+        currentTask.retryBackoffMs ?? 3e4
+      );
+      tx.update(tasks2).set({
+        status: recoveryStatus,
+        startedAt: null,
+        finishedAt: isDeadLetter ? finishedAt : null,
+        retryCount,
+        retryAfter: retryAfterMs,
+        resultLog: log
+      }).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).run();
+      if (recoveryStatus === "dead_letter") {
+        tx.update(tasks2).set({
+          status: "dead_letter",
+          finishedAt,
+          retryAfter: null,
+          resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${taskId} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+        }).where(blockedDependentsOf(taskId)).run();
+      }
+      return {
+        status: recoveryStatus,
+        retryCount,
+        retryAfterMs
+      };
+    }, { behavior: "immediate" });
+    return recovery;
+  }
+  static async interruptRun(taskId, runId, log) {
+    return db.transaction((tx) => {
+      const currentRun = tx.select({ id: taskRuns2.id }).from(taskRuns2).where(and(
+        eq(taskRuns2.id, runId),
+        eq(taskRuns2.taskId, taskId),
+        eq(taskRuns2.status, "running")
+      )).get();
+      if (!currentRun) return false;
+      const updatedRun = tx.update(taskRuns2).set({ status: "failed", finishedAt: /* @__PURE__ */ new Date(), log }).where(and(eq(taskRuns2.id, runId), eq(taskRuns2.status, "running"))).returning({ id: taskRuns2.id }).get();
+      tx.update(tasks2).set({
+        status: "pending",
+        startedAt: null,
+        finishedAt: null,
+        retryAfter: null,
+        resultLog: log
+      }).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).run();
+      return updatedRun != null;
+    }, { behavior: "immediate" });
+  }
+  static async resolveBlockedDependencies() {
+    const finishedAt = /* @__PURE__ */ new Date();
+    const result = await db.update(tasks2).set({
+      status: "dead_letter",
+      finishedAt,
+      retryAfter: null,
+      resultLog: "\u4F9D\u8D56\u4EFB\u52A1\u4E0D\u5B58\u5728\u3001\u8DE8\u9879\u76EE\u6216\u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001"
+    }).where(sql`${tasks2.id} IN (
+                WITH RECURSIVE blocked_task(id) AS (
+                    SELECT candidate.id
+                    FROM tasks AS candidate
+                    WHERE candidate.status IN ('pending', 'failed')
+                      AND candidate.depends_on IS NOT NULL
+                      AND NOT EXISTS (
+                          SELECT 1 FROM tasks AS viable_dependency
+                          WHERE viable_dependency.id = candidate.depends_on
+                            AND viable_dependency.cwd IS candidate.cwd
+                            AND (
+                                viable_dependency.status IN ('pending', 'running', 'done')
+                                OR (
+                                    viable_dependency.status = 'failed'
+                                    AND viable_dependency.retry_count <= viable_dependency.max_retries
+                                )
+                            )
+                      )
+                    UNION
+                    SELECT descendant.id
+                    FROM tasks AS descendant
+                    INNER JOIN blocked_task ON descendant.depends_on = blocked_task.id
+                    WHERE descendant.status IN ('pending', 'failed')
+                )
+                SELECT id FROM blocked_task
+            )`).returning();
+    return result.length;
+  }
+  static async rejectBlockedDependents(prerequisiteId) {
     const result = await db.update(tasks2).set({
-      status: isDeadLetter ? "dead_letter" : "failed",
+      status: "dead_letter",
       finishedAt: /* @__PURE__ */ new Date(),
-      resultLog: log,
-      retryCount: newRetryCount,
-      retryAfter: isDeadLetter ? null : options?.retryAfterMs ?? Date.now() + computeBackoff(
-        newRetryCount,
-        current.retryBackoffMs ?? 3e4
-      )
-    }).where(and(...conditions)).returning();
-    return result[0] || null;
+      retryAfter: null,
+      resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${prerequisiteId} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+    }).where(blockedDependentsOf(prerequisiteId)).returning({ id: tasks2.id });
+    return result.length;
   }
   static async markPendingForRetry(id, retryAfterMs, retryCount) {
     const result = await db.update(tasks2).set({
@@ -16831,8 +17123,18 @@ var TaskService = class {
     return result[0] || null;
   }
   static async markDeadLetter(id, retryCount) {
-    const result = await db.update(tasks2).set({ status: "dead_letter", finishedAt: /* @__PURE__ */ new Date(), retryCount }).where(eq(tasks2.id, id)).returning();
-    return result[0] || null;
+    return db.transaction((tx) => {
+      const finishedAt = /* @__PURE__ */ new Date();
+      const task = tx.update(tasks2).set({ status: "dead_letter", finishedAt, retryCount }).where(eq(tasks2.id, id)).returning().get();
+      if (!task) return null;
+      tx.update(tasks2).set({
+        status: "dead_letter",
+        finishedAt,
+        retryAfter: null,
+        resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${id} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+      }).where(blockedDependentsOf(id)).run();
+      return task;
+    }, { behavior: "immediate" });
   }
   static async resetRunningToPending(ids) {
     if (ids.length === 0) return 0;
@@ -16875,41 +17177,91 @@ var TaskService = class {
       ),
       ...this.buildScopeWhere(scope)
     ];
-    const result = await db.update(tasks2).set({
-      status: "cancelled",
-      finishedAt: /* @__PURE__ */ new Date(),
-      retryAfter: null
-    }).where(and(...conditions)).returning();
-    return result[0] || null;
+    return db.transaction((tx) => {
+      const finishedAt = /* @__PURE__ */ new Date();
+      const task = tx.update(tasks2).set({
+        status: "cancelled",
+        finishedAt,
+        retryAfter: null
+      }).where(and(...conditions)).returning().get();
+      if (!task) return null;
+      tx.update(tasks2).set({
+        status: "dead_letter",
+        finishedAt,
+        retryAfter: null,
+        resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${id} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+      }).where(blockedDependentsOf(id)).run();
+      return task;
+    }, { behavior: "immediate" });
   }
   static async retry(id, scope = {}) {
-    const current = await this.getById(id, scope);
-    if (!current) return null;
-    if (current.status !== "failed" && current.status !== "dead_letter") return null;
-    const conditions = [eq(tasks2.id, id), ...this.buildScopeWhere(scope)];
-    const result = await db.update(tasks2).set({
-      status: "pending",
-      startedAt: null,
-      finishedAt: null,
-      retryAfter: null,
-      retryCount: 0
-    }).where(and(...conditions)).returning();
-    return result[0] || null;
-  }
-  static async retryBatch(batchId, scope = {}) {
     const conditions = [
-      eq(tasks2.batchId, batchId),
+      eq(tasks2.id, id),
       or(eq(tasks2.status, "failed"), eq(tasks2.status, "dead_letter")),
       ...this.buildScopeWhere(scope)
     ];
-    const result = await db.update(tasks2).set({
+    return db.transaction((tx) => tx.update(tasks2).set({
       status: "pending",
       startedAt: null,
       finishedAt: null,
       retryAfter: null,
       retryCount: 0
-    }).where(and(...conditions)).returning();
-    return result.length;
+    }).where(and(...conditions, hasViableDependency())).returning().get() ?? null, { behavior: "immediate" });
+  }
+  static async retryBatch(batchId, scope = {}) {
+    const sqlite2 = getSqlite();
+    const scopeFilter = scope.cwd === void 0 ? "" : "AND candidate.cwd = ?";
+    const parameters = scope.cwd === void 0 ? [batchId] : [batchId, scope.cwd];
+    return db.transaction(() => sqlite2.query(`
+            WITH RECURSIVE
+            candidate(id, cwd, depends_on) AS MATERIALIZED (
+                SELECT candidate.id, candidate.cwd, candidate.depends_on
+                FROM tasks AS candidate
+                WHERE candidate.batch_id = ?
+                  AND candidate.status IN ('failed', 'dead_letter')
+                  ${scopeFilter}
+            ),
+            retryable(id, cwd, depends_on) AS (
+                SELECT candidate.id,
+                       candidate.cwd,
+                       candidate.depends_on
+                FROM candidate
+                WHERE candidate.depends_on IS NULL
+                   OR (
+                       NOT EXISTS (
+                           SELECT 1 FROM candidate AS internal_parent
+                           WHERE internal_parent.id = candidate.depends_on
+                       )
+                       AND EXISTS (
+                           SELECT 1 FROM tasks AS external_parent
+                           WHERE external_parent.id = candidate.depends_on
+                             AND external_parent.cwd IS candidate.cwd
+                             AND (
+                                 external_parent.status IN ('pending', 'running', 'done')
+                                 OR (
+                                     external_parent.status = 'failed'
+                                     AND external_parent.retry_count <= external_parent.max_retries
+                                 )
+                             )
+                       )
+                   )
+                UNION
+                SELECT child.id,
+                       child.cwd,
+                       child.depends_on
+                FROM candidate AS child
+                INNER JOIN retryable AS parent
+                    ON child.depends_on = parent.id
+                   AND child.cwd IS parent.cwd
+            )
+            UPDATE tasks
+            SET status = 'pending',
+                started_at = NULL,
+                finished_at = NULL,
+                retry_after = NULL,
+                retry_count = 0
+            WHERE id IN (SELECT id FROM retryable)
+        `).run(...parameters).changes, { behavior: "immediate" });
   }
   static async getById(id, scope = {}) {
     const conditions = [eq(tasks2.id, id), ...this.buildScopeWhere(scope)];
@@ -16974,28 +17326,151 @@ var TaskService = class {
     return stats;
   }
   static async delete(id, scope = {}) {
-    const conditions = [eq(tasks2.id, id), ...this.buildScopeWhere(scope)];
-    const existing = await db.select({ id: tasks2.id }).from(tasks2).where(and(...conditions)).limit(1);
-    if (!existing[0]) return false;
-    await db.delete(taskRuns2).where(eq(taskRuns2.taskId, id));
+    const conditions = [
+      eq(tasks2.id, id),
+      sql`${tasks2.status} <> 'running'`,
+      sql`NOT EXISTS (
+                SELECT 1 FROM ${taskRuns2}
+                WHERE ${taskRuns2.taskId} = ${tasks2.id}
+                  AND ${taskRuns2.status} = 'running'
+            )`,
+      hasNoExecutableDependents(),
+      ...this.buildScopeWhere(scope)
+    ];
     const result = await db.delete(tasks2).where(and(...conditions)).returning();
-    return result.length > 0;
+    if (result.length > 0) {
+      await db.delete(taskRuns2).where(eq(taskRuns2.taskId, id));
+      return true;
+    }
+    if (!await this.getById(id, scope)) return false;
+    const dependent = await db.select({ id: tasks2.id }).from(tasks2).where(and(
+      eq(tasks2.dependsOn, id),
+      sql`${tasks2.status} IN ('pending', 'running', 'failed', 'dead_letter')`
+    )).orderBy(asc(tasks2.id)).limit(1);
+    if (dependent[0]) {
+      throw new TaskDeletionConflictError(
+        `\u4EFB\u52A1 #${id} \u4ECD\u88AB\u53EF\u6267\u884C\u4EFB\u52A1 #${dependent[0].id} \u4F9D\u8D56\uFF0C\u8BF7\u5148\u5904\u7406\u4F9D\u8D56\u4EFB\u52A1`
+      );
+    }
+    throw new TaskDeletionConflictError(
+      `\u4EFB\u52A1 #${id} \u6B63\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148\u53D6\u6D88\u4EFB\u52A1\u5E76\u7B49\u5F85\u6267\u884C\u8FDB\u7A0B\u9000\u51FA`
+    );
   }
-  static async deleteOlderThan(retentionDays) {
+  static async deleteOlderThan(retentionDays, shouldStop = () => false) {
     const cutoffSec = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
-    const result = await db.delete(tasks2).where(
-      and(
-        sql`${tasks2.status} IN ('done', 'failed', 'dead_letter')`,
-        sql`${tasks2.finishedAt} IS NOT NULL`,
-        sql`${tasks2.finishedAt} < ${cutoffSec}`
-      )
-    ).returning();
-    return result.length;
+    const batchSize = 500;
+    const sqlite2 = getSqlite();
+    cleanupInvocation += 1;
+    const candidateTable = `cleanup_candidates_${process.pid}_${cleanupInvocation}`;
+    let deletedTotal = 0;
+    sqlite2.exec(`
+            CREATE TEMP TABLE ${candidateTable} (
+                id INTEGER NOT NULL PRIMARY KEY
+            ) WITHOUT ROWID;
+        `);
+    try {
+      let ceilingId = null;
+      while (true) {
+        if (shouldStop()) return deletedTotal;
+        const batch = db.transaction(() => {
+          sqlite2.query(`DELETE FROM ${candidateTable}`).run();
+          const ceilingPredicate = ceilingId == null ? "" : "AND candidate.id < ?";
+          const rawCandidateStatement = sqlite2.query(`
+                        INSERT INTO ${candidateTable}(id)
+                        SELECT candidate.id
+                        FROM tasks AS candidate NOT INDEXED
+                        WHERE candidate.status IN ('done', 'dead_letter', 'cancelled')
+                          AND candidate.finished_at IS NOT NULL
+                          AND candidate.finished_at < ?
+                          ${ceilingPredicate}
+                          AND NOT EXISTS (
+                              SELECT 1 FROM task_runs AS active_run
+                              WHERE active_run.task_id = candidate.id
+                                AND active_run.status = 'running'
+                          )
+                        ORDER BY candidate.id DESC
+                        LIMIT ?
+                    `);
+          const rawCount = ceilingId == null ? rawCandidateStatement.run(cutoffSec, batchSize).changes : rawCandidateStatement.run(cutoffSec, ceilingId, batchSize).changes;
+          if (rawCount === 0) return { deleted: 0, nextCeilingId: null };
+          const rawPage = sqlite2.query(`
+                        SELECT min(id) AS nextCeilingId FROM ${candidateTable}
+                    `).get();
+          sqlite2.query(`
+                        DELETE FROM ${candidateTable}
+                        WHERE EXISTS (
+                            SELECT 1 FROM tasks AS anomalous
+                            WHERE anomalous.id = ${candidateTable}.id
+                              AND anomalous.depends_on IS NOT NULL
+                              AND anomalous.depends_on >= anomalous.id
+                        )
+                    `).run();
+          while (true) {
+            const pruned = sqlite2.query(`
+                            DELETE FROM ${candidateTable}
+                            WHERE EXISTS (
+                                SELECT 1 FROM tasks AS dependent_task
+                                WHERE dependent_task.depends_on = ${candidateTable}.id
+                                  AND NOT EXISTS (
+                                      SELECT 1 FROM ${candidateTable} AS selected_dependent
+                                      WHERE selected_dependent.id = dependent_task.id
+                                  )
+                            )
+                        `).run().changes;
+            if (pruned === 0) break;
+          }
+          const selected = sqlite2.query(`
+                        SELECT count(*) AS count FROM ${candidateTable}
+                    `).get();
+          if (selected.count === 0) {
+            return { deleted: 0, nextCeilingId: rawPage.nextCeilingId };
+          }
+          sqlite2.query(`
+                        DELETE FROM tasks
+                        WHERE id IN (SELECT id FROM ${candidateTable})
+                    `).run();
+          const remaining = sqlite2.query(`
+                        SELECT count(*) AS count
+                        FROM tasks
+                        WHERE id IN (SELECT id FROM ${candidateTable})
+                    `).get();
+          if (remaining.count !== 0) {
+            throw new Error("\u5386\u53F2\u6E05\u7406\u5019\u9009\u5728\u540C\u4E00\u5199\u4E8B\u52A1\u5185\u53D1\u751F\u6F02\u79FB\uFF0C\u5DF2\u56DE\u6EDA\u672C\u6279\u5220\u9664");
+          }
+          return { deleted: selected.count, nextCeilingId: rawPage.nextCeilingId };
+        }, { behavior: "immediate" });
+        if (batch.nextCeilingId == null) break;
+        ceilingId = batch.nextCeilingId;
+        deletedTotal += batch.deleted;
+        await Bun.sleep(0);
+        if (shouldStop()) return deletedTotal;
+      }
+      return deletedTotal;
+    } finally {
+      sqlite2.exec(`DROP TABLE IF EXISTS ${candidateTable}`);
+    }
   }
 };
 
+// src/core/process-control.ts
+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";
+  }
+}
+
 // src/core/services/task-run.service.ts
-var { taskRuns: taskRuns3 } = schema_exports;
+var { tasks: tasks3, taskRuns: taskRuns3 } = schema_exports;
+var LegacyRunAbandonConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LegacyRunAbandonConflictError";
+  }
+};
 var TaskRunService = class {
   static async create(data) {
     const result = await db.insert(taskRuns3).values(data).returning();
@@ -17025,12 +17500,12 @@ var TaskRunService = class {
     const result = await db.update(taskRuns3).set({ heartbeatAt: Date.now() }).where(and(eq(taskRuns3.id, id), eq(taskRuns3.status, "running"))).returning();
     return result[0] || null;
   }
-  static async updatePid(id, workerPid, childPid) {
+  static async updatePid(id, workerPid, childPid, lockedBy = `gateway-${process.pid}`) {
     const result = await db.update(taskRuns3).set({
       workerPid,
       childPid,
       lockedAt: Date.now(),
-      lockedBy: `gateway-${process.pid}`
+      lockedBy
     }).where(and(eq(taskRuns3.id, id), eq(taskRuns3.status, "running"))).returning();
     return result[0] || null;
   }
@@ -17058,39 +17533,108 @@ var TaskRunService = class {
   }
   static async getStaleRuns(heartbeatTimeoutMs) {
     const cutoffMs = Date.now() - heartbeatTimeoutMs;
-    const cutoffSec = Math.floor(cutoffMs / 1e3);
     const { tasks: tasksTable } = schema_exports;
     const result = await db.select({
       runId: taskRuns3.id,
       taskId: taskRuns3.taskId,
       childPid: taskRuns3.childPid,
+      workerPid: taskRuns3.workerPid,
+      launchProtocol: taskRuns3.launchProtocol,
+      lockedBy: taskRuns3.lockedBy,
+      startedAt: taskRuns3.startedAt,
+      heartbeatAt: taskRuns3.heartbeatAt,
       taskRetryCount: tasksTable.retryCount,
       taskMaxRetries: tasksTable.maxRetries,
-      taskRetryBackoffMs: tasksTable.retryBackoffMs
-    }).from(taskRuns3).innerJoin(tasksTable, eq(taskRuns3.taskId, tasksTable.id)).where(
-      and(
-        eq(taskRuns3.status, "running"),
-        or(
-          and(
-            sql`${taskRuns3.heartbeatAt} IS NULL`,
-            sql`${taskRuns3.startedAt} < ${cutoffSec}`
-          ),
-          and(
-            sql`${taskRuns3.heartbeatAt} IS NOT NULL`,
-            sql`${taskRuns3.heartbeatAt} < ${cutoffMs}`
-          )
-        )
-      )
-    );
-    return result.map((row) => ({
+      taskRetryBackoffMs: tasksTable.retryBackoffMs,
+      taskStatus: tasksTable.status,
+      taskCwd: tasksTable.cwd
+    }).from(taskRuns3).innerJoin(tasksTable, eq(taskRuns3.taskId, tasksTable.id)).where(eq(taskRuns3.status, "running"));
+    return result.filter((row) => {
+      const heartbeatExpired = row.heartbeatAt == null ? row.startedAt == null || row.startedAt.getTime() < cutoffMs : row.heartbeatAt < cutoffMs;
+      const ownerExited = row.workerPid != null && row.workerPid > 0 && !isProcessAlive(row.workerPid);
+      return heartbeatExpired || ownerExited;
+    }).map((row) => ({
       runId: row.runId,
       taskId: row.taskId,
       childPid: row.childPid,
+      workerPid: row.workerPid,
+      launchProtocol: row.launchProtocol,
+      lockedBy: row.lockedBy,
       taskRetryCount: row.taskRetryCount ?? 0,
       taskMaxRetries: row.taskMaxRetries ?? 3,
-      taskRetryBackoffMs: row.taskRetryBackoffMs ?? 3e4
+      taskRetryBackoffMs: row.taskRetryBackoffMs ?? 3e4,
+      taskStatus: row.taskStatus,
+      taskCwd: row.taskCwd,
+      ownerAlive: row.workerPid != null && row.workerPid > 0 && isProcessAlive(row.workerPid)
+    }));
+  }
+  static async listLegacyQuarantinedRuns(heartbeatTimeoutMs = 0) {
+    const staleRuns = await this.getStaleRuns(heartbeatTimeoutMs);
+    return staleRuns.filter(
+      (row) => row.launchProtocol == null && row.childPid == null
+    ).map((row) => ({
+      runId: row.runId,
+      taskId: row.taskId,
+      taskStatus: row.taskStatus,
+      taskCwd: row.taskCwd,
+      workerPid: row.workerPid,
+      ownerAlive: row.ownerAlive
     }));
   }
+  static async abandonLegacyRun(runId) {
+    return db.transaction((tx) => {
+      const current = tx.select({
+        runId: taskRuns3.id,
+        taskId: taskRuns3.taskId,
+        runStatus: taskRuns3.status,
+        taskStatus: tasks3.status,
+        workerPid: taskRuns3.workerPid,
+        childPid: taskRuns3.childPid,
+        launchProtocol: taskRuns3.launchProtocol,
+        log: taskRuns3.log
+      }).from(taskRuns3).innerJoin(tasks3, eq(taskRuns3.taskId, tasks3.id)).where(eq(taskRuns3.id, runId)).get();
+      if (!current) return null;
+      if (current.runStatus !== "running") {
+        throw new LegacyRunAbandonConflictError(`run #${runId} \u5DF2\u4E0D\u662F running \u72B6\u6001`);
+      }
+      if (current.launchProtocol != null) {
+        throw new LegacyRunAbandonConflictError(
+          `run #${runId} \u4F7F\u7528\u672A\u77E5\u6216\u53D7\u7BA1\u534F\u8BAE ${current.launchProtocol}\uFF0C\u7981\u6B62\u4EBA\u5DE5 abandon`
+        );
+      }
+      if (current.childPid != null) {
+        throw new LegacyRunAbandonConflictError(
+          `run #${runId} \u5DF2\u8BB0\u5F55 child PID ${current.childPid}\uFF0C\u5FC5\u987B\u7531 Worker/Watchdog \u786E\u8BA4\u8FDB\u7A0B\u6811\u9000\u51FA`
+        );
+      }
+      if (current.workerPid != null && isProcessAlive(current.workerPid)) {
+        throw new LegacyRunAbandonConflictError(
+          `run #${runId} \u7684 owner PID ${current.workerPid} \u4ECD\u5B58\u6D3B`
+        );
+      }
+      if (current.taskStatus !== "cancelled") {
+        throw new LegacyRunAbandonConflictError(
+          `\u4EFB\u52A1 #${current.taskId} \u5FC5\u987B\u5148\u53D6\u6D88\u5E76\u4FDD\u6301 cancelled \u72B6\u6001`
+        );
+      }
+      const note = "\u64CD\u4F5C\u5458\u5DF2\u786E\u8BA4\u65E7\u7248\u65E0 PID \u6267\u884C\u4E0D\u5B58\u5728\uFF0C\u5E76\u901A\u8FC7 run abandon \u5173\u95ED\u9694\u79BB\u8BB0\u5F55";
+      const updated = tx.update(taskRuns3).set({
+        status: "failed",
+        finishedAt: /* @__PURE__ */ new Date(),
+        log: current.log ? `${current.log}
+${note}` : note
+      }).where(and(eq(taskRuns3.id, runId), eq(taskRuns3.status, "running"))).returning({ id: taskRuns3.id }).get();
+      if (!updated) {
+        throw new LegacyRunAbandonConflictError(`run #${runId} \u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8`);
+      }
+      return {
+        runId,
+        taskId: current.taskId,
+        runStatus: "failed",
+        taskStatus: "cancelled"
+      };
+    }, { behavior: "immediate" });
+  }
   static async getRunningRunByTaskId(taskId) {
     const result = await db.select().from(taskRuns3).where(and(eq(taskRuns3.taskId, taskId), eq(taskRuns3.status, "running"))).orderBy(desc(taskRuns3.startedAt), desc(taskRuns3.id)).limit(1);
     return result[0] || null;
@@ -17132,19 +17676,17 @@ var TaskTemplateService = class {
   static async create(data) {
     this.validate(data);
     const now = Date.now();
-    const result = await db.insert(taskTemplates2).values({ ...data, createdAt: now, updatedAt: now }).returning();
-    const tmpl = result[0];
-    if (tmpl.nextRunAt == null) {
-      const nextRunAt = this.calculateNextRunAt(
-        tmpl.scheduleType,
-        tmpl
-      );
-      if (nextRunAt != null) {
-        await db.update(taskTemplates2).set({ nextRunAt }).where(eq(taskTemplates2.id, tmpl.id));
-        tmpl.nextRunAt = nextRunAt;
-      }
-    }
-    return tmpl;
+    const nextRunAt = data.nextRunAt ?? this.calculateNextRunAt(
+      data.scheduleType,
+      {
+        cronExpr: data.cronExpr ?? null,
+        intervalMs: data.intervalMs ?? null,
+        runAt: data.runAt ?? null
+      },
+      now
+    );
+    const result = await db.insert(taskTemplates2).values({ ...data, nextRunAt, createdAt: now, updatedAt: now }).returning();
+    return result[0];
   }
   static validate(data) {
     if (!data.name.trim()) throw new Error("name \u4E0D\u80FD\u4E3A\u7A7A");
@@ -17184,8 +17726,18 @@ var TaskTemplateService = class {
     return result[0] || null;
   }
   static async enable(id) {
-    const result = await db.update(taskTemplates2).set({ enabled: true, updatedAt: Date.now() }).where(eq(taskTemplates2.id, id)).returning();
-    return result[0] || null;
+    return db.transaction((tx) => {
+      const template = tx.select().from(taskTemplates2).where(eq(taskTemplates2.id, id)).limit(1).get();
+      if (!template) return null;
+      const nextRunAt = template.nextRunAt ?? this.calculateNextRunAt(
+        template.scheduleType,
+        template
+      );
+      if (nextRunAt == null) {
+        throw new Error(`\u6A21\u677F #${id} \u65E0\u6CD5\u8BA1\u7B97\u4E0B\u4E00\u6B21\u6267\u884C\u65F6\u95F4\uFF0C\u5DF2\u4FDD\u6301\u7981\u7528`);
+      }
+      return tx.update(taskTemplates2).set({ enabled: true, nextRunAt, updatedAt: Date.now() }).where(eq(taskTemplates2.id, id)).returning().get() ?? null;
+    }, { behavior: "immediate" });
   }
   static async disable(id) {
     const result = await db.update(taskTemplates2).set({ enabled: false, updatedAt: Date.now() }).where(eq(taskTemplates2.id, id)).returning();
@@ -17195,6 +17747,47 @@ var TaskTemplateService = class {
     const result = await db.delete(taskTemplates2).where(eq(taskTemplates2.id, id)).returning();
     return result.length > 0;
   }
+  static async deleteExpiredDelayed(retentionDays, shouldStop = () => false) {
+    const cutoffMs = Date.now() - retentionDays * 864e5;
+    const batchSize = 500;
+    let deletedTotal = 0;
+    while (!shouldStop()) {
+      const deleted = db.transaction((tx) => tx.delete(taskTemplates2).where(and(
+        sql`${taskTemplates2.id} IN (
+                        SELECT candidate.id
+                        FROM task_templates AS candidate
+                        WHERE candidate.schedule_type = 'delayed'
+                          AND candidate.enabled = 0
+                          AND candidate.last_run_at IS NOT NULL
+                          AND candidate.last_run_at < ${cutoffMs}
+                          AND NOT EXISTS (
+                              SELECT 1 FROM tasks AS active_task
+                              WHERE active_task.template_id = candidate.id
+                                AND (
+                                    active_task.status IN ('pending', 'running')
+                                    OR (
+                                        active_task.status = 'failed'
+                                        AND active_task.retry_count <= active_task.max_retries
+                                    )
+                                )
+                          )
+                          AND NOT EXISTS (
+                              SELECT 1
+                              FROM task_runs AS active_run
+                              INNER JOIN tasks AS run_task ON run_task.id = active_run.task_id
+                              WHERE run_task.template_id = candidate.id
+                                AND active_run.status = 'running'
+                          )
+                        ORDER BY candidate.last_run_at, candidate.id
+                        LIMIT ${batchSize}
+                    )`
+      )).returning({ id: taskTemplates2.id }).all().length, { behavior: "immediate" });
+      if (deleted === 0) break;
+      deletedTotal += deleted;
+      await Bun.sleep(0);
+    }
+    return deletedTotal;
+  }
   static calculateNextRunAt(scheduleType, template, afterMs) {
     const base = afterMs ?? Date.now();
     switch (scheduleType) {
@@ -17220,8 +17813,6 @@ import { Database as Database3 } from "bun:sqlite";
 import { randomUUID } from "crypto";
 import {
   chmodSync,
-  constants,
-  copyFileSync,
   existsSync as existsSync2,
   mkdirSync as mkdirSync2,
   renameSync,
@@ -17231,19 +17822,6 @@ import {
 } from "fs";
 import { tmpdir } from "os";
 import { basename, dirname as dirname2, resolve } from "path";
-
-// src/core/process-control.ts
-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";
-  }
-}
-
-// src/core/services/database-maintenance.service.ts
 var REQUIRED_TABLES = ["gateway_lock", "tasks", "task_runs", "task_templates"];
 var DatabaseMaintenanceConflictError = class extends Error {
   constructor(message) {
@@ -17268,6 +17846,12 @@ function safeUnlink(path) {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function columnDefinitionsMatch(left, right) {
+  return left.type.trim().toUpperCase() === right.type.trim().toUpperCase() && left.notNull === right.notNull && left.defaultValue === right.defaultValue && left.primaryKeyOrder === right.primaryKeyOrder;
+}
 var DatabaseMaintenanceService = class {
   static check() {
     return this.inspect(getSqlite(), DB_FILE_PATH);
@@ -17291,9 +17875,11 @@ var DatabaseMaintenanceService = class {
       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");
+      const businessTables = this.readRestoreTables(sqlite2, "main");
+      sqlite2.exec("PRAGMA defer_foreign_keys = ON");
+      for (const table of businessTables.values()) {
+        sqlite2.exec(`DELETE FROM main.${quoteIdentifier(table.name)}`);
+      }
       sqlite2.exec("COMMIT");
       return {
         backupPath: backup.path,
@@ -17315,78 +17901,102 @@ var DatabaseMaintenanceService = class {
     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;
+    let attached = false;
+    let committed = false;
     try {
-      copyFileSync(source, stagePath, constants.COPYFILE_EXCL);
+      current.exec("BEGIN EXCLUSIVE");
+      this.assertGatewaySafe(current, false);
+      this.assertNoRunningWork(current);
+      if (!existsSync2(source)) {
+        throw new Error(`\u5907\u4EFD\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${source}`);
+      }
+      const sourceStat = statSync(source);
+      if (!sourceStat.isFile()) throw new Error(`\u5907\u4EFD\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6\uFF1A${source}`);
+      const liveStat = statSync(livePath);
+      if (sourceStat.dev === liveStat.dev && sourceStat.ino === liveStat.ino) {
+        throw new Error("\u6062\u590D\u6765\u6E90\u4E0D\u80FD\u662F\u5F53\u524D\u6570\u636E\u5E93\u7684\u7B26\u53F7\u94FE\u63A5\u6216\u786C\u94FE\u63A5\u522B\u540D");
+      }
+      let sourceCheck;
+      try {
+        const sourceDatabase = new Database3(source, { readonly: true, strict: true });
+        try {
+          sourceDatabase.exec("BEGIN");
+          sourceCheck = this.inspect(sourceDatabase, source);
+          if (!sourceCheck.ok) {
+            throw new Error(
+              sourceCheck.integrityMessages.join("; ") || "schema/foreign key error"
+            );
+          }
+          writeFileSync(stagePath, sourceDatabase.serialize(), {
+            flag: "wx",
+            mode: 384
+          });
+        } finally {
+          if (sourceDatabase.inTransaction) sourceDatabase.exec("ROLLBACK");
+          sourceDatabase.close();
+        }
+      } catch (error) {
+        throw new Error(`\u5907\u4EFD\u6587\u4EF6\u65E0\u6548\uFF1A${errorMessage(error)}`);
+      }
       chmodSync(stagePath, 384);
       const staged = new Database3(stagePath);
       try {
+        staged.exec("PRAGMA journal_mode = DELETE;");
+        staged.exec("PRAGMA busy_timeout = 5000;");
+        migrateSqliteDatabase(staged);
         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");
+      const sqlite2 = current;
+      let recoveredRunningTasks = 0;
+      let closedRunningRuns = 0;
       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 {
+        sqlite2.query("ATTACH DATABASE ? AS restore_source").run(stagePath);
+        attached = true;
+        const restorePlan = this.buildRestorePlan(sqlite2);
         recoveredRunningTasks = this.scalar(
-          restored,
-          "SELECT COUNT(*) AS count FROM tasks WHERE status = 'running'"
+          sqlite2,
+          "SELECT COUNT(*) AS count FROM restore_source.tasks WHERE status = 'running'"
         );
         closedRunningRuns = this.scalar(
-          restored,
-          "SELECT COUNT(*) AS count FROM task_runs WHERE status = 'running'"
+          sqlite2,
+          "SELECT COUNT(*) AS count FROM restore_source.task_runs WHERE status = 'running'"
         );
+        sqlite2.exec("PRAGMA defer_foreign_keys = ON");
+        for (const table of restorePlan) {
+          sqlite2.exec(`DELETE FROM main.${quoteIdentifier(table.name)}`);
+        }
+        for (const table of restorePlan) {
+          if (!table.sourceExists) continue;
+          const columns = table.columns.map((column) => quoteIdentifier(column.name)).join(", ");
+          sqlite2.exec(`
+                        INSERT INTO main.${quoteIdentifier(table.name)} (${columns})
+                        SELECT ${columns} FROM restore_source.${quoteIdentifier(table.name)}
+                    `);
+        }
+        const liveTableNames = restorePlan.map((table) => table.name);
+        const sourceTableNames = restorePlan.filter((table) => table.sourceExists).map((table) => table.name);
+        const livePlaceholders = liveTableNames.map(() => "?").join(", ");
+        sqlite2.query(
+          `DELETE FROM main.sqlite_sequence WHERE name IN (${livePlaceholders})`
+        ).run(...liveTableNames);
+        if (sourceTableNames.length > 0) {
+          const sourcePlaceholders = sourceTableNames.map(() => "?").join(", ");
+          sqlite2.query(`
+                        INSERT INTO main.sqlite_sequence(name, seq)
+                        SELECT name, seq FROM restore_source.sqlite_sequence
+                        WHERE name IN (${sourcePlaceholders})
+                    `).run(...sourceTableNames);
+        }
         const finishedAt = Math.floor(Date.now() / 1e3);
-        restored.query(`
+        sqlite2.query(`
                     UPDATE task_runs
                     SET status = 'failed', finished_at = ?,
                         log = CASE
@@ -17396,20 +18006,34 @@ var DatabaseMaintenanceService = class {
                         END
                     WHERE status = 'running'
                 `).run(finishedAt);
-        restored.exec(`
+        sqlite2.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");
+        sqlite2.exec("DELETE FROM gateway_lock");
+        const violations = sqlite2.query("PRAGMA foreign_key_check").all();
+        if (violations.length > 0) {
+          throw new Error(`\u6062\u590D\u6570\u636E\u5305\u542B ${violations.length} \u6761\u5916\u952E\u8FDD\u89C4`);
+        }
+        const transactionCheck = this.inspect(sqlite2, livePath);
+        if (!transactionCheck.ok) throw new Error("\u6062\u590D\u540E\u7684\u6570\u636E\u5E93\u672A\u901A\u8FC7\u5B8C\u6574\u6027\u6821\u9A8C");
+        sqlite2.exec("COMMIT");
+        committed = true;
       } catch (error) {
-        if (restored.inTransaction) restored.exec("ROLLBACK");
+        if (sqlite2.inTransaction) sqlite2.exec("ROLLBACK");
         throw error;
+      } finally {
+        if (attached && !sqlite2.inTransaction) {
+          try {
+            sqlite2.exec("DETACH DATABASE restore_source");
+          } catch {
+          }
+          attached = false;
+        }
       }
-      const check = this.inspect(restored, livePath);
+      const check = this.inspect(sqlite2, 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,
@@ -17418,31 +18042,19 @@ var DatabaseMaintenanceService = class {
         check
       };
     } catch (error) {
-      closeDb();
-      safeUnlink(`${livePath}-wal`);
-      safeUnlink(`${livePath}-shm`);
+      if (current.inTransaction) current.exec("ROLLBACK");
       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)}`);
+      const rollbackHint = committed ? "\uFF1B\u4E8B\u52A1\u5DF2\u63D0\u4EA4\uFF0C\u672A\u81EA\u52A8\u8986\u76D6\u540E\u7EED\u5199\u5165" : "\uFF1B\u4E8B\u52A1\u5DF2\u56DE\u6EDA";
+      throw new Error(`\u6062\u590D\u6570\u636E\u5E93\u5931\u8D25${rollbackHint}${backupHint}\uFF1A${errorMessage(error)}`);
+    } finally {
+      safeUnlink(stagePath);
+      safeUnlink(`${stagePath}-journal`);
+      safeUnlink(`${stagePath}-wal`);
+      safeUnlink(`${stagePath}-shm`);
     }
   }
   static inspectFile(path) {
@@ -17458,6 +18070,78 @@ var DatabaseMaintenanceService = class {
       sqlite2.close();
     }
   }
+  static buildRestorePlan(sqlite2) {
+    const liveTables = this.readRestoreTables(sqlite2, "main");
+    const sourceTables = this.readRestoreTables(sqlite2, "restore_source");
+    for (const [tableName, sourceTable] of sourceTables) {
+      const liveTable = liveTables.get(tableName);
+      if (!liveTable) {
+        throw new Error(`\u6062\u590D\u6765\u6E90\u5305\u542B\u5F53\u524D\u6570\u636E\u5E93\u4E0D\u8BA4\u8BC6\u7684\u4E1A\u52A1\u8868\uFF1A${tableName}`);
+      }
+      const liveColumns = new Map(liveTable.columns.map((column) => [column.name, column]));
+      for (const sourceColumn of sourceTable.columns) {
+        const liveColumn = liveColumns.get(sourceColumn.name);
+        if (!liveColumn) {
+          throw new Error(
+            `\u6062\u590D\u6765\u6E90\u7684\u8868 ${tableName} \u5305\u542B\u5F53\u524D\u6570\u636E\u5E93\u4E0D\u8BA4\u8BC6\u7684\u53EF\u5199\u5217\uFF1A${sourceColumn.name}`
+          );
+        }
+        if (!columnDefinitionsMatch(liveColumn, sourceColumn)) {
+          throw new Error(`\u6062\u590D\u6765\u6E90\u7684\u8868 ${tableName}.${sourceColumn.name} \u4E0E\u5F53\u524D\u6570\u636E\u5E93\u5B9A\u4E49\u4E0D\u517C\u5BB9`);
+        }
+      }
+    }
+    const plan = [];
+    for (const [tableName, liveTable] of liveTables) {
+      const sourceTable = sourceTables.get(tableName);
+      if (!sourceTable) {
+        plan.push({ ...liveTable, columns: [], sourceExists: false });
+        continue;
+      }
+      const sourceColumns = new Map(sourceTable.columns.map((column) => [column.name, column]));
+      for (const liveColumn of liveTable.columns) {
+        if (sourceColumns.has(liveColumn.name)) continue;
+        if (liveColumn.primaryKeyOrder > 0 || liveColumn.notNull && liveColumn.defaultValue == null) {
+          throw new Error(
+            `\u5F53\u524D\u6570\u636E\u5E93\u7684\u8868 ${tableName}.${liveColumn.name} \u65E0\u6CD5\u4ECE\u65E7\u5907\u4EFD\u5B89\u5168\u8865\u9ED8\u8BA4\u503C`
+          );
+        }
+      }
+      plan.push({
+        name: tableName,
+        columns: sourceTable.columns,
+        sourceExists: true
+      });
+    }
+    return plan;
+  }
+  static readRestoreTables(sqlite2, databaseName) {
+    const tableRows = sqlite2.query(`
+            SELECT name
+            FROM ${databaseName}.sqlite_schema
+            WHERE type = 'table'
+              AND name NOT LIKE 'sqlite_%'
+              AND name NOT IN ('gateway_lock', '__drizzle_migrations')
+            ORDER BY name
+        `).all();
+    const result = /* @__PURE__ */ new Map();
+    for (const row of tableRows) {
+      const columns = sqlite2.query(
+        `PRAGMA ${databaseName}.table_xinfo(${quoteIdentifier(row.name)})`
+      ).all();
+      result.set(row.name, {
+        name: row.name,
+        columns: columns.filter((column) => column.hidden === 0).map((column) => ({
+          name: column.name,
+          type: column.type,
+          notNull: column.notnull !== 0,
+          defaultValue: column.dflt_value,
+          primaryKeyOrder: column.pk
+        }))
+      });
+    }
+    return result;
+  }
   static inspect(sqlite2, path) {
     const tableRows = sqlite2.query(
       "SELECT name FROM sqlite_master WHERE type = 'table'"
@@ -17677,10 +18361,14 @@ var state = null;
 function componentStatus(component, enabled, maxAgeMs, now) {
   const lastActivityAt = state?.lastActivityAt[component] ?? null;
   const ageMs = lastActivityAt == null ? null : Math.max(0, now - lastActivityAt);
+  const consecutiveFailures = state?.consecutiveFailures[component] ?? 0;
   return {
     enabled,
-    healthy: !enabled || ageMs != null && ageMs <= maxAgeMs,
+    healthy: !enabled || ageMs != null && ageMs <= maxAgeMs && consecutiveFailures === 0,
     lastActivityAt,
+    lastSuccessAt: state?.lastSuccessAt[component] ?? null,
+    consecutiveFailures,
+    lastError: state?.lastError[component] ?? null,
     ageMs,
     maxAgeMs
   };
@@ -17704,6 +18392,12 @@ function getGatewayHealth(now = Date.now()) {
     Math.max((state?.config.watchdogCheckIntervalMs ?? 6e4) * 3, 5e3),
     now
   );
+  const watchdogCleanup = componentStatus(
+    "watchdogCleanup",
+    true,
+    Math.max((state?.config.watchdogCleanupIntervalMs ?? 864e5) * 2, 6e4),
+    now
+  );
   let lock = { pid: null, heartbeatAt: null, readyAt: null, ageMs: null, healthy: false };
   try {
     const row = sqlite.prepare(
@@ -17721,16 +18415,95 @@ function getGatewayHealth(now = Date.now()) {
     }
   } catch {
   }
-  const healthy = state != null && lock.healthy && worker.healthy && scheduler.healthy && watchdog.healthy;
+  const healthy = state != null && lock.healthy && worker.healthy && scheduler.healthy && watchdog.healthy && watchdogCleanup.healthy;
   return {
     status: healthy ? "ok" : "degraded",
     pid: process.pid,
     uptimeMs: state ? Math.max(0, now - state.startedAt) : 0,
     lock,
-    components: { worker, scheduler, watchdog }
+    components: { worker, scheduler, watchdog, watchdogCleanup }
   };
 }
 
+// src/gateway/scheduler/job-templates.ts
+var { taskTemplates: taskTemplates3 } = schema_exports;
+async function triggerTaskFromTemplate(templateId) {
+  return createTaskFromTemplate(templateId, {
+    advanceSchedule: false,
+    namePrefix: "[\u624B\u52A8\u89E6\u53D1] "
+  });
+}
+function createTaskFromTemplate(templateId, options) {
+  const nowMs = Date.now();
+  return db.transaction((tx) => {
+    const tmpl = tx.select().from(taskTemplates3).where(eq(taskTemplates3.id, templateId)).limit(1).get();
+    if (!tmpl || options.advanceSchedule && !tmpl.enabled) return null;
+    const activeTasks = tx.select({ count: sql`count(*)` }).from(schema_exports.tasks).where(and(
+      eq(schema_exports.tasks.templateId, templateId),
+      sql`${schema_exports.tasks.status} IN ('pending', 'running')`
+    )).get();
+    const retryableTasks = tx.select({ count: sql`count(*)` }).from(schema_exports.tasks).where(and(
+      eq(schema_exports.tasks.templateId, templateId),
+      eq(schema_exports.tasks.status, "failed"),
+      sql`${schema_exports.tasks.retryCount} <= ${schema_exports.tasks.maxRetries}`
+    )).get();
+    const detachedRuns = tx.select({ count: sql`count(DISTINCT ${schema_exports.taskRuns.taskId})` }).from(schema_exports.taskRuns).innerJoin(schema_exports.tasks, eq(schema_exports.tasks.id, schema_exports.taskRuns.taskId)).where(and(
+      eq(schema_exports.taskRuns.status, "running"),
+      eq(schema_exports.tasks.templateId, templateId),
+      sql`NOT (
+                    ${schema_exports.tasks.status} IN ('pending', 'running')
+                    OR (
+                        ${schema_exports.tasks.status} = 'failed'
+                        AND ${schema_exports.tasks.retryCount} <= ${schema_exports.tasks.maxRetries}
+                    )
+                )`
+    )).get();
+    const activeCount = Number(activeTasks?.count ?? 0) + Number(retryableTasks?.count ?? 0) + Number(detachedRuns?.count ?? 0);
+    if (activeCount >= (tmpl.maxInstances ?? 1)) {
+      if (options.advanceSchedule && tmpl.scheduleType !== "delayed") {
+        const nextRunAt2 = TaskTemplateService.calculateNextRunAt(
+          tmpl.scheduleType,
+          tmpl,
+          nowMs
+        );
+        tx.update(taskTemplates3).set({ nextRunAt: nextRunAt2, updatedAt: nowMs }).where(and(eq(taskTemplates3.id, templateId), eq(taskTemplates3.enabled, true))).run();
+      }
+      return null;
+    }
+    const isDelayed = tmpl.scheduleType === "delayed";
+    const nextRunAt = isDelayed ? null : TaskTemplateService.calculateNextRunAt(
+      tmpl.scheduleType,
+      tmpl,
+      nowMs
+    );
+    const task = tx.insert(schema_exports.tasks).values({
+      name: `${options.namePrefix ?? ""}${tmpl.name}`,
+      agent: tmpl.agent,
+      model: tmpl.model ?? "default",
+      prompt: tmpl.prompt,
+      cwd: tmpl.cwd ?? null,
+      category: tmpl.category ?? "general",
+      importance: tmpl.importance ?? 3,
+      urgency: tmpl.urgency ?? 3,
+      batchId: tmpl.batchId,
+      maxRetries: tmpl.maxRetries ?? 3,
+      retryBackoffMs: tmpl.retryBackoffMs ?? 3e4,
+      timeoutMs: tmpl.timeoutMs,
+      templateId: tmpl.id,
+      scheduledAt: options.advanceSchedule ? tmpl.nextRunAt ?? nowMs : nowMs
+    }).returning().get();
+    if (options.advanceSchedule) {
+      tx.update(taskTemplates3).set({
+        lastRunAt: nowMs,
+        nextRunAt,
+        enabled: isDelayed ? false : tmpl.enabled,
+        updatedAt: nowMs
+      }).where(and(eq(taskTemplates3.id, templateId), eq(taskTemplates3.enabled, true))).run();
+    }
+    return task;
+  }, { behavior: "immediate" });
+}
+
 // src/web/index.tsx
 var app = new Hono2();
 var TASK_STATUSES = /* @__PURE__ */ new Set([
@@ -17914,8 +18687,9 @@ var SHARED_STYLES = html`
 function renderLayout(title, activeTab, body) {
   return `<!DOCTYPE html><html><head><meta charset="UTF-8"><title>${title} - SuperTask</title>${SHARED_STYLES}
 <script>
-async function retryTask(id){if(!confirm('\u786E\u5B9A\u91CD\u8BD5\u4EFB\u52A1 #'+id+'?'))return;await fetch('/api/tasks/'+id+'/retry',{method:'POST'});location.reload();}
-async function deleteTask(id){if(!confirm('\u786E\u5B9A\u5220\u9664\u4EFB\u52A1 #'+id+'?'))return;await fetch('/api/tasks/'+id,{method:'DELETE'});location.reload();}
+async function retryTask(id){if(!confirm('\u786E\u5B9A\u91CD\u8BD5\u4EFB\u52A1 #'+id+'?'))return;const r=await fetch('/api/tasks/'+id+'/retry',{method:'POST'});const d=await r.json();if(!r.ok){alert('\u91CD\u8BD5\u5931\u8D25: '+d.error);return;}location.reload();}
+async function cancelTask(id){if(!confirm('\u786E\u5B9A\u53D6\u6D88\u4EFB\u52A1 #'+id+'?'))return;const r=await fetch('/api/tasks/'+id+'/cancel',{method:'POST'});const d=await r.json();if(!r.ok){alert('\u53D6\u6D88\u5931\u8D25: '+d.error);return;}location.reload();}
+async function deleteTask(id){if(!confirm('\u786E\u5B9A\u5220\u9664\u4EFB\u52A1 #'+id+'?'))return;const r=await fetch('/api/tasks/'+id,{method:'DELETE'});const d=await r.json();if(!r.ok){alert('\u5220\u9664\u5931\u8D25: '+d.error);return;}location.reload();}
 async function showDetail(id){try{const r=await fetch('/api/tasks/'+id);const t=await r.json();document.getElementById('dc').textContent=JSON.stringify(t,null,2);document.getElementById('dd').showModal();}catch(e){alert('\u83B7\u53D6\u8BE6\u60C5\u5931\u8D25');}}
 async function showRunDetail(id){try{const r=await fetch('/api/runs/'+id);const t=await r.json();document.getElementById('dc').textContent=JSON.stringify(t,null,2);document.getElementById('dd').showModal();}catch(e){alert('\u83B7\u53D6\u8BE6\u60C5\u5931\u8D25');}}
 async function showTemplateDetail(id){try{const r=await fetch('/api/templates/'+id);const t=await r.json();document.getElementById('dc').textContent=JSON.stringify(t,null,2);document.getElementById('dd').showModal();}catch(e){alert('\u83B7\u53D6\u8BE6\u60C5\u5931\u8D25');}}
@@ -17992,11 +18766,11 @@ app.get("/", async (c) => {
   if (statusFilter && !parsedStatus) return c.text("invalid status", 400);
   const limit = 50;
   const offset = (page - 1) * limit;
-  const [tasks3, statsData] = await Promise.all([
+  const [tasks4, statsData] = await Promise.all([
     TaskService.list({ limit, offset, ...parsedStatus ? { status: parsedStatus } : {} }),
     TaskService.stats({})
   ]);
-  const taskIds = tasks3.map((t) => t.id);
+  const taskIds = tasks4.map((t) => t.id);
   const latestRuns = await TaskRunService.getLatestByTaskIds(taskIds);
   const counts = {
     pending: statsData.pending || 0,
@@ -18015,9 +18789,10 @@ app.get("/", async (c) => {
       <a href="/?status=dead_letter" class="btn ${statusFilter === "dead_letter" ? "btn-primary" : ""}">Dead Letter</a>
     </div>`;
   let rows = "";
-  for (const task of tasks3) {
+  for (const task of tasks4) {
     const status = safeStatus(task.status);
     const st = status.toUpperCase();
+    const executionActive = latestRuns.get(task.id)?.status === "running";
     rows += `<tr>
           <td class="mu">#${task.id}</td>
           <td><div style="font-weight:500">${esc(task.name)}</div><div class="mu sm el">${esc(task.prompt.substring(0, 120))}</div></td>
@@ -18028,7 +18803,8 @@ app.get("/", async (c) => {
           <td>
             <button class="btn btn-sm" onclick="showDetail(${task.id})">\u8BE6\u60C5</button>
             ${task.status === "failed" || task.status === "dead_letter" ? `<button class="btn btn-sm btn-warn" onclick="retryTask(${task.id})">\u91CD\u8BD5</button>` : ""}
-            <button class="btn btn-sm btn-danger" onclick="deleteTask(${task.id})">\u5220\u9664</button>
+            ${["pending", "running", "failed"].includes(task.status ?? "") ? `<button class="btn btn-sm btn-warn" onclick="cancelTask(${task.id})">\u53D6\u6D88</button>` : ""}
+            ${task.status === "running" || executionActive ? "" : `<button class="btn btn-sm btn-danger" onclick="deleteTask(${task.id})">\u5220\u9664</button>`}
           </td></tr>`;
   }
   const qp = statusFilter ? `&status=${statusFilter}` : "";
@@ -18280,11 +19056,25 @@ app.post("/api/tasks/:id/retry", async (c) => {
   if (task) return c.json({ success: true });
   return await TaskService.getById(id) ? c.json({ error: "task status does not allow retry" }, 409) : c.json({ error: "not found" }, 404);
 });
+app.post("/api/tasks/:id/cancel", async (c) => {
+  const id = parsePositiveInteger(c.req.param("id"));
+  if (id === null) return c.json({ error: "invalid id" }, 400);
+  const task = await TaskService.cancel(id);
+  if (task) return c.json({ success: true });
+  return await TaskService.getById(id) ? c.json({ error: "task status does not allow cancellation" }, 409) : c.json({ error: "not found" }, 404);
+});
 app.delete("/api/tasks/:id", async (c) => {
   const id = parsePositiveInteger(c.req.param("id"));
   if (id === null) return c.json({ error: "invalid id" }, 400);
-  const deleted = await TaskService.delete(id);
-  return deleted ? c.json({ success: true }) : c.json({ error: "not found" }, 404);
+  try {
+    const deleted = await TaskService.delete(id);
+    return deleted ? c.json({ success: true }) : c.json({ error: "not found" }, 404);
+  } catch (error) {
+    if (error instanceof TaskDeletionConflictError) {
+      return c.json({ error: error.message }, 409);
+    }
+    throw error;
+  }
 });
 app.post("/api/templates/:id/enable", async (c) => {
   const id = parsePositiveInteger(c.req.param("id"));
@@ -18309,21 +19099,8 @@ app.post("/api/templates/:id/trigger", async (c) => {
   if (id === null) return c.json({ error: "invalid id" }, 400);
   const tmpl = await TaskTemplateService.getById(id);
   if (!tmpl) return c.json({ error: "not found" }, 404);
-  const task = await TaskService.add({
-    name: `[\u624B\u52A8\u89E6\u53D1] ${tmpl.name}`,
-    agent: tmpl.agent,
-    model: tmpl.model,
-    prompt: tmpl.prompt,
-    cwd: tmpl.cwd,
-    category: tmpl.category,
-    importance: tmpl.importance,
-    urgency: tmpl.urgency,
-    batchId: tmpl.batchId,
-    maxRetries: tmpl.maxRetries,
-    retryBackoffMs: tmpl.retryBackoffMs,
-    timeoutMs: tmpl.timeoutMs,
-    templateId: tmpl.id
-  });
+  const task = await triggerTaskFromTemplate(id);
+  if (!task) return c.json({ error: "maxInstances reached" }, 409);
   return c.json({ success: true, taskId: task.id });
 });
 app.put("/api/config", async (c) => {
@@ -18365,6 +19142,7 @@ app.post("/api/database/clear", async (c) => {
 });
 var dashboardApp = app;
 var web_default = {
+  hostname: "127.0.0.1",
   port: 4680,
   fetch: app.fetch
 };