opencode-supertask 0.1.20 → 0.1.22

package/dist/plugin/supertask.js

@@ -234,7 +234,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}`);
         }
@@ -8079,11 +8079,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");
@@ -8975,9 +8975,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;
@@ -9100,8 +9100,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static parseFileSync(filePath) {
-        const { readFileSync: readFileSync2 } = __require("fs");
-        const data = readFileSync2(filePath, "utf8");
+        const { readFileSync: readFileSync4 } = __require("fs");
+        const data = readFileSync4(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -11968,11 +11968,11 @@ var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
     return payload;
   };
 });
-function handleArrayResult(result, final, index) {
+function handleArrayResult(result, final, index2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+    final.issues.push(...prefixIssues(index2, result.issues));
   }
-  final.value[index] = result.value;
+  final.value[index2] = result.value;
 }
 var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   $ZodType.init(inst, def);
@@ -12367,14 +12367,14 @@ function mergeValues(a, b) {
       return { valid: false, mergeErrorPath: [] };
     }
     const newArray = [];
-    for (let index = 0; index < a.length; index++) {
-      const itemA = a[index];
-      const itemB = b[index];
+    for (let index2 = 0; index2 < a.length; index2++) {
+      const itemA = a[index2];
+      const itemB = b[index2];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [index2, ...sharedValue.mergeErrorPath]
         };
       }
       newArray.push(sharedValue.data);
@@ -12466,11 +12466,11 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     return payload;
   };
 });
-function handleTupleResult(result, final, index) {
+function handleTupleResult(result, final, index2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+    final.issues.push(...prefixIssues(index2, result.issues));
   }
-  final.value[index] = result.value;
+  final.value[index2] = result.value;
 }
 var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
@@ -22653,7 +22653,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join3(chunks, separator) {
+  function join5(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -22663,7 +22663,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join3;
+  sql2.join = join5;
   function identifier(value) {
     return new Name(value);
   }
@@ -22822,8 +22822,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;
     }
   }
@@ -24389,8 +24389,8 @@ var SQLiteDialect = class {
     }
     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;
@@ -24407,7 +24407,7 @@ var SQLiteDialect = class {
             sql`${sql.raw(joinMeta.joinType)} join ${table} on ${joinMeta.on}`
           );
         }
-        if (index < joins.length - 1) {
+        if (index2 < joins.length - 1) {
           joinsArray.push(sql` `);
         }
       }
@@ -24420,9 +24420,9 @@ var SQLiteDialect = class {
   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`, `);
         }
       }
@@ -24471,9 +24471,9 @@ var SQLiteDialect = class {
     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`, `);
         }
       }
@@ -24959,7 +24959,7 @@ var SQLiteSelectQueryBuilderBase = class extends TypedQueryBuilder {
     return (table, on) => {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins?.some((join3) => join3.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join5) => join5.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -25772,7 +25772,7 @@ var SQLiteUpdateBase = class extends QueryPromise {
   createJoin(joinType) {
     return (table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join3) => join3.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join5) => join5.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
@@ -26401,6 +26401,52 @@ var BaseSQLiteDatabase = class {
   }
 };
 
+// node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+  constructor(name, unique) {
+    this.name = name;
+    this.unique = unique;
+  }
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+};
+var IndexBuilder = class {
+  static [entityKind] = "SQLiteIndexBuilder";
+  /** @internal */
+  config;
+  constructor(name, columns, unique) {
+    this.config = {
+      name,
+      columns,
+      unique,
+      where: void 0
+    };
+  }
+  /**
+   * Condition for partial index.
+   */
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
+  }
+};
+var Index = class {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  constructor(config2, table) {
+    this.config = { ...config2, table };
+  }
+};
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
+
 // node_modules/drizzle-orm/sqlite-core/session.js
 var ExecuteResultSync = class extends QueryPromise {
   constructor(resultCb) {
@@ -26747,12 +26793,17 @@ var tasks = sqliteTable("tasks", {
   resultLog: text("result_log"),
   retryCount: integer2("retry_count").default(0),
   maxRetries: integer2("max_retries").default(3),
+  retryBackoffMs: integer2("retry_backoff_ms").default(3e4),
   // Gateway 扩展字段（毫秒）
   retryAfter: integer2("retry_after"),
   timeoutMs: integer2("timeout_ms"),
   templateId: integer2("template_id"),
   scheduledAt: integer2("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)
+]);
 var TASK_CATEGORIES = [
   "translate",
   "generate",
@@ -26762,7 +26813,7 @@ var TASK_CATEGORIES = [
 ];
 var taskRuns = sqliteTable("task_runs", {
   id: integer2("id").primaryKey({ autoIncrement: true }),
-  taskId: integer2("task_id").notNull().references(() => tasks.id),
+  taskId: integer2("task_id").notNull().references(() => tasks.id, { onDelete: "cascade" }),
   sessionId: text("session_id"),
   model: text("model"),
   status: text("status").default("running"),
@@ -26775,7 +26826,10 @@ var taskRuns = sqliteTable("task_runs", {
   heartbeatAt: integer2("heartbeat_at"),
   workerPid: integer2("worker_pid"),
   childPid: integer2("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)
+]);
 var taskTemplates = sqliteTable("task_templates", {
   id: integer2("id").primaryKey({ autoIncrement: true }),
   name: text("name").notNull(),
@@ -26786,6 +26840,7 @@ var taskTemplates = sqliteTable("task_templates", {
   category: text("category").default("general"),
   importance: integer2("importance").default(3),
   urgency: integer2("urgency").default(3),
+  batchId: text("batch_id"),
   scheduleType: text("schedule_type").notNull(),
   cronExpr: text("cron_expr"),
   intervalMs: integer2("interval_ms"),
@@ -26793,12 +26848,15 @@ var taskTemplates = sqliteTable("task_templates", {
   maxInstances: integer2("max_instances").default(1),
   maxRetries: integer2("max_retries").default(3),
   retryBackoffMs: integer2("retry_backoff_ms").default(3e4),
+  timeoutMs: integer2("timeout_ms"),
   lastRunAt: integer2("last_run_at"),
   nextRunAt: integer2("next_run_at"),
   enabled: integer2("enabled", { mode: "boolean" }).default(true),
   createdAt: integer2("created_at").default(0),
   updatedAt: integer2("updated_at").default(0)
-});
+}, (table) => [
+  index("task_templates_due_idx").on(table.enabled, table.nextRunAt, table.id)
+]);
 
 // src/core/db/index.ts
 import { existsSync, mkdirSync } from "fs";
@@ -26835,16 +26893,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}`);
     }
@@ -26883,7 +26955,7 @@ function computeBackoff(retryCount, baseMs = 3e4, maxMs = MAX_BACKOFF_MS) {
 }
 
 // src/core/services/task.service.ts
-var { tasks: tasks2 } = schema_exports;
+var { tasks: tasks2, taskRuns: taskRuns2 } = schema_exports;
 var TaskService = class {
   static buildScopeWhere(scope) {
     const conditions = [];
@@ -26893,9 +26965,27 @@ var TaskService = class {
     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();
@@ -26918,7 +27008,7 @@ var TaskService = class {
       ),
       and(
         eq(tasks2.status, "failed"),
-        sql`${tasks2.retryCount} < ${tasks2.maxRetries}`,
+        sql`${tasks2.retryCount} <= ${tasks2.maxRetries}`,
         retryAfterFilter
       )
     );
@@ -26932,7 +27022,8 @@ var TaskService = class {
     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) {
@@ -26953,7 +27044,7 @@ var TaskService = class {
         eq(tasks2.status, "pending"),
         and(
           eq(tasks2.status, "failed"),
-          sql`${tasks2.retryCount} < ${tasks2.maxRetries}`
+          sql`${tasks2.retryCount} <= ${tasks2.maxRetries}`
         )
       ),
       ...this.buildScopeWhere(scope)
@@ -26966,7 +27057,11 @@ var TaskService = class {
     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(),
@@ -26977,17 +27072,24 @@ var TaskService = class {
   }
   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;
   }
@@ -27019,9 +27121,38 @@ var TaskService = class {
     ).returning();
     return result.length;
   }
+  static async resetOrphanRunningToPending() {
+    const result = await db.update(tasks2).set({
+      status: "pending",
+      startedAt: null,
+      finishedAt: null
+    }).where(
+      and(
+        eq(tasks2.status, "running"),
+        sql`NOT EXISTS (
+                        SELECT 1 FROM ${taskRuns2}
+                        WHERE ${taskRuns2.taskId} = ${tasks2.id}
+                          AND ${taskRuns2.status} = 'running'
+                    )`
+      )
+    ).returning();
+    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 = {}) {
@@ -27033,7 +27164,8 @@ var TaskService = class {
       status: "pending",
       startedAt: null,
       finishedAt: null,
-      retryAfter: null
+      retryAfter: null,
+      retryCount: 0
     }).where(and(...conditions)).returning();
     return result[0] || null;
   }
@@ -27047,7 +27179,8 @@ var TaskService = class {
       status: "pending",
       startedAt: null,
       finishedAt: null,
-      retryAfter: null
+      retryAfter: null,
+      retryCount: 0
     }).where(and(...conditions)).returning();
     return result.length;
   }
@@ -27115,6 +27248,9 @@ var TaskService = class {
   }
   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;
   }
@@ -27156,6 +27292,7 @@ function isValidCronExpr(expr) {
 var { taskTemplates: taskTemplates2 } = schema_exports;
 var TaskTemplateService = class {
   static async create(data) {
+    this.validate(data);
     const now = Date.now();
     const result = await db.insert(taskTemplates2).values({ ...data, createdAt: now, updatedAt: now }).returning();
     const tmpl = result[0];
@@ -27171,8 +27308,38 @@ var TaskTemplateService = class {
     }
     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));
@@ -27241,85 +27408,261 @@ function parseDuration(input) {
 
 // src/daemon/pm2.ts
 import { execSync, spawnSync } from "child_process";
-import { join as join2, dirname as dirname2 } from "path";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, isAbsolute, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
+import { Database as Database3 } from "bun:sqlite";
+
+// src/gateway/config.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
 import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var DEFAULT_CONFIG = {
+  configVersion: 2,
+  worker: {
+    maxConcurrency: 2,
+    pollIntervalMs: 1e3,
+    heartbeatIntervalMs: 3e4,
+    taskTimeoutMs: 18e5,
+    shutdownGracePeriodMs: 3e4
+  },
+  scheduler: {
+    enabled: true,
+    checkIntervalMs: 1e3
+  },
+  watchdog: {
+    heartbeatTimeoutMs: 6e5,
+    checkIntervalMs: 6e4,
+    cleanupIntervalMs: 864e5,
+    retentionDays: 30
+  },
+  dashboard: {
+    enabled: true,
+    port: 4680
+  }
+};
+var DEFAULT_CONFIG_PATH = join2(homedir2(), ".config/opencode/supertask.json");
+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 value;
+}
+function integerAt(source, key, fallback, min, max, path) {
+  const value = source[key];
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
+    throw new Error(`${path}.${key} \u5FC5\u987B\u662F ${min} \u5230 ${max} \u4E4B\u95F4\u7684\u6574\u6570`);
+  }
+  return value;
+}
+function booleanAt(source, key, fallback, path) {
+  const value = source[key];
+  if (value === void 0) return fallback;
+  if (typeof value !== "boolean") throw new Error(`${path}.${key} \u5FC5\u987B\u662F\u5E03\u5C14\u503C`);
+  return value;
+}
+function validateConfig(input) {
+  const root = objectAt(input, "config");
+  const version3 = root.configVersion ?? 1;
+  if (version3 !== 1 && version3 !== 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 (version3 === 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 {
+    return validateConfig(JSON.parse(readFileSync(path, "utf-8")));
+  } catch (error45) {
+    const message = error45 instanceof Error ? error45.message : String(error45);
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u914D\u7F6E ${path}: ${message}`);
+  }
+}
+
+// src/daemon/pm2.ts
 var __dirname = dirname2(fileURLToPath2(import.meta.url));
-var GATEWAY_ENTRY = join2(__dirname, "../gateway/index.js");
 var PROCESS_NAME = "supertask-gateway";
-var VERSION_FILE = join2(homedir2(), ".local/share/opencode/supertask-gateway-version");
+var GATEWAY_LOCK_STALE_MS = 3e4;
 function getPackageVersion() {
+  const envVersion = process.env.npm_package_version;
+  if (envVersion) return envVersion;
   try {
-    const pkgPath = join2(__dirname, "../package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-    return pkg.version || "0.0.0";
+    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 {
-    if (!existsSync2(VERSION_FILE)) return null;
-    return readFileSync(VERSION_FILE, "utf-8").trim() || null;
+    const path = versionFile();
+    if (!existsSync3(path)) return null;
+    return readFileSync2(path, "utf-8").trim() || null;
   } catch {
     return null;
   }
 }
 function writeRunningVersion(version3) {
-  try {
-    writeFileSync(VERSION_FILE, version3, "utf-8");
-  } catch {
-  }
+  const path = versionFile();
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync(path, version3, "utf-8");
 }
 function pm2Bin() {
-  return process.platform === "win32" ? "pm2.cmd" : "pm2";
+  return process.env.SUPERTASK_PM2_BIN ?? (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;
-  }
+  const result = spawnSync(pm2Bin(), ["--version"], {
+    stdio: "ignore",
+    shell: process.platform === "win32"
+  });
+  return result.status === 0;
 }
 function pm2Exec(args) {
-  const bin = pm2Bin();
+  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 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) };
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed)) throw new Error("result is not an array");
+    return parsed;
+  } catch (error45) {
+    const message = error45 instanceof Error ? error45.message : String(error45);
+    throw new Error(`[supertask] Invalid pm2 jlist output: ${message}`);
   }
 }
-function pm2JsonList() {
-  const { ok, output } = pm2Exec(["jlist"]);
-  if (!ok) return [];
+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 {
-    return JSON.parse(output);
+    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 [];
+    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 cmd = process.platform === "win32" ? "where bun" : "which bun";
-    return execSync(cmd, { stdio: "pipe" }).toString().trim().split("\n")[0];
+    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(version3) {
-  const bunPath = findBunPath();
-  return pm2Exec([
+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",
-    bunPath,
+    findBunPath(),
     "--name",
     PROCESS_NAME,
     "--interpreter",
@@ -27328,80 +27671,146 @@ function pm2StartGateway(version3) {
     "5000",
     "--max-restarts",
     "30",
+    "--kill-timeout",
+    String(killTimeoutMs),
     "--",
-    GATEWAY_ENTRY
-  ]);
+    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 upgrade() {
+function upgrade(target) {
+  if (!isPm2Installed()) {
+    throw new Error("[supertask] pm2 is not installed. Run `supertask install` first.");
+  }
   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) {
+  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);
-    pm2Exec(["save"]);
-    console.log(`[supertask] Gateway upgraded: ${before ?? "unknown"} \u2192 ${currentVersion}`);
-  } else {
-    throw new Error(`[supertask] Failed to start Gateway after upgrade`);
+    savePm2State();
+    return { before, after: currentVersion, restarted: true };
+  } catch (error45) {
+    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 = error45 instanceof Error ? error45.message : String(error45);
+      const rollback = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+      throw new Error(`${original}; \u65E7 Gateway \u56DE\u6EDA\u4E5F\u5931\u8D25: ${rollback}`);
+    }
+    const message = error45 instanceof Error ? error45.message : String(error45);
+    throw new Error(`${message}; \u5DF2\u56DE\u6EDA\u5230\u65E7 Gateway`);
   }
-  return { before, after: currentVersion, restarted: true };
 }
 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" };
+}
+
+// src/daemon/update.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+var PACKAGE_NAME = "opencode-supertask";
+function pluginAt(packageDir) {
+  const packageJson = join4(packageDir, "package.json");
+  const gatewayEntry = join4(packageDir, "dist/gateway/index.js");
+  if (!existsSync4(packageJson) || !existsSync4(gatewayEntry)) return null;
   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;
-    }
+    const pkg = JSON.parse(readFileSync3(packageJson, "utf8"));
+    if (pkg.name !== PACKAGE_NAME || typeof pkg.version !== "string") return null;
+    return { packageDir, gatewayEntry, version: pkg.version };
   } catch {
+    return null;
   }
-  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 versionParts(version3) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version3);
+  return match ? match.slice(1).map(Number) : null;
+}
+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 cacheRoot() {
+  return process.env.SUPERTASK_OPENCODE_CACHE_DIR ?? join4(homedir4(), ".cache/opencode/packages");
+}
+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;
+  }
+  const root = cacheRoot();
+  const packageDirs = existsSync4(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}`);
+  }
+  return installed[0];
+}
+function opencodeBin() {
+  return process.env.SUPERTASK_OPENCODE_BIN ?? "opencode";
+}
+function installLatestPlugin() {
+  const result = spawnSync2(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 version3 = getPackageVersion();
-    const { ok } = pm2StartGateway(version3);
-    if (ok) writeRunningVersion(version3);
+  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();
 }
 
 // plugin/supertask.ts
-import { homedir as homedir3 } from "os";
 var _initialized = false;
 function ensureInit() {
   if (_initialized) return;
-  _initialized = true;
   try {
     getDb();
   } catch (err) {
@@ -27409,65 +27818,23 @@ function ensureInit() {
     return;
   }
   try {
-    const lockRow = sqlite.prepare("SELECT pid, heartbeat_at FROM gateway_lock WHERE id = 1").get();
-    if (lockRow && Date.now() - lockRow.heartbeat_at < 3e4) {
+    const lockRow = sqlite.prepare("SELECT pid, heartbeat_at, ready_at FROM gateway_lock WHERE id = 1").get();
+    if (lockRow?.ready_at != null && Date.now() - lockRow.heartbeat_at < 3e4) {
+      _initialized = true;
       return;
     }
   } catch {
   }
   try {
-    ensureGateway();
-  } catch {
+    const gateway = ensureGateway();
+    if (!gateway.ok) {
+      console.warn("[supertask] Gateway \u672A\u81EA\u52A8\u542F\u52A8\uFF1A\u672A\u5B89\u88C5 pm2\u3002\u8FD0\u884C `supertask install` \u542F\u7528\u5E38\u9A7B\u6267\u884C\uFF0C\u6216\u8FD0\u884C `supertask gateway` \u524D\u53F0\u542F\u52A8\u3002");
+    }
+  } catch (error45) {
+    console.error("[supertask] Gateway init failed:", error45 instanceof Error ? error45.message : String(error45));
   }
+  _initialized = true;
 }
-var RUNNER_PROMPT = `\u4F60\u662F **SuperTask \u4EFB\u52A1\u6267\u884C\u5668**\u3002
-
-## \u5DE5\u4F5C\u6D41\u7A0B
-
-### 1. \u83B7\u53D6\u4EFB\u52A1
-
-- \u5982\u679C\u7528\u6237\u8F93\u5165\u5305\u542B \`\u6267\u884C\u4EFB\u52A1 ID: <\u6570\u5B57>\`\uFF0C\u7528 \`supertask_get(id)\` \u83B7\u53D6\u8BE5\u4EFB\u52A1
-- \u5426\u5219\u7528 \`supertask_next\` \u83B7\u53D6\u4E0B\u4E00\u4E2A\u5F85\u6267\u884C\u4EFB\u52A1
-- \u5982\u679C\u6CA1\u6709\u4EFB\u52A1\uFF0C\u62A5\u544A"\u961F\u5217\u4E3A\u7A7A"\u5E76\u7ED3\u675F
-
-### 2. \u6807\u8BB0\u5F00\u59CB
-
-- \u5982\u679C\u4EFB\u52A1\u72B6\u6001\u662F \`pending\`\uFF0C\u8C03\u7528 \`supertask_start(id)\` \u6807\u8BB0\u4E3A running
-- \u5982\u679C\u5DF2\u7ECF\u662F \`running\`\uFF08Worker \u5DF2\u6807\u8BB0\uFF09\uFF0C\u8DF3\u8FC7\u6B64\u6B65
-
-### 3. \u6267\u884C\u4EFB\u52A1
-
-\u7528 Bash \u5DE5\u5177\u6267\u884C\u5B50 Agent\uFF0C**\u5FC5\u987B\u4F20\u5165 timeout \u53C2\u6570**\uFF1A
-
-**\u5DE5\u5177\u8C03\u7528\u683C\u5F0F**\uFF1A
-\`\`\`
-Bash(
-  command: "opencode run --agent \\"<task.agent>\\" -m \\"<model>\\" --format json \\"<task.prompt>\\"",
-  workdir: "<task.cwd>",
-  timeout: 3600000
-)
-\`\`\`
-
-- **command**\uFF1A\u6267\u884C\u5B50 Agent \u7684\u547D\u4EE4
-- **workdir**\uFF1A\u4F7F\u7528 \`task.cwd\`\uFF08\u82E5\u4E3A\u7A7A\u5219\u7528\u5F53\u524D\u76EE\u5F55\uFF09
-- **model**\uFF1A\u4ECE\u7528\u6237\u8F93\u5165\u89E3\u6790 \`OVERRIDE_MODEL=xxx\`\uFF0C\u7528\u5B83\u4F5C\u4E3A \`-m\` \u53C2\u6570\uFF1B\u89E3\u6790\u4E0D\u5230\u5C31\u4E0D\u4F20 \`-m\`
-- **timeout**\uFF1A**\u5FC5\u987B\u8BBE\u7F6E\u4E3A 3600000\uFF0860 \u5206\u949F\uFF09**
-- **\u5B89\u5168\u68C0\u67E5**\uFF1A\u5982\u679C \`task.agent\` \u662F \`supertask-runner\`\uFF0C\u76F4\u63A5 fail \u5E76\u7ED3\u675F\uFF08\u9632\u6B62\u9012\u5F52\uFF09
-
-### 4. \u5224\u65AD\u7ED3\u679C\u5E76\u66F4\u65B0\u72B6\u6001
-
-\u770B\u5B50 Agent \u7684\u8F93\u51FA\u5185\u5BB9\uFF0C\u5224\u65AD\u4EFB\u52A1\u662F\u5426\u6210\u529F\u5B8C\u6210\uFF1A
-
-- **\u6210\u529F**\uFF1A\u5B50 Agent \u5B8C\u6210\u4E86\u4EFB\u52A1\u8981\u6C42\u7684\u5DE5\u4F5C \u2192 \u8C03\u7528 \`supertask_done(id, "\u7B80\u8981\u63CF\u8FF0\u5B8C\u6210\u60C5\u51B5")\`
-- **\u5931\u8D25**\uFF1A\u5B50 Agent \u62A5\u9519\u3001\u62D2\u7EDD\u6267\u884C\u3001\u660E\u786E\u8BF4\u65E0\u6CD5\u5B8C\u6210\u3001\u6216\u660E\u663E\u6CA1\u505A\u5B8C \u2192 \u8C03\u7528 \`supertask_fail(id, "\u5931\u8D25\u539F\u56E0")\`
-
-\u7528\u4F60\u7684\u5224\u65AD\u529B\uFF0C\u4E0D\u9700\u8981\u6B7B\u677F\u7684\u89C4\u5219\u3002
-
-## \u6CE8\u610F\u4E8B\u9879
-
-1. \u4F60\u662F\u8C03\u5EA6\u5668\uFF0C\u4E0D\u8981\u81EA\u5DF1\u6267\u884C\u4EFB\u52A1\u5185\u5BB9\uFF0C\u5FC5\u987B\u7528 Bash \u8C03\u7528 \`opencode run\`
-2. \u5B8C\u6574\u4F20\u9012 \`task.prompt\`\uFF0C\u4E0D\u8981\u64C5\u81EA\u4FEE\u6539
-3. \u4E00\u6B21\u53EA\u5904\u7406\u4E00\u4E2A\u4EFB\u52A1\uFF0C\u5904\u7406\u5B8C\u5C31\u7ED3\u675F`;
 var SYSTEM_INSTRUCTION = `
 ## SuperTask \u4EFB\u52A1\u961F\u5217\u7CFB\u7EDF
 
@@ -27494,18 +27861,7 @@ var SYSTEM_INSTRUCTION = `
 `;
 var SuperTaskPlugin = async () => {
   return {
-    async config(cfg) {
-      cfg.agent = cfg.agent ?? {};
-      cfg.agent["supertask-runner"] = {
-        description: "SuperTask \u4EFB\u52A1\u6267\u884C\u5668 - \u4ECE\u4EFB\u52A1\u961F\u5217\u83B7\u53D6\u4EFB\u52A1\u5E76\u6D3E\u53D1\u7ED9\u5B50 Agent \u6267\u884C",
-        mode: "all",
-        hidden: true,
-        prompt: RUNNER_PROMPT,
-        temperature: 0.3,
-        permission: {
-          bash: "allow"
-        }
-      };
+    async config() {
       ensureInit();
     },
     async "experimental.chat.system.transform"(input, output) {
@@ -27514,7 +27870,7 @@ var SuperTaskPlugin = async () => {
     tool: {
       // 创建任务
       supertask_add: tool({
-        description: "\u521B\u5EFA\u65B0\u4EFB\u52A1\u5230\u961F\u5217\u3002\u8FD4\u56DE\u4EFB\u52A1 ID\u3002\u4EFB\u52A1\u5C06\u6309\u4F18\u5148\u7EA7\uFF08importance \xD7 urgency\uFF09\u6392\u5E8F\u6267\u884C\u3002",
+        description: "\u521B\u5EFA\u65B0\u4EFB\u52A1\u5230\u961F\u5217\u3002\u8FD4\u56DE\u4EFB\u52A1 ID\u3002\u4EFB\u52A1\u6309 urgency\u3001importance\u3001createdAt\u3001id \u7684\u987A\u5E8F\u8C03\u5EA6\u3002",
         args: {
           name: tool.schema.string().describe("\u4EFB\u52A1\u540D\u79F0\uFF08\u4EBA\u7C7B\u53EF\u8BFB\uFF09"),
           agent: tool.schema.string().describe("\u6267\u884C\u7684 Agent \u540D\u79F0\uFF0C\u5982 localize-gen, course-gen"),
@@ -27525,6 +27881,9 @@ var SuperTaskPlugin = async () => {
           urgency: tool.schema.number().optional().describe("\u7D27\u6025\u7A0B\u5EA6 1-5\uFF085 \u6700\u7D27\u6025\uFF09"),
           batchId: tool.schema.string().optional().describe("\u6279\u6B21 ID\uFF0C\u7528\u4E8E\u5206\u7EC4\u7BA1\u7406"),
           dependsOn: tool.schema.number().optional().describe("\u4F9D\u8D56\u7684\u4EFB\u52A1 ID\uFF0C\u8BE5\u4EFB\u52A1\u5B8C\u6210\u540E\u624D\u4F1A\u6267\u884C"),
+          max_retries: tool.schema.number().optional().describe("\u9996\u6B21\u6267\u884C\u4E4B\u5916\u5141\u8BB8\u7684\u91CD\u8BD5\u6B21\u6570\uFF0C\u9ED8\u8BA4 3"),
+          retry_backoff_ms: tool.schema.number().optional().describe("\u91CD\u8BD5\u9000\u907F\u57FA\u7840\u95F4\u9694 ms\uFF0C\u9ED8\u8BA4 30000"),
+          timeout_ms: tool.schema.number().optional().describe("\u4EFB\u52A1\u786C\u8D85\u65F6 ms\uFF1B\u672A\u4F20\u5219\u4F7F\u7528 Gateway \u9ED8\u8BA4\u503C"),
           cwd: tool.schema.string().optional().describe(
             "(\u5DF2\u5E9F\u5F03) \u5DE5\u4F5C\u76EE\u5F55\u3002\u7CFB\u7EDF\u4F1A\u81EA\u52A8\u8BB0\u5F55\u63D0\u4EA4\u4EFB\u52A1\u65F6\u7684 opencode run \u542F\u52A8\u76EE\u5F55\u3002"
           )
@@ -27542,7 +27901,10 @@ var SuperTaskPlugin = async () => {
               urgency: args.urgency ?? 3,
               batchId: args.batchId,
               dependsOn: args.dependsOn,
-              cwd: submitCwd
+              cwd: submitCwd,
+              maxRetries: args.max_retries,
+              retryBackoffMs: args.retry_backoff_ms,
+              timeoutMs: args.timeout_ms
             });
             return JSON.stringify({ id: task.id, status: "created" });
           } catch (error45) {
@@ -27554,7 +27916,7 @@ var SuperTaskPlugin = async () => {
       }),
       // 获取下一条任务
       supertask_next: tool({
-        description: "\u83B7\u53D6\u4E0B\u4E00\u4E2A\u5F85\u6267\u884C\u7684\u4EFB\u52A1\u3002\u4F18\u5148\u5904\u7406\u53EF\u91CD\u8BD5\u7684\u5931\u8D25\u4EFB\u52A1\uFF08retryCount < maxRetries\uFF09\uFF0C\u518D\u5904\u7406 pending \u4EFB\u52A1\uFF0C\u5747\u6309\u521B\u5EFA\u65F6\u95F4\u5347\u5E8F\u6392\u5217\uFF0C\u4F1A\u81EA\u52A8\u8DF3\u8FC7\u4F9D\u8D56\u672A\u5B8C\u6210\u7684\u4EFB\u52A1\u3002",
+        description: "\u83B7\u53D6\u4E0B\u4E00\u4E2A\u53EF\u6267\u884C\u4EFB\u52A1\u3002\u5019\u9009\u5305\u62EC pending \u548C\u9000\u907F\u5230\u671F\u4E14 retryCount <= maxRetries \u7684 failed \u4EFB\u52A1\uFF0C\u6309 urgency\u3001importance\u3001createdAt\u3001id \u6392\u5E8F\uFF0C\u5E76\u8DF3\u8FC7\u4F9D\u8D56\u672A\u5B8C\u6210\u7684\u4EFB\u52A1\u3002",
         args: {
           cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u8FD4\u56DE\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
         },
@@ -27575,7 +27937,7 @@ var SuperTaskPlugin = async () => {
                 urgency: task.urgency
               });
             } else {
-              return JSON.stringify({ id: null, message: "No pending tasks" });
+              return JSON.stringify({ id: null, message: "No executable tasks" });
             }
           } catch (error45) {
             return JSON.stringify({
@@ -27602,7 +27964,7 @@ var SuperTaskPlugin = async () => {
               error: "Task status does not allow start",
               id: existing.id,
               status: existing.status,
-              message: `Only pending tasks can be started; current status is '${existing.status}'.`
+              message: `Only pending or retryable failed tasks can be started; current status is '${existing.status}'.`
             });
           } catch (error45) {
             return JSON.stringify({
@@ -27789,7 +28151,8 @@ var SuperTaskPlugin = async () => {
           }).describe("\u8C03\u5EA6\u914D\u7F6E"),
           max_instances: tool.schema.number().optional().describe("\u6700\u5927\u5E76\u53D1\u5B9E\u4F8B\u6570\uFF0C\u9ED8\u8BA4 1"),
           max_retries: tool.schema.number().optional().describe("\u514B\u9686\u7ED9 task \u7684\u6700\u5927\u91CD\u8BD5\u6B21\u6570\uFF0C\u9ED8\u8BA4 3"),
-          retry_backoff_ms: tool.schema.number().optional().describe("\u514B\u9686\u7ED9 task \u7684\u9000\u907F\u57FA\u7840\u95F4\u9694 ms\uFF0C\u9ED8\u8BA4 30000")
+          retry_backoff_ms: tool.schema.number().optional().describe("\u514B\u9686\u7ED9 task \u7684\u9000\u907F\u57FA\u7840\u95F4\u9694 ms\uFF0C\u9ED8\u8BA4 30000"),
+          timeout_ms: tool.schema.number().optional().describe("\u514B\u9686\u7ED9 task \u7684\u786C\u8D85\u65F6 ms\uFF1B\u672A\u4F20\u5219\u4F7F\u7528 Gateway \u9ED8\u8BA4\u503C")
         },
         async execute(args) {
           try {
@@ -27821,13 +28184,16 @@ var SuperTaskPlugin = async () => {
               category: args.category ?? "general",
               importance: args.importance ?? 3,
               urgency: args.urgency ?? 3,
+              cwd: process.cwd(),
+              batchId: args.batchId,
               scheduleType,
               cronExpr,
               intervalMs,
               runAt,
               maxInstances: args.max_instances,
               maxRetries: args.max_retries,
-              retryBackoffMs: args.retry_backoff_ms
+              retryBackoffMs: args.retry_backoff_ms,
+              timeoutMs: args.timeout_ms
             });
             return JSON.stringify({
               id: tmpl.id,
@@ -27844,27 +28210,22 @@ var SuperTaskPlugin = async () => {
         }
       }),
       supertask_upgrade: tool({
-        description: "\u5347\u7EA7 SuperTask \u63D2\u4EF6\u3002\u5148\u901A\u8FC7 npm \u66F4\u65B0\u63D2\u4EF6\u5305\u5230\u6700\u65B0\u7248\u672C\uFF0C\u7136\u540E\u91CD\u542F Gateway \u8FDB\u7A0B\u3002\u5F53\u7528\u6237\u8BF4'\u5347\u7EA7\u63D2\u4EF6'\u3001'\u66F4\u65B0 supertask'\u3001'upgrade'\u65F6\u4F7F\u7528\u3002",
+        description: "\u5347\u7EA7 SuperTask \u63D2\u4EF6\u3002\u901A\u8FC7 OpenCode \u5237\u65B0\u63D2\u4EF6\u7F13\u5B58\uFF0C\u6821\u9A8C\u65B0\u7248\u6784\u5EFA\u4EA7\u7269\u540E\u91CD\u542F Gateway\u3002\u5F53\u7528\u6237\u8BF4'\u5347\u7EA7\u63D2\u4EF6'\u3001'\u66F4\u65B0 supertask'\u3001'upgrade'\u65F6\u4F7F\u7528\u3002",
         args: {},
         async execute() {
           try {
-            const { execSync: execSync2 } = await import("child_process");
-            const configDir = `${homedir3()}/.config/opencode`;
-            console.log("[supertask] Updating npm package...");
+            console.log("[supertask] Updating OpenCode plugin cache...");
+            let installed;
             try {
-              execSync2("npm install opencode-supertask@latest", {
-                cwd: configDir,
-                stdio: "pipe",
-                timeout: 6e4
-              });
-            } catch (npmErr) {
+              installed = installLatestPlugin();
+            } catch (updateError) {
               return JSON.stringify({
                 success: false,
-                error: `npm install failed: ${npmErr instanceof Error ? npmErr.message : String(npmErr)}`,
-                hint: "Try manually: cd ~/.config/opencode && npm install opencode-supertask@latest"
+                error: updateError instanceof Error ? updateError.message : String(updateError),
+                hint: "Try manually: opencode plugin opencode-supertask@latest --global --force"
               });
             }
-            const result = upgrade();
+            const result = upgrade(installed);
             return JSON.stringify({
               success: true,
               before: result.before,