opencode-supertask 0.1.26 → 0.1.27

package/dist/gateway/index.js

@@ -1204,7 +1204,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw2;
-      function join3(chunks, separator) {
+      function join5(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -1214,7 +1214,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join3;
+      sql2.join = join5;
       function identifier(value) {
         return new Name(value);
       }
@@ -3830,7 +3830,7 @@ var init_select2 = __esm({
         return (table, on) => {
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins?.some((join3) => join3.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join5) => join5.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -4672,7 +4672,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join3) => join3.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join5) => join5.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -6033,7 +6033,9 @@ var init_schema = __esm({
     }, (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)
     ]);
     TASK_CATEGORIES = [
       "translate",
@@ -6056,7 +6058,8 @@ var init_schema = __esm({
       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)
@@ -6086,7 +6089,13 @@ var init_schema = __esm({
       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
+      )
     ]);
   }
 });
@@ -6109,36 +6118,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;");
+  }
+}
+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 });
   }
-  _db = drizzle(_sqlite, { schema: schema_exports });
+  _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);
@@ -6149,6 +6169,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;
 }
@@ -6370,7 +6392,52 @@ var init_backoff = __esm({
 });
 
 // src/core/services/task.service.ts
-var tasks2, taskRuns2, TaskService;
+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 tasks2, taskRuns2, cleanupInvocation, TaskDeletionConflictError, TaskService;
 var init_task_service = __esm({
   "src/core/services/task.service.ts"() {
     "use strict";
@@ -6378,6 +6445,13 @@ var init_task_service = __esm({
     init_drizzle_orm();
     init_backoff();
     ({ tasks: tasks2, taskRuns: taskRuns2 } = schema_exports);
+    cleanupInvocation = 0;
+    TaskDeletionConflictError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "TaskDeletionConflictError";
+      }
+    };
     TaskService = class {
       static buildScopeWhere(scope) {
         const conditions = [];
@@ -6388,8 +6462,28 @@ var init_task_service = __esm({
       }
       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");
@@ -6441,23 +6535,54 @@ var init_task_service = __esm({
         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 = [
@@ -6493,27 +6618,202 @@ var init_task_service = __esm({
         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({
@@ -6526,8 +6826,18 @@ var init_task_service = __esm({
         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;
@@ -6570,41 +6880,91 @@ var init_task_service = __esm({
           ),
           ...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)];
@@ -6669,36 +7029,360 @@ var init_task_service = __esm({
         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/launch-protocol.ts
+function isLaunchIdentity(value) {
+  return value != null && /^gateway-[1-9]\d*:launch:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function isMatchingDrainProof(message, launchIdentity) {
+  if (typeof message !== "object" || message == null) return false;
+  const candidate = message;
+  return candidate.type === DRAIN_PROOF_MESSAGE_TYPE && candidate.identity === launchIdentity;
+}
+var LEGACY_GUARDIAN_LAUNCH_PROTOCOL, TOKEN_GUARDIAN_LAUNCH_PROTOCOL, LAUNCH_IDENTITY_ARGUMENT, DRAIN_PROOF_MESSAGE_TYPE, MANAGED_RUN_ENV, MANAGED_RUN_ENV_VALUE;
+var init_launch_protocol = __esm({
+  "src/core/launch-protocol.ts"() {
+    "use strict";
+    LEGACY_GUARDIAN_LAUNCH_PROTOCOL = "gated-v2-guardian";
+    TOKEN_GUARDIAN_LAUNCH_PROTOCOL = "gated-v3-token-guardian";
+    LAUNCH_IDENTITY_ARGUMENT = "--supertask-launch-identity";
+    DRAIN_PROOF_MESSAGE_TYPE = "supertask-drained";
+    MANAGED_RUN_ENV = "SUPERTASK_MANAGED_RUN";
+    MANAGED_RUN_ENV_VALUE = "1";
+  }
+});
+
+// src/core/process-control.ts
+import { spawnSync } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { basename, dirname as dirname2, resolve } from "path";
+function isSafePid(pid) {
+  return Number.isInteger(pid) && pid > 1 && pid !== process.pid;
+}
+function absentLeaderResult(pid) {
+  return inspectSpawnedProcessTreePresence(pid) === "not-running" ? "not-running" : "inspect-failed";
+}
+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 isSpawnedProcessTreeAlive(pid) {
+  return inspectSpawnedProcessTreePresence(pid) === "running";
+}
+function inspectSpawnedProcessTreePresence(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return "unknown";
+  if (process.platform === "win32") {
+    const processIds = inspectWindowsProcessTree(pid);
+    if (processIds == null) return "unknown";
+    return processIds.length > 0 ? "running" : "not-running";
+  }
+  try {
+    process.kill(-pid, 0);
+    return "running";
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error)) return "unknown";
+    if (error.code === "EPERM") return "running";
+    if (error.code === "ESRCH") return "not-running";
+    return "unknown";
+  }
+}
+function inspectUnixProcess(pid) {
+  const result = spawnSync("ps", ["-o", "pgid=", "-o", "command=", "-p", String(pid)], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: OS_COMMAND_TIMEOUT_MS,
+    killSignal: "SIGKILL"
+  });
+  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 inspectWindowsCommand(pid) {
+  const script = `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`;
+  const result = spawnSync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-Command", script],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: OS_COMMAND_TIMEOUT_MS,
+      killSignal: "SIGKILL"
+    }
+  );
+  if (result.status !== 0) return null;
+  return result.stdout.trim() || null;
+}
+function inspectWindowsProcessTree(rootPid) {
+  const script = `$root=${rootPid}; $all=@(Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId); $ids=New-Object 'System.Collections.Generic.HashSet[int]'; [void]$ids.Add($root); do { $added=$false; foreach($p in $all) { if($ids.Contains([int]$p.ParentProcessId) -and $ids.Add([int]$p.ProcessId)) { $added=$true } } } while($added); $all | Where-Object { $ids.Contains([int]$_.ProcessId) } | Select-Object -ExpandProperty ProcessId`;
+  const result = spawnSync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-Command", script],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: OS_COMMAND_TIMEOUT_MS,
+      killSignal: "SIGKILL"
+    }
+  );
+  if (result.status !== 0) return null;
+  return result.stdout.split(/\s+/).filter(Boolean).map(Number).filter((pid) => Number.isInteger(pid) && pid > 0);
+}
+function executableName(value) {
+  return basename(value).trim().toLowerCase().replace(/\.(?:exe|cmd|bat)$/i, "");
+}
+function commandTokens(command) {
+  return command.trim().split(/\s+/).map((token) => token.replace(/^["']|["']$/g, ""));
+}
+function openCodeArgsMatch(args) {
+  const agentIndex = args.indexOf("--agent");
+  const formatIndex = args.indexOf("--format");
+  return args[0] === "run" && agentIndex >= 0 && Boolean(args[agentIndex + 1]) && formatIndex >= 0 && args[formatIndex + 1] === "json";
+}
+function guardianLauncherPath() {
+  const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
+  return resolve(dirname2(fileURLToPath2(import.meta.url)), `../worker/launcher.${extension}`).replaceAll("\\", "/");
+}
+function commandMatches(command, expectedExecutable, launchProtocol, expectedLaunchIdentity) {
+  const expectedName = executableName(expectedExecutable);
+  if (!expectedName) return false;
+  const tokens = commandTokens(command);
+  if (launchProtocol === TOKEN_GUARDIAN_LAUNCH_PROTOCOL) {
+    if (!isLaunchIdentity(expectedLaunchIdentity)) return false;
+    const expectedLauncher = guardianLauncherPath();
+    const launcherIndex = tokens.findIndex((token, index2) => index2 > 0 && index2 <= 3 && token.replaceAll("\\", "/") === expectedLauncher);
+    if (launcherIndex < 0) return false;
+    const runtimeName = executableName(process.execPath);
+    const hasRuntime = tokens.slice(0, launcherIndex).some((token) => executableName(token) === runtimeName || executableName(token) === "bun");
+    const identityArgumentIndex = launcherIndex + 1;
+    const launchIdentityIndex = launcherIndex + 2;
+    const executableIndex2 = launcherIndex + 3;
+    return hasRuntime && tokens[identityArgumentIndex] === LAUNCH_IDENTITY_ARGUMENT && tokens[launchIdentityIndex] === expectedLaunchIdentity && executableName(tokens[executableIndex2] ?? "") === expectedName && openCodeArgsMatch(tokens.slice(executableIndex2 + 1));
+  }
+  if (launchProtocol != null) return false;
+  const executableIndex = tokens.findIndex((token, index2) => index2 <= 3 && executableName(token) === expectedName);
+  if (executableIndex < 0) return false;
+  return openCodeArgsMatch(tokens.slice(executableIndex + 1, executableIndex + 12));
+}
+function identifyGatewayProcess(pid) {
+  if (!isProcessAlive(pid)) return "not-running";
+  const command = process.platform === "win32" ? inspectWindowsCommand(pid) : inspectUnixProcess(pid)?.command ?? null;
+  if (!command) return "unknown";
+  const tokens = command.trim().split(/\s+/).map((token) => token.replace(/^['"]|['"]$/g, "").replaceAll("\\", "/"));
+  const runtimeName = executableName(process.execPath);
+  const hasRuntime = tokens.slice(0, 4).some((token) => executableName(token) === runtimeName || executableName(token) === "bun");
+  const hasGatewayEntry = tokens.some((token) => /(?:^|\/)gateway\/index\.(?:js|ts)$/.test(token));
+  const cliEntryIndex = tokens.findIndex((token) => /(?:^|\/)cli\/index\.(?:js|ts)$/.test(token));
+  const hasCliGatewayCommand = cliEntryIndex >= 0 && tokens.slice(cliEntryIndex + 1).includes("gateway");
+  const supertaskIndex = tokens.findIndex((token, index2) => index2 <= 3 && executableName(token) === "supertask");
+  const hasBinGatewayCommand = supertaskIndex >= 0 && tokens[supertaskIndex + 1] === "gateway";
+  return hasRuntime && (hasGatewayEntry || hasCliGatewayCommand || hasBinGatewayCommand) ? "match" : "mismatch";
+}
+function signalRecordedProcessTreeWithResult(pid, signal, expectedExecutable, launchProtocol = null, expectedLaunchIdentity = null) {
+  if (!isSafePid(pid)) return "identity-mismatch";
+  if (!isProcessAlive(pid)) return absentLeaderResult(pid);
+  if (process.platform === "win32") {
+    const command = inspectWindowsCommand(pid);
+    if (!command) return isProcessAlive(pid) ? "inspect-failed" : absentLeaderResult(pid);
+    if (!commandMatches(
+      command,
+      expectedExecutable,
+      launchProtocol,
+      expectedLaunchIdentity
+    )) {
+      return "identity-mismatch";
+    }
+    const args = ["/PID", String(pid), "/T"];
+    if (signal === "SIGKILL") args.push("/F");
+    const status = spawnSync("taskkill", args, {
+      stdio: "ignore",
+      timeout: OS_COMMAND_TIMEOUT_MS,
+      killSignal: "SIGKILL"
+    }).status;
+    if (status === 0) return "signalled";
+    return isProcessAlive(pid) ? "signal-failed" : absentLeaderResult(pid);
+  }
+  const info = inspectUnixProcess(pid);
+  if (!info) return isProcessAlive(pid) ? "inspect-failed" : absentLeaderResult(pid);
+  if (!commandMatches(
+    info.command,
+    expectedExecutable,
+    launchProtocol,
+    expectedLaunchIdentity
+  )) {
+    return "identity-mismatch";
+  }
+  try {
+    if (info.processGroupId === pid) process.kill(-pid, signal);
+    else process.kill(pid, signal);
+    return "signalled";
+  } catch {
+    return isProcessAlive(pid) ? "signal-failed" : absentLeaderResult(pid);
+  }
+}
+async function waitForSpawnedProcessTreeExit(pid, timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (inspectSpawnedProcessTreePresence(pid) !== "not-running" && Date.now() < deadline) {
+    await Bun.sleep(Math.min(50, deadline - Date.now()));
+  }
+  return inspectSpawnedProcessTreePresence(pid) === "not-running";
+}
+var OS_COMMAND_TIMEOUT_MS;
+var init_process_control = __esm({
+  "src/core/process-control.ts"() {
+    "use strict";
+    init_launch_protocol();
+    OS_COMMAND_TIMEOUT_MS = 2e3;
+  }
+});
+
 // src/core/services/task-run.service.ts
-var taskRuns3, TaskRunService;
+var tasks3, taskRuns3, LegacyRunAbandonConflictError, TaskRunService;
 var init_task_run_service = __esm({
   "src/core/services/task-run.service.ts"() {
     "use strict";
     init_db2();
     init_drizzle_orm();
-    ({ taskRuns: taskRuns3 } = schema_exports);
+    init_process_control();
+    ({ tasks: tasks3, taskRuns: taskRuns3 } = schema_exports);
+    LegacyRunAbandonConflictError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "LegacyRunAbandonConflictError";
+      }
+    };
     TaskRunService = class {
       static async create(data) {
         const result = await db.insert(taskRuns3).values(data).returning();
@@ -6728,12 +7412,12 @@ var init_task_run_service = __esm({
         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;
       }
@@ -6761,39 +7445,108 @@ var init_task_run_service = __esm({
       }
       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;
@@ -6819,23 +7572,63 @@ function initializeGatewayHealth(config) {
     lastActivityAt: {
       worker: now,
       scheduler: now,
-      watchdog: now
+      watchdog: now,
+      watchdogCleanup: now
+    },
+    lastSuccessAt: {
+      worker: now,
+      scheduler: now,
+      watchdog: now,
+      watchdogCleanup: now
+    },
+    consecutiveFailures: {
+      worker: 0,
+      scheduler: 0,
+      watchdog: 0,
+      watchdogCleanup: 0
+    },
+    lastError: {
+      worker: null,
+      scheduler: null,
+      watchdog: null,
+      watchdogCleanup: null
     }
   };
 }
 function markGatewayActivity(component) {
   if (state) state.lastActivityAt[component] = Date.now();
 }
+function markGatewaySuccess(component) {
+  if (!state) return;
+  const now = Date.now();
+  state.lastActivityAt[component] = now;
+  state.lastSuccessAt[component] = now;
+  state.consecutiveFailures[component] = 0;
+}
+function markGatewayFailure(component, error) {
+  if (!state) return;
+  const now = Date.now();
+  state.lastActivityAt[component] = now;
+  state.consecutiveFailures[component] += 1;
+  state.lastError[component] = {
+    at: now,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
 function resetGatewayHealth() {
   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
   };
@@ -6859,6 +7652,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(
@@ -6876,13 +7675,13 @@ 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 }
   };
 }
 var LOCK_STALE_MS, state;
@@ -6895,80 +7694,6 @@ var init_health = __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";
-  }
-});
-
 // node_modules/cron-parser/dist/fields/types.js
 var require_types = __commonJS({
   "node_modules/cron-parser/dist/fields/types.js"(exports) {
@@ -10686,12 +11411,12 @@ var require_luxon = __commonJS({
         if (!this.loc.equals(other.loc)) {
           return false;
         }
-        function eq3(v1, v2) {
+        function eq2(v1, v2) {
           if (v1 === void 0 || v1 === 0) return v2 === void 0 || v2 === 0;
           return v1 === v2;
         }
         for (const u of orderedUnits$1) {
-          if (!eq3(this.values[u], other.values[u])) {
+          if (!eq2(this.values[u], other.values[u])) {
             return false;
           }
         }
@@ -16035,8 +16760,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static parseFileSync(filePath) {
-        const { readFileSync: readFileSync3 } = __require("fs");
-        const data = readFileSync3(filePath, "utf8");
+        const { readFileSync: readFileSync4 } = __require("fs");
+        const data = readFileSync4(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -16174,19 +16899,17 @@ var init_task_template_service = __esm({
       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");
@@ -16226,8 +16949,18 @@ var init_task_template_service = __esm({
         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();
@@ -16237,6 +16970,47 @@ var init_task_template_service = __esm({
         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) {
@@ -16259,6 +17033,134 @@ var init_task_template_service = __esm({
   }
 });
 
+// src/gateway/scheduler/job-templates.ts
+async function cloneTaskFromTemplate(templateId) {
+  return createTaskFromTemplate(templateId, { advanceSchedule: true });
+}
+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" });
+}
+async function getDueTemplates(cursor = null, cutoffNow = Date.now()) {
+  return await db.select().from(taskTemplates3).where(
+    and(
+      eq(taskTemplates3.enabled, true),
+      sql`${taskTemplates3.nextRunAt} IS NOT NULL`,
+      sql`${taskTemplates3.nextRunAt} <= ${cutoffNow}`,
+      cursor ? sql`(
+                        ${taskTemplates3.nextRunAt} > ${cursor.nextRunAt}
+                        OR (
+                            ${taskTemplates3.nextRunAt} = ${cursor.nextRunAt}
+                            AND ${taskTemplates3.id} > ${cursor.id}
+                        )
+                    )` : void 0
+    )
+  ).orderBy(asc(taskTemplates3.nextRunAt), asc(taskTemplates3.id)).limit(DUE_TEMPLATE_BATCH_SIZE);
+}
+async function initializeNextRunAt(templateId) {
+  return db.transaction((tx) => {
+    const tmpl = tx.select().from(taskTemplates3).where(and(
+      eq(taskTemplates3.id, templateId),
+      eq(taskTemplates3.enabled, true),
+      isNull(taskTemplates3.nextRunAt)
+    )).limit(1).get();
+    if (!tmpl) return null;
+    const nextRunAt = TaskTemplateService.calculateNextRunAt(
+      tmpl.scheduleType,
+      tmpl
+    );
+    if (nextRunAt == null) return null;
+    return tx.update(taskTemplates3).set({ nextRunAt, updatedAt: Date.now() }).where(and(
+      eq(taskTemplates3.id, templateId),
+      eq(taskTemplates3.enabled, true),
+      isNull(taskTemplates3.nextRunAt)
+    )).returning().get() ?? null;
+  }, { behavior: "immediate" });
+}
+var taskTemplates3, DUE_TEMPLATE_BATCH_SIZE;
+var init_job_templates = __esm({
+  "src/gateway/scheduler/job-templates.ts"() {
+    "use strict";
+    init_db2();
+    init_drizzle_orm();
+    init_task_template_service();
+    ({ taskTemplates: taskTemplates3 } = schema_exports);
+    DUE_TEMPLATE_BATCH_SIZE = 100;
+  }
+});
+
 // node_modules/hono/dist/compose.js
 var compose;
 var init_compose = __esm({
@@ -18595,12 +19497,10 @@ var init_html2 = __esm({
 
 // src/core/services/database-maintenance.service.ts
 import { Database as Database3 } from "bun:sqlite";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import {
   chmodSync,
-  constants,
-  copyFileSync,
-  existsSync as existsSync3,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync2,
   renameSync,
   statSync,
@@ -18608,12 +19508,12 @@ import {
   writeFileSync
 } from "fs";
 import { tmpdir } from "os";
-import { basename as basename2, dirname as dirname2, resolve } from "path";
+import { basename as basename2, dirname as dirname5, resolve as resolve2 } 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);
+  return path === ":memory:" ? path : resolve2(path);
 }
 function safeUnlink(path) {
   try {
@@ -18626,6 +19526,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 REQUIRED_TABLES, DatabaseMaintenanceConflictError, DatabaseMaintenanceService;
 var init_database_maintenance_service = __esm({
   "src/core/services/database-maintenance.service.ts"() {
@@ -18662,9 +19568,11 @@ var init_database_maintenance_service = __esm({
           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,
@@ -18686,78 +19594,102 @@ var init_database_maintenance_service = __esm({
         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 (!existsSync3(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`;
+        const stagePath = `${livePath}.restore-${process.pid}-${randomUUID2()}.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 (!existsSync5(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
@@ -18767,20 +19699,34 @@ var init_database_maintenance_service = __esm({
                         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,
@@ -18789,31 +19735,19 @@ var init_database_maintenance_service = __esm({
             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 && existsSync3(rollbackPath)) {
-            safeUnlink(livePath);
-            renameSync(rollbackPath, livePath);
-            try {
-              const original = getSqlite();
-              original.query("DELETE FROM gateway_lock WHERE pid = ?").run(process.pid);
-            } catch {
-            }
-          } else if (existsSync3(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) {
@@ -18829,6 +19763,78 @@ var init_database_maintenance_service = __esm({
           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'"
@@ -18842,7 +19848,7 @@ var init_database_maintenance_service = __esm({
         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:" || !existsSync3(path) ? sqlite2.serialize().byteLength : statSync(path).size;
+        const sizeBytes = path === ":memory:" || !existsSync5(path) ? sqlite2.serialize().byteLength : statSync(path).size;
         return {
           ok: integrityMessages.length === 1 && integrityMessages[0] === "ok" && foreignKeyViolations === 0 && missingTables.length === 0,
           path: normalizedPath(path),
@@ -18863,9 +19869,9 @@ var init_database_maintenance_service = __esm({
         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 (existsSync3(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()}`;
+        if (existsSync5(output)) throw new Error(`\u5907\u4EFD\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1A${output}`);
+        mkdirSync2(dirname5(output), { recursive: true });
+        const temporary = `${output}.tmp-${process.pid}-${randomUUID2()}`;
         try {
           writeFileSync(temporary, sqlite2.serialize(), { flag: "wx", mode: 384 });
           const standalone = new Database3(temporary, { readwrite: true, create: false });
@@ -18889,9 +19895,9 @@ var init_database_maintenance_service = __esm({
         }
       }
       static createBackupPath(kind) {
-        const directory = DB_FILE_PATH === ":memory:" ? tmpdir() : dirname2(normalizedPath(DB_FILE_PATH));
+        const directory = DB_FILE_PATH === ":memory:" ? tmpdir() : dirname5(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`);
+        return resolve2(directory, `${base}.${kind}-${timestamp()}-${randomUUID2().slice(0, 8)}.db`);
       }
       static readCounts(sqlite2) {
         return {
@@ -18931,8 +19937,8 @@ __export(web_exports, {
   dashboardApp: () => dashboardApp,
   default: () => web_default
 });
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, renameSync as renameSync2 } from "fs";
-import { dirname as dirname3 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, renameSync as renameSync2 } from "fs";
+import { dirname as dirname6 } from "path";
 function parsePositiveInteger(value) {
   if (!/^\d+$/.test(value)) return null;
   const parsed = Number(value);
@@ -18982,17 +19988,17 @@ function esc(s) {
 }
 function readCurrentConfig() {
   const configPath = getConfigPath();
-  if (!existsSync4(configPath)) return {};
+  if (!existsSync6(configPath)) return {};
   try {
-    return JSON.parse(readFileSync2(configPath, "utf-8"));
+    return JSON.parse(readFileSync3(configPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(cfg) {
   const configPath = getConfigPath();
-  const dir = dirname3(configPath);
-  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+  const dir = dirname6(configPath);
+  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
   const tempPath = `${configPath}.${process.pid}.tmp`;
   writeFileSync2(tempPath, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
   renameSync2(tempPath, configPath);
@@ -19000,8 +20006,9 @@ function writeConfig(cfg) {
 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');}}
@@ -19083,6 +20090,7 @@ var init_web = __esm({
     init_db2();
     init_config();
     init_health();
+    init_job_templates();
     app = new Hono2();
     TASK_STATUSES = /* @__PURE__ */ new Set([
       "pending",
@@ -19207,11 +20215,11 @@ var init_web = __esm({
       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,
@@ -19230,9 +20238,10 @@ var init_web = __esm({
       <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>
@@ -19243,7 +20252,8 @@ var init_web = __esm({
           <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}` : "";
@@ -19387,7 +20397,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 = existsSync6(configPath);
       let runRows = "";
       if (runningRuns.length > 0) {
         for (const run of runningRuns) {
@@ -19495,11 +20505,25 @@ var init_web = __esm({
       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"));
@@ -19524,21 +20548,8 @@ var init_web = __esm({
       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) => {
@@ -19580,6 +20591,7 @@ var init_web = __esm({
     });
     dashboardApp = app;
     web_default = {
+      hostname: "127.0.0.1",
       port: 4680,
       fetch: app.fetch
     };
@@ -19595,9 +20607,21 @@ init_task_service();
 init_task_run_service();
 init_health();
 init_process_control();
+init_launch_protocol();
 import { spawn } from "child_process";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+import { randomUUID } from "crypto";
 var DEFAULT_MAX_OUTPUT_CHARS = 64 * 1024;
 var FORBIDDEN_AGENT = "supertask-runner";
+function assertWorkerProcessIsolationSupported(platform = process.platform) {
+  if (platform === "win32") {
+    throw new Error(
+      "Windows Worker \u5DF2\u5B89\u5168\u7981\u7528\uFF1A\u5F53\u524D\u8FD0\u884C\u65F6\u65E0\u6CD5\u7528 Job Object \u8BC1\u660E\u6574\u4E2A OpenCode \u8FDB\u7A0B\u6811\u5DF2\u9000\u51FA"
+    );
+  }
+}
 var WorkerEngine = class {
   activeBatchIds = /* @__PURE__ */ new Set();
   runningTasks = /* @__PURE__ */ new Map();
@@ -19614,10 +20638,13 @@ var WorkerEngine = class {
     this.maxOutputChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   }
   start() {
+    assertWorkerProcessIsolationSupported();
     this.stopped = false;
     markGatewayActivity("worker");
     this.poll();
-    this.heartbeatTimer = setInterval(() => this.updateHeartbeats(), this.cfg.heartbeatIntervalMs);
+    this.heartbeatTimer = setInterval(() => {
+      this.runDetached(this.updateHeartbeats(), "worker heartbeat cycle failed");
+    }, this.cfg.heartbeatIntervalMs);
   }
   async stop(gracePeriodMs = 0) {
     this.stopped = true;
@@ -19636,14 +20663,23 @@ var WorkerEngine = class {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
     }
-    const interruptedTaskIds = [...this.runningTasks.keys()];
-    const killPromises = [];
-    for (const entry of this.runningTasks.values()) {
-      entry.shutdown = true;
-      killPromises.push(this.killEntry(entry));
-    }
-    await Promise.allSettled(killPromises);
-    return interruptedTaskIds;
+    const interrupted = [];
+    const entries = [...this.runningTasks.values()];
+    await Promise.all(entries.map(async (entry) => {
+      if (entry.settled) {
+        if (entry.settlementPromise) await entry.settlementPromise;
+        return;
+      }
+      const termination = entry.termination ?? {
+        kind: "shutdown",
+        message: "Gateway shutdown"
+      };
+      const terminated = await this.terminateEntry(entry, termination);
+      if (terminated && termination.kind === "shutdown") {
+        interrupted.push({ taskId: entry.task.id, runId: entry.runId });
+      }
+    }));
+    return interrupted;
   }
   getRunningTaskIds() {
     return [...this.runningTasks.keys()];
@@ -19651,24 +20687,40 @@ var WorkerEngine = class {
   getRunningCount() {
     return this.runningTasks.size;
   }
+  ownsRun(taskId, runId) {
+    return this.runningTasks.get(taskId)?.runId === runId;
+  }
   poll() {
     if (this.stopped) return;
     markGatewayActivity("worker");
-    this.pollCyclePromise = this.tryDispatch().finally(() => {
+    this.pollCyclePromise = this.tryDispatch().then((healthy) => {
+      if (healthy) markGatewaySuccess("worker");
+    }).catch((err) => {
+      markGatewayFailure("worker", err);
+      this.logError("worker poll failed", err);
+    }).finally(() => {
       this.pollCyclePromise = null;
       if (this.stopped) return;
       this.pollTimer = setTimeout(() => this.poll(), this.cfg.pollIntervalMs);
     });
   }
   async tryDispatch() {
+    await TaskService.resetOrphanRunningToPending();
     await this.reconcileCancelledTasks();
+    await this.reconcileQuarantinedTasks();
+    const quarantined = [...this.runningTasks.values()].filter((entry) => entry.quarantined);
+    if (quarantined.length > 0) {
+      return false;
+    }
     while (!this.stopped && this.runningTasks.size < this.cfg.maxConcurrency) {
+      const databaseRunningCount = await TaskService.countRunning();
+      if (databaseRunningCount >= this.cfg.maxConcurrency) break;
       let task;
       try {
         task = await TaskService.next({ excludedBatchIds: [...this.activeBatchIds] });
       } catch (err) {
         this.logError("task claim failed", err);
-        break;
+        throw err;
       }
       if (!task) break;
       if (this.stopped) break;
@@ -19679,12 +20731,19 @@ var WorkerEngine = class {
         this.releaseBatch(task);
         break;
       }
+      let runId = null;
       try {
+        const launchIdentity = `gateway-${process.pid}:launch:${randomUUID()}`;
         const run = await TaskRunService.create({
           taskId: task.id,
           model: this.resolveModel(task.model),
-          status: "running"
+          status: "running",
+          workerPid: process.pid,
+          lockedAt: Date.now(),
+          lockedBy: launchIdentity,
+          launchProtocol: TOKEN_GUARDIAN_LAUNCH_PROTOCOL
         });
+        runId = run.id;
         if (this.stopped) {
           await TaskRunService.fail(run.id, "Gateway shutdown before spawn");
           await TaskService.resetRunningToPending([task.id]);
@@ -19693,49 +20752,82 @@ var WorkerEngine = class {
         }
         if (task.agent === FORBIDDEN_AGENT) {
           const message = `\u7981\u6B62\u6267\u884C\u9012\u5F52 Agent: ${FORBIDDEN_AGENT}`;
-          await TaskRunService.fail(run.id, message);
-          await TaskService.fail(task.id, message, {}, { setDeadLetter: true });
+          await TaskService.failRun(task.id, run.id, message, { setDeadLetter: true });
           this.releaseBatch(task);
           continue;
         }
-        this.spawnTask(task, run.id);
+        await this.spawnTask(task, run.id, launchIdentity);
       } catch (err) {
         this.releaseBatch(task);
         const message = `Worker \u542F\u52A8\u4EFB\u52A1\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`;
         try {
-          await TaskService.fail(task.id, message);
+          if (runId == null) {
+            await TaskService.fail(task.id, message);
+          } else {
+            const failed = await TaskService.failRun(task.id, runId, message);
+            if (!failed) {
+              await TaskRunService.fail(runId, `${message}
+\u4EFB\u52A1\u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8`);
+            }
+          }
         } catch (failErr) {
           this.logError("failed to compensate task startup", failErr, task.id);
         }
         this.logError("task dispatch failed", err, task.id);
       }
     }
+    return ![...this.runningTasks.values()].some((entry) => entry.quarantined);
+  }
+  launcherEntry() {
+    const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
+    const moduleDir = dirname3(fileURLToPath3(import.meta.url));
+    const candidates = [
+      join3(moduleDir, `launcher.${extension}`),
+      join3(moduleDir, `../worker/launcher.${extension}`)
+    ];
+    const entry = candidates.find((candidate) => existsSync3(candidate));
+    if (!entry) throw new Error(`Worker launcher \u4E0D\u5B58\u5728\uFF1A${candidates.join(", ")}`);
+    return entry;
   }
-  spawnTask(task, runId) {
+  async spawnTask(task, runId, launchIdentity) {
     const model = this.resolveModel(task.model);
     const args = ["run", "--agent", task.agent, "--format", "json"];
     if (model) args.push("-m", model);
     args.push(task.prompt);
-    const child = spawn(this.opencodeBin, args, {
+    const child = spawn(process.execPath, [
+      this.launcherEntry(),
+      LAUNCH_IDENTITY_ARGUMENT,
+      launchIdentity,
+      this.opencodeBin,
+      ...args
+    ], {
       cwd: task.cwd || process.cwd(),
-      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        [MANAGED_RUN_ENV]: MANAGED_RUN_ENV_VALUE
+      },
+      stdio: ["pipe", "pipe", "pipe", "ipc"],
       detached: process.platform !== "win32"
     });
     const entry = {
       task,
       runId,
+      launchIdentity,
       child,
       output: "",
       sessionId: null,
       timeoutTimer: null,
-      shutdown: false,
+      termination: null,
+      terminationPromise: null,
+      settlementPromise: null,
+      guardianDrained: false,
+      quarantined: false,
       settled: false
     };
     this.runningTasks.set(task.id, entry);
     const handleData = (data) => {
       const text2 = data.toString();
       entry.output = (entry.output + text2).slice(-this.maxOutputChars);
-      process.stdout.write(text2);
       const match2 = entry.output.match(/"sessionID"\s*:\s*"(ses_[^"]+)"/);
       if (match2?.[1] && match2[1] !== entry.sessionId) {
         entry.sessionId = match2[1];
@@ -19746,107 +20838,210 @@ var WorkerEngine = class {
     };
     child.stdout?.on("data", handleData);
     child.stderr?.on("data", handleData);
-    child.once("error", (err) => {
-      void this.finishEntry(entry, null, `\u65E0\u6CD5\u542F\u52A8 opencode\uFF1A${err.message}`);
+    child.on("message", (message) => {
+      if (isMatchingDrainProof(message, entry.launchIdentity)) {
+        entry.guardianDrained = true;
+      }
+    });
+    let spawnError = null;
+    const spawned = new Promise((resolve3, reject) => {
+      child.once("spawn", resolve3);
+      child.once("error", (error) => {
+        spawnError = error;
+        reject(error);
+      });
     });
     child.once("close", (code, signal) => {
-      const failure = code === 0 ? void 0 : `opencode \u9000\u51FA\u7801 ${code ?? "null"}${signal ? `\uFF0C\u4FE1\u53F7 ${signal}` : ""}`;
-      void this.finishEntry(entry, code, failure);
+      this.handleChildClose(entry, code, signal, spawnError);
     });
+    try {
+      await spawned;
+    } catch (error) {
+      entry.settled = true;
+      this.runningTasks.delete(task.id);
+      this.releaseBatch(task);
+      throw error;
+    }
+    const childPid = child.pid;
+    if (!childPid) {
+      entry.settled = true;
+      this.runningTasks.delete(task.id);
+      this.releaseBatch(task);
+      throw new Error("launcher \u672A\u8FD4\u56DE PID");
+    }
+    let pidRecorded = false;
+    try {
+      pidRecorded = await TaskRunService.updatePid(
+        runId,
+        process.pid,
+        childPid,
+        launchIdentity
+      ) !== null;
+    } catch (error) {
+      await this.terminateForFailure(
+        entry,
+        `\u8BB0\u5F55 Worker PID \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
+    if (!pidRecorded) {
+      await this.terminateForFailure(entry, "\u8BB0\u5F55 Worker PID \u5931\u8D25\uFF1Arun \u5DF2\u4E0D\u518D\u5904\u4E8E running \u72B6\u6001");
+      return;
+    }
+    if (!child.stdin) {
+      await this.terminateForFailure(entry, "\u653E\u884C OpenCode \u5931\u8D25\uFF1Alauncher stdin \u4E0D\u53EF\u7528");
+      return;
+    }
+    try {
+      await new Promise((resolve3, reject) => {
+        child.stdin.end("START\n", (error) => {
+          if (error) reject(error);
+          else resolve3();
+        });
+      });
+    } catch (error) {
+      await this.terminateForFailure(
+        entry,
+        `\u653E\u884C OpenCode \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
     const timeoutMs = task.timeoutMs ?? this.cfg.taskTimeoutMs;
     if (timeoutMs > 0) {
       entry.timeoutTimer = setTimeout(() => {
-        this.signalEntry(entry, "SIGKILL");
-        void this.finishEntry(entry, null, `\u4EFB\u52A1\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`);
+        this.runDetached(
+          this.terminateForFailure(entry, `\u4EFB\u52A1\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`, "SIGKILL"),
+          "timeout termination failed",
+          entry.task.id
+        );
       }, timeoutMs);
     }
-    TaskRunService.updatePid(runId, process.pid, child.pid ?? 0).catch((err) => {
-      this.signalEntry(entry, "SIGKILL");
-      void this.finishEntry(entry, null, `\u8BB0\u5F55 Worker PID \u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
-    });
   }
-  async finishEntry(entry, code, failure) {
-    if (entry.settled) return;
-    entry.settled = true;
-    if (entry.timeoutTimer) {
-      clearTimeout(entry.timeoutTimer);
-      entry.timeoutTimer = null;
-    }
-    try {
-      if (entry.shutdown) return;
-      const currentRun = await TaskRunService.getById(entry.runId);
-      if (!currentRun || currentRun.status !== "running") return;
-      const output = entry.output.trim();
-      const log = failure ? `${failure}${output ? `
-${output}` : ""}` : output;
-      if (code === 0 && !failure) {
-        const completed = await TaskService.done(entry.task.id, log);
-        if (completed) {
-          await TaskRunService.done(entry.runId, log);
-          console.log(JSON.stringify({
-            ts: (/* @__PURE__ */ new Date()).toISOString(),
-            level: "info",
-            msg: "task done",
-            taskId: entry.task.id
-          }));
-          return;
-        }
-        await TaskRunService.fail(entry.runId, "\u4EFB\u52A1\u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8");
+  handleChildClose(entry, code, signal, spawnError) {
+    if (entry.settled || entry.termination) return;
+    if (!entry.guardianDrained) {
+      const pid = entry.child.pid;
+      const presence = pid == null ? spawnError == null ? "unknown" : "not-running" : inspectSpawnedProcessTreePresence(pid);
+      const message = "guardian \u672A\u63D0\u4F9B\u8FDB\u7A0B\u6811\u6392\u7A7A\u8BC1\u660E";
+      if (presence !== "not-running") {
+        if (entry.timeoutTimer) {
+          clearTimeout(entry.timeoutTimer);
+          entry.timeoutTimer = null;
+        }
+        entry.termination = { kind: "failure", message };
+        entry.quarantined = true;
+        markGatewayFailure(
+          "worker",
+          new Error(`${message}\uFF1B\u4EFB\u52A1 #${entry.task.id} \u4FDD\u6301\u9694\u79BB`)
+        );
         return;
       }
-      await TaskRunService.fail(entry.runId, log);
-      const failed = await TaskService.fail(entry.task.id, log);
-      if (!failed) {
-        this.logError("task failure state transition rejected", failure ?? "unknown failure", entry.task.id);
-      }
-      console.error(JSON.stringify({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        level: "error",
-        msg: "task failed",
-        taskId: entry.task.id,
-        error: failure
-      }));
-    } finally {
-      this.runningTasks.delete(entry.task.id);
-      this.releaseBatch(entry.task);
-    }
-  }
-  async reconcileCancelledTasks() {
-    for (const entry of [...this.runningTasks.values()]) {
-      try {
-        const task = await TaskService.getById(entry.task.id);
-        if (task?.status === "cancelled") await this.cancelEntry(entry);
-      } catch (err) {
-        this.logError("cancel reconciliation failed", err, entry.task.id);
-      }
+      this.runDetached(
+        this.settleEntry(entry, null, message),
+        "task settlement failed",
+        entry.task.id
+      );
+      return;
     }
+    const failure = code === 0 ? void 0 : `${spawnError ? "\u65E0\u6CD5\u542F\u52A8 opencode" : "opencode \u9000\u51FA\u7801"} ${spawnError?.message ?? code ?? "null"}${signal ? `\uFF0C\u4FE1\u53F7 ${signal}` : ""}`;
+    this.runDetached(
+      this.settleEntry(entry, code, failure),
+      "task settlement failed",
+      entry.task.id
+    );
   }
-  async cancelEntry(entry) {
-    if (entry.settled) return;
+  settleEntry(entry, code, failure) {
+    if (entry.settlementPromise) return entry.settlementPromise;
+    if (entry.settled) return Promise.resolve(false);
     entry.settled = true;
     if (entry.timeoutTimer) {
       clearTimeout(entry.timeoutTimer);
       entry.timeoutTimer = null;
     }
-    try {
-      await this.killEntry(entry);
-      const output = entry.output.trim();
-      const log = `\u4EFB\u52A1\u5DF2\u53D6\u6D88${output ? `
-${output}` : ""}`;
-      await TaskRunService.fail(entry.runId, log);
+    const settlement = this.commitEntry(entry, code, failure).then(() => true).catch((error) => {
+      markGatewayFailure("worker", error);
+      this.logError("task settlement failed", error, entry.task.id);
+      return false;
+    }).finally(() => {
+      this.runningTasks.delete(entry.task.id);
+      this.releaseBatch(entry.task);
+    });
+    entry.settlementPromise = settlement;
+    return settlement;
+  }
+  async commitEntry(entry, code, failure) {
+    const termination = entry.termination;
+    if (termination?.kind === "shutdown") return;
+    if (termination?.kind === "cancel") {
+      const output2 = entry.output.trim();
+      const log2 = `${termination.message}${output2 ? `
+${output2}` : ""}`;
+      await TaskRunService.fail(entry.runId, log2);
       console.log(JSON.stringify({
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         level: "info",
         msg: "running task cancelled",
         taskId: entry.task.id
       }));
-    } finally {
-      this.runningTasks.delete(entry.task.id);
-      this.releaseBatch(entry.task);
+      return;
+    }
+    const currentRun = await TaskRunService.getById(entry.runId);
+    if (!currentRun || currentRun.status !== "running") return;
+    const output = entry.output.trim();
+    const log = failure ? `${failure}${output ? `
+${output}` : ""}` : output;
+    if (code === 0 && !failure) {
+      const completed = await TaskService.completeRun(entry.task.id, entry.runId, log);
+      if (completed) {
+        console.log(JSON.stringify({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "info",
+          msg: "task done",
+          taskId: entry.task.id
+        }));
+        return;
+      }
+      await TaskRunService.fail(entry.runId, "\u4EFB\u52A1\u6216\u6267\u884C\u8BB0\u5F55\u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8");
+      return;
+    }
+    const failed = await TaskService.failRun(entry.task.id, entry.runId, log);
+    if (!failed) {
+      await TaskRunService.fail(
+        entry.runId,
+        `${log}${log ? "\n" : ""}\u4EFB\u52A1\u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8`
+      );
+      this.logError("task failure state transition rejected", failure ?? "unknown failure", entry.task.id);
+    }
+    console.error(JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "error",
+      msg: "task failed",
+      taskId: entry.task.id,
+      error: failure
+    }));
+  }
+  async reconcileCancelledTasks() {
+    for (const entry of [...this.runningTasks.values()]) {
+      try {
+        const task = await TaskService.getById(entry.task.id);
+        if (task?.status === "cancelled") await this.cancelEntry(entry);
+      } catch (err) {
+        this.logError("cancel reconciliation failed", err, entry.task.id);
+      }
+    }
+  }
+  async reconcileQuarantinedTasks() {
+    for (const entry of [...this.runningTasks.values()]) {
+      if (!entry.quarantined || !entry.termination) continue;
+      await this.terminateEntry(entry, entry.termination);
     }
   }
+  async cancelEntry(entry) {
+    await this.terminateEntry(entry, { kind: "cancel", message: "\u4EFB\u52A1\u5DF2\u53D6\u6D88" });
+  }
   async updateHeartbeats() {
     for (const entry of this.runningTasks.values()) {
+      if (entry.quarantined) continue;
       try {
         await TaskRunService.heartbeat(entry.runId);
       } catch (err) {
@@ -19854,26 +21049,75 @@ ${output}` : ""}`;
       }
     }
   }
-  killEntry(entry) {
-    if (entry.child.exitCode !== null || entry.child.signalCode !== null) {
-      return Promise.resolve();
+  async terminateForFailure(entry, message, initialSignal = "SIGTERM") {
+    return this.terminateEntry(entry, { kind: "failure", message }, initialSignal);
+  }
+  terminateEntry(entry, termination, initialSignal = "SIGTERM") {
+    if (entry.terminationPromise) return entry.terminationPromise;
+    if (entry.settled) return entry.settlementPromise ?? Promise.resolve(false);
+    entry.termination ??= termination;
+    if (entry.timeoutTimer) {
+      clearTimeout(entry.timeoutTimer);
+      entry.timeoutTimer = null;
     }
-    return new Promise((resolve2) => {
-      const timeout = setTimeout(() => {
-        this.signalEntry(entry, "SIGKILL");
-        resolve2();
-      }, 5e3);
-      entry.child.once("close", () => {
-        clearTimeout(timeout);
-        resolve2();
-      });
-      this.signalEntry(entry, "SIGTERM");
+    entry.quarantined = true;
+    const terminationPromise = this.completeTermination(entry, initialSignal).finally(() => {
+      if (!entry.settled && entry.terminationPromise === terminationPromise) {
+        entry.terminationPromise = null;
+      }
     });
+    entry.terminationPromise = terminationPromise;
+    return terminationPromise;
+  }
+  async completeTermination(entry, initialSignal) {
+    const termination = entry.termination;
+    if (!termination) return false;
+    try {
+      const exited = await this.killEntry(entry, initialSignal);
+      if (!exited) {
+        markGatewayFailure(
+          "worker",
+          new Error(`${termination.message}\uFF1B\u4EFB\u52A1 #${entry.task.id} \u7684\u8FDB\u7A0B\u65E0\u6CD5\u786E\u8BA4\u9000\u51FA`)
+        );
+        return false;
+      }
+      entry.quarantined = false;
+      return await this.settleEntry(
+        entry,
+        null,
+        termination.kind === "failure" ? termination.message : void 0
+      );
+    } catch (error) {
+      markGatewayFailure("worker", error);
+      this.logError("task termination failed", error, entry.task.id);
+      return false;
+    }
+  }
+  async killEntry(entry, initialSignal = "SIGTERM") {
+    if (entry.guardianDrained && (entry.child.exitCode !== null || entry.child.signalCode !== null)) return true;
+    const pid = entry.child.pid;
+    if (!pid) return false;
+    const initialResult = this.signalEntry(entry, initialSignal);
+    if (initialResult === "not-running") return true;
+    if (initialResult !== "signalled") return false;
+    if (await waitForSpawnedProcessTreeExit(pid, 2500)) return true;
+    if (initialSignal === "SIGKILL") return false;
+    if (entry.guardianDrained && (entry.child.exitCode !== null || entry.child.signalCode !== null)) return true;
+    const forcedResult = this.signalEntry(entry, "SIGKILL");
+    if (forcedResult === "not-running") return true;
+    if (forcedResult !== "signalled") return false;
+    return waitForSpawnedProcessTreeExit(pid, 2500);
   }
   signalEntry(entry, signal) {
     const pid = entry.child.pid;
-    if (!pid) return;
-    signalSpawnedProcessTree(pid, signal);
+    if (!pid) return "not-running";
+    return signalRecordedProcessTreeWithResult(
+      pid,
+      signal,
+      this.opencodeBin,
+      TOKEN_GUARDIAN_LAUNCH_PROTOCOL,
+      entry.launchIdentity
+    );
   }
   releaseBatch(task) {
     if (task.batchId) this.activeBatchIds.delete(task.batchId);
@@ -19882,6 +21126,12 @@ ${output}` : ""}`;
     if (!taskModel || taskModel === "default") return null;
     return taskModel;
   }
+  runDetached(operation, message, taskId) {
+    operation.catch((error) => {
+      markGatewayFailure("worker", error);
+      this.logError(message, error, taskId);
+    });
+  }
   logError(message, error, taskId) {
     console.error(JSON.stringify({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -19896,56 +21146,136 @@ ${output}` : ""}`;
 // src/gateway/watchdog/heartbeat.ts
 init_task_run_service();
 init_task_service();
-init_backoff();
 init_process_control();
-async function checkHeartbeats(heartbeatTimeoutMs) {
+init_launch_protocol();
+async function checkHeartbeats(heartbeatTimeoutMs, isOwnedRun = () => false, shouldStop = () => false) {
   const staleRuns = await TaskRunService.getStaleRuns(heartbeatTimeoutMs);
-  if (staleRuns.length === 0) return;
+  const result = {
+    staleRuns: staleRuns.length,
+    recoveredRuns: 0,
+    quarantinedRuns: 0,
+    failedRuns: 0
+  };
+  if (staleRuns.length === 0) return result;
   for (const run of staleRuns) {
+    await Bun.sleep(1);
+    if (shouldStop()) break;
+    if (isOwnedRun(run.taskId, run.runId)) continue;
     try {
-      if (run.childPid != null && run.childPid > 0) {
+      if (run.launchProtocol != null && run.launchProtocol !== LEGACY_GUARDIAN_LAUNCH_PROTOCOL && run.launchProtocol !== TOKEN_GUARDIAN_LAUNCH_PROTOCOL) {
+        console.warn(JSON.stringify({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "warn",
+          msg: "unknown launch protocol remains quarantined",
+          taskId: run.taskId,
+          runId: run.runId,
+          launchProtocol: run.launchProtocol,
+          remediation: "\u5347\u7EA7\u5230\u652F\u6301\u8BE5\u534F\u8BAE\u7684 SuperTask \u7248\u672C\uFF1B\u7981\u6B62\u4F7F\u7528 run abandon \u7ED5\u8FC7\u672A\u77E5\u534F\u8BAE"
+        }));
+        result.quarantinedRuns += 1;
+        continue;
+      }
+      if (run.childPid != null && run.launchProtocol !== TOKEN_GUARDIAN_LAUNCH_PROTOCOL) {
+        if (!isProcessAlive(run.childPid) && !isSpawnedProcessTreeAlive(run.childPid)) {
+        } else {
+          console.warn(JSON.stringify({
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "warn",
+            msg: "stale run has no per-run process identity; run remains quarantined",
+            taskId: run.taskId,
+            runId: run.runId,
+            childPid: run.childPid,
+            launchProtocol: run.launchProtocol,
+            remediation: "\u65E7\u542F\u52A8\u534F\u8BAE\u4E0D\u80FD\u6392\u9664 PID \u590D\u7528\uFF0C\u7981\u6B62\u81EA\u52A8\u7EC8\u6B62\uFF1B\u8BF7\u4EBA\u5DE5\u786E\u8BA4\u8FDB\u7A0B\u4E0E\u6570\u636E\u72B6\u6001"
+          }));
+          result.quarantinedRuns += 1;
+          continue;
+        }
+      }
+      if (run.childPid == null && run.launchProtocol == null) {
+        console.warn(JSON.stringify({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "warn",
+          msg: "legacy stale run has no recorded child pid; run remains quarantined",
+          taskId: run.taskId,
+          runId: run.runId,
+          remediation: {
+            taskCwd: run.taskCwd,
+            owner: run.ownerAlive ? `owner PID ${run.workerPid} \u4ECD\u5B58\u6D3B\uFF0C\u5FC5\u987B\u5148\u786E\u8BA4\u5E76\u505C\u6B62\u5BF9\u5E94\u8FDB\u7A0B` : "owner PID \u5DF2\u9000\u51FA\u6216\u672A\u8BB0\u5F55",
+            cancelCommand: run.taskStatus === "cancelled" ? null : run.taskCwd == null ? `\u4EFB\u52A1\u6CA1\u6709\u8BB0\u5F55 cwd\uFF0C\u8BF7\u5728 Dashboard \u53D6\u6D88\u4EFB\u52A1 #${run.taskId}` : `\u5728 ${run.taskCwd} \u6267\u884C: supertask cancel --id ${run.taskId}`,
+            abandonCommand: `\u786E\u8BA4\u6CA1\u6709\u9057\u7559 OpenCode \u8FDB\u7A0B\u540E\u6267\u884C: supertask run abandon --id ${run.runId} --confirm ABANDON`
+          }
+        }));
+        result.quarantinedRuns += 1;
+        continue;
+      }
+      if (run.childPid != null && run.childPid > 0 && run.launchProtocol === TOKEN_GUARDIAN_LAUNCH_PROTOCOL) {
         const expectedExecutable = process.env.SUPERTASK_OPENCODE_BIN ?? "opencode";
-        const killed = signalRecordedProcessTree(run.childPid, "SIGKILL", expectedExecutable);
-        if (!killed) {
+        const signalResult = signalRecordedProcessTreeWithResult(
+          run.childPid,
+          "SIGKILL",
+          expectedExecutable,
+          run.launchProtocol,
+          run.lockedBy
+        );
+        if (signalResult === "signalled") {
+          const exited = await waitForSpawnedProcessTreeExit(run.childPid);
+          if (!exited) {
+            console.warn(JSON.stringify({
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              level: "warn",
+              msg: "stale child process did not exit; task remains quarantined",
+              taskId: run.taskId,
+              runId: run.runId,
+              childPid: run.childPid
+            }));
+            result.quarantinedRuns += 1;
+            continue;
+          }
+        } else if (signalResult !== "not-running") {
           console.warn(JSON.stringify({
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             level: "warn",
-            msg: "stale child process was not killed because identity validation failed",
+            msg: "stale child process could not be safely terminated; task remains quarantined",
             taskId: run.taskId,
             runId: run.runId,
-            childPid: run.childPid
+            childPid: run.childPid,
+            reason: signalResult
           }));
+          result.quarantinedRuns += 1;
+          continue;
         }
       }
-      await TaskRunService.fail(run.runId, `\u5FC3\u8DF3\u8D85\u65F6 (${heartbeatTimeoutMs / 1e3}s)\uFF0CWatchdog kill`);
-      const newRetryCount = run.taskRetryCount + 1;
-      const maxRetries = run.taskMaxRetries;
-      if (newRetryCount > maxRetries) {
-        await TaskService.markDeadLetter(run.taskId, newRetryCount);
+      const recovery = await TaskService.recoverRun(
+        run.taskId,
+        run.runId,
+        `\u6267\u884C\u6240\u6709\u8005\u9000\u51FA\u6216\u5FC3\u8DF3\u8D85\u65F6 (${heartbeatTimeoutMs / 1e3}s)\uFF0CWatchdog \u5DF2\u786E\u8BA4\u5B50\u8FDB\u7A0B\u7ED3\u675F`
+      );
+      if (!recovery) continue;
+      result.recoveredRuns += 1;
+      if (recovery.status === "dead_letter") {
         console.log(JSON.stringify({
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           level: "warn",
           msg: "task dead_letter",
           taskId: run.taskId,
           runId: run.runId,
-          retryCount: newRetryCount,
-          maxRetries
+          retryCount: recovery.retryCount,
+          maxRetries: run.taskMaxRetries
         }));
       } else {
-        const backoffMs = computeBackoff(newRetryCount, run.taskRetryBackoffMs);
-        const retryAfter = Date.now() + backoffMs;
-        await TaskService.markPendingForRetry(run.taskId, retryAfter, newRetryCount);
         console.log(JSON.stringify({
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           level: "warn",
           msg: "task retry scheduled",
           taskId: run.taskId,
           runId: run.runId,
-          retryCount: newRetryCount,
-          retryAfterMs: backoffMs
+          retryCount: recovery.retryCount,
+          retryAfterMs: recovery.retryAfterMs == null ? null : Math.max(0, recovery.retryAfterMs - Date.now())
         }));
       }
     } catch (err) {
+      result.failedRuns += 1;
       console.error(JSON.stringify({
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         level: "error",
@@ -19956,47 +21286,46 @@ async function checkHeartbeats(heartbeatTimeoutMs) {
       }));
     }
   }
+  return result;
 }
 
 // src/gateway/watchdog/cleanup.ts
 init_task_service();
-init_task_run_service();
-init_db2();
-init_drizzle_orm();
-async function cleanupOldRecords(retentionDays) {
-  const cutoffSec = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
-  const { tasks: tasksTable } = schema_exports;
-  const oldTasks = await db.select({ id: tasksTable.id }).from(tasksTable).where(
-    and(
-      sql`${tasksTable.status} IN ('done', 'failed', 'dead_letter')`,
-      sql`${tasksTable.finishedAt} IS NOT NULL`,
-      sql`${tasksTable.finishedAt} < ${cutoffSec}`
-    )
+init_task_template_service();
+async function cleanupOldRecords(retentionDays, shouldStop = () => false) {
+  const deletedTasks = await TaskService.deleteOlderThan(retentionDays, shouldStop);
+  const deletedDelayedTemplates = await TaskTemplateService.deleteExpiredDelayed(
+    retentionDays,
+    shouldStop
   );
-  if (oldTasks.length === 0) return 0;
-  const taskIds = oldTasks.map((t) => t.id);
-  const deletedRuns = await TaskRunService.deleteByTaskIds(taskIds);
-  const deletedTasks = await TaskService.deleteOlderThan(retentionDays);
-  console.log(JSON.stringify({
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    level: "info",
-    msg: "cleanup completed",
-    deletedTasks,
-    deletedRuns
-  }));
+  if (deletedTasks > 0 || deletedDelayedTemplates > 0) {
+    console.log(JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "info",
+      msg: "cleanup completed",
+      deletedTasks,
+      deletedDelayedTemplates
+    }));
+  }
   return deletedTasks;
 }
 
 // src/gateway/watchdog/index.ts
 init_health();
 var Watchdog = class {
-  constructor(cfg) {
+  constructor(cfg, isOwnedRun = () => false) {
     this.cfg = cfg;
+    this.isOwnedRun = isOwnedRun;
   }
   cfg;
+  isOwnedRun;
   stopped = false;
   heartbeatTimer = null;
   cleanupTimer = null;
+  checkingHeartbeats = false;
+  cleaning = false;
+  heartbeatCheckPromise = null;
+  cleanupPromise = null;
   start() {
     this.stopped = false;
     markGatewayActivity("watchdog");
@@ -20008,8 +21337,9 @@ var Watchdog = class {
       () => this.runCleanup(),
       this.cfg.watchdog.cleanupIntervalMs
     );
+    void this.runHeartbeatCheck();
   }
-  stop() {
+  async stop() {
     this.stopped = true;
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
@@ -20019,108 +21349,79 @@ var Watchdog = class {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
     }
+    await Promise.all([
+      this.heartbeatCheckPromise,
+      this.cleanupPromise
+    ]);
   }
-  async runHeartbeatCheck() {
-    if (this.stopped) return;
+  runHeartbeatCheck() {
+    if (this.stopped) return Promise.resolve();
+    if (this.heartbeatCheckPromise) return this.heartbeatCheckPromise;
+    this.checkingHeartbeats = true;
     markGatewayActivity("watchdog");
-    try {
-      await checkHeartbeats(this.cfg.watchdog.heartbeatTimeoutMs);
-    } catch (err) {
-      console.error(JSON.stringify({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        level: "error",
-        msg: "watchdog heartbeat check failed",
-        error: err instanceof Error ? err.message : String(err)
-      }));
-    }
+    const operation = (async () => {
+      try {
+        const result = await checkHeartbeats(
+          this.cfg.watchdog.heartbeatTimeoutMs,
+          this.isOwnedRun,
+          () => this.stopped
+        );
+        if (result.quarantinedRuns > 0 || result.failedRuns > 0) {
+          throw new Error(
+            `Watchdog \u6709 ${result.quarantinedRuns} \u4E2A\u9694\u79BB run\u3001${result.failedRuns} \u4E2A\u6062\u590D\u5931\u8D25 run`
+          );
+        }
+        markGatewaySuccess("watchdog");
+      } catch (err) {
+        markGatewayFailure("watchdog", err);
+        console.error(JSON.stringify({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "error",
+          msg: "watchdog heartbeat check failed",
+          error: err instanceof Error ? err.message : String(err)
+        }));
+      } finally {
+        this.checkingHeartbeats = false;
+      }
+    })();
+    this.heartbeatCheckPromise = operation.finally(() => {
+      this.heartbeatCheckPromise = null;
+    });
+    return this.heartbeatCheckPromise;
   }
-  async runCleanup() {
-    if (this.stopped) return;
-    try {
-      await cleanupOldRecords(this.cfg.watchdog.retentionDays);
-    } catch (err) {
-      console.error(JSON.stringify({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        level: "error",
-        msg: "watchdog cleanup failed",
-        error: err instanceof Error ? err.message : String(err)
-      }));
-    }
+  runCleanup() {
+    if (this.stopped) return Promise.resolve();
+    if (this.cleanupPromise) return this.cleanupPromise;
+    this.cleaning = true;
+    markGatewayActivity("watchdogCleanup");
+    const operation = (async () => {
+      try {
+        await cleanupOldRecords(
+          this.cfg.watchdog.retentionDays,
+          () => this.stopped
+        );
+        markGatewaySuccess("watchdogCleanup");
+      } catch (err) {
+        markGatewayFailure("watchdogCleanup", err);
+        console.error(JSON.stringify({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "error",
+          msg: "watchdog cleanup failed",
+          error: err instanceof Error ? err.message : String(err)
+        }));
+      } finally {
+        this.cleaning = false;
+      }
+    })();
+    this.cleanupPromise = operation.finally(() => {
+      this.cleanupPromise = null;
+    });
+    return this.cleanupPromise;
   }
 };
 
-// src/gateway/scheduler/job-templates.ts
-init_db2();
-init_drizzle_orm();
-init_task_service();
-init_task_template_service();
-var { taskTemplates: taskTemplates3 } = schema_exports;
-async function cloneTaskFromTemplate(templateId) {
-  const rows = await db.select().from(taskTemplates3).where(eq(taskTemplates3.id, templateId)).limit(1);
-  const tmpl = rows[0];
-  if (!tmpl || !tmpl.enabled) return null;
-  const activeCount = await db.select({ count: sql`count(*)` }).from(schema_exports.tasks).where(
-    and(
-      eq(schema_exports.tasks.templateId, templateId),
-      sql`${schema_exports.tasks.status} IN ('pending', 'running')`
-    )
-  ).then((r) => r[0].count);
-  if (activeCount >= (tmpl.maxInstances ?? 1)) return null;
-  const nowMs = Date.now();
-  const isDelayed = tmpl.scheduleType === "delayed";
-  const nextRunAt = isDelayed ? null : TaskTemplateService.calculateNextRunAt(
-    tmpl.scheduleType,
-    tmpl,
-    nowMs
-  );
-  const task = await TaskService.add({
-    name: 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: nowMs
-  });
-  await db.update(taskTemplates3).set({
-    lastRunAt: nowMs,
-    nextRunAt,
-    enabled: isDelayed ? false : tmpl.enabled,
-    updatedAt: nowMs
-  }).where(eq(taskTemplates3.id, templateId));
-  return task;
-}
-async function getDueTemplates() {
-  const nowMs = Date.now();
-  return await db.select().from(taskTemplates3).where(
-    and(
-      eq(taskTemplates3.enabled, true),
-      sql`${taskTemplates3.nextRunAt} IS NOT NULL`,
-      sql`${taskTemplates3.nextRunAt} <= ${nowMs}`
-    )
-  ).orderBy(asc(taskTemplates3.nextRunAt), asc(taskTemplates3.id));
-}
-async function initializeNextRunAt(templateId) {
-  const rows = await db.select().from(taskTemplates3).where(eq(taskTemplates3.id, templateId)).limit(1);
-  const tmpl = rows[0];
-  if (!tmpl || tmpl.nextRunAt != null) return;
-  const nextRunAt = TaskTemplateService.calculateNextRunAt(
-    tmpl.scheduleType,
-    tmpl
-  );
-  if (nextRunAt != null) {
-    await db.update(taskTemplates3).set({ nextRunAt }).where(eq(taskTemplates3.id, templateId));
-  }
-}
-
 // src/gateway/scheduler/index.ts
+init_job_templates();
 init_db2();
 init_drizzle_orm();
 init_health();
@@ -20132,11 +21433,13 @@ var Scheduler = class {
   stopped = false;
   ticking = false;
   timer = null;
+  dueSweep = null;
   async start() {
     if (!this.cfg.scheduler.enabled) return;
     this.stopped = false;
     markGatewayActivity("scheduler");
     await this.initializeTemplates();
+    markGatewaySuccess("scheduler");
     this.timer = setInterval(() => this.tick(), this.cfg.scheduler.checkIntervalMs);
   }
   stop() {
@@ -20150,8 +21453,11 @@ var Scheduler = class {
     if (this.stopped || this.ticking) return;
     markGatewayActivity("scheduler");
     this.ticking = true;
+    let hadFailure = false;
     try {
-      const dueTemplates = await getDueTemplates();
+      const sweep = this.dueSweep ?? { cutoffNow: Date.now(), cursor: null };
+      const dueTemplates = await getDueTemplates(sweep.cursor, sweep.cutoffNow);
+      const lastTemplate = dueTemplates.at(-1);
       for (const tmpl of dueTemplates) {
         try {
           const task = await cloneTaskFromTemplate(tmpl.id);
@@ -20165,6 +21471,8 @@ var Scheduler = class {
             }));
           }
         } catch (err) {
+          hadFailure = true;
+          markGatewayFailure("scheduler", err);
           console.error(JSON.stringify({
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             level: "error",
@@ -20174,7 +21482,13 @@ var Scheduler = class {
           }));
         }
       }
+      this.dueSweep = dueTemplates.length < DUE_TEMPLATE_BATCH_SIZE || lastTemplate?.nextRunAt == null ? null : {
+        cutoffNow: sweep.cutoffNow,
+        cursor: { nextRunAt: lastTemplate.nextRunAt, id: lastTemplate.id }
+      };
+      if (!hadFailure) markGatewaySuccess("scheduler");
     } catch (err) {
+      markGatewayFailure("scheduler", err);
       console.error(JSON.stringify({
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         level: "error",
@@ -20187,9 +21501,22 @@ var Scheduler = class {
   }
   async initializeTemplates() {
     const { taskTemplates: taskTemplates4 } = schema_exports;
-    const templates = await db.select().from(taskTemplates4).where(isNull(taskTemplates4.nextRunAt));
-    for (const tmpl of templates) {
-      await initializeNextRunAt(tmpl.id);
+    const batchSize = 100;
+    let cursor = 0;
+    while (!this.stopped) {
+      const templates = await db.select({ id: taskTemplates4.id }).from(taskTemplates4).where(and(
+        eq(taskTemplates4.enabled, true),
+        isNull(taskTemplates4.nextRunAt),
+        gt(taskTemplates4.id, cursor)
+      )).orderBy(asc(taskTemplates4.id)).limit(batchSize);
+      if (templates.length === 0) break;
+      for (const tmpl of templates) {
+        if (this.stopped) break;
+        await initializeNextRunAt(tmpl.id);
+      }
+      cursor = templates.at(-1).id;
+      if (templates.length < batchSize) break;
+      await Bun.sleep(0);
     }
   }
 };
@@ -20197,10 +21524,45 @@ var Scheduler = class {
 // src/gateway/index.ts
 init_db2();
 init_task_service();
-init_task_run_service();
 init_health();
 init_process_control();
+
+// src/core/package-version.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function getPackageVersion() {
+  let directory = dirname4(fileURLToPath4(import.meta.url));
+  for (let depth = 0; depth < 5; depth += 1) {
+    const packagePath = join4(directory, "package.json");
+    if (existsSync4(packagePath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(packagePath, "utf8"));
+        if (typeof pkg.version === "string") return pkg.version;
+      } catch {
+        return "0.0.0";
+      }
+    }
+    directory = dirname4(directory);
+  }
+  return "0.0.0";
+}
+
+// src/gateway/index.ts
 var STALE_THRESHOLD_MS = 3e4;
+async function runGatewayShutdownStep(failures, step, operation) {
+  try {
+    await operation();
+  } catch (error) {
+    failures.push({
+      step,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function resolveGatewayShutdownExitCode(requestedExitCode, failures) {
+  return failures.length > 0 ? 1 : requestedExitCode;
+}
 function acquireLock() {
   const now = Date.now();
   const pid = process.pid;
@@ -20209,15 +21571,26 @@ function acquireLock() {
     const existing = sqlite.prepare("SELECT id, pid, heartbeat_at FROM gateway_lock WHERE id = 1").get();
     if (existing) {
       const lockHolderAlive = existing.pid !== pid && isProcessAlive(existing.pid);
-      if (now - existing.heartbeat_at < STALE_THRESHOLD_MS && lockHolderAlive) {
-        sqlite.exec("ROLLBACK");
-        console.error(JSON.stringify({
+      if (lockHolderAlive) {
+        const identity = identifyGatewayProcess(existing.pid);
+        const lockIsFresh = now - existing.heartbeat_at < STALE_THRESHOLD_MS;
+        if (lockIsFresh || identity !== "mismatch") {
+          sqlite.exec("ROLLBACK");
+          console.error(JSON.stringify({
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "fatal",
+            msg: "another Gateway instance is already running",
+            existingPid: existing.pid,
+            identity
+          }));
+          return false;
+        }
+        console.warn(JSON.stringify({
           ts: (/* @__PURE__ */ new Date()).toISOString(),
-          level: "fatal",
-          msg: "another Gateway instance is already running",
+          level: "warn",
+          msg: "taking over stale Gateway lock from a reused PID",
           existingPid: existing.pid
         }));
-        return false;
       }
       sqlite.exec("DELETE FROM gateway_lock WHERE id = 1");
     }
@@ -20249,18 +21622,22 @@ function releaseLock() {
 }
 function updateLockHeartbeat() {
   try {
-    sqlite.exec(
-      "UPDATE gateway_lock SET heartbeat_at = ? WHERE pid = ?",
-      [Date.now(), process.pid]
-    );
+    const result = sqlite.query(
+      "UPDATE gateway_lock SET heartbeat_at = ? WHERE id = 1 AND pid = ?"
+    ).run(Date.now(), process.pid);
+    return result.changes === 1;
   } catch {
+    return false;
   }
 }
 function markGatewayReady() {
-  sqlite.exec(
-    "UPDATE gateway_lock SET heartbeat_at = ?, ready_at = ? WHERE pid = ?",
-    [Date.now(), Date.now(), process.pid]
-  );
+  const now = Date.now();
+  const result = sqlite.query(
+    "UPDATE gateway_lock SET heartbeat_at = ?, ready_at = ?, version = ? WHERE id = 1 AND pid = ?"
+  ).run(now, now, getPackageVersion(), process.pid);
+  if (result.changes !== 1) {
+    throw new Error("Gateway \u5728\u5C31\u7EEA\u524D\u5931\u53BB\u4E86\u6570\u636E\u5E93\u5355\u5B9E\u4F8B\u9501");
+  }
 }
 function markGatewayNotReady() {
   try {
@@ -20270,89 +21647,159 @@ function markGatewayNotReady() {
 }
 async function main() {
   console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "SuperTask Gateway starting", pid: process.pid }));
+  assertWorkerProcessIsolationSupported();
   if (!acquireLock()) {
     process.exit(1);
   }
-  const heartbeatTimer = setInterval(updateLockHeartbeat, 1e4);
-  heartbeatTimer.unref();
   const cfg = loadConfig();
   const worker = new WorkerEngine(cfg);
-  const watchdog = new Watchdog(cfg);
+  const watchdog = new Watchdog(cfg, (taskId, runId) => worker.ownsRun(taskId, runId));
   const scheduler = new Scheduler(cfg);
-  const recoveredOrphans = await TaskService.resetOrphanRunningToPending();
-  if (recoveredOrphans > 0) {
-    console.log(JSON.stringify({
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      level: "warn",
-      msg: "reset orphan running tasks to pending",
-      count: recoveredOrphans
-    }));
-  }
-  initializeGatewayHealth({
-    workerPollIntervalMs: cfg.worker.pollIntervalMs,
-    schedulerEnabled: cfg.scheduler.enabled,
-    schedulerCheckIntervalMs: cfg.scheduler.checkIntervalMs,
-    watchdogCheckIntervalMs: cfg.watchdog.checkIntervalMs
-  });
-  worker.start();
-  watchdog.start();
-  await scheduler.start();
-  if (cfg.dashboard.enabled) {
-    const { dashboardApp: dashboardApp2 } = await Promise.resolve().then(() => (init_web(), web_exports));
-    Bun.serve({
-      hostname: "127.0.0.1",
-      port: cfg.dashboard.port,
-      fetch: dashboardApp2.fetch
-    });
-    console.log(JSON.stringify({
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      level: "info",
-      msg: "Dashboard started",
-      url: `http://localhost:${cfg.dashboard.port}`
-    }));
-  }
-  markGatewayReady();
-  console.log(JSON.stringify({
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    level: "info",
-    msg: "Gateway started",
-    maxConcurrency: cfg.worker.maxConcurrency,
-    schedulerEnabled: cfg.scheduler.enabled
-  }));
+  let heartbeatTimer = null;
+  let dashboardServer = null;
   let shuttingDown = false;
-  const shutdown = async (signal) => {
+  const shutdown = async (signal, exitCode = 0) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: `received ${signal}, shutting down...` }));
-    clearInterval(heartbeatTimer);
-    markGatewayNotReady();
-    scheduler.stop();
-    watchdog.stop();
-    const runningIds = await worker.stop(cfg.worker.shutdownGracePeriodMs);
-    if (runningIds.length > 0) {
-      const resetCount = await TaskService.resetRunningToPending(runningIds);
-      console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "reset running tasks to pending", count: resetCount }));
-    }
-    const allRunningRuns = await TaskRunService.getAllRunningRuns();
-    for (const run of allRunningRuns) {
-      await TaskRunService.fail(run.id, "Gateway shutdown");
+    const failures = [];
+    try {
+      console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: `received ${signal}, shutting down...` }));
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
+      markGatewayNotReady();
+      await runGatewayShutdownStep(failures, "dashboard.stop", () => {
+        const server = dashboardServer;
+        dashboardServer = null;
+        server?.stop(true);
+      });
+      await runGatewayShutdownStep(failures, "scheduler.stop", () => scheduler.stop());
+      await runGatewayShutdownStep(failures, "watchdog.stop", () => watchdog.stop());
+      let interruptedRuns = [];
+      await runGatewayShutdownStep(failures, "worker.stop", async () => {
+        interruptedRuns = await worker.stop(cfg.worker.shutdownGracePeriodMs);
+      });
+      let resetCount = 0;
+      for (const run of interruptedRuns) {
+        await runGatewayShutdownStep(
+          failures,
+          `task.interrupt:${run.taskId}:${run.runId}`,
+          async () => {
+            if (await TaskService.interruptRun(
+              run.taskId,
+              run.runId,
+              "Gateway shutdown after child exit"
+            )) {
+              resetCount += 1;
+            }
+          }
+        );
+      }
+      if (resetCount > 0) {
+        console.log(JSON.stringify({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "info",
+          msg: "reset confirmed interrupted tasks to pending",
+          count: resetCount
+        }));
+      }
+      await runGatewayShutdownStep(failures, "lock.release", () => releaseLock());
+      await runGatewayShutdownStep(failures, "health.reset", () => resetGatewayHealth());
+      await runGatewayShutdownStep(failures, "database.close", () => closeDb());
+      if (failures.length > 0) {
+        console.error(JSON.stringify({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "error",
+          msg: "Gateway stopped with shutdown failures",
+          failures
+        }));
+      } else {
+        console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "Gateway stopped" }));
+      }
+    } finally {
+      process.exit(resolveGatewayShutdownExitCode(exitCode, failures));
     }
-    releaseLock();
-    resetGatewayHealth();
-    closeDb();
-    console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "Gateway stopped" }));
-    process.exit(0);
   };
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => {
+    void shutdown("SIGTERM");
+  });
+  process.on("SIGINT", () => {
+    void shutdown("SIGINT");
+  });
   process.on("uncaughtException", (err) => {
     console.error(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "fatal", msg: "uncaughtException", error: err.message, stack: err.stack }));
-    process.exit(1);
+    void shutdown("uncaughtException", 1);
   });
   process.on("unhandledRejection", (reason) => {
     console.error(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "fatal", msg: "unhandledRejection", reason: String(reason) }));
-    process.exit(1);
+    void shutdown("unhandledRejection", 1);
   });
+  heartbeatTimer = setInterval(() => {
+    if (updateLockHeartbeat()) return;
+    console.error(JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "fatal",
+      msg: "Gateway lost its database lock and will stop",
+      pid: process.pid
+    }));
+    void shutdown("database lock lost", 1);
+  }, 1e4);
+  heartbeatTimer.unref();
+  try {
+    const recoveredOrphans = await TaskService.resetOrphanRunningToPending();
+    if (recoveredOrphans > 0) {
+      console.log(JSON.stringify({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "warn",
+        msg: "reset orphan running tasks to pending",
+        count: recoveredOrphans
+      }));
+    }
+    await TaskService.resolveBlockedDependencies();
+    initializeGatewayHealth({
+      workerPollIntervalMs: cfg.worker.pollIntervalMs,
+      schedulerEnabled: cfg.scheduler.enabled,
+      schedulerCheckIntervalMs: cfg.scheduler.checkIntervalMs,
+      watchdogCheckIntervalMs: cfg.watchdog.checkIntervalMs,
+      watchdogCleanupIntervalMs: cfg.watchdog.cleanupIntervalMs
+    });
+    await scheduler.start();
+    if (shuttingDown) return;
+    if (cfg.dashboard.enabled) {
+      const { dashboardApp: dashboardApp2 } = await Promise.resolve().then(() => (init_web(), web_exports));
+      if (shuttingDown) return;
+      dashboardServer = Bun.serve({
+        hostname: "127.0.0.1",
+        port: cfg.dashboard.port,
+        fetch: dashboardApp2.fetch
+      });
+      console.log(JSON.stringify({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "info",
+        msg: "Dashboard started",
+        url: `http://localhost:${cfg.dashboard.port}`
+      }));
+    }
+    watchdog.start();
+    worker.start();
+    markGatewayReady();
+    console.log(JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "info",
+      msg: "Gateway started",
+      maxConcurrency: cfg.worker.maxConcurrency,
+      schedulerEnabled: cfg.scheduler.enabled
+    }));
+  } catch (error) {
+    console.error(JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "fatal",
+      msg: "Gateway startup failed",
+      error: error instanceof Error ? error.message : String(error)
+    }));
+    await shutdown("startup failure", 1);
+  }
 }
 if (import.meta.main) {
   main();
@@ -20360,6 +21807,9 @@ if (import.meta.main) {
 export {
   acquireLock,
   main,
-  releaseLock
+  releaseLock,
+  resolveGatewayShutdownExitCode,
+  runGatewayShutdownStep,
+  updateLockHeartbeat
 };
 //# sourceMappingURL=index.js.map