opencode-supertask 0.1.20 → 0.1.22

package/dist/worker/index.js

@@ -1205,8 +1205,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;
     }
   }
@@ -2772,8 +2772,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;
@@ -2790,7 +2790,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` `);
         }
       }
@@ -2803,9 +2803,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`, `);
         }
       }
@@ -2854,9 +2854,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`, `);
         }
       }
@@ -4784,6 +4784,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(config, table) {
+    this.config = { ...config, table };
+  }
+};
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
+
 // node_modules/drizzle-orm/sqlite-core/session.js
 var ExecuteResultSync = class extends QueryPromise {
   constructor(resultCb) {
@@ -5130,12 +5176,17 @@ var tasks = sqliteTable("tasks", {
   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)
+]);
 var TASK_CATEGORIES = [
   "translate",
   "generate",
@@ -5145,7 +5196,7 @@ var TASK_CATEGORIES = [
 ];
 var 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"),
@@ -5158,7 +5209,10 @@ var taskRuns = sqliteTable("task_runs", {
   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)
+]);
 var taskTemplates = sqliteTable("task_templates", {
   id: integer("id").primaryKey({ autoIncrement: true }),
   name: text("name").notNull(),
@@ -5169,6 +5223,7 @@ var taskTemplates = sqliteTable("task_templates", {
   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"),
@@ -5176,12 +5231,15 @@ var taskTemplates = sqliteTable("task_templates", {
   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)
+]);
 
 // src/core/db/index.ts
 import { existsSync, mkdirSync } from "fs";
@@ -5218,16 +5276,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}`);
     }
@@ -5266,7 +5338,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 = [];
@@ -5276,9 +5348,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();
@@ -5301,7 +5391,7 @@ var TaskService = class {
       ),
       and(
         eq(tasks2.status, "failed"),
-        sql`${tasks2.retryCount} < ${tasks2.maxRetries}`,
+        sql`${tasks2.retryCount} <= ${tasks2.maxRetries}`,
         retryAfterFilter
       )
     );
@@ -5315,7 +5405,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) {
@@ -5336,7 +5427,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)
@@ -5349,7 +5440,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(),
@@ -5360,17 +5455,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;
   }
@@ -5402,9 +5504,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 = {}) {
@@ -5416,7 +5547,8 @@ var TaskService = class {
       status: "pending",
       startedAt: null,
       finishedAt: null,
-      retryAfter: null
+      retryAfter: null,
+      retryCount: 0
     }).where(and(...conditions)).returning();
     return result[0] || null;
   }
@@ -5430,7 +5562,8 @@ var TaskService = class {
       status: "pending",
       startedAt: null,
       finishedAt: null,
-      retryAfter: null
+      retryAfter: null,
+      retryCount: 0
     }).where(and(...conditions)).returning();
     return result.length;
   }
@@ -5498,6 +5631,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;
   }
@@ -5515,59 +5651,59 @@ var TaskService = class {
 };
 
 // src/core/services/task-run.service.ts
-var { taskRuns: taskRuns2 } = schema_exports;
+var { taskRuns: taskRuns3 } = schema_exports;
 var 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)) {
@@ -5581,22 +5717,23 @@ var TaskRunService = class {
     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}`
           )
         )
       )
@@ -5606,57 +5743,103 @@ var TaskRunService = class {
       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/worker/index.ts
 import { spawn } from "child_process";
+
+// src/gateway/health.ts
+var state = null;
+function markGatewayActivity(component) {
+  if (state) state.lastActivityAt[component] = Date.now();
+}
+
+// src/core/process-control.ts
+function isSafePid(pid) {
+  return Number.isInteger(pid) && pid > 1 && pid !== process.pid;
+}
+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;
+  }
+}
+
+// src/worker/index.ts
+var DEFAULT_MAX_OUTPUT_CHARS = 64 * 1024;
+var FORBIDDEN_AGENT = "supertask-runner";
 var WorkerEngine = class {
   activeBatchIds = /* @__PURE__ */ new Set();
   runningTasks = /* @__PURE__ */ new Map();
   stopped = false;
   pollTimer = null;
   heartbeatTimer = null;
+  pollCyclePromise = null;
   cfg;
-  constructor(cfg) {
+  opencodeBin;
+  maxOutputChars;
+  constructor(cfg, options = {}) {
     this.cfg = cfg.worker;
+    this.opencodeBin = options.opencodeBin ?? process.env.SUPERTASK_OPENCODE_BIN ?? "opencode";
+    this.maxOutputChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   }
   start() {
     this.stopped = false;
+    markGatewayActivity("worker");
     this.poll();
     this.heartbeatTimer = setInterval(() => this.updateHeartbeats(), this.cfg.heartbeatIntervalMs);
   }
-  stop() {
+  async stop(gracePeriodMs = 0) {
     this.stopped = true;
     if (this.pollTimer) {
       clearTimeout(this.pollTimer);
       this.pollTimer = null;
     }
+    if (this.pollCyclePromise) await this.pollCyclePromise;
+    if (gracePeriodMs > 0 && this.runningTasks.size > 0) {
+      const deadline = Date.now() + gracePeriodMs;
+      while (this.runningTasks.size > 0 && Date.now() < deadline) {
+        await Bun.sleep(Math.min(50, deadline - Date.now()));
+      }
+    }
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
     }
+    const interruptedTaskIds = [...this.runningTasks.keys()];
     const killPromises = [];
-    for (const [, entry] of this.runningTasks) {
+    for (const entry of this.runningTasks.values()) {
       entry.shutdown = true;
       killPromises.push(this.killEntry(entry));
     }
-    return Promise.allSettled(killPromises).then(() => {
-    });
+    await Promise.allSettled(killPromises);
+    return interruptedTaskIds;
   }
   getRunningTaskIds() {
     return [...this.runningTasks.keys()];
@@ -5666,136 +5849,244 @@ var WorkerEngine = class {
   }
   poll() {
     if (this.stopped) return;
-    this.tryDispatch().then(() => {
+    markGatewayActivity("worker");
+    this.pollCyclePromise = this.tryDispatch().finally(() => {
+      this.pollCyclePromise = null;
       if (this.stopped) return;
       this.pollTimer = setTimeout(() => this.poll(), this.cfg.pollIntervalMs);
     });
   }
   async tryDispatch() {
+    await this.reconcileCancelledTasks();
     while (!this.stopped && this.runningTasks.size < this.cfg.maxConcurrency) {
+      let task;
+      try {
+        task = await TaskService.next({ excludedBatchIds: [...this.activeBatchIds] });
+      } catch (err) {
+        this.logError("task claim failed", err);
+        break;
+      }
+      if (!task) break;
+      if (this.stopped) break;
+      if (!await TaskService.start(task.id)) continue;
+      if (task.batchId) this.activeBatchIds.add(task.batchId);
+      if (this.stopped) {
+        await TaskService.resetRunningToPending([task.id]);
+        this.releaseBatch(task);
+        break;
+      }
       try {
-        const excludedBatchIds = [...this.activeBatchIds];
-        const task = await TaskService.next({ excludedBatchIds });
-        if (!task) break;
-        if (!await TaskService.start(task.id)) continue;
-        if (task.batchId) {
-          this.activeBatchIds.add(task.batchId);
-        }
         const run = await TaskRunService.create({
           taskId: task.id,
           model: this.resolveModel(task.model),
           status: "running"
         });
-        const modelToUse = this.resolveModel(task.model);
-        const args = ["run", "--agent", "supertask-runner", "--format", "json"];
-        if (modelToUse) {
-          args.push("-m", modelToUse);
+        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 match = text2.match(/"sessionID"\s*:\s*"(ses_[^"]+)"/);
-          if (match) {
-            TaskRunService.updateSessionId(run.id, match[1]).then(() => {
-              console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: "info", msg: "sessionId captured", taskId: task.id, sessionId: match[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 match = entry.output.match(/"sessionID"\s*:\s*"(ses_[^"]+)"/);
+      if (match?.[1] && match[1] !== entry.sessionId) {
+        entry.sessionId = match[1];
+        TaskRunService.updateSessionId(runId, match[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)
+    }));
+  }
 };
 export {
   WorkerEngine