opencode-supertask 0.1.19 → 0.1.21

package/dist/gateway/index.js

@@ -1358,8 +1358,8 @@ function haveSameKeys(left, right) {
   if (leftKeys.length !== rightKeys.length) {
     return false;
   }
-  for (const [index, key] of leftKeys.entries()) {
-    if (key !== rightKeys[index]) {
+  for (const [index2, key] of leftKeys.entries()) {
+    if (key !== rightKeys[index2]) {
       return false;
     }
   }
@@ -3220,8 +3220,8 @@ var init_dialect = __esm({
         }
         const joinsArray = [];
         if (joins) {
-          for (const [index, joinMeta] of joins.entries()) {
-            if (index === 0) {
+          for (const [index2, joinMeta] of joins.entries()) {
+            if (index2 === 0) {
               joinsArray.push(sql` `);
             }
             const table = joinMeta.table;
@@ -3238,7 +3238,7 @@ var init_dialect = __esm({
                 sql`${sql.raw(joinMeta.joinType)} join ${table} on ${joinMeta.on}`
               );
             }
-            if (index < joins.length - 1) {
+            if (index2 < joins.length - 1) {
               joinsArray.push(sql` `);
             }
           }
@@ -3251,9 +3251,9 @@ var init_dialect = __esm({
       buildOrderBy(orderBy) {
         const orderByList = [];
         if (orderBy) {
-          for (const [index, orderByValue] of orderBy.entries()) {
+          for (const [index2, orderByValue] of orderBy.entries()) {
             orderByList.push(orderByValue);
-            if (index < orderBy.length - 1) {
+            if (index2 < orderBy.length - 1) {
               orderByList.push(sql`, `);
             }
           }
@@ -3302,9 +3302,9 @@ var init_dialect = __esm({
         const havingSql = having ? sql` having ${having}` : void 0;
         const groupByList = [];
         if (groupBy) {
-          for (const [index, groupByValue] of groupBy.entries()) {
+          for (const [index2, groupByValue] of groupBy.entries()) {
             groupByList.push(groupByValue);
-            if (index < groupBy.length - 1) {
+            if (index2 < groupBy.length - 1) {
               groupByList.push(sql`, `);
             }
           }
@@ -5393,6 +5393,9 @@ var init_checks = __esm({
 });
 
 // node_modules/drizzle-orm/sqlite-core/indexes.js
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
 var IndexBuilderOn, IndexBuilder, Index;
 var init_indexes = __esm({
   "node_modules/drizzle-orm/sqlite-core/indexes.js"() {
@@ -6021,12 +6024,17 @@ var init_schema = __esm({
       resultLog: text("result_log"),
       retryCount: integer("retry_count").default(0),
       maxRetries: integer("max_retries").default(3),
+      retryBackoffMs: integer("retry_backoff_ms").default(3e4),
       // Gateway 扩展字段（毫秒）
       retryAfter: integer("retry_after"),
       timeoutMs: integer("timeout_ms"),
       templateId: integer("template_id"),
       scheduledAt: integer("scheduled_at")
-    });
+    }, (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)
+    ]);
     TASK_CATEGORIES = [
       "translate",
       "generate",
@@ -6036,7 +6044,7 @@ var init_schema = __esm({
     ];
     taskRuns = sqliteTable("task_runs", {
       id: integer("id").primaryKey({ autoIncrement: true }),
-      taskId: integer("task_id").notNull().references(() => tasks.id),
+      taskId: integer("task_id").notNull().references(() => tasks.id, { onDelete: "cascade" }),
       sessionId: text("session_id"),
       model: text("model"),
       status: text("status").default("running"),
@@ -6049,7 +6057,10 @@ var init_schema = __esm({
       heartbeatAt: integer("heartbeat_at"),
       workerPid: integer("worker_pid"),
       childPid: integer("child_pid")
-    });
+    }, (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)
+    ]);
     taskTemplates = sqliteTable("task_templates", {
       id: integer("id").primaryKey({ autoIncrement: true }),
       name: text("name").notNull(),
@@ -6060,6 +6071,7 @@ var init_schema = __esm({
       category: text("category").default("general"),
       importance: integer("importance").default(3),
       urgency: integer("urgency").default(3),
+      batchId: text("batch_id"),
       scheduleType: text("schedule_type").notNull(),
       cronExpr: text("cron_expr"),
       intervalMs: integer("interval_ms"),
@@ -6067,12 +6079,15 @@ var init_schema = __esm({
       maxInstances: integer("max_instances").default(1),
       maxRetries: integer("max_retries").default(3),
       retryBackoffMs: integer("retry_backoff_ms").default(3e4),
+      timeoutMs: integer("timeout_ms"),
       lastRunAt: integer("last_run_at"),
       nextRunAt: integer("next_run_at"),
       enabled: integer("enabled", { mode: "boolean" }).default(true),
       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)
+    ]);
   }
 });
 
@@ -6084,7 +6099,15 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 function getMigrationsFolder() {
   const __dirname = dirname(fileURLToPath(import.meta.url));
-  return join(__dirname, "../../../drizzle");
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = join(dir, "drizzle", "meta", "_journal.json");
+    if (existsSync(candidate)) {
+      return join(dir, "drizzle");
+    }
+    dir = dirname(dir);
+  }
+  return join(__dirname, "../../drizzle");
 }
 function initDb() {
   const dataDir = dirname(DB_FILE_PATH);
@@ -6099,16 +6122,30 @@ function initDb() {
             id INTEGER PRIMARY KEY CHECK (id = 1),
             pid INTEGER NOT NULL,
             acquired_at INTEGER NOT NULL,
-            heartbeat_at INTEGER NOT NULL
+            heartbeat_at INTEGER NOT NULL,
+            ready_at INTEGER
         );
     `);
+  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;");
+  }
   _db = drizzle(_sqlite, { schema: schema_exports });
   if (!_migrationRan) {
-    _migrationRan = true;
     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`);
+      }
+      _migrationRan = true;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
+      _migrationRan = false;
+      _sqlite.close();
+      _sqlite = null;
+      _db = null;
       console.error(`[supertask] migration failed: ${msg}`);
       throw new Error(`[supertask] DB migration failed: ${msg}`);
     }
@@ -6128,6 +6165,7 @@ function closeDb() {
     _sqlite.close();
     _sqlite = null;
     _db = null;
+    _migrationRan = false;
   }
 }
 var DEFAULT_DB_PATH, DB_FILE_PATH, _sqlite, _db, _migrationRan, db, sqlite;
@@ -6162,71 +6200,123 @@ var init_db2 = __esm({
 });
 
 // src/gateway/config.ts
-import { readFileSync, existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-function deepMerge(base, override) {
-  const result = { ...base };
-  for (const key of Object.keys(override)) {
-    const val = override[key];
-    if (val !== null && typeof val === "object" && !Array.isArray(val) && key in result) {
-      const baseVal = result[key];
-      if (baseVal !== null && typeof baseVal === "object" && !Array.isArray(baseVal)) {
-        result[key] = deepMerge(baseVal, val);
-        continue;
-      }
-    }
-    if (val !== void 0) {
-      result[key] = val;
-    }
+function getConfigPath() {
+  return process.env.SUPERTASK_CONFIG_PATH ?? DEFAULT_CONFIG_PATH;
+}
+function objectAt(value, path) {
+  if (value === void 0) return {};
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${path} \u5FC5\u987B\u662F\u5BF9\u8C61`);
   }
-  return result;
+  return value;
+}
+function integerAt(source, key, fallback, min, max, path) {
+  const value = source[key];
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
+    throw new Error(`${path}.${key} \u5FC5\u987B\u662F ${min} \u5230 ${max} \u4E4B\u95F4\u7684\u6574\u6570`);
+  }
+  return value;
+}
+function booleanAt(source, key, fallback, path) {
+  const value = source[key];
+  if (value === void 0) return fallback;
+  if (typeof value !== "boolean") throw new Error(`${path}.${key} \u5FC5\u987B\u662F\u5E03\u5C14\u503C`);
+  return value;
 }
-function loadConfig() {
-  if (!existsSync2(CONFIG_PATH)) {
-    return DEFAULT_CONFIG;
+function validateConfig(input) {
+  const root = objectAt(input, "config");
+  const version2 = root.configVersion ?? 1;
+  if (version2 !== 1 && version2 !== 2) {
+    throw new Error("config.configVersion \u53EA\u652F\u6301 1 \u6216 2");
   }
+  const worker = objectAt(root.worker, "worker");
+  const scheduler = objectAt(root.scheduler, "scheduler");
+  const watchdog = objectAt(root.watchdog, "watchdog");
+  const dashboard = objectAt(root.dashboard, "dashboard");
+  const heartbeatIntervalMs = integerAt(worker, "heartbeatIntervalMs", DEFAULT_CONFIG.worker.heartbeatIntervalMs, 1e3, 36e5, "worker");
+  const heartbeatTimeoutMs = integerAt(watchdog, "heartbeatTimeoutMs", DEFAULT_CONFIG.watchdog.heartbeatTimeoutMs, 1e3, 864e5, "watchdog");
+  let checkIntervalMs;
+  let cleanupIntervalMs;
+  if (version2 === 1 && watchdog.checkIntervalMs === void 0 && watchdog.cleanupIntervalMs !== void 0) {
+    checkIntervalMs = integerAt(watchdog, "cleanupIntervalMs", DEFAULT_CONFIG.watchdog.checkIntervalMs, 1e3, 36e5, "watchdog");
+    cleanupIntervalMs = DEFAULT_CONFIG.watchdog.cleanupIntervalMs;
+  } else {
+    checkIntervalMs = integerAt(watchdog, "checkIntervalMs", DEFAULT_CONFIG.watchdog.checkIntervalMs, 1e3, 36e5, "watchdog");
+    cleanupIntervalMs = integerAt(watchdog, "cleanupIntervalMs", DEFAULT_CONFIG.watchdog.cleanupIntervalMs, 6e4, 6048e5, "watchdog");
+  }
+  if (heartbeatIntervalMs >= heartbeatTimeoutMs) {
+    throw new Error("worker.heartbeatIntervalMs \u5FC5\u987B\u5C0F\u4E8E watchdog.heartbeatTimeoutMs");
+  }
+  if (checkIntervalMs > heartbeatTimeoutMs) {
+    throw new Error("watchdog.checkIntervalMs \u4E0D\u80FD\u5927\u4E8E watchdog.heartbeatTimeoutMs");
+  }
+  return {
+    configVersion: 2,
+    worker: {
+      maxConcurrency: integerAt(worker, "maxConcurrency", DEFAULT_CONFIG.worker.maxConcurrency, 1, 64, "worker"),
+      pollIntervalMs: integerAt(worker, "pollIntervalMs", DEFAULT_CONFIG.worker.pollIntervalMs, 50, 6e4, "worker"),
+      heartbeatIntervalMs,
+      taskTimeoutMs: integerAt(worker, "taskTimeoutMs", DEFAULT_CONFIG.worker.taskTimeoutMs, 1e3, 6048e5, "worker"),
+      shutdownGracePeriodMs: integerAt(worker, "shutdownGracePeriodMs", DEFAULT_CONFIG.worker.shutdownGracePeriodMs, 0, 36e5, "worker")
+    },
+    scheduler: {
+      enabled: booleanAt(scheduler, "enabled", DEFAULT_CONFIG.scheduler.enabled, "scheduler"),
+      checkIntervalMs: integerAt(scheduler, "checkIntervalMs", DEFAULT_CONFIG.scheduler.checkIntervalMs, 100, 6e4, "scheduler")
+    },
+    watchdog: {
+      heartbeatTimeoutMs,
+      checkIntervalMs,
+      cleanupIntervalMs,
+      retentionDays: integerAt(watchdog, "retentionDays", DEFAULT_CONFIG.watchdog.retentionDays, 1, 3650, "watchdog")
+    },
+    dashboard: {
+      enabled: booleanAt(dashboard, "enabled", DEFAULT_CONFIG.dashboard.enabled, "dashboard"),
+      port: integerAt(dashboard, "port", DEFAULT_CONFIG.dashboard.port, 1, 65535, "dashboard")
+    }
+  };
+}
+function loadConfig(path = getConfigPath()) {
+  if (!existsSync2(path)) return validateConfig({ configVersion: 2 });
   try {
-    const raw2 = readFileSync(CONFIG_PATH, "utf-8");
-    const userConfig = JSON.parse(raw2);
-    return deepMerge(DEFAULT_CONFIG, userConfig);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", msg: "config load failed, using defaults", path: CONFIG_PATH, error: msg }));
-    return DEFAULT_CONFIG;
+    return validateConfig(JSON.parse(readFileSync(path, "utf-8")));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u914D\u7F6E ${path}: ${message}`);
   }
 }
-var DEFAULT_CONFIG, CONFIG_PATH;
+var DEFAULT_CONFIG, DEFAULT_CONFIG_PATH;
 var init_config = __esm({
   "src/gateway/config.ts"() {
     "use strict";
     DEFAULT_CONFIG = {
+      configVersion: 2,
       worker: {
         maxConcurrency: 2,
         pollIntervalMs: 1e3,
         heartbeatIntervalMs: 3e4,
-        taskTimeoutMs: 18e5
+        taskTimeoutMs: 18e5,
+        shutdownGracePeriodMs: 3e4
       },
       scheduler: {
         enabled: true,
-        checkIntervalMs: 1e3,
-        catchUp: "next"
+        checkIntervalMs: 1e3
       },
       watchdog: {
         heartbeatTimeoutMs: 6e5,
-        cleanupIntervalMs: 6e4,
+        checkIntervalMs: 6e4,
+        cleanupIntervalMs: 864e5,
         retentionDays: 30
       },
       dashboard: {
         enabled: true,
         port: 4680
-      },
-      logging: {
-        level: "info",
-        format: "json"
       }
     };
-    CONFIG_PATH = join2(homedir2(), ".config/opencode/supertask.json");
+    DEFAULT_CONFIG_PATH = join2(homedir2(), ".config/opencode/supertask.json");
   }
 });
 
@@ -6280,14 +6370,14 @@ var init_backoff = __esm({
 });
 
 // src/core/services/task.service.ts
-var tasks2, TaskService;
+var tasks2, taskRuns2, TaskService;
 var init_task_service = __esm({
   "src/core/services/task.service.ts"() {
     "use strict";
     init_db2();
     init_drizzle_orm();
     init_backoff();
-    ({ tasks: tasks2 } = schema_exports);
+    ({ tasks: tasks2, taskRuns: taskRuns2 } = schema_exports);
     TaskService = class {
       static buildScopeWhere(scope) {
         const conditions = [];
@@ -6297,9 +6387,27 @@ var init_task_service = __esm({
         return conditions;
       }
       static async add(data) {
+        this.validateNewTask(data);
         const result = await db.insert(tasks2).values(data).returning();
         return result[0];
       }
+      static validateNewTask(data) {
+        if (!data.name.trim()) throw new Error("name \u4E0D\u80FD\u4E3A\u7A7A");
+        if (!data.agent.trim()) throw new Error("agent \u4E0D\u80FD\u4E3A\u7A7A");
+        if (!data.prompt.trim()) throw new Error("prompt \u4E0D\u80FD\u4E3A\u7A7A");
+        this.validateInteger("importance", data.importance, 1, 5);
+        this.validateInteger("urgency", data.urgency, 1, 5);
+        this.validateInteger("maxRetries", data.maxRetries, 0, 1e3);
+        this.validateInteger("retryBackoffMs", data.retryBackoffMs, 0, 864e5);
+        this.validateInteger("timeoutMs", data.timeoutMs, 1e3, 6048e5);
+        this.validateInteger("dependsOn", data.dependsOn, 1, Number.MAX_SAFE_INTEGER);
+      }
+      static validateInteger(name, value, min, max) {
+        if (value === void 0 || value === null) return;
+        if (!Number.isInteger(value) || value < min || value > max) {
+          throw new Error(`${name} \u5FC5\u987B\u662F ${min} \u5230 ${max} \u4E4B\u95F4\u7684\u6574\u6570`);
+        }
+      }
       static async next(scope = {}) {
         const baseConditions = [...this.buildScopeWhere(scope)];
         const nowMs = Date.now();
@@ -6322,7 +6430,7 @@ var init_task_service = __esm({
           ),
           and(
             eq(tasks2.status, "failed"),
-            sql`${tasks2.retryCount} < ${tasks2.maxRetries}`,
+            sql`${tasks2.retryCount} <= ${tasks2.maxRetries}`,
             retryAfterFilter
           )
         );
@@ -6336,7 +6444,8 @@ var init_task_service = __esm({
         const allTasks = await db.select().from(tasks2).where(and(...conditions)).orderBy(
           desc(tasks2.urgency),
           desc(tasks2.importance),
-          asc(tasks2.createdAt)
+          asc(tasks2.createdAt),
+          asc(tasks2.id)
         );
         for (const task of allTasks) {
           if (task.dependsOn) {
@@ -6357,7 +6466,7 @@ var init_task_service = __esm({
             eq(tasks2.status, "pending"),
             and(
               eq(tasks2.status, "failed"),
-              sql`${tasks2.retryCount} < ${tasks2.maxRetries}`
+              sql`${tasks2.retryCount} <= ${tasks2.maxRetries}`
             )
           ),
           ...this.buildScopeWhere(scope)
@@ -6370,7 +6479,11 @@ var init_task_service = __esm({
         return result[0] || null;
       }
       static async done(id, log, scope = {}) {
-        const conditions = [eq(tasks2.id, id), ...this.buildScopeWhere(scope)];
+        const conditions = [
+          eq(tasks2.id, id),
+          eq(tasks2.status, "running"),
+          ...this.buildScopeWhere(scope)
+        ];
         const result = await db.update(tasks2).set({
           status: "done",
           finishedAt: /* @__PURE__ */ new Date(),
@@ -6381,17 +6494,24 @@ var init_task_service = __esm({
       }
       static async fail(id, log, scope = {}, options) {
         const current = await this.getById(id, scope);
-        if (!current) return null;
+        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), ...this.buildScopeWhere(scope)];
+        const isDeadLetter = options?.setDeadLetter ?? newRetryCount > maxRetries;
+        const conditions = [
+          eq(tasks2.id, id),
+          eq(tasks2.status, "running"),
+          ...this.buildScopeWhere(scope)
+        ];
         const result = await db.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)
+          retryAfter: isDeadLetter ? null : options?.retryAfterMs ?? Date.now() + computeBackoff(
+            newRetryCount,
+            current.retryBackoffMs ?? 3e4
+          )
         }).where(and(...conditions)).returning();
         return result[0] || null;
       }
@@ -6424,8 +6544,20 @@ var init_task_service = __esm({
         return result.length;
       }
       static async cancel(id, scope = {}) {
-        const conditions = [eq(tasks2.id, id), ...this.buildScopeWhere(scope)];
-        const result = await db.update(tasks2).set({ status: "cancelled" }).where(and(...conditions)).returning();
+        const conditions = [
+          eq(tasks2.id, id),
+          or(
+            eq(tasks2.status, "pending"),
+            eq(tasks2.status, "running"),
+            eq(tasks2.status, "failed")
+          ),
+          ...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;
       }
       static async retry(id, scope = {}) {
@@ -6437,7 +6569,8 @@ var init_task_service = __esm({
           status: "pending",
           startedAt: null,
           finishedAt: null,
-          retryAfter: null
+          retryAfter: null,
+          retryCount: 0
         }).where(and(...conditions)).returning();
         return result[0] || null;
       }
@@ -6451,7 +6584,8 @@ var init_task_service = __esm({
           status: "pending",
           startedAt: null,
           finishedAt: null,
-          retryAfter: null
+          retryAfter: null,
+          retryCount: 0
         }).where(and(...conditions)).returning();
         return result.length;
       }
@@ -6519,6 +6653,9 @@ var init_task_service = __esm({
       }
       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 result = await db.delete(tasks2).where(and(...conditions)).returning();
         return result.length > 0;
       }
@@ -6538,65 +6675,65 @@ var init_task_service = __esm({
 });
 
 // src/core/services/task-run.service.ts
-var taskRuns2, TaskRunService;
+var taskRuns3, TaskRunService;
 var init_task_run_service = __esm({
   "src/core/services/task-run.service.ts"() {
     "use strict";
     init_db2();
     init_drizzle_orm();
-    ({ taskRuns: taskRuns2 } = schema_exports);
+    ({ taskRuns: taskRuns3 } = schema_exports);
     TaskRunService = class {
       static async create(data) {
-        const result = await db.insert(taskRuns2).values(data).returning();
+        const result = await db.insert(taskRuns3).values(data).returning();
         return result[0];
       }
       static async updateSessionId(id, sessionId) {
-        const result = await db.update(taskRuns2).set({ sessionId }).where(eq(taskRuns2.id, id)).returning();
+        const result = await db.update(taskRuns3).set({ sessionId }).where(and(eq(taskRuns3.id, id), eq(taskRuns3.status, "running"))).returning();
         return result[0] || null;
       }
       static async done(id, log) {
-        const result = await db.update(taskRuns2).set({
+        const result = await db.update(taskRuns3).set({
           status: "done",
           finishedAt: /* @__PURE__ */ new Date(),
           log
-        }).where(eq(taskRuns2.id, id)).returning();
+        }).where(and(eq(taskRuns3.id, id), eq(taskRuns3.status, "running"))).returning();
         return result[0] || null;
       }
       static async fail(id, log) {
-        const result = await db.update(taskRuns2).set({
+        const result = await db.update(taskRuns3).set({
           status: "failed",
           finishedAt: /* @__PURE__ */ new Date(),
           log
-        }).where(eq(taskRuns2.id, id)).returning();
+        }).where(and(eq(taskRuns3.id, id), eq(taskRuns3.status, "running"))).returning();
         return result[0] || null;
       }
       static async heartbeat(id) {
-        const result = await db.update(taskRuns2).set({ heartbeatAt: Date.now() }).where(and(eq(taskRuns2.id, id), eq(taskRuns2.status, "running"))).returning();
+        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) {
-        const result = await db.update(taskRuns2).set({
+        const result = await db.update(taskRuns3).set({
           workerPid,
           childPid,
           lockedAt: Date.now(),
           lockedBy: `gateway-${process.pid}`
-        }).where(eq(taskRuns2.id, id)).returning();
+        }).where(and(eq(taskRuns3.id, id), eq(taskRuns3.status, "running"))).returning();
         return result[0] || null;
       }
       static async getById(id) {
-        const result = await db.select().from(taskRuns2).where(eq(taskRuns2.id, id));
+        const result = await db.select().from(taskRuns3).where(eq(taskRuns3.id, id));
         return result[0] || null;
       }
       static async listByTaskId(taskId) {
-        return await db.select().from(taskRuns2).where(eq(taskRuns2.taskId, taskId)).orderBy(desc(taskRuns2.startedAt), desc(taskRuns2.id));
+        return await db.select().from(taskRuns3).where(eq(taskRuns3.taskId, taskId)).orderBy(desc(taskRuns3.startedAt), desc(taskRuns3.id));
       }
       static async getLatestByTaskId(taskId) {
-        const result = await db.select().from(taskRuns2).where(eq(taskRuns2.taskId, taskId)).orderBy(desc(taskRuns2.startedAt), desc(taskRuns2.id)).limit(1);
+        const result = await db.select().from(taskRuns3).where(eq(taskRuns3.taskId, taskId)).orderBy(desc(taskRuns3.startedAt), desc(taskRuns3.id)).limit(1);
         return result[0] || null;
       }
       static async getLatestByTaskIds(taskIds) {
         if (taskIds.length === 0) return /* @__PURE__ */ new Map();
-        const latestRuns = await db.select().from(taskRuns2).where(inArray(taskRuns2.taskId, taskIds)).orderBy(desc(taskRuns2.startedAt));
+        const latestRuns = await db.select().from(taskRuns3).where(inArray(taskRuns3.taskId, taskIds)).orderBy(desc(taskRuns3.startedAt), desc(taskRuns3.id));
         const result = /* @__PURE__ */ new Map();
         for (const run of latestRuns) {
           if (!result.has(run.taskId)) {
@@ -6610,22 +6747,23 @@ var init_task_run_service = __esm({
         const cutoffSec = Math.floor(cutoffMs / 1e3);
         const { tasks: tasksTable } = schema_exports;
         const result = await db.select({
-          runId: taskRuns2.id,
-          taskId: taskRuns2.taskId,
-          childPid: taskRuns2.childPid,
+          runId: taskRuns3.id,
+          taskId: taskRuns3.taskId,
+          childPid: taskRuns3.childPid,
           taskRetryCount: tasksTable.retryCount,
-          taskMaxRetries: tasksTable.maxRetries
-        }).from(taskRuns2).innerJoin(tasksTable, eq(taskRuns2.taskId, tasksTable.id)).where(
+          taskMaxRetries: tasksTable.maxRetries,
+          taskRetryBackoffMs: tasksTable.retryBackoffMs
+        }).from(taskRuns3).innerJoin(tasksTable, eq(taskRuns3.taskId, tasksTable.id)).where(
           and(
-            eq(taskRuns2.status, "running"),
+            eq(taskRuns3.status, "running"),
             or(
               and(
-                sql`${taskRuns2.heartbeatAt} IS NULL`,
-                sql`${taskRuns2.startedAt} < ${cutoffSec}`
+                sql`${taskRuns3.heartbeatAt} IS NULL`,
+                sql`${taskRuns3.startedAt} < ${cutoffSec}`
               ),
               and(
-                sql`${taskRuns2.heartbeatAt} IS NOT NULL`,
-                sql`${taskRuns2.heartbeatAt} < ${cutoffMs}`
+                sql`${taskRuns3.heartbeatAt} IS NOT NULL`,
+                sql`${taskRuns3.heartbeatAt} < ${cutoffMs}`
               )
             )
           )
@@ -6635,25 +6773,111 @@ var init_task_run_service = __esm({
           taskId: row.taskId,
           childPid: row.childPid,
           taskRetryCount: row.taskRetryCount ?? 0,
-          taskMaxRetries: row.taskMaxRetries ?? 3
+          taskMaxRetries: row.taskMaxRetries ?? 3,
+          taskRetryBackoffMs: row.taskRetryBackoffMs ?? 3e4
         }));
       }
       static async getRunningRunByTaskId(taskId) {
-        const result = await db.select().from(taskRuns2).where(and(eq(taskRuns2.taskId, taskId), eq(taskRuns2.status, "running"))).orderBy(desc(taskRuns2.startedAt), desc(taskRuns2.id)).limit(1);
+        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;
       }
       static async deleteByTaskIds(taskIds) {
         if (taskIds.length === 0) return 0;
-        const result = await db.delete(taskRuns2).where(inArray(taskRuns2.taskId, taskIds)).returning();
+        const result = await db.delete(taskRuns3).where(inArray(taskRuns3.taskId, taskIds)).returning();
         return result.length;
       }
       static async getAllRunningRuns() {
-        return await db.select().from(taskRuns2).where(eq(taskRuns2.status, "running"));
+        return await db.select().from(taskRuns3).where(eq(taskRuns3.status, "running"));
       }
     };
   }
 });
 
+// src/gateway/health.ts
+function initializeGatewayHealth(config) {
+  const now = Date.now();
+  state = {
+    startedAt: now,
+    config,
+    lastActivityAt: {
+      worker: now,
+      scheduler: now,
+      watchdog: now
+    }
+  };
+}
+function markGatewayActivity(component) {
+  if (state) state.lastActivityAt[component] = Date.now();
+}
+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);
+  return {
+    enabled,
+    healthy: !enabled || ageMs != null && ageMs <= maxAgeMs,
+    lastActivityAt,
+    ageMs,
+    maxAgeMs
+  };
+}
+function getGatewayHealth(now = Date.now()) {
+  const worker = componentStatus(
+    "worker",
+    true,
+    Math.max((state?.config.workerPollIntervalMs ?? 1e3) * 5, 5e3),
+    now
+  );
+  const scheduler = componentStatus(
+    "scheduler",
+    state?.config.schedulerEnabled ?? false,
+    Math.max((state?.config.schedulerCheckIntervalMs ?? 1e3) * 5, 5e3),
+    now
+  );
+  const watchdog = componentStatus(
+    "watchdog",
+    true,
+    Math.max((state?.config.watchdogCheckIntervalMs ?? 6e4) * 3, 5e3),
+    now
+  );
+  let lock = { pid: null, heartbeatAt: null, readyAt: null, ageMs: null, healthy: false };
+  try {
+    const row = sqlite.prepare(
+      "SELECT pid, heartbeat_at, ready_at FROM gateway_lock WHERE id = 1"
+    ).get();
+    if (row) {
+      const ageMs = Math.max(0, now - row.heartbeat_at);
+      lock = {
+        pid: row.pid,
+        heartbeatAt: row.heartbeat_at,
+        readyAt: row.ready_at,
+        ageMs,
+        healthy: row.pid === process.pid && row.ready_at != null && ageMs < LOCK_STALE_MS
+      };
+    }
+  } catch {
+  }
+  const healthy = state != null && lock.healthy && worker.healthy && scheduler.healthy && watchdog.healthy;
+  return {
+    status: healthy ? "ok" : "degraded",
+    pid: process.pid,
+    uptimeMs: state ? Math.max(0, now - state.startedAt) : 0,
+    lock,
+    components: { worker, scheduler, watchdog }
+  };
+}
+var LOCK_STALE_MS, state;
+var init_health = __esm({
+  "src/gateway/health.ts"() {
+    "use strict";
+    init_db2();
+    LOCK_STALE_MS = 3e4;
+    state = null;
+  }
+});
+
 // node_modules/cron-parser/dist/fields/types.js
 var require_types = __commonJS({
   "node_modules/cron-parser/dist/fields/types.js"(exports) {
@@ -6854,7 +7078,7 @@ var require_CronField = __commonJS({
         if (!isValidRange) {
           throw new Error(`${this.constructor.name} Validation error, got value ${badValue} expected range ${this.min}-${this.max}${charsString}`);
         }
-        const duplicate = this.#values.find((value, index) => this.#values.indexOf(value) !== index);
+        const duplicate = this.#values.find((value, index2) => this.#values.indexOf(value) !== index2);
         if (duplicate) {
           throw new Error(`${this.constructor.name} Validation error, duplicate values found: ${duplicate}`);
         }
@@ -14699,11 +14923,11 @@ var require_CronFieldCollection = __commonJS({
           throw new Error("Unexpected range end");
         }
         if (step * multiplier > range.end) {
-          const mapFn = (_, index) => {
+          const mapFn = (_, index2) => {
             if (typeof range.start !== "number") {
               throw new Error("Unexpected range start");
             }
-            return index % step === 0 ? range.start + index : null;
+            return index2 % step === 0 ? range.start + index2 : null;
           };
           if (typeof range.start !== "number") {
             throw new Error("Unexpected range start");
@@ -15595,9 +15819,9 @@ var require_CronExpressionParser = __commonJS({
         if (field === CronUnit.DayOfWeek && max % 7 === 0) {
           stack.push(0);
         }
-        for (let index = min; index <= max; index += repeatInterval) {
-          if (stack.indexOf(index) === -1) {
-            stack.push(index);
+        for (let index2 = min; index2 <= max; index2 += repeatInterval) {
+          if (stack.indexOf(index2) === -1) {
+            stack.push(index2);
           }
         }
         return stack;
@@ -15820,11 +16044,6 @@ var require_dist = __commonJS({
 });
 
 // src/core/cron-parser.ts
-var cron_parser_exports = {};
-__export(cron_parser_exports, {
-  getNextCronRun: () => getNextCronRun,
-  isValidCronExpr: () => isValidCronExpr
-});
 function getNextCronRun(expr, afterMs) {
   try {
     const fromDate = afterMs != null ? new Date(afterMs) : /* @__PURE__ */ new Date();
@@ -15862,6 +16081,7 @@ var init_task_template_service = __esm({
     ({ taskTemplates: taskTemplates2 } = schema_exports);
     TaskTemplateService = class {
       static async create(data) {
+        this.validate(data);
         const now = Date.now();
         const result = await db.insert(taskTemplates2).values({ ...data, createdAt: now, updatedAt: now }).returning();
         const tmpl = result[0];
@@ -15877,8 +16097,38 @@ var init_task_template_service = __esm({
         }
         return tmpl;
       }
+      static validate(data) {
+        if (!data.name.trim()) throw new Error("name \u4E0D\u80FD\u4E3A\u7A7A");
+        if (!data.agent.trim()) throw new Error("agent \u4E0D\u80FD\u4E3A\u7A7A");
+        if (!data.prompt.trim()) throw new Error("prompt \u4E0D\u80FD\u4E3A\u7A7A");
+        const scheduleType = data.scheduleType;
+        if (!["cron", "delayed", "recurring"].includes(scheduleType)) {
+          throw new Error("scheduleType \u5FC5\u987B\u662F cron\u3001delayed \u6216 recurring");
+        }
+        if (scheduleType === "cron" && (!data.cronExpr || !isValidCronExpr(data.cronExpr))) {
+          throw new Error("cronExpr \u7F3A\u5931\u6216\u683C\u5F0F\u65E0\u6548");
+        }
+        if (scheduleType === "recurring" && (!Number.isInteger(data.intervalMs) || (data.intervalMs ?? 0) <= 0)) {
+          throw new Error("intervalMs \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+        }
+        if (scheduleType === "delayed" && (!Number.isInteger(data.runAt) || (data.runAt ?? 0) <= 0)) {
+          throw new Error("runAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\u65F6\u95F4\u6233");
+        }
+        this.validateInteger("importance", data.importance, 1, 5);
+        this.validateInteger("urgency", data.urgency, 1, 5);
+        this.validateInteger("maxInstances", data.maxInstances, 1, 1e3);
+        this.validateInteger("maxRetries", data.maxRetries, 0, 1e3);
+        this.validateInteger("retryBackoffMs", data.retryBackoffMs, 0, 864e5);
+        this.validateInteger("timeoutMs", data.timeoutMs, 1e3, 6048e5);
+      }
+      static validateInteger(name, value, min, max) {
+        if (value === void 0 || value === null) return;
+        if (!Number.isInteger(value) || value < min || value > max) {
+          throw new Error(`${name} \u5FC5\u987B\u662F ${min} \u5230 ${max} \u4E4B\u95F4\u7684\u6574\u6570`);
+        }
+      }
       static async list(limit = 50) {
-        return await db.select().from(taskTemplates2).orderBy(desc(taskTemplates2.createdAt)).limit(limit);
+        return await db.select().from(taskTemplates2).orderBy(desc(taskTemplates2.createdAt), desc(taskTemplates2.id)).limit(limit);
       }
       static async getById(id) {
         const result = await db.select().from(taskTemplates2).where(eq(taskTemplates2.id, id));
@@ -15925,13 +16175,13 @@ var init_compose = __esm({
     "use strict";
     compose = (middleware, onError, onNotFound) => {
       return (context, next) => {
-        let index = -1;
+        let index2 = -1;
         return dispatch(0);
         async function dispatch(i) {
-          if (i <= index) {
+          if (i <= index2) {
             throw new Error("next() called multiple times");
           }
-          index = i;
+          index2 = i;
           let res;
           let isError = false;
           let handler;
@@ -16046,8 +16296,8 @@ var init_body = __esm({
     handleParsingNestedValues = (form, key, value) => {
       let nestedForm = form;
       const keys = key.split(".");
-      keys.forEach((key2, index) => {
-        if (index === keys.length - 1) {
+      keys.forEach((key2, index2) => {
+        if (index2 === keys.length - 1) {
           nestedForm[key2] = value;
         } else {
           if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
@@ -16079,8 +16329,8 @@ var init_url = __esm({
     };
     extractGroupsFromPath = (path) => {
       const groups = [];
-      path = path.replace(/\{[^}]+\}/g, (match2, index) => {
-        const mark = `@${index}`;
+      path = path.replace(/\{[^}]+\}/g, (match2, index2) => {
+        const mark = `@${index2}`;
         groups.push([mark, match2]);
         return mark;
       });
@@ -16599,10 +16849,10 @@ var init_html = __esm({
         return;
       }
       let escape;
-      let index;
+      let index2;
       let lastIndex = 0;
-      for (index = match2; index < str.length; index++) {
-        switch (str.charCodeAt(index)) {
+      for (index2 = match2; index2 < str.length; index2++) {
+        switch (str.charCodeAt(index2)) {
           case 34:
             escape = "&quot;";
             break;
@@ -16621,10 +16871,10 @@ var init_html = __esm({
           default:
             continue;
         }
-        buffer[0] += str.substring(lastIndex, index) + escape;
-        lastIndex = index + 1;
+        buffer[0] += str.substring(lastIndex, index2) + escape;
+        lastIndex = index2 + 1;
       }
-      buffer[0] += str.substring(lastIndex, index);
+      buffer[0] += str.substring(lastIndex, index2);
     };
     resolveCallbackSync = (str) => {
       const callbacks = str.callbacks;
@@ -17500,8 +17750,8 @@ function match(method, path) {
     if (!match3) {
       return [[], emptyParam];
     }
-    const index = match3.indexOf("", 1);
-    return [matcher[1][index], match3];
+    const index2 = match3.indexOf("", 1);
+    return [matcher[1][index2], match3];
   });
   this.match = match2;
   return match2(method, path);
@@ -17548,7 +17798,7 @@ var init_node = __esm({
       #index;
       #varIndex;
       #children = /* @__PURE__ */ Object.create(null);
-      insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+      insert(tokens, index2, paramMap, context, pathErrorCheckOnly) {
         if (tokens.length === 0) {
           if (this.#index !== void 0) {
             throw PATH_ERROR;
@@ -17556,7 +17806,7 @@ var init_node = __esm({
           if (pathErrorCheckOnly) {
             return;
           }
-          this.#index = index;
+          this.#index = index2;
           return;
         }
         const [token, ...restTokens] = tokens;
@@ -17606,7 +17856,7 @@ var init_node = __esm({
             node = this.#children[token] = new _Node();
           }
         }
-        node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+        node.insert(restTokens, index2, paramMap, context, pathErrorCheckOnly);
       }
       buildRegExpStr() {
         const childKeys = Object.keys(this.#children).sort(compareKey);
@@ -17638,7 +17888,7 @@ var init_trie = __esm({
     Trie = class {
       #context = { varIndex: 0 };
       #root = new Node();
-      insert(path, index, pathErrorCheckOnly) {
+      insert(path, index2, pathErrorCheckOnly) {
         const paramAssoc = [];
         const groups = [];
         for (let i = 0; ; ) {
@@ -17664,7 +17914,7 @@ var init_trie = __esm({
             }
           }
         }
-        this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
+        this.#root.insert(tokens, index2, paramAssoc, this.#context, pathErrorCheckOnly);
         return paramAssoc;
       }
       buildRegExp() {
@@ -18258,8 +18508,19 @@ __export(web_exports, {
   dashboardApp: () => dashboardApp,
   default: () => web_default
 });
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, renameSync } from "fs";
 import { dirname as dirname2 } from "path";
+function parsePositiveInteger(value) {
+  if (!/^\d+$/.test(value)) return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function parseTaskStatus(value) {
+  return TASK_STATUSES.has(value) ? value : null;
+}
+function safeStatus(value) {
+  return value && TASK_STATUSES.has(value) ? value : "unknown";
+}
 function formatDuration(startAt, endAt) {
   if (!startAt) return "-";
   const start = new Date(startAt).getTime();
@@ -18297,17 +18558,21 @@ function esc(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 function readCurrentConfig() {
-  if (!existsSync3(CONFIG_PATH)) return {};
+  const configPath = getConfigPath();
+  if (!existsSync3(configPath)) return {};
   try {
-    return JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync2(configPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(cfg) {
-  const dir = dirname2(CONFIG_PATH);
+  const configPath = getConfigPath();
+  const dir = dirname2(configPath);
   if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+  const tempPath = `${configPath}.${process.pid}.tmp`;
+  writeFileSync(tempPath, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+  renameSync(tempPath, configPath);
 }
 function renderLayout(title, activeTab, body) {
   return `<!DOCTYPE html><html><head><meta charset="UTF-8"><title>${title} - SuperTask</title>${SHARED_STYLES}
@@ -18346,11 +18611,11 @@ async function saveConfig(){
     scheduler:{
       enabled:form.se.checked,
       checkIntervalMs:Number(form.si.value),
-      catchUp:form.cu.value,
     },
     watchdog:{
       heartbeatTimeoutMs:Number(form.wt.value)*1000,
-      cleanupIntervalMs:Number(form.wc.value)*1000,
+      checkIntervalMs:Number(form.wci.value)*1000,
+      cleanupIntervalMs:Number(form.wcl.value)*3600000,
       retentionDays:Number(form.rd.value),
     }
   };
@@ -18381,7 +18646,7 @@ async function saveConfig(){
 <dialog id="dd"><div class="dh"><h3 style="margin:0">\u8BE6\u60C5</h3><button class="cb" onclick="document.getElementById('dd').close()">&times;</button></div><div class="db"><pre id="dc"></pre></div></dialog>
 </body></html>`;
 }
-var app, SHARED_STYLES, dashboardApp, web_default;
+var app, TASK_STATUSES, SHARED_STYLES, dashboardApp, web_default;
 var init_web = __esm({
   "src/web/index.tsx"() {
     "use strict";
@@ -18393,7 +18658,47 @@ var init_web = __esm({
     init_drizzle_orm();
     init_db2();
     init_config();
+    init_health();
     app = new Hono2();
+    TASK_STATUSES = /* @__PURE__ */ new Set([
+      "pending",
+      "running",
+      "done",
+      "failed",
+      "dead_letter",
+      "cancelled"
+    ]);
+    app.use("*", async (c, next) => {
+      await next();
+      c.header("X-Content-Type-Options", "nosniff");
+      c.header("X-Frame-Options", "DENY");
+      c.header("Referrer-Policy", "no-referrer");
+    });
+    app.use("/api/*", async (c, next) => {
+      if (["GET", "HEAD", "OPTIONS"].includes(c.req.method)) return next();
+      const fetchSite = c.req.header("Sec-Fetch-Site");
+      if (fetchSite && !["same-origin", "none"].includes(fetchSite)) {
+        return c.json({ error: "cross-site request rejected" }, 403);
+      }
+      const origin = c.req.header("Origin");
+      if (origin) {
+        try {
+          const originUrl = new URL(origin);
+          const requestUrl = new URL(c.req.url);
+          const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(originUrl.hostname);
+          if (!loopback || originUrl.origin !== requestUrl.origin) {
+            return c.json({ error: "cross-site request rejected" }, 403);
+          }
+        } catch {
+          return c.json({ error: "invalid origin" }, 403);
+        }
+      }
+      return next();
+    });
+    app.get("/health", (c) => {
+      const health = getGatewayHealth();
+      return c.json(health, health.status === "ok" ? 200 : 503);
+    });
     SHARED_STYLES = html`
 <style>
   :root { --bg:#0d1117; --card:#161b22; --border:#30363d; --t1:#c9d1d9; --t2:#8b949e; --green:#238636; --red:#da3633; --yellow:#d29922; --blue:#1f6feb; --purple:#8957e5; }
@@ -18470,12 +18775,16 @@ var init_web = __esm({
 </style>
 `;
     app.get("/", async (c) => {
-      const page = Number(c.req.query("page") || "1");
+      const pageParam = c.req.query("page") || "1";
+      const page = parsePositiveInteger(pageParam);
+      if (page === null) return c.text("invalid page", 400);
       const statusFilter = c.req.query("status") || "";
+      const parsedStatus = statusFilter ? parseTaskStatus(statusFilter) : null;
+      if (statusFilter && !parsedStatus) return c.text("invalid status", 400);
       const limit = 50;
       const offset = (page - 1) * limit;
       const [tasks3, statsData] = await Promise.all([
-        TaskService.list({ limit, offset, ...statusFilter ? { status: statusFilter } : {} }),
+        TaskService.list({ limit, offset, ...parsedStatus ? { status: parsedStatus } : {} }),
         TaskService.stats({})
       ]);
       const taskIds = tasks3.map((t) => t.id);
@@ -18498,12 +18807,13 @@ var init_web = __esm({
     </div>`;
       let rows = "";
       for (const task of tasks3) {
-        const st = (task.status ?? "").toUpperCase();
+        const status = safeStatus(task.status);
+        const st = status.toUpperCase();
         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>
           <td><span class="tag">${esc(task.agent)}</span></td>
-          <td><span class="badge b-${task.status}">${st}</span></td>
+          <td><span class="badge b-${status}">${st}</span></td>
           <td class="sm ${task.status === "running" ? "" : "mu"}">${formatDuration(task.startedAt, task.finishedAt)}</td>
           <td class="mu sm">${(task.retryCount ?? 0) > 0 ? task.retryCount : "-"}</td>
           <td>
@@ -18535,21 +18845,13 @@ var init_web = __esm({
     });
     app.get("/templates", async (c) => {
       const templates = await TaskTemplateService.list(100);
-      for (const tmpl of templates) {
-        if (tmpl.enabled && tmpl.scheduleType === "cron" && tmpl.cronExpr) {
-          try {
-            const { getNextCronRun: getNextCronRun2 } = await Promise.resolve().then(() => (init_cron_parser(), cron_parser_exports));
-            tmpl.nextRunAt = getNextCronRun2(tmpl.cronExpr, Date.now());
-          } catch {
-          }
-        }
-      }
       const enabled = templates.filter((t) => t.enabled).length;
       const disabled = templates.length - enabled;
       let rows = "";
       for (const t of templates) {
-        const typeLabel = t.scheduleType === "cron" ? "Cron" : t.scheduleType === "recurring" ? "\u5FAA\u73AF" : "\u5B9A\u65F6";
-        const typeClass = "tag t-" + t.scheduleType;
+        const scheduleType = ["cron", "recurring", "delayed"].includes(t.scheduleType) ? t.scheduleType : "unknown";
+        const typeLabel = scheduleType === "cron" ? "Cron" : scheduleType === "recurring" ? "\u5FAA\u73AF" : scheduleType === "delayed" ? "\u5B9A\u65F6" : "\u672A\u77E5";
+        const typeClass = "tag t-" + scheduleType;
         let rule = "-";
         if (t.scheduleType === "cron") rule = t.cronExpr || "-";
         else if (t.scheduleType === "recurring") rule = t.intervalMs ? `${Math.floor(t.intervalMs / 6e4)}\u5206\u949F` : "-";
@@ -18561,7 +18863,7 @@ var init_web = __esm({
           <td><div style="font-weight:500">${esc(t.name)}</div><div class="mu sm el">${esc(t.prompt.substring(0, 100))}</div>
             <div class="sm" style="margin-top:2px"><span class="tag">${esc(t.agent)}</span>${t.model && t.model !== "default" ? ` <span class="tag">${esc(t.model)}</span>` : ""}</div></td>
           <td><span class="${typeClass}">${typeLabel}</span></td>
-          <td class="m sm">${rule}</td>
+          <td class="m sm">${esc(rule)}</td>
           <td>${statusBadge}</td>
           <td class="sm">${t.lastRunAt ? timeAgo(t.lastRunAt) : "-"}</td>
           <td class="sm">${t.nextRunAt ? timeUntil(t.nextRunAt) : "-"}</td>
@@ -18589,7 +18891,8 @@ var init_web = __esm({
       return c.html(renderLayout("\u5B9A\u65F6\u4EFB\u52A1", "templates", body));
     });
     app.get("/runs", async (c) => {
-      const page = Number(c.req.query("page") || "1");
+      const page = parsePositiveInteger(c.req.query("page") || "1");
+      if (page === null) return c.text("invalid page", 400);
       const limit = 50;
       const offset = (page - 1) * limit;
       const { taskRuns: tr, tasks: tk } = schema_exports;
@@ -18607,13 +18910,14 @@ var init_web = __esm({
         childPid: tr.childPid,
         taskName: tk.name,
         taskAgent: tk.agent
-      }).from(tr).innerJoin(tk, eq(tr.taskId, tk.id)).orderBy(desc(tr.startedAt)).limit(limit).offset(offset);
+      }).from(tr).innerJoin(tk, eq(tr.taskId, tk.id)).orderBy(desc(tr.startedAt), desc(tr.id)).limit(limit).offset(offset);
       const totalResult = await db.select({ count: sql`count(*)` }).from(tr);
       const total = Number(totalResult[0]?.count ?? 0);
       const totalPages = Math.ceil(total / limit);
       let rows = "";
       const logsHtml = [];
       for (const run of runs) {
+        const status = safeStatus(run.status);
         const shortSession = run.sessionId ? run.sessionId.slice(4, 7) + "***" + run.sessionId.slice(-3) : "-";
         const logBtn = run.log ? `<button class="btn btn-sm" onclick="toggleLog(${run.id})">\u65E5\u5FD7</button>` : "";
         rows += `<tr>
@@ -18621,15 +18925,15 @@ var init_web = __esm({
           <td><div style="font-weight:500">${esc(run.taskName)} <span class="mu">(#${run.taskId})</span></div>
             ${run.model ? `<div class="sm"><span class="tag">${esc(run.model)}</span></div>` : ""}</td>
           <td><span class="tag">${esc(run.taskAgent)}</span></td>
-          <td><span class="badge b-${run.status}">${(run.status ?? "").toUpperCase()}</span></td>
+          <td><span class="badge b-${status}">${status.toUpperCase()}</span></td>
           <td class="sm">${formatDuration(run.startedAt, run.finishedAt)}</td>
           <td class="sm mu">${run.heartbeatAt ? timeAgo(run.heartbeatAt) : "-"}</td>
           <td><button class="btn btn-sm" onclick="showRunDetail(${run.id})">\u8BE6\u60C5</button>${logBtn}</td>
         </tr>`;
         if (run.log) {
           logsHtml.push(`<div id="log-${run.id}" style="display:none" class="mt8">
-              <div class="panel"><div class="ph"><h3>Run #${run.id} \u65E5\u5FD7 \u2014 ${run.taskName}</h3></div>
-              <div class="log-box">${run.log.replace(/</g, "&lt;")}</div></div></div>`);
+              <div class="panel"><div class="ph"><h3>Run #${run.id} \u65E5\u5FD7 \u2014 ${esc(run.taskName)}</h3></div>
+              <div class="log-box">${esc(run.log)}</div></div></div>`);
         }
       }
       let paging = `<div class="pn">`;
@@ -18655,17 +18959,18 @@ var init_web = __esm({
     });
     app.get("/system", async (c) => {
       const config = loadConfig();
+      const configPath = getConfigPath();
       const stats = await TaskService.stats({});
       const runningRuns = await TaskRunService.getAllRunningRuns();
       const templates = await TaskTemplateService.list(100);
-      const configExists = existsSync3(CONFIG_PATH);
+      const configExists = existsSync3(configPath);
       let runRows = "";
       if (runningRuns.length > 0) {
         for (const run of runningRuns) {
           const shortS = run.sessionId ? run.sessionId.slice(4, 7) + "***" + run.sessionId.slice(-3) : "-";
           runRows += `<tr>
               <td class="mu">#${run.id}</td><td>#${run.taskId}</td>
-              <td class="m sm">${shortS}</td>
+              <td class="m sm">${esc(shortS)}</td>
               <td class="sm">${esc(run.model) || "-"}</td>
               <td class="sm">${formatDate(run.startedAt)}</td>
               <td class="sm">${run.heartbeatAt ? timeAgo(run.heartbeatAt) : "-"}</td>
@@ -18690,19 +18995,14 @@ var init_web = __esm({
           <h3 style="margin:0 0 12px;font-size:14px">Scheduler \u914D\u7F6E</h3>
           <div class="form-row"><label>\u542F\u7528\u8C03\u5EA6</label><input type="checkbox" name="se" ${config.scheduler.enabled ? "checked" : ""}></div>
           <div class="form-row"><label>\u68C0\u67E5\u95F4\u9694(ms)</label><input type="number" name="si" value="${config.scheduler.checkIntervalMs}" min="100" style="width:100px"></div>
-          <div class="form-row"><label>\u8FFD\u8D76\u6A21\u5F0F</label><select name="cu" style="width:100px">
-            <option value="next" ${config.scheduler.catchUp === "next" ? "selected" : ""}>next</option>
-            <option value="all" ${config.scheduler.catchUp === "all" ? "selected" : ""}>all</option>
-            <option value="latest" ${config.scheduler.catchUp === "latest" ? "selected" : ""}>latest</option>
-          </select></div>
           <div class="ir"><span class="ik">\u6D3B\u8DC3\u6A21\u677F</span><span class="iv">${templates.filter((t) => t.enabled).length} / ${templates.length}</span></div>
         </div>
         <div class="card">
           <h3 style="margin:0 0 12px;font-size:14px">Watchdog \u914D\u7F6E</h3>
           <div class="form-row"><label>\u5FC3\u8DF3\u8D85\u65F6(\u79D2)</label><input type="number" name="wt" value="${config.watchdog.heartbeatTimeoutMs / 1e3}" min="10" style="width:100px"></div>
-          <div class="form-row"><label>\u6E05\u7406\u95F4\u9694(\u79D2)</label><input type="number" name="wc" value="${config.watchdog.cleanupIntervalMs / 1e3}" min="10" style="width:100px"></div>
+          <div class="form-row"><label>\u68C0\u67E5\u95F4\u9694(\u79D2)</label><input type="number" name="wci" value="${config.watchdog.checkIntervalMs / 1e3}" min="1" style="width:100px"></div>
+          <div class="form-row"><label>\u6E05\u7406\u95F4\u9694(\u5C0F\u65F6)</label><input type="number" name="wcl" value="${config.watchdog.cleanupIntervalMs / 36e5}" min="1" style="width:100px"></div>
           <div class="form-row"><label>\u6570\u636E\u4FDD\u7559(\u5929)</label><input type="number" name="rd" value="${config.watchdog.retentionDays}" min="1" style="width:100px"></div>
-          <div class="ir"><span class="ik">\u65E5\u5FD7\u683C\u5F0F</span><span class="iv">${config.logging.format}</span></div>
         </div>
       </div>
       <div style="text-align:center;margin-bottom:24px">
@@ -18731,7 +19031,7 @@ var init_web = __esm({
 
       <div class="card mt16">
         <h3 style="margin:0 0 12px;font-size:14px">\u914D\u7F6E\u6587\u4EF6</h3>
-        <div class="ir"><span class="ik">\u8DEF\u5F84</span><span class="iv m sm">${CONFIG_PATH}</span></div>
+        <div class="ir"><span class="ik">\u8DEF\u5F84</span><span class="iv m sm">${esc(configPath)}</span></div>
         <div class="ir"><span class="ik">\u6587\u4EF6\u5B58\u5728</span><span class="iv">${configFileStatus}</span></div>
       </div>
 
@@ -18743,46 +19043,61 @@ var init_web = __esm({
       return c.html(renderLayout("\u7CFB\u7EDF\u72B6\u6001", "system", body));
     });
     app.get("/api/tasks/:id", async (c) => {
-      const id = Number(c.req.param("id"));
+      const id = parsePositiveInteger(c.req.param("id"));
+      if (id === null) return c.json({ error: "invalid id" }, 400);
       const task = await TaskService.getById(id);
       if (!task) return c.json({ error: "not found" }, 404);
       const runs = await TaskRunService.listByTaskId(id);
       return c.json({ ...task, _runs: runs });
     });
     app.get("/api/runs/:id", async (c) => {
-      const id = Number(c.req.param("id"));
+      const id = parsePositiveInteger(c.req.param("id"));
+      if (id === null) return c.json({ error: "invalid id" }, 400);
       const run = await TaskRunService.getById(id);
       if (!run) return c.json({ error: "not found" }, 404);
       return c.json(run);
     });
     app.get("/api/templates/:id", async (c) => {
-      const id = Number(c.req.param("id"));
+      const id = parsePositiveInteger(c.req.param("id"));
+      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);
       return c.json(tmpl);
     });
     app.post("/api/tasks/:id/retry", async (c) => {
-      await TaskService.retry(Number(c.req.param("id")));
-      return c.json({ success: true });
+      const id = parsePositiveInteger(c.req.param("id"));
+      if (id === null) return c.json({ error: "invalid id" }, 400);
+      const task = await TaskService.retry(id);
+      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.delete("/api/tasks/:id", async (c) => {
-      await TaskService.delete(Number(c.req.param("id")));
-      return c.json({ success: true });
+      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);
     });
     app.post("/api/templates/:id/enable", async (c) => {
-      const result = await TaskTemplateService.enable(Number(c.req.param("id")));
-      return c.json({ success: !!result });
+      const id = parsePositiveInteger(c.req.param("id"));
+      if (id === null) return c.json({ error: "invalid id" }, 400);
+      const result = await TaskTemplateService.enable(id);
+      return result ? c.json({ success: true }) : c.json({ error: "not found" }, 404);
     });
     app.post("/api/templates/:id/disable", async (c) => {
-      const result = await TaskTemplateService.disable(Number(c.req.param("id")));
-      return c.json({ success: !!result });
+      const id = parsePositiveInteger(c.req.param("id"));
+      if (id === null) return c.json({ error: "invalid id" }, 400);
+      const result = await TaskTemplateService.disable(id);
+      return result ? c.json({ success: true }) : c.json({ error: "not found" }, 404);
     });
     app.delete("/api/templates/:id", async (c) => {
-      const ok = await TaskTemplateService.delete(Number(c.req.param("id")));
-      return c.json({ success: ok });
+      const id = parsePositiveInteger(c.req.param("id"));
+      if (id === null) return c.json({ error: "invalid id" }, 400);
+      const ok = await TaskTemplateService.delete(id);
+      return ok ? c.json({ success: true }) : c.json({ error: "not found" }, 404);
     });
     app.post("/api/templates/:id/trigger", async (c) => {
-      const id = Number(c.req.param("id"));
+      const id = parsePositiveInteger(c.req.param("id"));
+      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({
@@ -18794,7 +19109,10 @@ var init_web = __esm({
         category: tmpl.category,
         importance: tmpl.importance,
         urgency: tmpl.urgency,
+        batchId: tmpl.batchId,
         maxRetries: tmpl.maxRetries,
+        retryBackoffMs: tmpl.retryBackoffMs,
+        timeoutMs: tmpl.timeoutMs,
         templateId: tmpl.id
       });
       return c.json({ success: true, taskId: task.id });
@@ -18809,22 +19127,29 @@ var init_web = __esm({
         const bW = body.worker ?? {};
         const bS = body.scheduler ?? {};
         const bD = body.watchdog ?? {};
-        const merged = { ...current, ...body, worker: { ...curW, ...bW }, scheduler: { ...curS, ...bS }, watchdog: { ...curD, ...bD } };
-        writeConfig(merged);
+        const merged = {
+          ...current,
+          ...body,
+          configVersion: 2,
+          worker: { ...curW, ...bW },
+          scheduler: { ...curS, ...bS },
+          watchdog: { ...curD, ...bD }
+        };
+        writeConfig(validateConfig(merged));
         return c.json({ success: true });
       } catch (err) {
-        return c.json({ success: false, error: err instanceof Error ? err.message : String(err) });
+        return c.json({ success: false, error: err instanceof Error ? err.message : String(err) }, 400);
       }
     });
     app.post("/api/database/clear", async (c) => {
       try {
-        const { tasks: tasks3, taskRuns: taskRuns3, taskTemplates: taskTemplates4 } = schema_exports;
-        await db.delete(taskRuns3);
+        const { tasks: tasks3, taskRuns: taskRuns4, taskTemplates: taskTemplates4 } = schema_exports;
+        await db.delete(taskRuns4);
         await db.delete(taskTemplates4);
         await db.delete(tasks3);
         return c.json({ success: true });
       } catch (err) {
-        return c.json({ success: false, error: err instanceof Error ? err.message : String(err) });
+        return c.json({ success: false, error: err instanceof Error ? err.message : String(err) }, 500);
       }
     });
     dashboardApp = app;
@@ -18842,39 +19167,118 @@ init_config();
 // src/worker/index.ts
 init_task_service();
 init_task_run_service();
+init_health();
 import { spawn } from "child_process";
+
+// 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 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;
+  }
+}
+
+// src/worker/index.ts
+var DEFAULT_MAX_OUTPUT_CHARS = 64 * 1024;
+var FORBIDDEN_AGENT = "supertask-runner";
 var WorkerEngine = class {
   activeBatchIds = /* @__PURE__ */ new Set();
   runningTasks = /* @__PURE__ */ new Map();
   stopped = false;
   pollTimer = null;
   heartbeatTimer = null;
+  pollCyclePromise = null;
   cfg;
-  constructor(cfg) {
+  opencodeBin;
+  maxOutputChars;
+  constructor(cfg, options = {}) {
     this.cfg = cfg.worker;
+    this.opencodeBin = options.opencodeBin ?? process.env.SUPERTASK_OPENCODE_BIN ?? "opencode";
+    this.maxOutputChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   }
   start() {
     this.stopped = false;
+    markGatewayActivity("worker");
     this.poll();
     this.heartbeatTimer = setInterval(() => this.updateHeartbeats(), this.cfg.heartbeatIntervalMs);
   }
-  stop() {
+  async stop(gracePeriodMs = 0) {
     this.stopped = true;
     if (this.pollTimer) {
       clearTimeout(this.pollTimer);
       this.pollTimer = null;
     }
+    if (this.pollCyclePromise) await this.pollCyclePromise;
+    if (gracePeriodMs > 0 && this.runningTasks.size > 0) {
+      const deadline = Date.now() + gracePeriodMs;
+      while (this.runningTasks.size > 0 && Date.now() < deadline) {
+        await Bun.sleep(Math.min(50, deadline - Date.now()));
+      }
+    }
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
     }
+    const interruptedTaskIds = [...this.runningTasks.keys()];
     const killPromises = [];
-    for (const [, entry] of this.runningTasks) {
+    for (const entry of this.runningTasks.values()) {
       entry.shutdown = true;
       killPromises.push(this.killEntry(entry));
     }
-    return Promise.allSettled(killPromises).then(() => {
-    });
+    await Promise.allSettled(killPromises);
+    return interruptedTaskIds;
   }
   getRunningTaskIds() {
     return [...this.runningTasks.keys()];
@@ -18884,136 +19288,244 @@ var WorkerEngine = class {
   }
   poll() {
     if (this.stopped) return;
-    this.tryDispatch().then(() => {
+    markGatewayActivity("worker");
+    this.pollCyclePromise = this.tryDispatch().finally(() => {
+      this.pollCyclePromise = null;
       if (this.stopped) return;
       this.pollTimer = setTimeout(() => this.poll(), this.cfg.pollIntervalMs);
     });
   }
   async tryDispatch() {
+    await this.reconcileCancelledTasks();
     while (!this.stopped && this.runningTasks.size < this.cfg.maxConcurrency) {
+      let task;
+      try {
+        task = await TaskService.next({ excludedBatchIds: [...this.activeBatchIds] });
+      } catch (err) {
+        this.logError("task claim failed", err);
+        break;
+      }
+      if (!task) break;
+      if (this.stopped) break;
+      if (!await TaskService.start(task.id)) continue;
+      if (task.batchId) this.activeBatchIds.add(task.batchId);
+      if (this.stopped) {
+        await TaskService.resetRunningToPending([task.id]);
+        this.releaseBatch(task);
+        break;
+      }
       try {
-        const excludedBatchIds = [...this.activeBatchIds];
-        const task = await TaskService.next({ excludedBatchIds });
-        if (!task) break;
-        if (!await TaskService.start(task.id)) continue;
-        if (task.batchId) {
-          this.activeBatchIds.add(task.batchId);
-        }
         const run = await TaskRunService.create({
           taskId: task.id,
           model: this.resolveModel(task.model),
           status: "running"
         });
-        const modelToUse = this.resolveModel(task.model);
-        const args = ["run", "--agent", "supertask-runner", "--format", "json"];
-        if (modelToUse) {
-          args.push("-m", modelToUse);
-        }
-        args.push(`\u6267\u884C\u4EFB\u52A1 ID: ${task.id}${modelToUse ? ` OVERRIDE_MODEL=${modelToUse}` : ""}`);
-        const cwd = task.cwd || process.cwd();
-        const child = spawn("opencode", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
-        await TaskRunService.updatePid(run.id, process.pid, child.pid ?? 0);
-        let output = "";
-        const handleData = (data) => {
-          const text2 = data.toString();
-          output += text2;
-          process.stdout.write(text2);
-          const match2 = text2.match(/"sessionID"\s*:\s*"(ses_[^"]+)"/);
-          if (match2) {
-            TaskRunService.updateSessionId(run.id, match2[1]).then(() => {
-              console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "sessionId captured", taskId: task.id, sessionId: match2[1] }));
-            });
-          }
-        };
-        child.stdout?.on("data", handleData);
-        child.stderr?.on("data", handleData);
-        const entry = { task, runId: run.id, child, startedAt: Date.now(), shutdown: false };
-        this.runningTasks.set(task.id, entry);
-        child.on("close", async (code) => {
-          this.runningTasks.delete(task.id);
-          if (task.batchId) this.activeBatchIds.delete(task.batchId);
-          if (entry.shutdown) return;
-          const currentRun = await TaskRunService.getById(run.id);
-          if (!currentRun || currentRun.status !== "running") return;
-          if (code === 0) {
-            await TaskRunService.done(run.id);
-            await TaskService.done(task.id);
-            console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "task done", taskId: task.id }));
-          } else {
-            const lastOutput = output.slice(-2e3);
-            await TaskRunService.fail(run.id, lastOutput);
-            const currentStatus = await TaskService.getById(task.id);
-            if (currentStatus?.status === "running") {
-              await TaskService.fail(task.id, "Worker\u6267\u884C\u5F02\u5E38\uFF1AOpencode \u8FDB\u7A0B\u975E\u6B63\u5E38\u9000\u51FA");
-            }
-            console.error(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "error", msg: "task failed", taskId: task.id, code }));
-          }
-        });
-        child.on("error", async (err) => {
-          this.runningTasks.delete(task.id);
-          if (task.batchId) this.activeBatchIds.delete(task.batchId);
-          if (entry.shutdown) return;
-          const currentRun = await TaskRunService.getById(run.id);
-          if (!currentRun || currentRun.status !== "running") return;
-          await TaskRunService.fail(run.id, err.message);
-          const currentStatus = await TaskService.getById(task.id);
-          if (currentStatus?.status === "running") {
-            await TaskService.fail(task.id, `spawn \u5F02\u5E38: ${err.message}`);
-          }
-          console.error(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "error", msg: "task spawn error", taskId: task.id, error: err.message }));
+        if (this.stopped) {
+          await TaskRunService.fail(run.id, "Gateway shutdown before spawn");
+          await TaskService.resetRunningToPending([task.id]);
+          this.releaseBatch(task);
+          break;
+        }
+        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 });
+          this.releaseBatch(task);
+          continue;
+        }
+        this.spawnTask(task, run.id);
+      } 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);
+        } catch (failErr) {
+          this.logError("failed to compensate task startup", failErr, task.id);
+        }
+        this.logError("task dispatch failed", err, task.id);
+      }
+    }
+  }
+  spawnTask(task, runId) {
+    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, {
+      cwd: task.cwd || process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    const entry = {
+      task,
+      runId,
+      child,
+      output: "",
+      sessionId: null,
+      timeoutTimer: null,
+      shutdown: 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];
+        TaskRunService.updateSessionId(runId, match2[1]).catch((err) => {
+          this.logError("sessionId update failed", err, task.id);
         });
+      }
+    };
+    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.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);
+    });
+    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`);
+      }, 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");
+        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) {
-        console.error(JSON.stringify({
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          level: "error",
-          msg: "tryDispatch iteration failed",
-          error: err instanceof Error ? err.message : String(err)
-        }));
-        break;
+        this.logError("cancel reconciliation failed", err, entry.task.id);
       }
     }
   }
+  async cancelEntry(entry) {
+    if (entry.settled) return;
+    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);
+      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);
+    }
+  }
   async updateHeartbeats() {
-    for (const [, entry] of this.runningTasks) {
+    for (const entry of this.runningTasks.values()) {
       try {
         await TaskRunService.heartbeat(entry.runId);
-      } catch {
+      } catch (err) {
+        this.logError("heartbeat update failed", err, entry.task.id);
       }
     }
   }
   killEntry(entry) {
-    if (entry.child.exitCode !== null) {
+    if (entry.child.exitCode !== null || entry.child.signalCode !== null) {
       return Promise.resolve();
     }
     return new Promise((resolve) => {
       const timeout = setTimeout(() => {
-        try {
-          if (entry.child.pid) process.kill(entry.child.pid, "SIGKILL");
-        } catch {
-        }
+        this.signalEntry(entry, "SIGKILL");
         resolve();
       }, 5e3);
-      entry.child.on("close", () => {
+      entry.child.once("close", () => {
         clearTimeout(timeout);
         resolve();
       });
-      try {
-        if (entry.child.pid) {
-          entry.child.kill("SIGTERM");
-        } else {
-          clearTimeout(timeout);
-          resolve();
-        }
-      } catch {
-        clearTimeout(timeout);
-        resolve();
-      }
+      this.signalEntry(entry, "SIGTERM");
     });
   }
+  signalEntry(entry, signal) {
+    const pid = entry.child.pid;
+    if (!pid) return;
+    signalSpawnedProcessTree(pid, signal);
+  }
+  releaseBatch(task) {
+    if (task.batchId) this.activeBatchIds.delete(task.batchId);
+  }
   resolveModel(taskModel) {
     if (!taskModel || taskModel === "default") return null;
     return taskModel;
   }
+  logError(message, error, taskId) {
+    console.error(JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "error",
+      msg: message,
+      taskId,
+      error: error instanceof Error ? error.message : String(error)
+    }));
+  }
 };
 
 // src/gateway/watchdog/heartbeat.ts
@@ -19026,15 +19538,23 @@ async function checkHeartbeats(heartbeatTimeoutMs) {
   for (const run of staleRuns) {
     try {
       if (run.childPid != null && run.childPid > 0) {
-        try {
-          process.kill(run.childPid, "SIGKILL");
-        } catch {
+        const expectedExecutable = process.env.SUPERTASK_OPENCODE_BIN ?? "opencode";
+        const killed = signalRecordedProcessTree(run.childPid, "SIGKILL", expectedExecutable);
+        if (!killed) {
+          console.warn(JSON.stringify({
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "warn",
+            msg: "stale child process was not killed because identity validation failed",
+            taskId: run.taskId,
+            runId: run.runId,
+            childPid: run.childPid
+          }));
         }
       }
       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) {
+      if (newRetryCount > maxRetries) {
         await TaskService.markDeadLetter(run.taskId, newRetryCount);
         console.log(JSON.stringify({
           ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -19046,7 +19566,7 @@ async function checkHeartbeats(heartbeatTimeoutMs) {
           maxRetries
         }));
       } else {
-        const backoffMs = computeBackoff(newRetryCount);
+        const backoffMs = computeBackoff(newRetryCount, run.taskRetryBackoffMs);
         const retryAfter = Date.now() + backoffMs;
         await TaskService.markPendingForRetry(run.taskId, retryAfter, newRetryCount);
         console.log(JSON.stringify({
@@ -19102,6 +19622,7 @@ async function cleanupOldRecords(retentionDays) {
 }
 
 // src/gateway/watchdog/index.ts
+init_health();
 var Watchdog = class {
   constructor(cfg) {
     this.cfg = cfg;
@@ -19112,13 +19633,14 @@ var Watchdog = class {
   cleanupTimer = null;
   start() {
     this.stopped = false;
+    markGatewayActivity("watchdog");
     this.heartbeatTimer = setInterval(
       () => this.runHeartbeatCheck(),
-      this.cfg.watchdog.cleanupIntervalMs
+      this.cfg.watchdog.checkIntervalMs
     );
     this.cleanupTimer = setInterval(
       () => this.runCleanup(),
-      this.cfg.watchdog.cleanupIntervalMs * 24 * 60
+      this.cfg.watchdog.cleanupIntervalMs
     );
   }
   stop() {
@@ -19134,6 +19656,7 @@ var Watchdog = class {
   }
   async runHeartbeatCheck() {
     if (this.stopped) return;
+    markGatewayActivity("watchdog");
     try {
       await checkHeartbeats(this.cfg.watchdog.heartbeatTimeoutMs);
     } catch (err) {
@@ -19169,7 +19692,7 @@ 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) return null;
+  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),
@@ -19178,7 +19701,8 @@ async function cloneTaskFromTemplate(templateId) {
   ).then((r) => r[0].count);
   if (activeCount >= (tmpl.maxInstances ?? 1)) return null;
   const nowMs = Date.now();
-  const nextRunAt = TaskTemplateService.calculateNextRunAt(
+  const isDelayed = tmpl.scheduleType === "delayed";
+  const nextRunAt = isDelayed ? null : TaskTemplateService.calculateNextRunAt(
     tmpl.scheduleType,
     tmpl,
     nowMs
@@ -19192,13 +19716,17 @@ async function cloneTaskFromTemplate(templateId) {
     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;
@@ -19211,7 +19739,7 @@ async function getDueTemplates() {
       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);
@@ -19229,6 +19757,7 @@ async function initializeNextRunAt(templateId) {
 // src/gateway/scheduler/index.ts
 init_db2();
 init_drizzle_orm();
+init_health();
 var Scheduler = class {
   constructor(cfg) {
     this.cfg = cfg;
@@ -19240,6 +19769,7 @@ var Scheduler = class {
   async start() {
     if (!this.cfg.scheduler.enabled) return;
     this.stopped = false;
+    markGatewayActivity("scheduler");
     await this.initializeTemplates();
     this.timer = setInterval(() => this.tick(), this.cfg.scheduler.checkIntervalMs);
   }
@@ -19252,6 +19782,7 @@ var Scheduler = class {
   }
   async tick() {
     if (this.stopped || this.ticking) return;
+    markGatewayActivity("scheduler");
     this.ticking = true;
     try {
       const dueTemplates = await getDueTemplates();
@@ -19301,6 +19832,7 @@ var Scheduler = class {
 init_db2();
 init_task_service();
 init_task_run_service();
+init_health();
 var STALE_THRESHOLD_MS = 3e4;
 function acquireLock() {
   const now = Date.now();
@@ -19322,7 +19854,7 @@ function acquireLock() {
       sqlite.exec("DELETE FROM gateway_lock WHERE id = 1");
     }
     sqlite.exec(
-      "INSERT INTO gateway_lock (id, pid, acquired_at, heartbeat_at) VALUES (1, ?, ?, ?)",
+      "INSERT INTO gateway_lock (id, pid, acquired_at, heartbeat_at, ready_at) VALUES (1, ?, ?, ?, NULL)",
       [pid, now, now]
     );
     sqlite.exec("COMMIT");
@@ -19356,6 +19888,18 @@ function updateLockHeartbeat() {
   } catch {
   }
 }
+function markGatewayReady() {
+  sqlite.exec(
+    "UPDATE gateway_lock SET heartbeat_at = ?, ready_at = ? WHERE pid = ?",
+    [Date.now(), Date.now(), process.pid]
+  );
+}
+function markGatewayNotReady() {
+  try {
+    sqlite.exec("UPDATE gateway_lock SET ready_at = NULL WHERE pid = ?", [process.pid]);
+  } catch {
+  }
+}
 async function main() {
   console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "SuperTask Gateway starting", pid: process.pid }));
   if (!acquireLock()) {
@@ -19367,20 +19911,21 @@ async function main() {
   const worker = new WorkerEngine(cfg);
   const watchdog = new Watchdog(cfg);
   const scheduler = new Scheduler(cfg);
+  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(req) {
-        const url = new URL(req.url);
-        if (url.hostname !== "localhost" && url.hostname !== "127.0.0.1" && url.hostname !== "::1") {
-          return new Response("Forbidden", { status: 403 });
-        }
-        return dashboardApp2.fetch(req);
-      }
+      fetch: dashboardApp2.fetch
     });
     console.log(JSON.stringify({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -19389,6 +19934,7 @@ async function main() {
       url: `http://localhost:${cfg.dashboard.port}`
     }));
   }
+  markGatewayReady();
   console.log(JSON.stringify({
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     level: "info",
@@ -19402,10 +19948,10 @@ async function main() {
     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 = worker.getRunningTaskIds();
-    await worker.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 }));
@@ -19415,6 +19961,7 @@ async function main() {
       await TaskRunService.fail(run.id, "Gateway shutdown");
     }
     releaseLock();
+    resetGatewayHealth();
     closeDb();
     console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "Gateway stopped" }));
     process.exit(0);