opencode-supertask 0.1.19 → 0.1.21

package/dist/cli/index.js

@@ -2353,11 +2353,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         };
         this._checkNumberOfArguments();
         const processedArgs = [];
-        this.registeredArguments.forEach((declaredArg, index) => {
+        this.registeredArguments.forEach((declaredArg, index2) => {
           let value = declaredArg.defaultValue;
           if (declaredArg.variadic) {
-            if (index < this.args.length) {
-              value = this.args.slice(index);
+            if (index2 < this.args.length) {
+              value = this.args.slice(index2);
               if (declaredArg.parseArg) {
                 value = value.reduce((processed, v) => {
                   return myParseArg(declaredArg, v, processed);
@@ -2366,13 +2366,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
             } else if (value === void 0) {
               value = [];
             }
-          } else if (index < this.args.length) {
-            value = this.args[index];
+          } else if (index2 < this.args.length) {
+            value = this.args[index2];
             if (declaredArg.parseArg) {
               value = myParseArg(declaredArg, value, declaredArg.defaultValue);
             }
           }
-          processedArgs[index] = value;
+          processedArgs[index2] = value;
         });
         this.processedArgs = processedArgs;
       }
@@ -2658,10 +2658,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
             }
           }
           if (/^--[^=]+=/.test(arg)) {
-            const index = arg.indexOf("=");
-            const option = this._findOption(arg.slice(0, index));
+            const index2 = arg.indexOf("=");
+            const option = this._findOption(arg.slice(0, index2));
             if (option && (option.required || option.optional)) {
-              this.emit(`option:${option.name()}`, arg.slice(index + 1));
+              this.emit(`option:${option.name()}`, arg.slice(index2 + 1));
               continue;
             }
           }
@@ -4506,7 +4506,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw2;
-      function join4(chunks, separator) {
+      function join5(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -4516,7 +4516,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join4;
+      sql2.join = join5;
       function identifier(value) {
         return new Name(value);
       }
@@ -4660,8 +4660,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;
     }
   }
@@ -6522,8 +6522,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;
@@ -6540,7 +6540,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` `);
             }
           }
@@ -6553,9 +6553,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`, `);
             }
           }
@@ -6604,9 +6604,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`, `);
             }
           }
@@ -7132,7 +7132,7 @@ var init_select2 = __esm({
         return (table, on) => {
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins?.some((join4) => join4.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) {
@@ -7974,7 +7974,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join4) => join4.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") {
@@ -8695,6 +8695,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"() {
@@ -9274,10 +9277,6 @@ var init_migrator = __esm({
 });
 
 // node_modules/drizzle-orm/bun-sqlite/migrator.js
-var migrator_exports = {};
-__export(migrator_exports, {
-  migrate: () => migrate
-});
 function migrate(db2, config) {
   const migrations = readMigrationFiles(config);
   db2.dialect.migrate(migrations, db2.session, config);
@@ -9327,12 +9326,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",
@@ -9342,7 +9346,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"),
@@ -9355,7 +9359,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(),
@@ -9366,6 +9373,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"),
@@ -9373,12 +9381,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)
+    ]);
   }
 });
 
@@ -9400,7 +9411,15 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 function getMigrationsFolder() {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
-  return join(__dirname2, "../../../drizzle");
+  let dir = __dirname2;
+  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(__dirname2, "../../drizzle");
 }
 function initDb() {
   const dataDir = dirname(DB_FILE_PATH);
@@ -9415,16 +9434,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}`);
     }
@@ -9444,6 +9477,7 @@ function closeDb() {
     _sqlite.close();
     _sqlite = null;
     _db = null;
+    _migrationRan = false;
   }
 }
 var DEFAULT_DB_PATH, DB_FILE_PATH, _sqlite, _db, _migrationRan, db, sqlite;
@@ -9527,14 +9561,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 = [];
@@ -9544,9 +9578,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();
@@ -9569,7 +9621,7 @@ var init_task_service = __esm({
           ),
           and(
             eq(tasks2.status, "failed"),
-            sql`${tasks2.retryCount} < ${tasks2.maxRetries}`,
+            sql`${tasks2.retryCount} <= ${tasks2.maxRetries}`,
             retryAfterFilter
           )
         );
@@ -9583,7 +9635,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) {
@@ -9604,7 +9657,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)
@@ -9617,7 +9670,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(),
@@ -9628,17 +9685,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;
       }
@@ -9671,8 +9735,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 = {}) {
@@ -9684,7 +9760,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;
       }
@@ -9698,7 +9775,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;
       }
@@ -9766,6 +9844,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;
       }
@@ -9984,7 +10065,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}`);
         }
@@ -17829,11 +17910,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");
@@ -18725,9 +18806,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;
@@ -18850,8 +18931,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static parseFileSync(filePath) {
-        const { readFileSync: readFileSync4 } = __require("fs");
-        const data = readFileSync4(filePath, "utf8");
+        const { readFileSync: readFileSync5 } = __require("fs");
+        const data = readFileSync5(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -18950,11 +19031,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();
@@ -18992,6 +19068,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];
@@ -19007,8 +19084,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));
@@ -19051,137 +19158,466 @@ var init_task_template_service = __esm({
 // src/gateway/config.ts
 var config_exports = {};
 __export(config_exports, {
-  CONFIG_PATH: () => CONFIG_PATH,
-  loadConfig: () => loadConfig
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  DEFAULT_CONFIG_PATH: () => DEFAULT_CONFIG_PATH,
+  getConfigPath: () => getConfigPath,
+  loadConfig: () => loadConfig,
+  validateConfig: () => validateConfig
 });
-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 loadConfig() {
-  if (!existsSync2(CONFIG_PATH)) {
-    return DEFAULT_CONFIG;
+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 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");
+  }
+});
+
+// src/daemon/pm2.ts
+var pm2_exports = {};
+__export(pm2_exports, {
+  ensureGateway: () => ensureGateway,
+  getPackageVersion: () => getPackageVersion,
+  install: () => install,
+  isGatewayReady: () => isGatewayReady,
+  isGatewayRunning: () => isGatewayRunning,
+  isPm2Installed: () => isPm2Installed,
+  resolveGatewayEntry: () => resolveGatewayEntry,
+  uninstall: () => uninstall,
+  upgrade: () => upgrade
+});
+import { execSync, spawnSync } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Database as Database3 } from "bun:sqlite";
+function getPackageVersion() {
+  const envVersion = process.env.npm_package_version;
+  if (envVersion) return envVersion;
+  try {
+    const pkgPath = join3(__dirname, "../../package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function resolveGatewayEntry() {
+  const override = process.env.SUPERTASK_GATEWAY_ENTRY;
+  if (override) {
+    if (!existsSync3(override)) throw new Error(`[supertask] Gateway entry not found: ${override}`);
+    return override;
+  }
+  const candidates = [
+    join3(__dirname, "../gateway/index.js"),
+    join3(__dirname, "../gateway/index.ts")
+  ];
+  const entry = candidates.find((candidate) => existsSync3(candidate));
+  if (!entry) throw new Error(`[supertask] Gateway entry not found. Checked: ${candidates.join(", ")}`);
+  return entry;
+}
+function versionFile() {
+  return process.env.SUPERTASK_VERSION_FILE ?? join3(homedir3(), ".local/share/opencode/supertask-gateway-version");
+}
+function getRunningVersion() {
+  try {
+    const path = versionFile();
+    if (!existsSync3(path)) return null;
+    return readFileSync2(path, "utf-8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function writeRunningVersion(version2) {
+  const path = versionFile();
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync(path, version2, "utf-8");
+}
+function pm2Bin() {
+  return process.env.SUPERTASK_PM2_BIN ?? (process.platform === "win32" ? "pm2.cmd" : "pm2");
+}
+function isPm2Installed() {
+  const result = spawnSync(pm2Bin(), ["--version"], {
+    stdio: "ignore",
+    shell: process.platform === "win32"
+  });
+  return result.status === 0;
+}
+function installPm2() {
+  console.log("[supertask] Installing pm2...");
+  try {
+    execSync("npm install -g pm2", { stdio: "inherit" });
+    return true;
+  } catch {
+    try {
+      execSync("bun install -g pm2", { stdio: "inherit" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function pm2Exec(args) {
+  const result = spawnSync(pm2Bin(), args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: process.env,
+    shell: process.platform === "win32"
+  });
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  if (result.error) return { ok: false, output: result.error.message };
+  return { ok: result.status === 0, output };
+}
+function requirePm2(args, action) {
+  const result = pm2Exec(args);
+  if (!result.ok) throw new Error(`[supertask] ${action} failed: ${result.output || "unknown pm2 error"}`);
+  return result.output;
+}
+function pm2JsonList() {
+  const output = requirePm2(["jlist"], "pm2 jlist");
+  try {
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed)) throw new Error("result is not an array");
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`[supertask] Invalid pm2 jlist output: ${message}`);
+  }
+}
+function isGatewayRunning() {
+  if (!isPm2Installed()) return false;
+  const proc = pm2JsonList().find((item) => item.name === PROCESS_NAME);
+  return proc?.pm2_env?.status === "online" && typeof proc.pid === "number" && isGatewayReady(proc.pid);
+}
+function databasePath() {
+  return process.env.SUPERTASK_DB_PATH ?? join3(homedir3(), ".local/share/opencode/tasks.db");
+}
+function isGatewayReady(expectedPid) {
+  const path = databasePath();
+  if (!existsSync3(path)) return false;
+  let database = null;
+  try {
+    database = new Database3(path, { readonly: true });
+    const row = database.query(
+      "SELECT pid, heartbeat_at, ready_at FROM gateway_lock WHERE id = 1"
+    ).get();
+    if (!row || row.ready_at == null) return false;
+    if (expectedPid !== void 0 && row.pid !== expectedPid) return false;
+    const ageMs = Date.now() - row.heartbeat_at;
+    return ageMs >= -5e3 && ageMs < GATEWAY_LOCK_STALE_MS;
+  } catch {
+    return false;
+  } finally {
+    database?.close();
+  }
+}
+function readyTimeoutMs() {
+  const value = Number(process.env.SUPERTASK_GATEWAY_READY_TIMEOUT_MS ?? 3e4);
+  return Number.isFinite(value) && value > 0 ? value : 3e4;
+}
+function waitForGatewayReady(pid) {
+  const deadline = Date.now() + readyTimeoutMs();
+  const sleeper = new Int32Array(new SharedArrayBuffer(4));
+  while (Date.now() < deadline) {
+    if (isGatewayReady(pid)) return true;
+    Atomics.wait(sleeper, 0, 0, 100);
+  }
+  return isGatewayReady(pid);
+}
+function findBunPath() {
+  const override = process.env.SUPERTASK_BUN_BIN;
+  if (override) return override;
+  try {
+    const command = process.platform === "win32" ? "where bun" : "which bun";
+    return execSync(command, { stdio: "pipe" }).toString().trim().split("\n")[0];
+  } catch {
+    return process.execPath;
+  }
+}
+function pm2StartGateway(gatewayEntry = resolveGatewayEntry()) {
+  const configuredKillTimeout = Number(process.env.SUPERTASK_PM2_KILL_TIMEOUT_MS);
+  const killTimeoutMs = Number.isInteger(configuredKillTimeout) && configuredKillTimeout >= 5e3 ? configuredKillTimeout : loadConfig().worker.shutdownGracePeriodMs + 5e3;
+  requirePm2([
+    "start",
+    findBunPath(),
+    "--name",
+    PROCESS_NAME,
+    "--interpreter",
+    "none",
+    "--restart-delay",
+    "5000",
+    "--max-restarts",
+    "30",
+    "--kill-timeout",
+    String(killTimeoutMs),
+    "--",
+    gatewayEntry
+  ], "pm2 start");
+  const started = pm2JsonList().find((item) => item.name === PROCESS_NAME);
+  if (started?.pm2_env?.status !== "online") {
+    throw new Error(`[supertask] Gateway did not become online (status: ${started?.pm2_env?.status ?? "missing"})`);
+  }
+  if (typeof started.pid !== "number" || !waitForGatewayReady(started.pid)) {
+    throw new Error("[supertask] Gateway \u8FDB\u7A0B online\uFF0C\u4F46\u672A\u5728\u9650\u5B9A\u65F6\u95F4\u5185\u5C31\u7EEA\uFF1B\u8BF7\u67E5\u770B pm2 logs supertask-gateway");
+  }
+}
+function savePm2State() {
+  requirePm2(["save"], "pm2 save");
+}
+function install() {
+  if (!isPm2Installed() && !installPm2()) {
+    throw new Error("[supertask] Failed to install pm2. Please install it manually: npm install -g pm2");
+  }
+  const existing = pm2JsonList().find((item) => item.name === PROCESS_NAME);
+  if (existing) requirePm2(["delete", PROCESS_NAME], "pm2 delete existing Gateway");
+  const version2 = getPackageVersion();
+  pm2StartGateway();
+  writeRunningVersion(version2);
+  savePm2State();
+  const startup = pm2Exec(["startup"]);
+  if (startup.output) console.log(startup.output);
+  if (!startup.ok) {
+    console.warn("[supertask] pm2 startup \u672A\u5B8C\u6210\uFF1B\u8BF7\u6309 pm2 \u8F93\u51FA\u6267\u884C\u9700\u8981\u7BA1\u7406\u5458\u6743\u9650\u7684\u547D\u4EE4\uFF0C\u7136\u540E\u8FD0\u884C `pm2 save`\u3002");
+  }
+  console.log("[supertask] Gateway installed and running.");
+  console.log("[supertask] Manage with: pm2 status / pm2 logs supertask-gateway");
+}
+function uninstall() {
+  if (!isPm2Installed()) throw new Error("[supertask] pm2 is not installed");
+  const existing = pm2JsonList().find((item) => item.name === PROCESS_NAME);
+  if (existing) requirePm2(["delete", PROCESS_NAME], "pm2 delete Gateway");
+  savePm2State();
+  console.log("[supertask] Gateway removed from pm2. Other pm2 startup entries were preserved.");
+}
+function upgrade(target) {
+  if (!isPm2Installed()) {
+    throw new Error("[supertask] pm2 is not installed. Run `supertask install` first.");
+  }
+  const before = getRunningVersion();
+  const oldGatewayEntry = resolveGatewayEntry();
+  const currentVersion = target?.version ?? getPackageVersion();
+  const existing = pm2JsonList().find((item) => item.name === PROCESS_NAME);
+  if (existing) requirePm2(["delete", PROCESS_NAME], "pm2 delete old Gateway");
+  try {
+    pm2StartGateway(target?.gatewayEntry ?? oldGatewayEntry);
+    writeRunningVersion(currentVersion);
+    savePm2State();
+    return { before, after: currentVersion, restarted: true };
+  } catch (error) {
+    const failed = pm2JsonList().find((item) => item.name === PROCESS_NAME);
+    if (failed) requirePm2(["delete", PROCESS_NAME], "pm2 delete failed Gateway");
+    try {
+      pm2StartGateway(oldGatewayEntry);
+      if (before) writeRunningVersion(before);
+      savePm2State();
+    } catch (rollbackError) {
+      const original = error instanceof Error ? error.message : String(error);
+      const rollback = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+      throw new Error(`${original}; \u65E7 Gateway \u56DE\u6EDA\u4E5F\u5931\u8D25: ${rollback}`);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${message}; \u5DF2\u56DE\u6EDA\u5230\u65E7 Gateway`);
+  }
+}
+function ensureGateway() {
+  if (!isPm2Installed()) {
+    return { ok: false, reason: "pm2-not-installed" };
+  }
+  const currentVersion = getPackageVersion();
+  const processList = pm2JsonList();
+  const existing = processList.find((item) => item.name === PROCESS_NAME);
+  if (existing?.pm2_env?.status === "online" && typeof existing.pid === "number" && isGatewayReady(existing.pid) && getRunningVersion() === currentVersion) {
+    return { ok: true, action: "already-running" };
+  }
+  if (existing) requirePm2(["delete", PROCESS_NAME], "pm2 delete stale Gateway");
+  pm2StartGateway();
+  writeRunningVersion(currentVersion);
+  savePm2State();
+  return { ok: true, action: existing ? "restarted" : "started" };
+}
+var __dirname, PROCESS_NAME, GATEWAY_LOCK_STALE_MS;
+var init_pm2 = __esm({
+  "src/daemon/pm2.ts"() {
+    "use strict";
+    init_config();
+    __dirname = dirname2(fileURLToPath2(import.meta.url));
+    PROCESS_NAME = "supertask-gateway";
+    GATEWAY_LOCK_STALE_MS = 3e4;
   }
 });
 
 // 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)) {
@@ -19195,22 +19631,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}`
               )
             )
           )
@@ -19220,65 +19657,234 @@ 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;
+  }
+});
+
+// src/core/process-control.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { basename } from "path";
+function isSafePid(pid) {
+  return Number.isInteger(pid) && pid > 1 && pid !== process.pid;
+}
+function inspectUnixProcess(pid) {
+  const result = spawnSync2("ps", ["-o", "pgid=", "-o", "command=", "-p", String(pid)], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) return null;
+  const match2 = result.stdout.trim().match(/^(\d+)\s+(.+)$/s);
+  if (!match2) return null;
+  return { processGroupId: Number(match2[1]), command: match2[2] };
+}
+function commandMatches(command, expectedExecutable) {
+  const expectedName = basename(expectedExecutable).trim().toLowerCase();
+  if (!expectedName) return false;
+  return command.toLowerCase().includes(expectedName);
+}
+function signalSpawnedProcessTree(pid, signal) {
+  if (!isSafePid(pid)) return false;
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+      return true;
+    } catch {
+    }
+  }
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function signalRecordedProcessTree(pid, signal, expectedExecutable) {
+  if (!isSafePid(pid)) return false;
+  if (process.platform === "win32") {
+    const list = spawnSync2("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (list.status !== 0 || !commandMatches(list.stdout, expectedExecutable)) return false;
+    const args = ["/PID", String(pid), "/T"];
+    if (signal === "SIGKILL") args.push("/F");
+    return spawnSync2("taskkill", args, { stdio: "ignore" }).status === 0;
+  }
+  const info = inspectUnixProcess(pid);
+  if (!info || !commandMatches(info.command, expectedExecutable)) return false;
+  try {
+    if (info.processGroupId === pid) process.kill(-pid, signal);
+    else process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_process_control = __esm({
+  "src/core/process-control.ts"() {
+    "use strict";
+  }
+});
+
 // src/worker/index.ts
 import { spawn } from "child_process";
-var WorkerEngine;
+var DEFAULT_MAX_OUTPUT_CHARS, FORBIDDEN_AGENT, WorkerEngine;
 var init_worker = __esm({
   "src/worker/index.ts"() {
     "use strict";
     init_task_service();
     init_task_run_service();
+    init_health();
+    init_process_control();
+    DEFAULT_MAX_OUTPUT_CHARS = 64 * 1024;
+    FORBIDDEN_AGENT = "supertask-runner";
     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()];
@@ -19288,136 +19894,244 @@ var init_worker = __esm({
       }
       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);
+            if (this.stopped) {
+              await TaskRunService.fail(run.id, "Gateway shutdown before spawn");
+              await TaskService.resetRunningToPending([task.id]);
+              this.releaseBatch(task);
+              break;
             }
-            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 (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)
+        }));
+      }
     };
   }
 });
@@ -19429,15 +20143,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(),
@@ -19449,7 +20171,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({
@@ -19480,6 +20202,7 @@ var init_heartbeat = __esm({
     init_task_run_service();
     init_task_service();
     init_backoff();
+    init_process_control();
   }
 });
 
@@ -19524,6 +20247,7 @@ var init_watchdog = __esm({
     "use strict";
     init_heartbeat();
     init_cleanup();
+    init_health();
     Watchdog = class {
       constructor(cfg) {
         this.cfg = cfg;
@@ -19534,13 +20258,14 @@ var init_watchdog = __esm({
       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() {
@@ -19556,6 +20281,7 @@ var init_watchdog = __esm({
       }
       async runHeartbeatCheck() {
         if (this.stopped) return;
+        markGatewayActivity("watchdog");
         try {
           await checkHeartbeats(this.cfg.watchdog.heartbeatTimeoutMs);
         } catch (err) {
@@ -19588,7 +20314,7 @@ var init_watchdog = __esm({
 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),
@@ -19597,7 +20323,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
@@ -19611,13 +20338,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;
@@ -19630,7 +20361,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);
@@ -19664,6 +20395,7 @@ var init_scheduler = __esm({
     init_job_templates();
     init_db2();
     init_drizzle_orm();
+    init_health();
     Scheduler = class {
       constructor(cfg) {
         this.cfg = cfg;
@@ -19675,6 +20407,7 @@ var init_scheduler = __esm({
       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);
       }
@@ -19687,6 +20420,7 @@ var init_scheduler = __esm({
       }
       async tick() {
         if (this.stopped || this.ticking) return;
+        markGatewayActivity("scheduler");
         this.ticking = true;
         try {
           const dueTemplates = await getDueTemplates();
@@ -19741,13 +20475,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;
@@ -19862,8 +20596,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) {
@@ -19895,8 +20629,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;
       });
@@ -20415,10 +21149,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;
@@ -20437,10 +21171,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;
@@ -21316,8 +22050,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);
@@ -21364,7 +22098,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;
@@ -21372,7 +22106,7 @@ var init_node = __esm({
           if (pathErrorCheckOnly) {
             return;
           }
-          this.#index = index;
+          this.#index = index2;
           return;
         }
         const [token, ...restTokens] = tokens;
@@ -21422,7 +22156,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);
@@ -21454,7 +22188,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; ; ) {
@@ -21480,7 +22214,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() {
@@ -22074,8 +22808,19 @@ __export(web_exports, {
   dashboardApp: () => dashboardApp,
   default: () => web_default
 });
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, renameSync } from "fs";
+import { dirname as dirname3 } 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();
@@ -22113,17 +22858,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 (!existsSync4(configPath)) return {};
   try {
-    return JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync3(configPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(cfg) {
-  const dir = dirname2(CONFIG_PATH);
-  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+  const configPath = getConfigPath();
+  const dir = dirname3(configPath);
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+  const tempPath = `${configPath}.${process.pid}.tmp`;
+  writeFileSync2(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}
@@ -22162,11 +22911,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),
     }
   };
@@ -22197,7 +22946,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";
@@ -22209,7 +22958,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; }
@@ -22286,12 +23075,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);
@@ -22314,12 +23107,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>
@@ -22351,21 +23145,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` : "-";
@@ -22377,7 +23163,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>
@@ -22405,7 +23191,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;
@@ -22423,13 +23210,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>
@@ -22437,15 +23225,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">`;
@@ -22471,17 +23259,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 = existsSync4(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>
@@ -22506,19 +23295,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">
@@ -22547,7 +23331,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>
 
@@ -22559,46 +23343,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({
@@ -22610,7 +23409,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 });
@@ -22625,22 +23427,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;
@@ -22676,7 +23485,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");
@@ -22710,6 +23519,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()) {
@@ -22721,20 +23542,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(),
@@ -22743,6 +23565,7 @@ async function main() {
       url: `http://localhost:${cfg.dashboard.port}`
     }));
   }
+  markGatewayReady();
   console.log(JSON.stringify({
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     level: "info",
@@ -22756,10 +23579,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 }));
@@ -22769,6 +23592,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);
@@ -22796,6 +23620,7 @@ var init_gateway = __esm({
     init_db2();
     init_task_service();
     init_task_run_service();
+    init_health();
     STALE_THRESHOLD_MS = 3e4;
     if (import.meta.main) {
       main();
@@ -22803,247 +23628,87 @@ var init_gateway = __esm({
   }
 });
 
-// src/daemon/pm2.ts
-var pm2_exports = {};
-__export(pm2_exports, {
-  ensureGateway: () => ensureGateway,
-  install: () => install,
-  isGatewayRunning: () => isGatewayRunning,
-  uninstall: () => uninstall,
-  upgrade: () => upgrade
+// src/daemon/update.ts
+var update_exports = {};
+__export(update_exports, {
+  installLatestPlugin: () => installLatestPlugin,
+  resolveInstalledPlugin: () => resolveInstalledPlugin
 });
-import { execSync, spawnSync } from "child_process";
-import { join as join3, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-function getPackageVersion() {
-  try {
-    const pkgPath = join3(__dirname, "../package.json");
-    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
-    return pkg.version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-function getRunningVersion() {
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+function pluginAt(packageDir) {
+  const packageJson = join4(packageDir, "package.json");
+  const gatewayEntry = join4(packageDir, "dist/gateway/index.js");
+  if (!existsSync5(packageJson) || !existsSync5(gatewayEntry)) return null;
   try {
-    if (!existsSync4(VERSION_FILE)) return null;
-    return readFileSync3(VERSION_FILE, "utf-8").trim() || null;
+    const pkg = JSON.parse(readFileSync4(packageJson, "utf8"));
+    if (pkg.name !== PACKAGE_NAME || typeof pkg.version !== "string") return null;
+    return { packageDir, gatewayEntry, version: pkg.version };
   } catch {
     return null;
   }
 }
-function writeRunningVersion(version2) {
-  try {
-    writeFileSync2(VERSION_FILE, version2, "utf-8");
-  } catch {
-  }
-}
-function pm2Bin() {
-  return process.platform === "win32" ? "pm2.cmd" : "pm2";
-}
-function isPm2Installed() {
-  try {
-    const cmd = process.platform === "win32" ? "where pm2" : "which pm2";
-    execSync(cmd, { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function installPm2() {
-  console.log("[supertask] Installing pm2...");
-  try {
-    execSync("npm install -g pm2", { stdio: "inherit" });
-    return true;
-  } catch {
-    try {
-      execSync("bun install -g pm2", { stdio: "inherit" });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-function pm2Exec(args) {
-  const bin = pm2Bin();
-  try {
-    const result = spawnSync(bin, args, {
-      stdio: ["pipe", "pipe", "pipe"],
-      encoding: "utf-8",
-      shell: process.platform === "win32"
-    });
-    const output = (result.stdout ?? "") + (result.stderr ?? "");
-    return { ok: result.status === 0, output };
-  } catch (err) {
-    return { ok: false, output: err instanceof Error ? err.message : String(err) };
-  }
-}
-function pm2JsonList() {
-  const { ok, output } = pm2Exec(["jlist"]);
-  if (!ok) return [];
-  try {
-    return JSON.parse(output);
-  } catch {
-    return [];
-  }
-}
-function isGatewayRunning() {
-  const list = pm2JsonList();
-  const proc = list.find((p) => p.name === PROCESS_NAME);
-  if (!proc) return false;
-  return proc.pm2_env?.status === "online";
+function versionParts(version2) {
+  const match2 = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version2);
+  return match2 ? match2.slice(1).map(Number) : null;
 }
-function findBunPath() {
-  try {
-    const cmd = process.platform === "win32" ? "where bun" : "which bun";
-    return execSync(cmd, { stdio: "pipe" }).toString().trim().split("\n")[0];
-  } catch {
-    return process.execPath;
+function compareVersions(left, right) {
+  const a = versionParts(left);
+  const b = versionParts(right);
+  if (!a || !b) return left.localeCompare(right);
+  for (let index2 = 0; index2 < 3; index2 += 1) {
+    if (a[index2] !== b[index2]) return a[index2] - b[index2];
   }
+  return 0;
 }
-function pm2StartGateway(version2) {
-  const bunPath = findBunPath();
-  return pm2Exec([
-    "start",
-    bunPath,
-    "--name",
-    PROCESS_NAME,
-    "--interpreter",
-    "none",
-    "--restart-delay",
-    "5000",
-    "--max-restarts",
-    "30",
-    "--",
-    GATEWAY_ENTRY
-  ]);
+function cacheRoot() {
+  return process.env.SUPERTASK_OPENCODE_CACHE_DIR ?? join4(homedir4(), ".cache/opencode/packages");
 }
-function install() {
-  if (!isPm2Installed()) {
-    if (!installPm2()) {
-      throw new Error("[supertask] Failed to install pm2. Please install it manually: npm install -g pm2");
-    }
+function resolveInstalledPlugin() {
+  const override = process.env.SUPERTASK_PLUGIN_PACKAGE_DIR;
+  if (override) {
+    const plugin = pluginAt(override);
+    if (!plugin) throw new Error(`[supertask] \u5B89\u88C5\u5305\u65E0\u6548\u6216\u7F3A\u5C11 Gateway \u6784\u5EFA\u4EA7\u7269: ${override}`);
+    return plugin;
   }
-  console.log("[supertask] pm2 ready");
-  const list = pm2JsonList();
-  const existing = list.find((p) => p.name === PROCESS_NAME);
-  if (existing) {
-    console.log("[supertask] Gateway process already registered, reloading...");
-    const { ok } = pm2Exec(["reload", PROCESS_NAME]);
-    if (!ok) {
-      console.error("[supertask] pm2 reload failed, trying restart...");
-      pm2Exec(["restart", PROCESS_NAME]);
-    }
-  } else {
-    console.log("[supertask] Starting Gateway with pm2...");
-    const version2 = getPackageVersion();
-    const { ok, output } = pm2StartGateway(version2);
-    if (!ok) {
-      throw new Error(`[supertask] pm2 start failed: ${output}`);
-    }
-    writeRunningVersion(version2);
-  }
-  pm2Exec(["save"]);
-  console.log("[supertask] Configuring startup...");
-  const { ok: startupOk, output: startupOutput } = pm2Exec(["startup"]);
-  if (!startupOk) {
-    if (startupOutput.includes("sudo") || startupOutput.includes("run as root")) {
-      console.log("[supertask] pm2 startup requires elevated permissions.");
-      console.log("[supertask] Run the command shown above, or manually execute:");
-      console.log(`  pm2 startup`);
-      console.log(`  pm2 save`);
-    } else if (process.platform === "win32") {
-      console.log("[supertask] On Windows, use pm2-installer for startup:");
-      console.log("  npm install -g pm2-windows-startup");
-      console.log("  pm2-startup install");
-    }
+  const root = cacheRoot();
+  const packageDirs = existsSync5(root) ? readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && (entry.name === PACKAGE_NAME || entry.name.startsWith(`${PACKAGE_NAME}@`))).map((entry) => join4(root, entry.name, "node_modules", PACKAGE_NAME)) : [];
+  const installed = packageDirs.map(pluginAt).filter((plugin) => plugin !== null).sort((left, right) => compareVersions(right.version, left.version));
+  if (!installed[0]) {
+    throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u7F13\u5B58\u4E2D\u627E\u4E0D\u5230\u53EF\u8FD0\u884C\u7684 ${PACKAGE_NAME}`);
   }
-  console.log("\n[supertask] Gateway installed and running!");
-  console.log("[supertask] Manage with: pm2 status / pm2 logs supertask-gateway");
+  return installed[0];
 }
-function uninstall() {
-  console.log("[supertask] Stopping Gateway...");
-  pm2Exec(["stop", PROCESS_NAME]);
-  console.log("[supertask] Removing Gateway from pm2...");
-  pm2Exec(["delete", PROCESS_NAME]);
-  pm2Exec(["save"]);
-  console.log("\n[supertask] Gateway removed from pm2.");
-  console.log("[supertask] Note: pm2 startup config was not removed (you may have other pm2 processes).");
-  console.log("[supertask] To fully remove pm2 startup: pm2 unstartup");
+function opencodeBin() {
+  return process.env.SUPERTASK_OPENCODE_BIN ?? "opencode";
 }
-function upgrade() {
-  const before = getRunningVersion();
-  const currentVersion = getPackageVersion();
-  const list = pm2JsonList();
-  const proc = list.find((p) => p.name === PROCESS_NAME);
-  if (proc) {
-    console.log(`[supertask] Stopping Gateway (version ${before ?? "unknown"})...`);
-    pm2Exec(["delete", PROCESS_NAME]);
-  }
-  console.log(`[supertask] Starting Gateway (version ${currentVersion})...`);
-  const { ok } = pm2StartGateway(currentVersion);
-  if (ok) {
-    writeRunningVersion(currentVersion);
-    pm2Exec(["save"]);
-    console.log(`[supertask] Gateway upgraded: ${before ?? "unknown"} \u2192 ${currentVersion}`);
-  } else {
-    throw new Error(`[supertask] Failed to start Gateway after upgrade`);
-  }
-  return { before, after: currentVersion, restarted: true };
-}
-function ensureGateway() {
-  const currentVersion = getPackageVersion();
-  try {
-    const list = pm2JsonList();
-    const proc = list.find((p) => p.name === PROCESS_NAME);
-    if (proc && proc.pm2_env?.status === "online") {
-      const runningVersion = getRunningVersion();
-      if (runningVersion === currentVersion) {
-        return;
-      }
-      console.log(`[supertask] Version changed: ${runningVersion ?? "unknown"} \u2192 ${currentVersion}, reloading Gateway...`);
-      pm2Exec(["delete", PROCESS_NAME]);
-      const { ok } = pm2StartGateway(currentVersion);
-      if (ok) writeRunningVersion(currentVersion);
-      pm2Exec(["save"]);
-      return;
-    }
-  } catch {
-  }
-  if (!isPm2Installed()) {
-    console.log("[supertask] Installing pm2 for Gateway process management...");
-    try {
-      execSync("npm install -g pm2", { stdio: "pipe" });
-    } catch {
-      try {
-        execSync("bun install -g pm2", { stdio: "pipe" });
-      } catch {
-        console.warn("[supertask] Could not install pm2. Gateway will not auto-start. Run `supertask install` manually.");
-        return;
-      }
-    }
+function installLatestPlugin() {
+  const result = spawnSync3(opencodeBin(), [
+    "plugin",
+    `${PACKAGE_NAME}@latest`,
+    "--global",
+    "--force"
+  ], {
+    encoding: "utf8",
+    env: process.env,
+    timeout: 12e4
+  });
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  if (result.error) {
+    throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u66F4\u65B0\u5931\u8D25: ${result.error.message}`);
   }
-  const pm2List = pm2JsonList();
-  const existing = pm2List.find((p) => p.name === PROCESS_NAME);
-  if (existing) {
-    pm2Exec(["restart", PROCESS_NAME]);
-  } else {
-    const version2 = getPackageVersion();
-    const { ok } = pm2StartGateway(version2);
-    if (ok) writeRunningVersion(version2);
+  if (result.status !== 0) {
+    throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u66F4\u65B0\u5931\u8D25: ${output || `\u9000\u51FA\u7801 ${result.status}`}`);
   }
-  pm2Exec(["save"]);
+  return resolveInstalledPlugin();
 }
-var __dirname, GATEWAY_ENTRY, PROCESS_NAME, VERSION_FILE;
-var init_pm2 = __esm({
-  "src/daemon/pm2.ts"() {
+var PACKAGE_NAME;
+var init_update2 = __esm({
+  "src/daemon/update.ts"() {
     "use strict";
-    __dirname = dirname3(fileURLToPath2(import.meta.url));
-    GATEWAY_ENTRY = join3(__dirname, "../gateway/index.js");
-    PROCESS_NAME = "supertask-gateway";
-    VERSION_FILE = join3(homedir3(), ".local/share/opencode/supertask-gateway-version");
+    PACKAGE_NAME = "opencode-supertask";
   }
 });
 
@@ -23099,6 +23764,7 @@ function parseDuration(input) {
 }
 
 // src/cli/index.ts
+init_pm2();
 async function withDb(fn) {
   try {
     return await fn();
@@ -23111,9 +23777,14 @@ async function withDb(fn) {
   }
 }
 var program2 = new Command();
-program2.name("supertask").description("\u901A\u7528\u4EFB\u52A1\u7BA1\u7406\u7CFB\u7EDF - AI Agent \u4EFB\u52A1\u8C03\u5EA6\u5668").version("0.1.0");
-program2.command("add").description("\u521B\u5EFA\u65B0\u4EFB\u52A1").requiredOption("-n, --name <name>", "\u4EFB\u52A1\u540D\u79F0").requiredOption("-a, --agent <agent>", "\u4E3B Agent \u540D\u79F0").requiredOption("-p, --prompt <prompt>", "\u63D0\u793A\u8BCD").option("-m, --model <model>", "\u6A21\u578B").option("-c, --category <category>", "\u5206\u7C7B", "general").option("-i, --importance <number>", "\u91CD\u8981\u7A0B\u5EA6 (1-5)", "3").option("-u, --urgency <number>", "\u7D27\u6025\u7A0B\u5EA6 (1-5)", "3").option("-b, --batch <batchId>", "\u6279\u6B21 ID").option("-d, --depends <taskId>", "\u4F9D\u8D56\u7684\u4EFB\u52A1 ID").option("-w, --cwd <path>", "(\u5DF2\u5E9F\u5F03) \u5DE5\u4F5C\u76EE\u5F55\u3002\u7CFB\u7EDF\u4F1A\u81EA\u52A8\u8BB0\u5F55\u63D0\u4EA4\u4EFB\u52A1\u65F6\u7684\u5F53\u524D\u76EE\u5F55").action(async (options) => withDb(async () => {
+program2.name("supertask").description("\u901A\u7528\u4EFB\u52A1\u7BA1\u7406\u7CFB\u7EDF - AI Agent \u4EFB\u52A1\u8C03\u5EA6\u5668").version(getPackageVersion());
+program2.command("add").description("\u521B\u5EFA\u65B0\u4EFB\u52A1").requiredOption("-n, --name <name>", "\u4EFB\u52A1\u540D\u79F0").requiredOption("-a, --agent <agent>", "\u4E3B Agent \u540D\u79F0").requiredOption("-p, --prompt <prompt>", "\u63D0\u793A\u8BCD").option("-m, --model <model>", "\u6A21\u578B").option("-c, --category <category>", "\u5206\u7C7B", "general").option("-i, --importance <number>", "\u91CD\u8981\u7A0B\u5EA6 (1-5)", "3").option("-u, --urgency <number>", "\u7D27\u6025\u7A0B\u5EA6 (1-5)", "3").option("-b, --batch <batchId>", "\u6279\u6B21 ID").option("-d, --depends <taskId>", "\u4F9D\u8D56\u7684\u4EFB\u52A1 ID").option("--max-retries <number>", "\u9996\u6B21\u6267\u884C\u4E4B\u5916\u5141\u8BB8\u7684\u91CD\u8BD5\u6B21\u6570", "3").option("--retry-backoff <duration>", "\u91CD\u8BD5\u9000\u907F\u57FA\u7840\u95F4\u9694\uFF0C\u5982 30s / 5min", "30s").option("--timeout <duration>", "\u4EFB\u52A1\u786C\u8D85\u65F6\uFF0C\u5982 30min / 2h").option("-w, --cwd <path>", "(\u5DF2\u5E9F\u5F03) \u5DE5\u4F5C\u76EE\u5F55\u3002\u7CFB\u7EDF\u4F1A\u81EA\u52A8\u8BB0\u5F55\u63D0\u4EA4\u4EFB\u52A1\u65F6\u7684\u5F53\u524D\u76EE\u5F55").action(async (options) => withDb(async () => {
   const submitCwd = process.cwd();
+  const retryBackoffMs = parseDuration(options.retryBackoff);
+  const timeoutMs = options.timeout ? parseDuration(options.timeout) : null;
+  if (retryBackoffMs === null || options.timeout && timeoutMs === null) {
+    throw new Error("retry-backoff \u6216 timeout \u683C\u5F0F\u65E0\u6548");
+  }
   const task = await TaskService.add({
     name: options.name,
     agent: options.agent,
@@ -23124,7 +23795,10 @@ program2.command("add").description("\u521B\u5EFA\u65B0\u4EFB\u52A1").requiredOp
     urgency: parseInt(options.urgency),
     batchId: options.batch,
     dependsOn: options.depends ? parseInt(options.depends) : void 0,
-    cwd: submitCwd
+    cwd: submitCwd,
+    maxRetries: parseInt(options.maxRetries),
+    retryBackoffMs,
+    timeoutMs
   });
   console.log(JSON.stringify({ id: task.id, status: "created" }, null, 2));
 }));
@@ -23143,7 +23817,7 @@ program2.command("next").description("\u83B7\u53D6\u4E0B\u4E00\u4E2A\u5F85\u6267
       urgency: task.urgency
     }, null, 2));
   } else {
-    console.log(JSON.stringify({ id: null, message: "No pending tasks" }));
+    console.log(JSON.stringify({ id: null, message: "No executable tasks" }));
   }
 }));
 program2.command("start").description("\u5F00\u59CB\u6267\u884C\u4EFB\u52A1\uFF08\u6807\u8BB0\u4E3A running\uFF09").requiredOption("--id <id>", "\u4EFB\u52A1 ID").action(async (options) => withDb(async () => {
@@ -23231,9 +23905,14 @@ program2.command("delete").description("\u5220\u9664\u4EFB\u52A1").requiredOptio
   console.log(JSON.stringify({ deleted, id: parseInt(options.id) }));
 }));
 program2.command("template").description("\u7BA1\u7406\u4EFB\u52A1\u8C03\u5EA6\u6A21\u677F").addCommand(
-  new Command("add").description("\u521B\u5EFA\u8C03\u5EA6\u6A21\u677F").requiredOption("-n, --name <name>", "\u6A21\u677F\u540D\u79F0").requiredOption("-a, --agent <agent>", "Agent \u540D\u79F0").requiredOption("-p, --prompt <prompt>", "\u63D0\u793A\u8BCD").requiredOption("-t, --type <type>", "\u8C03\u5EA6\u7C7B\u578B\uFF1Acron/delayed/recurring").option("--cron <expr>", "cron \u8868\u8FBE\u5F0F\uFF08cron \u7C7B\u578B\u5FC5\u586B\uFF09").option("--delay <duration>", "\u5EF6\u8FDF\u65F6\u95F4\uFF08delayed \u7C7B\u578B\u5FC5\u586B\uFF09\uFF0C\u5982 30s / 5min / 1h / 2d").option("--interval <duration>", "\u5FAA\u73AF\u95F4\u9694\uFF08recurring \u7C7B\u578B\u5FC5\u586B\uFF09\uFF0C\u5982 1h / 30min / 5s").option("-m, --model <model>", "\u6A21\u578B").option("-c, --category <category>", "\u5206\u7C7B", "general").option("-i, --importance <number>", "\u91CD\u8981\u7A0B\u5EA6 1-5", "3").option("-u, --urgency <number>", "\u7D27\u6025\u7A0B\u5EA6 1-5", "3").option("--max-instances <number>", "\u6700\u5927\u5E76\u53D1\u5B9E\u4F8B\u6570", "1").option("--max-retries <number>", "\u6700\u5927\u91CD\u8BD5\u6B21\u6570", "3").option("--retry-backoff <ms>", "\u9000\u907F\u57FA\u7840\u95F4\u9694 ms", "30000").action(async (options) => withDb(async () => {
+  new Command("add").description("\u521B\u5EFA\u8C03\u5EA6\u6A21\u677F").requiredOption("-n, --name <name>", "\u6A21\u677F\u540D\u79F0").requiredOption("-a, --agent <agent>", "Agent \u540D\u79F0").requiredOption("-p, --prompt <prompt>", "\u63D0\u793A\u8BCD").requiredOption("-t, --type <type>", "\u8C03\u5EA6\u7C7B\u578B\uFF1Acron/delayed/recurring").option("--cron <expr>", "cron \u8868\u8FBE\u5F0F\uFF08cron \u7C7B\u578B\u5FC5\u586B\uFF09").option("--delay <duration>", "\u5EF6\u8FDF\u65F6\u95F4\uFF08delayed \u7C7B\u578B\u5FC5\u586B\uFF09\uFF0C\u5982 30s / 5min / 1h / 2d").option("--interval <duration>", "\u5FAA\u73AF\u95F4\u9694\uFF08recurring \u7C7B\u578B\u5FC5\u586B\uFF09\uFF0C\u5982 1h / 30min / 5s").option("-m, --model <model>", "\u6A21\u578B").option("-c, --category <category>", "\u5206\u7C7B", "general").option("-i, --importance <number>", "\u91CD\u8981\u7A0B\u5EA6 1-5", "3").option("-u, --urgency <number>", "\u7D27\u6025\u7A0B\u5EA6 1-5", "3").option("-b, --batch <batchId>", "\u6A21\u677F\u751F\u6210\u4EFB\u52A1\u7684\u6279\u6B21 ID").option("--max-instances <number>", "\u6700\u5927\u5E76\u53D1\u5B9E\u4F8B\u6570", "1").option("--max-retries <number>", "\u6700\u5927\u91CD\u8BD5\u6B21\u6570", "3").option("--retry-backoff <duration>", "\u9000\u907F\u57FA\u7840\u95F4\u9694\uFF0C\u5982 30s / 5min", "30s").option("--timeout <duration>", "\u6BCF\u6B21\u4EFB\u52A1\u786C\u8D85\u65F6\uFF0C\u5982 30min / 2h").action(async (options) => withDb(async () => {
     let intervalMs = null;
     let runAt = null;
+    const retryBackoffMs = parseDuration(options.retryBackoff);
+    const timeoutMs = options.timeout ? parseDuration(options.timeout) : null;
+    if (retryBackoffMs === null || options.timeout && timeoutMs === null) {
+      throw new Error("retry-backoff \u6216 timeout \u683C\u5F0F\u65E0\u6548");
+    }
     if (options.interval) {
       intervalMs = parseDuration(options.interval);
       if (intervalMs === null) {
@@ -23257,13 +23936,16 @@ program2.command("template").description("\u7BA1\u7406\u4EFB\u52A1\u8C03\u5EA6\u
       category: options.category,
       importance: parseInt(options.importance),
       urgency: parseInt(options.urgency),
+      cwd: process.cwd(),
+      batchId: options.batch,
       scheduleType: options.type,
       cronExpr: options.cron,
       intervalMs,
       runAt,
       maxInstances: parseInt(options.maxInstances),
       maxRetries: parseInt(options.maxRetries),
-      retryBackoffMs: parseInt(options.retryBackoff)
+      retryBackoffMs,
+      timeoutMs
     });
     console.log(JSON.stringify({ id: tmpl.id, status: "created", nextRunAt: tmpl.nextRunAt }, null, 2));
   }))
@@ -23299,36 +23981,29 @@ program2.command("template").description("\u7BA1\u7406\u4EFB\u52A1\u8C03\u5EA6\u
   }))
 );
 program2.command("init").description("Initialize SuperTask (create config + run migrations)").action(async () => withDb(async () => {
-  const { existsSync: existsSync5, mkdirSync: mkdirSync3, writeFileSync: writeFileSync3 } = await import("fs");
-  const { homedir: homedir4 } = await import("os");
-  const { join: join4, dirname: dirname4 } = await import("path");
-  const { CONFIG_PATH: CONFIG_PATH2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  if (!existsSync5(CONFIG_PATH2)) {
-    const dir = dirname4(CONFIG_PATH2);
-    if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
-    writeFileSync3(CONFIG_PATH2, JSON.stringify({
+  const { existsSync: existsSync6, mkdirSync: mkdirSync4, writeFileSync: writeFileSync3 } = await import("fs");
+  const { dirname: dirname4 } = await import("path");
+  const { getConfigPath: getConfigPath2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const configPath = getConfigPath2();
+  if (!existsSync6(configPath)) {
+    const dir = dirname4(configPath);
+    if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
+    writeFileSync3(configPath, JSON.stringify({
+      configVersion: 2,
       worker: { maxConcurrency: 2 },
       scheduler: { enabled: true }
     }, null, 2) + "\n");
-    console.log(JSON.stringify({ created: CONFIG_PATH2 }));
+    console.log(JSON.stringify({ created: configPath }));
   } else {
-    console.log(JSON.stringify({ exists: CONFIG_PATH2 }));
+    console.log(JSON.stringify({ exists: configPath }));
   }
   const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
-  const { migrate: migrate2 } = await Promise.resolve().then(() => (init_migrator2(), migrator_exports));
-  const { join: pJoin, dirname: pDirname } = await import("path");
-  const { fileURLToPath: fileURLToPath3 } = await import("url");
-  const __dirname2 = pDirname(fileURLToPath3(import.meta.url));
-  migrate2(getDb2(), { migrationsFolder: pJoin(__dirname2, "../../drizzle") });
+  getDb2();
   console.log(JSON.stringify({ migrated: true }));
 }));
 program2.command("migrate").description("Run database migrations").action(async () => withDb(async () => {
   const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
-  const { migrate: migrate2 } = await Promise.resolve().then(() => (init_migrator2(), migrator_exports));
-  const { join: join4, dirname: dirname4 } = await import("path");
-  const { fileURLToPath: fileURLToPath3 } = await import("url");
-  const __dirname2 = dirname4(fileURLToPath3(import.meta.url));
-  migrate2(getDb2(), { migrationsFolder: join4(__dirname2, "../../drizzle") });
+  getDb2();
   console.log(JSON.stringify({ migrated: true }));
 }));
 program2.command("gateway").description("Start the Gateway process (foreground)").action(async () => {
@@ -23370,26 +24045,20 @@ program2.command("uninstall").description("Stop and remove Gateway pm2 service")
     process.exit(1);
   }
 });
-program2.command("upgrade").description("Update npm package and restart Gateway").action(async () => {
-  const { execSync: execSync2 } = await import("child_process");
-  const { homedir: homedir4 } = await import("os");
-  const { join: join4 } = await import("path");
-  const configDir = join4(homedir4(), ".config/opencode");
+program2.command("upgrade").description("Update OpenCode plugin cache and restart Gateway").action(async () => {
   console.log("Updating opencode-supertask...");
+  let installed;
   try {
-    execSync2("npm install opencode-supertask@latest", {
-      cwd: configDir,
-      stdio: "inherit",
-      timeout: 6e4
-    });
+    const { installLatestPlugin: installLatestPlugin2 } = await Promise.resolve().then(() => (init_update2(), update_exports));
+    installed = installLatestPlugin2();
   } catch (err) {
-    console.error("npm install failed:", err instanceof Error ? err.message : String(err));
-    console.error("Try manually: cd ~/.config/opencode && npm install opencode-supertask@latest");
+    console.error(err instanceof Error ? err.message : String(err));
+    console.error("Try manually: opencode plugin opencode-supertask@latest --global --force");
     process.exit(1);
   }
   try {
     const { upgrade: pm2Upgrade } = await Promise.resolve().then(() => (init_pm2(), pm2_exports));
-    const result = pm2Upgrade();
+    const result = pm2Upgrade(installed);
     console.log(`
 SuperTask upgraded: ${result.before ?? "unknown"} \u2192 ${result.after}`);
     console.log("Gateway restarted. Please restart opencode to load the new plugin.");