opencode-supertask 0.1.25 → 0.1.27

package/dist/worker/index.js

@@ -1036,7 +1036,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join2(chunks, separator) {
+  function join3(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -1046,7 +1046,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join2;
+  sql2.join = join3;
   function identifier(value) {
     return new Name(value);
   }
@@ -3342,7 +3342,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((join2) => join2.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join3) => join3.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -4155,7 +4155,7 @@ var SQLiteUpdateBase = class extends QueryPromise {
   createJoin(joinType) {
     return (table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join2) => join2.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join3) => join3.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
@@ -5185,7 +5185,9 @@ var tasks = sqliteTable("tasks", {
 }, (table) => [
   index("tasks_queue_idx").on(table.status, table.retryAfter, table.urgency, table.importance, table.createdAt, table.id),
   index("tasks_batch_status_idx").on(table.batchId, table.status),
-  index("tasks_template_status_idx").on(table.templateId, table.status)
+  index("tasks_template_status_idx").on(table.templateId, table.status),
+  index("tasks_depends_on_status_idx").on(table.dependsOn, table.status),
+  index("tasks_cleanup_idx").on(table.finishedAt, table.id, table.status)
 ]);
 var TASK_CATEGORIES = [
   "translate",
@@ -5208,7 +5210,8 @@ var taskRuns = sqliteTable("task_runs", {
   lockedBy: text("locked_by"),
   heartbeatAt: integer("heartbeat_at"),
   workerPid: integer("worker_pid"),
-  childPid: integer("child_pid")
+  childPid: integer("child_pid"),
+  launchProtocol: text("launch_protocol")
 }, (table) => [
   index("task_runs_task_started_idx").on(table.taskId, table.startedAt, table.id),
   index("task_runs_status_heartbeat_idx").on(table.status, table.heartbeatAt)
@@ -5238,7 +5241,13 @@ var taskTemplates = sqliteTable("task_templates", {
   createdAt: integer("created_at").default(0),
   updatedAt: integer("updated_at").default(0)
 }, (table) => [
-  index("task_templates_due_idx").on(table.enabled, table.nextRunAt, table.id)
+  index("task_templates_due_idx").on(table.enabled, table.nextRunAt, table.id),
+  index("task_templates_retention_idx").on(
+    table.scheduleType,
+    table.enabled,
+    table.lastRunAt,
+    table.id
+  )
 ]);
 
 // src/core/db/index.ts
@@ -5263,36 +5272,47 @@ function getMigrationsFolder() {
   }
   return join(__dirname, "../../drizzle");
 }
-function initDb() {
-  const dataDir = dirname(DB_FILE_PATH);
-  if (!existsSync(dataDir)) {
-    mkdirSync(dataDir, { recursive: true });
-  }
-  _sqlite = new Database2(DB_FILE_PATH);
-  _sqlite.exec("PRAGMA journal_mode = WAL;");
-  _sqlite.exec("PRAGMA busy_timeout = 5000;");
-  _sqlite.exec(`
+function ensureGatewayLock(sqliteDb) {
+  sqliteDb.exec(`
         CREATE TABLE IF NOT EXISTS gateway_lock (
             id INTEGER PRIMARY KEY CHECK (id = 1),
             pid INTEGER NOT NULL,
             acquired_at INTEGER NOT NULL,
             heartbeat_at INTEGER NOT NULL,
-            ready_at INTEGER
+            ready_at INTEGER,
+            version TEXT
         );
     `);
-  const gatewayLockColumns = _sqlite.query("PRAGMA table_info(gateway_lock)").all();
-  if (!gatewayLockColumns.some((column) => column.name === "ready_at")) {
-    _sqlite.exec("ALTER TABLE gateway_lock ADD COLUMN ready_at INTEGER;");
+  const columns = sqliteDb.query("PRAGMA table_info(gateway_lock)").all();
+  if (!columns.some((column) => column.name === "ready_at")) {
+    sqliteDb.exec("ALTER TABLE gateway_lock ADD COLUMN ready_at INTEGER;");
+  }
+  if (!columns.some((column) => column.name === "version")) {
+    sqliteDb.exec("ALTER TABLE gateway_lock ADD COLUMN version TEXT;");
+  }
+}
+function migrateSqliteDatabase(sqliteDb) {
+  ensureGatewayLock(sqliteDb);
+  const drizzleDb = drizzle(sqliteDb, { schema: schema_exports });
+  migrate(drizzleDb, { migrationsFolder: getMigrationsFolder() });
+  sqliteDb.exec("PRAGMA foreign_keys = ON;");
+  const violations = sqliteDb.query("PRAGMA foreign_key_check;").all();
+  if (violations.length > 0) {
+    throw new Error(`\u68C0\u6D4B\u5230 ${violations.length} \u6761\u5B64\u7ACB\u5173\u8054\u8BB0\u5F55\uFF0C\u8BF7\u5148\u4FEE\u590D\u6570\u636E\u518D\u542F\u52A8`);
+  }
+  return drizzleDb;
+}
+function initDb() {
+  const dataDir = dirname(DB_FILE_PATH);
+  if (!existsSync(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
   }
-  _db = drizzle(_sqlite, { schema: schema_exports });
+  _sqlite = new Database2(DB_FILE_PATH);
+  _sqlite.exec("PRAGMA journal_mode = WAL;");
+  _sqlite.exec("PRAGMA busy_timeout = 5000;");
   if (!_migrationRan) {
     try {
-      migrate(_db, { migrationsFolder: getMigrationsFolder() });
-      _sqlite.exec("PRAGMA foreign_keys = ON;");
-      const violations = _sqlite.query("PRAGMA foreign_key_check;").all();
-      if (violations.length > 0) {
-        throw new Error(`\u68C0\u6D4B\u5230 ${violations.length} \u6761\u5B64\u7ACB\u5173\u8054\u8BB0\u5F55\uFF0C\u8BF7\u5148\u4FEE\u590D\u6570\u636E\u518D\u542F\u52A8`);
-      }
+      _db = migrateSqliteDatabase(_sqlite);
       _migrationRan = true;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -5303,6 +5323,8 @@ function initDb() {
       console.error(`[supertask] migration failed: ${msg}`);
       throw new Error(`[supertask] DB migration failed: ${msg}`);
     }
+  } else {
+    _db = drizzle(_sqlite, { schema: schema_exports });
   }
   return _db;
 }
@@ -5339,6 +5361,58 @@ function computeBackoff(retryCount, baseMs = 3e4, maxMs = MAX_BACKOFF_MS) {
 
 // src/core/services/task.service.ts
 var { tasks: tasks2, taskRuns: taskRuns2 } = schema_exports;
+var cleanupInvocation = 0;
+var TaskDeletionConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TaskDeletionConflictError";
+  }
+};
+function hasNoExecutableDependents() {
+  return sql`NOT EXISTS (
+        SELECT 1 FROM tasks AS dependent_task
+        WHERE dependent_task.depends_on = ${tasks2.id}
+          AND dependent_task.status IN ('pending', 'running', 'failed', 'dead_letter')
+    )`;
+}
+function hasViableDependency() {
+  return or(
+    isNull(tasks2.dependsOn),
+    sql`EXISTS (
+            SELECT 1 FROM tasks AS dependency_task
+            WHERE dependency_task.id = ${tasks2.dependsOn}
+              AND dependency_task.cwd IS ${tasks2.cwd}
+              AND (
+                  dependency_task.status IN ('pending', 'running', 'done')
+                  OR (
+                      dependency_task.status = 'failed'
+                      AND dependency_task.retry_count <= dependency_task.max_retries
+                  )
+              )
+        )`
+  );
+}
+function blockedDependentsOf(prerequisiteId) {
+  return sql`${tasks2.id} IN (
+        WITH RECURSIVE blocked_task(id) AS (
+            SELECT direct_dependent.id
+            FROM tasks AS direct_dependent
+            WHERE direct_dependent.depends_on = ${prerequisiteId}
+              AND direct_dependent.status IN ('pending', 'failed')
+              AND EXISTS (
+                  SELECT 1 FROM tasks AS prerequisite
+                  WHERE prerequisite.id = ${prerequisiteId}
+                    AND prerequisite.status IN ('dead_letter', 'cancelled')
+              )
+            UNION
+            SELECT descendant.id
+            FROM tasks AS descendant
+            INNER JOIN blocked_task ON descendant.depends_on = blocked_task.id
+            WHERE descendant.status IN ('pending', 'failed')
+        )
+        SELECT id FROM blocked_task
+    )`;
+}
 var TaskService = class {
   static buildScopeWhere(scope) {
     const conditions = [];
@@ -5349,8 +5423,28 @@ var TaskService = class {
   }
   static async add(data) {
     this.validateNewTask(data);
-    const result = await db.insert(tasks2).values(data).returning();
-    return result[0];
+    return db.transaction((tx) => {
+      if (data.dependsOn != null) {
+        const dependency = tx.select({
+          id: tasks2.id,
+          cwd: tasks2.cwd,
+          status: tasks2.status,
+          retryCount: tasks2.retryCount,
+          maxRetries: tasks2.maxRetries
+        }).from(tasks2).where(eq(tasks2.id, data.dependsOn)).get();
+        if (!dependency) {
+          throw new Error(`dependsOn \u6307\u5411\u7684\u4EFB\u52A1 #${data.dependsOn} \u4E0D\u5B58\u5728`);
+        }
+        if ((dependency.cwd ?? null) !== (data.cwd ?? null)) {
+          throw new Error("dependsOn \u5FC5\u987B\u6307\u5411\u540C\u4E00 cwd \u7684\u4EFB\u52A1");
+        }
+        const dependencyIsRecoverable = dependency.status === "pending" || dependency.status === "running" || dependency.status === "done" || dependency.status === "failed" && (dependency.retryCount ?? 0) <= (dependency.maxRetries ?? 3);
+        if (!dependencyIsRecoverable) {
+          throw new Error(`dependsOn \u6307\u5411\u7684\u4EFB\u52A1 #${data.dependsOn} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`);
+        }
+      }
+      return tx.insert(tasks2).values(data).returning().get();
+    }, { behavior: "immediate" });
   }
   static validateNewTask(data) {
     if (!data.name.trim()) throw new Error("name \u4E0D\u80FD\u4E3A\u7A7A");
@@ -5402,23 +5496,54 @@ var TaskService = class {
     if (batchFilter) {
       conditions.push(batchFilter);
     }
-    const allTasks = await db.select().from(tasks2).where(and(...conditions)).orderBy(
+    const result = await db.select().from(tasks2).where(and(
+      ...conditions,
+      or(
+        isNull(tasks2.dependsOn),
+        sql`EXISTS (
+                        SELECT 1 FROM tasks AS dependency_task
+                        WHERE dependency_task.id = ${tasks2.dependsOn}
+                          AND dependency_task.status = 'done'
+                          AND dependency_task.cwd IS ${tasks2.cwd}
+                    )`
+      ),
+      or(
+        isNull(tasks2.batchId),
+        sql`NOT EXISTS (
+                        SELECT 1 FROM tasks AS running_batch_task
+                        WHERE running_batch_task.batch_id = ${tasks2.batchId}
+                          AND (
+                              running_batch_task.status = 'running'
+                              OR EXISTS (
+                                  SELECT 1 FROM task_runs AS running_batch_run
+                                  WHERE running_batch_run.task_id = running_batch_task.id
+                                    AND running_batch_run.status = 'running'
+                              )
+                          )
+                        )`
+      ),
+      sql`NOT EXISTS (
+                    SELECT 1 FROM task_runs AS candidate_active_run
+                    WHERE candidate_active_run.task_id = ${tasks2.id}
+                      AND candidate_active_run.status = 'running'
+                )`
+    )).orderBy(
       desc(tasks2.urgency),
       desc(tasks2.importance),
       asc(tasks2.createdAt),
       asc(tasks2.id)
-    );
-    for (const task of allTasks) {
-      if (task.dependsOn) {
-        const depTask = await this.getById(task.dependsOn, scope);
-        if (depTask && depTask.status === "done") {
-          return task;
-        }
-        continue;
-      }
-      return task;
-    }
-    return null;
+    ).limit(1);
+    return result[0] ?? null;
+  }
+  static async countRunning() {
+    return db.transaction((tx) => {
+      const runningTasks = tx.select({ count: sql`count(*)` }).from(tasks2).where(eq(tasks2.status, "running")).get();
+      const runsWithoutRunningTask = tx.select({ count: sql`count(DISTINCT ${taskRuns2.taskId})` }).from(taskRuns2).innerJoin(tasks2, eq(tasks2.id, taskRuns2.taskId)).where(and(
+        eq(taskRuns2.status, "running"),
+        sql`${tasks2.status} <> 'running'`
+      )).get();
+      return Number(runningTasks?.count ?? 0) + Number(runsWithoutRunningTask?.count ?? 0);
+    }, { behavior: "deferred" });
   }
   static async start(id, scope = {}) {
     const conditions = [
@@ -5454,27 +5579,202 @@ var TaskService = class {
     return result[0] || null;
   }
   static async fail(id, log, scope = {}, options) {
-    const current = await this.getById(id, scope);
-    if (!current || current.status !== "running") return null;
-    const newRetryCount = (current.retryCount ?? 0) + 1;
-    const maxRetries = current.maxRetries ?? 3;
-    const isDeadLetter = options?.setDeadLetter ?? newRetryCount > maxRetries;
-    const conditions = [
-      eq(tasks2.id, id),
-      eq(tasks2.status, "running"),
-      ...this.buildScopeWhere(scope)
-    ];
+    return db.transaction((tx) => {
+      const current = tx.select().from(tasks2).where(and(
+        eq(tasks2.id, id),
+        eq(tasks2.status, "running"),
+        ...this.buildScopeWhere(scope)
+      )).get();
+      if (!current) return null;
+      const newRetryCount = (current.retryCount ?? 0) + 1;
+      const maxRetries = current.maxRetries ?? 3;
+      const isDeadLetter = options?.setDeadLetter ?? newRetryCount > maxRetries;
+      const failed = tx.update(tasks2).set({
+        status: isDeadLetter ? "dead_letter" : "failed",
+        finishedAt: /* @__PURE__ */ new Date(),
+        resultLog: log,
+        retryCount: newRetryCount,
+        retryAfter: isDeadLetter ? null : options?.retryAfterMs ?? Date.now() + computeBackoff(
+          newRetryCount,
+          current.retryBackoffMs ?? 3e4
+        )
+      }).where(and(eq(tasks2.id, id), eq(tasks2.status, "running"))).returning().get();
+      if (failed?.status === "dead_letter") {
+        tx.update(tasks2).set({
+          status: "dead_letter",
+          finishedAt: /* @__PURE__ */ new Date(),
+          retryAfter: null,
+          resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${id} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+        }).where(blockedDependentsOf(id)).run();
+      }
+      return failed ?? null;
+    }, { behavior: "immediate" });
+  }
+  static async completeRun(taskId, runId, log) {
+    return db.transaction((tx) => {
+      const currentTask = tx.select().from(tasks2).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).get();
+      const currentRun = tx.select({ id: taskRuns2.id }).from(taskRuns2).where(and(
+        eq(taskRuns2.id, runId),
+        eq(taskRuns2.taskId, taskId),
+        eq(taskRuns2.status, "running")
+      )).get();
+      if (!currentTask || !currentRun) return null;
+      const finishedAt = /* @__PURE__ */ new Date();
+      const completed = tx.update(tasks2).set({
+        status: "done",
+        finishedAt,
+        resultLog: log,
+        retryAfter: null
+      }).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).returning().get();
+      if (!completed) return null;
+      tx.update(taskRuns2).set({ status: "done", finishedAt, log }).where(and(eq(taskRuns2.id, runId), eq(taskRuns2.status, "running"))).run();
+      return completed;
+    }, { behavior: "immediate" });
+  }
+  static async failRun(taskId, runId, log, options) {
+    const failed = db.transaction((tx) => {
+      const currentTask = tx.select().from(tasks2).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).get();
+      const currentRun = tx.select({ id: taskRuns2.id }).from(taskRuns2).where(and(
+        eq(taskRuns2.id, runId),
+        eq(taskRuns2.taskId, taskId),
+        eq(taskRuns2.status, "running")
+      )).get();
+      if (!currentTask || !currentRun) return null;
+      const newRetryCount = (currentTask.retryCount ?? 0) + 1;
+      const maxRetries = currentTask.maxRetries ?? 3;
+      const isDeadLetter = options?.setDeadLetter ?? newRetryCount > maxRetries;
+      const finishedAt = /* @__PURE__ */ new Date();
+      const retryAfter = isDeadLetter ? null : options?.retryAfterMs ?? Date.now() + computeBackoff(
+        newRetryCount,
+        currentTask.retryBackoffMs ?? 3e4
+      );
+      const failed2 = tx.update(tasks2).set({
+        status: isDeadLetter ? "dead_letter" : "failed",
+        finishedAt,
+        resultLog: log,
+        retryCount: newRetryCount,
+        retryAfter
+      }).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).returning().get();
+      if (!failed2) return null;
+      tx.update(taskRuns2).set({ status: "failed", finishedAt, log }).where(and(eq(taskRuns2.id, runId), eq(taskRuns2.status, "running"))).run();
+      if (failed2.status === "dead_letter") {
+        tx.update(tasks2).set({
+          status: "dead_letter",
+          finishedAt,
+          retryAfter: null,
+          resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${taskId} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+        }).where(blockedDependentsOf(taskId)).run();
+      }
+      return failed2;
+    }, { behavior: "immediate" });
+    return failed;
+  }
+  static async recoverRun(taskId, runId, log) {
+    const recovery = db.transaction((tx) => {
+      const currentTask = tx.select().from(tasks2).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).get();
+      const currentRun = tx.select({ id: taskRuns2.id }).from(taskRuns2).where(and(
+        eq(taskRuns2.id, runId),
+        eq(taskRuns2.taskId, taskId),
+        eq(taskRuns2.status, "running")
+      )).get();
+      if (!currentRun) return null;
+      const finishedAt = /* @__PURE__ */ new Date();
+      tx.update(taskRuns2).set({ status: "failed", finishedAt, log }).where(and(eq(taskRuns2.id, runId), eq(taskRuns2.status, "running"))).run();
+      if (!currentTask) return null;
+      const retryCount = (currentTask.retryCount ?? 0) + 1;
+      const maxRetries = currentTask.maxRetries ?? 3;
+      const isDeadLetter = retryCount > maxRetries;
+      const recoveryStatus = isDeadLetter ? "dead_letter" : "pending";
+      const retryAfterMs = isDeadLetter ? null : Date.now() + computeBackoff(
+        retryCount,
+        currentTask.retryBackoffMs ?? 3e4
+      );
+      tx.update(tasks2).set({
+        status: recoveryStatus,
+        startedAt: null,
+        finishedAt: isDeadLetter ? finishedAt : null,
+        retryCount,
+        retryAfter: retryAfterMs,
+        resultLog: log
+      }).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).run();
+      if (recoveryStatus === "dead_letter") {
+        tx.update(tasks2).set({
+          status: "dead_letter",
+          finishedAt,
+          retryAfter: null,
+          resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${taskId} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+        }).where(blockedDependentsOf(taskId)).run();
+      }
+      return {
+        status: recoveryStatus,
+        retryCount,
+        retryAfterMs
+      };
+    }, { behavior: "immediate" });
+    return recovery;
+  }
+  static async interruptRun(taskId, runId, log) {
+    return db.transaction((tx) => {
+      const currentRun = tx.select({ id: taskRuns2.id }).from(taskRuns2).where(and(
+        eq(taskRuns2.id, runId),
+        eq(taskRuns2.taskId, taskId),
+        eq(taskRuns2.status, "running")
+      )).get();
+      if (!currentRun) return false;
+      const updatedRun = tx.update(taskRuns2).set({ status: "failed", finishedAt: /* @__PURE__ */ new Date(), log }).where(and(eq(taskRuns2.id, runId), eq(taskRuns2.status, "running"))).returning({ id: taskRuns2.id }).get();
+      tx.update(tasks2).set({
+        status: "pending",
+        startedAt: null,
+        finishedAt: null,
+        retryAfter: null,
+        resultLog: log
+      }).where(and(eq(tasks2.id, taskId), eq(tasks2.status, "running"))).run();
+      return updatedRun != null;
+    }, { behavior: "immediate" });
+  }
+  static async resolveBlockedDependencies() {
+    const finishedAt = /* @__PURE__ */ new Date();
+    const result = await db.update(tasks2).set({
+      status: "dead_letter",
+      finishedAt,
+      retryAfter: null,
+      resultLog: "\u4F9D\u8D56\u4EFB\u52A1\u4E0D\u5B58\u5728\u3001\u8DE8\u9879\u76EE\u6216\u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001"
+    }).where(sql`${tasks2.id} IN (
+                WITH RECURSIVE blocked_task(id) AS (
+                    SELECT candidate.id
+                    FROM tasks AS candidate
+                    WHERE candidate.status IN ('pending', 'failed')
+                      AND candidate.depends_on IS NOT NULL
+                      AND NOT EXISTS (
+                          SELECT 1 FROM tasks AS viable_dependency
+                          WHERE viable_dependency.id = candidate.depends_on
+                            AND viable_dependency.cwd IS candidate.cwd
+                            AND (
+                                viable_dependency.status IN ('pending', 'running', 'done')
+                                OR (
+                                    viable_dependency.status = 'failed'
+                                    AND viable_dependency.retry_count <= viable_dependency.max_retries
+                                )
+                            )
+                      )
+                    UNION
+                    SELECT descendant.id
+                    FROM tasks AS descendant
+                    INNER JOIN blocked_task ON descendant.depends_on = blocked_task.id
+                    WHERE descendant.status IN ('pending', 'failed')
+                )
+                SELECT id FROM blocked_task
+            )`).returning();
+    return result.length;
+  }
+  static async rejectBlockedDependents(prerequisiteId) {
     const result = await db.update(tasks2).set({
-      status: isDeadLetter ? "dead_letter" : "failed",
+      status: "dead_letter",
       finishedAt: /* @__PURE__ */ new Date(),
-      resultLog: log,
-      retryCount: newRetryCount,
-      retryAfter: isDeadLetter ? null : options?.retryAfterMs ?? Date.now() + computeBackoff(
-        newRetryCount,
-        current.retryBackoffMs ?? 3e4
-      )
-    }).where(and(...conditions)).returning();
-    return result[0] || null;
+      retryAfter: null,
+      resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${prerequisiteId} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+    }).where(blockedDependentsOf(prerequisiteId)).returning({ id: tasks2.id });
+    return result.length;
   }
   static async markPendingForRetry(id, retryAfterMs, retryCount) {
     const result = await db.update(tasks2).set({
@@ -5487,8 +5787,18 @@ var TaskService = class {
     return result[0] || null;
   }
   static async markDeadLetter(id, retryCount) {
-    const result = await db.update(tasks2).set({ status: "dead_letter", finishedAt: /* @__PURE__ */ new Date(), retryCount }).where(eq(tasks2.id, id)).returning();
-    return result[0] || null;
+    return db.transaction((tx) => {
+      const finishedAt = /* @__PURE__ */ new Date();
+      const task = tx.update(tasks2).set({ status: "dead_letter", finishedAt, retryCount }).where(eq(tasks2.id, id)).returning().get();
+      if (!task) return null;
+      tx.update(tasks2).set({
+        status: "dead_letter",
+        finishedAt,
+        retryAfter: null,
+        resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${id} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+      }).where(blockedDependentsOf(id)).run();
+      return task;
+    }, { behavior: "immediate" });
   }
   static async resetRunningToPending(ids) {
     if (ids.length === 0) return 0;
@@ -5531,41 +5841,91 @@ var TaskService = class {
       ),
       ...this.buildScopeWhere(scope)
     ];
-    const result = await db.update(tasks2).set({
-      status: "cancelled",
-      finishedAt: /* @__PURE__ */ new Date(),
-      retryAfter: null
-    }).where(and(...conditions)).returning();
-    return result[0] || null;
+    return db.transaction((tx) => {
+      const finishedAt = /* @__PURE__ */ new Date();
+      const task = tx.update(tasks2).set({
+        status: "cancelled",
+        finishedAt,
+        retryAfter: null
+      }).where(and(...conditions)).returning().get();
+      if (!task) return null;
+      tx.update(tasks2).set({
+        status: "dead_letter",
+        finishedAt,
+        retryAfter: null,
+        resultLog: `\u4F9D\u8D56\u4EFB\u52A1 #${id} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`
+      }).where(blockedDependentsOf(id)).run();
+      return task;
+    }, { behavior: "immediate" });
   }
   static async retry(id, scope = {}) {
-    const current = await this.getById(id, scope);
-    if (!current) return null;
-    if (current.status !== "failed" && current.status !== "dead_letter") return null;
-    const conditions = [eq(tasks2.id, id), ...this.buildScopeWhere(scope)];
-    const result = await db.update(tasks2).set({
-      status: "pending",
-      startedAt: null,
-      finishedAt: null,
-      retryAfter: null,
-      retryCount: 0
-    }).where(and(...conditions)).returning();
-    return result[0] || null;
-  }
-  static async retryBatch(batchId, scope = {}) {
     const conditions = [
-      eq(tasks2.batchId, batchId),
+      eq(tasks2.id, id),
       or(eq(tasks2.status, "failed"), eq(tasks2.status, "dead_letter")),
       ...this.buildScopeWhere(scope)
     ];
-    const result = await db.update(tasks2).set({
+    return db.transaction((tx) => tx.update(tasks2).set({
       status: "pending",
       startedAt: null,
       finishedAt: null,
       retryAfter: null,
       retryCount: 0
-    }).where(and(...conditions)).returning();
-    return result.length;
+    }).where(and(...conditions, hasViableDependency())).returning().get() ?? null, { behavior: "immediate" });
+  }
+  static async retryBatch(batchId, scope = {}) {
+    const sqlite2 = getSqlite();
+    const scopeFilter = scope.cwd === void 0 ? "" : "AND candidate.cwd = ?";
+    const parameters = scope.cwd === void 0 ? [batchId] : [batchId, scope.cwd];
+    return db.transaction(() => sqlite2.query(`
+            WITH RECURSIVE
+            candidate(id, cwd, depends_on) AS MATERIALIZED (
+                SELECT candidate.id, candidate.cwd, candidate.depends_on
+                FROM tasks AS candidate
+                WHERE candidate.batch_id = ?
+                  AND candidate.status IN ('failed', 'dead_letter')
+                  ${scopeFilter}
+            ),
+            retryable(id, cwd, depends_on) AS (
+                SELECT candidate.id,
+                       candidate.cwd,
+                       candidate.depends_on
+                FROM candidate
+                WHERE candidate.depends_on IS NULL
+                   OR (
+                       NOT EXISTS (
+                           SELECT 1 FROM candidate AS internal_parent
+                           WHERE internal_parent.id = candidate.depends_on
+                       )
+                       AND EXISTS (
+                           SELECT 1 FROM tasks AS external_parent
+                           WHERE external_parent.id = candidate.depends_on
+                             AND external_parent.cwd IS candidate.cwd
+                             AND (
+                                 external_parent.status IN ('pending', 'running', 'done')
+                                 OR (
+                                     external_parent.status = 'failed'
+                                     AND external_parent.retry_count <= external_parent.max_retries
+                                 )
+                             )
+                       )
+                   )
+                UNION
+                SELECT child.id,
+                       child.cwd,
+                       child.depends_on
+                FROM candidate AS child
+                INNER JOIN retryable AS parent
+                    ON child.depends_on = parent.id
+                   AND child.cwd IS parent.cwd
+            )
+            UPDATE tasks
+            SET status = 'pending',
+                started_at = NULL,
+                finished_at = NULL,
+                retry_after = NULL,
+                retry_count = 0
+            WHERE id IN (SELECT id FROM retryable)
+        `).run(...parameters).changes, { behavior: "immediate" });
   }
   static async getById(id, scope = {}) {
     const conditions = [eq(tasks2.id, id), ...this.buildScopeWhere(scope)];
@@ -5630,28 +5990,322 @@ var TaskService = class {
     return stats;
   }
   static async delete(id, scope = {}) {
-    const conditions = [eq(tasks2.id, id), ...this.buildScopeWhere(scope)];
-    const existing = await db.select({ id: tasks2.id }).from(tasks2).where(and(...conditions)).limit(1);
-    if (!existing[0]) return false;
-    await db.delete(taskRuns2).where(eq(taskRuns2.taskId, id));
+    const conditions = [
+      eq(tasks2.id, id),
+      sql`${tasks2.status} <> 'running'`,
+      sql`NOT EXISTS (
+                SELECT 1 FROM ${taskRuns2}
+                WHERE ${taskRuns2.taskId} = ${tasks2.id}
+                  AND ${taskRuns2.status} = 'running'
+            )`,
+      hasNoExecutableDependents(),
+      ...this.buildScopeWhere(scope)
+    ];
     const result = await db.delete(tasks2).where(and(...conditions)).returning();
-    return result.length > 0;
+    if (result.length > 0) {
+      await db.delete(taskRuns2).where(eq(taskRuns2.taskId, id));
+      return true;
+    }
+    if (!await this.getById(id, scope)) return false;
+    const dependent = await db.select({ id: tasks2.id }).from(tasks2).where(and(
+      eq(tasks2.dependsOn, id),
+      sql`${tasks2.status} IN ('pending', 'running', 'failed', 'dead_letter')`
+    )).orderBy(asc(tasks2.id)).limit(1);
+    if (dependent[0]) {
+      throw new TaskDeletionConflictError(
+        `\u4EFB\u52A1 #${id} \u4ECD\u88AB\u53EF\u6267\u884C\u4EFB\u52A1 #${dependent[0].id} \u4F9D\u8D56\uFF0C\u8BF7\u5148\u5904\u7406\u4F9D\u8D56\u4EFB\u52A1`
+      );
+    }
+    throw new TaskDeletionConflictError(
+      `\u4EFB\u52A1 #${id} \u6B63\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148\u53D6\u6D88\u4EFB\u52A1\u5E76\u7B49\u5F85\u6267\u884C\u8FDB\u7A0B\u9000\u51FA`
+    );
   }
-  static async deleteOlderThan(retentionDays) {
+  static async deleteOlderThan(retentionDays, shouldStop = () => false) {
     const cutoffSec = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
-    const result = await db.delete(tasks2).where(
-      and(
-        sql`${tasks2.status} IN ('done', 'failed', 'dead_letter')`,
-        sql`${tasks2.finishedAt} IS NOT NULL`,
-        sql`${tasks2.finishedAt} < ${cutoffSec}`
-      )
-    ).returning();
-    return result.length;
+    const batchSize = 500;
+    const sqlite2 = getSqlite();
+    cleanupInvocation += 1;
+    const candidateTable = `cleanup_candidates_${process.pid}_${cleanupInvocation}`;
+    let deletedTotal = 0;
+    sqlite2.exec(`
+            CREATE TEMP TABLE ${candidateTable} (
+                id INTEGER NOT NULL PRIMARY KEY
+            ) WITHOUT ROWID;
+        `);
+    try {
+      let ceilingId = null;
+      while (true) {
+        if (shouldStop()) return deletedTotal;
+        const batch = db.transaction(() => {
+          sqlite2.query(`DELETE FROM ${candidateTable}`).run();
+          const ceilingPredicate = ceilingId == null ? "" : "AND candidate.id < ?";
+          const rawCandidateStatement = sqlite2.query(`
+                        INSERT INTO ${candidateTable}(id)
+                        SELECT candidate.id
+                        FROM tasks AS candidate NOT INDEXED
+                        WHERE candidate.status IN ('done', 'dead_letter', 'cancelled')
+                          AND candidate.finished_at IS NOT NULL
+                          AND candidate.finished_at < ?
+                          ${ceilingPredicate}
+                          AND NOT EXISTS (
+                              SELECT 1 FROM task_runs AS active_run
+                              WHERE active_run.task_id = candidate.id
+                                AND active_run.status = 'running'
+                          )
+                        ORDER BY candidate.id DESC
+                        LIMIT ?
+                    `);
+          const rawCount = ceilingId == null ? rawCandidateStatement.run(cutoffSec, batchSize).changes : rawCandidateStatement.run(cutoffSec, ceilingId, batchSize).changes;
+          if (rawCount === 0) return { deleted: 0, nextCeilingId: null };
+          const rawPage = sqlite2.query(`
+                        SELECT min(id) AS nextCeilingId FROM ${candidateTable}
+                    `).get();
+          sqlite2.query(`
+                        DELETE FROM ${candidateTable}
+                        WHERE EXISTS (
+                            SELECT 1 FROM tasks AS anomalous
+                            WHERE anomalous.id = ${candidateTable}.id
+                              AND anomalous.depends_on IS NOT NULL
+                              AND anomalous.depends_on >= anomalous.id
+                        )
+                    `).run();
+          while (true) {
+            const pruned = sqlite2.query(`
+                            DELETE FROM ${candidateTable}
+                            WHERE EXISTS (
+                                SELECT 1 FROM tasks AS dependent_task
+                                WHERE dependent_task.depends_on = ${candidateTable}.id
+                                  AND NOT EXISTS (
+                                      SELECT 1 FROM ${candidateTable} AS selected_dependent
+                                      WHERE selected_dependent.id = dependent_task.id
+                                  )
+                            )
+                        `).run().changes;
+            if (pruned === 0) break;
+          }
+          const selected = sqlite2.query(`
+                        SELECT count(*) AS count FROM ${candidateTable}
+                    `).get();
+          if (selected.count === 0) {
+            return { deleted: 0, nextCeilingId: rawPage.nextCeilingId };
+          }
+          sqlite2.query(`
+                        DELETE FROM tasks
+                        WHERE id IN (SELECT id FROM ${candidateTable})
+                    `).run();
+          const remaining = sqlite2.query(`
+                        SELECT count(*) AS count
+                        FROM tasks
+                        WHERE id IN (SELECT id FROM ${candidateTable})
+                    `).get();
+          if (remaining.count !== 0) {
+            throw new Error("\u5386\u53F2\u6E05\u7406\u5019\u9009\u5728\u540C\u4E00\u5199\u4E8B\u52A1\u5185\u53D1\u751F\u6F02\u79FB\uFF0C\u5DF2\u56DE\u6EDA\u672C\u6279\u5220\u9664");
+          }
+          return { deleted: selected.count, nextCeilingId: rawPage.nextCeilingId };
+        }, { behavior: "immediate" });
+        if (batch.nextCeilingId == null) break;
+        ceilingId = batch.nextCeilingId;
+        deletedTotal += batch.deleted;
+        await Bun.sleep(0);
+        if (shouldStop()) return deletedTotal;
+      }
+      return deletedTotal;
+    } finally {
+      sqlite2.exec(`DROP TABLE IF EXISTS ${candidateTable}`);
+    }
   }
 };
 
+// src/core/process-control.ts
+import { spawnSync } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { basename, dirname as dirname2, resolve } from "path";
+
+// src/core/launch-protocol.ts
+var TOKEN_GUARDIAN_LAUNCH_PROTOCOL = "gated-v3-token-guardian";
+var LAUNCH_IDENTITY_ARGUMENT = "--supertask-launch-identity";
+var DRAIN_PROOF_MESSAGE_TYPE = "supertask-drained";
+var MANAGED_RUN_ENV = "SUPERTASK_MANAGED_RUN";
+var MANAGED_RUN_ENV_VALUE = "1";
+function isLaunchIdentity(value) {
+  return value != null && /^gateway-[1-9]\d*:launch:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function isMatchingDrainProof(message, launchIdentity) {
+  if (typeof message !== "object" || message == null) return false;
+  const candidate = message;
+  return candidate.type === DRAIN_PROOF_MESSAGE_TYPE && candidate.identity === launchIdentity;
+}
+
+// src/core/process-control.ts
+var OS_COMMAND_TIMEOUT_MS = 2e3;
+function isSafePid(pid) {
+  return Number.isInteger(pid) && pid > 1 && pid !== process.pid;
+}
+function absentLeaderResult(pid) {
+  return inspectSpawnedProcessTreePresence(pid) === "not-running" ? "not-running" : "inspect-failed";
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+function inspectSpawnedProcessTreePresence(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return "unknown";
+  if (process.platform === "win32") {
+    const processIds = inspectWindowsProcessTree(pid);
+    if (processIds == null) return "unknown";
+    return processIds.length > 0 ? "running" : "not-running";
+  }
+  try {
+    process.kill(-pid, 0);
+    return "running";
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error)) return "unknown";
+    if (error.code === "EPERM") return "running";
+    if (error.code === "ESRCH") return "not-running";
+    return "unknown";
+  }
+}
+function inspectUnixProcess(pid) {
+  const result = spawnSync("ps", ["-o", "pgid=", "-o", "command=", "-p", String(pid)], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: OS_COMMAND_TIMEOUT_MS,
+    killSignal: "SIGKILL"
+  });
+  if (result.status !== 0) return null;
+  const match = result.stdout.trim().match(/^(\d+)\s+(.+)$/s);
+  if (!match) return null;
+  return { processGroupId: Number(match[1]), command: match[2] };
+}
+function inspectWindowsCommand(pid) {
+  const script = `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`;
+  const result = spawnSync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-Command", script],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: OS_COMMAND_TIMEOUT_MS,
+      killSignal: "SIGKILL"
+    }
+  );
+  if (result.status !== 0) return null;
+  return result.stdout.trim() || null;
+}
+function inspectWindowsProcessTree(rootPid) {
+  const script = `$root=${rootPid}; $all=@(Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId); $ids=New-Object 'System.Collections.Generic.HashSet[int]'; [void]$ids.Add($root); do { $added=$false; foreach($p in $all) { if($ids.Contains([int]$p.ParentProcessId) -and $ids.Add([int]$p.ProcessId)) { $added=$true } } } while($added); $all | Where-Object { $ids.Contains([int]$_.ProcessId) } | Select-Object -ExpandProperty ProcessId`;
+  const result = spawnSync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-Command", script],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: OS_COMMAND_TIMEOUT_MS,
+      killSignal: "SIGKILL"
+    }
+  );
+  if (result.status !== 0) return null;
+  return result.stdout.split(/\s+/).filter(Boolean).map(Number).filter((pid) => Number.isInteger(pid) && pid > 0);
+}
+function executableName(value) {
+  return basename(value).trim().toLowerCase().replace(/\.(?:exe|cmd|bat)$/i, "");
+}
+function commandTokens(command) {
+  return command.trim().split(/\s+/).map((token) => token.replace(/^["']|["']$/g, ""));
+}
+function openCodeArgsMatch(args) {
+  const agentIndex = args.indexOf("--agent");
+  const formatIndex = args.indexOf("--format");
+  return args[0] === "run" && agentIndex >= 0 && Boolean(args[agentIndex + 1]) && formatIndex >= 0 && args[formatIndex + 1] === "json";
+}
+function guardianLauncherPath() {
+  const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
+  return resolve(dirname2(fileURLToPath2(import.meta.url)), `../worker/launcher.${extension}`).replaceAll("\\", "/");
+}
+function commandMatches(command, expectedExecutable, launchProtocol, expectedLaunchIdentity) {
+  const expectedName = executableName(expectedExecutable);
+  if (!expectedName) return false;
+  const tokens = commandTokens(command);
+  if (launchProtocol === TOKEN_GUARDIAN_LAUNCH_PROTOCOL) {
+    if (!isLaunchIdentity(expectedLaunchIdentity)) return false;
+    const expectedLauncher = guardianLauncherPath();
+    const launcherIndex = tokens.findIndex((token, index2) => index2 > 0 && index2 <= 3 && token.replaceAll("\\", "/") === expectedLauncher);
+    if (launcherIndex < 0) return false;
+    const runtimeName = executableName(process.execPath);
+    const hasRuntime = tokens.slice(0, launcherIndex).some((token) => executableName(token) === runtimeName || executableName(token) === "bun");
+    const identityArgumentIndex = launcherIndex + 1;
+    const launchIdentityIndex = launcherIndex + 2;
+    const executableIndex2 = launcherIndex + 3;
+    return hasRuntime && tokens[identityArgumentIndex] === LAUNCH_IDENTITY_ARGUMENT && tokens[launchIdentityIndex] === expectedLaunchIdentity && executableName(tokens[executableIndex2] ?? "") === expectedName && openCodeArgsMatch(tokens.slice(executableIndex2 + 1));
+  }
+  if (launchProtocol != null) return false;
+  const executableIndex = tokens.findIndex((token, index2) => index2 <= 3 && executableName(token) === expectedName);
+  if (executableIndex < 0) return false;
+  return openCodeArgsMatch(tokens.slice(executableIndex + 1, executableIndex + 12));
+}
+function signalRecordedProcessTreeWithResult(pid, signal, expectedExecutable, launchProtocol = null, expectedLaunchIdentity = null) {
+  if (!isSafePid(pid)) return "identity-mismatch";
+  if (!isProcessAlive(pid)) return absentLeaderResult(pid);
+  if (process.platform === "win32") {
+    const command = inspectWindowsCommand(pid);
+    if (!command) return isProcessAlive(pid) ? "inspect-failed" : absentLeaderResult(pid);
+    if (!commandMatches(
+      command,
+      expectedExecutable,
+      launchProtocol,
+      expectedLaunchIdentity
+    )) {
+      return "identity-mismatch";
+    }
+    const args = ["/PID", String(pid), "/T"];
+    if (signal === "SIGKILL") args.push("/F");
+    const status = spawnSync("taskkill", args, {
+      stdio: "ignore",
+      timeout: OS_COMMAND_TIMEOUT_MS,
+      killSignal: "SIGKILL"
+    }).status;
+    if (status === 0) return "signalled";
+    return isProcessAlive(pid) ? "signal-failed" : absentLeaderResult(pid);
+  }
+  const info = inspectUnixProcess(pid);
+  if (!info) return isProcessAlive(pid) ? "inspect-failed" : absentLeaderResult(pid);
+  if (!commandMatches(
+    info.command,
+    expectedExecutable,
+    launchProtocol,
+    expectedLaunchIdentity
+  )) {
+    return "identity-mismatch";
+  }
+  try {
+    if (info.processGroupId === pid) process.kill(-pid, signal);
+    else process.kill(pid, signal);
+    return "signalled";
+  } catch {
+    return isProcessAlive(pid) ? "signal-failed" : absentLeaderResult(pid);
+  }
+}
+async function waitForSpawnedProcessTreeExit(pid, timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (inspectSpawnedProcessTreePresence(pid) !== "not-running" && Date.now() < deadline) {
+    await Bun.sleep(Math.min(50, deadline - Date.now()));
+  }
+  return inspectSpawnedProcessTreePresence(pid) === "not-running";
+}
+
 // src/core/services/task-run.service.ts
-var { taskRuns: taskRuns3 } = schema_exports;
+var { tasks: tasks3, taskRuns: taskRuns3 } = schema_exports;
+var LegacyRunAbandonConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LegacyRunAbandonConflictError";
+  }
+};
 var TaskRunService = class {
   static async create(data) {
     const result = await db.insert(taskRuns3).values(data).returning();
@@ -5681,12 +6335,12 @@ var TaskRunService = class {
     const result = await db.update(taskRuns3).set({ heartbeatAt: Date.now() }).where(and(eq(taskRuns3.id, id), eq(taskRuns3.status, "running"))).returning();
     return result[0] || null;
   }
-  static async updatePid(id, workerPid, childPid) {
+  static async updatePid(id, workerPid, childPid, lockedBy = `gateway-${process.pid}`) {
     const result = await db.update(taskRuns3).set({
       workerPid,
       childPid,
       lockedAt: Date.now(),
-      lockedBy: `gateway-${process.pid}`
+      lockedBy
     }).where(and(eq(taskRuns3.id, id), eq(taskRuns3.status, "running"))).returning();
     return result[0] || null;
   }
@@ -5714,39 +6368,108 @@ var TaskRunService = class {
   }
   static async getStaleRuns(heartbeatTimeoutMs) {
     const cutoffMs = Date.now() - heartbeatTimeoutMs;
-    const cutoffSec = Math.floor(cutoffMs / 1e3);
     const { tasks: tasksTable } = schema_exports;
     const result = await db.select({
       runId: taskRuns3.id,
       taskId: taskRuns3.taskId,
       childPid: taskRuns3.childPid,
+      workerPid: taskRuns3.workerPid,
+      launchProtocol: taskRuns3.launchProtocol,
+      lockedBy: taskRuns3.lockedBy,
+      startedAt: taskRuns3.startedAt,
+      heartbeatAt: taskRuns3.heartbeatAt,
       taskRetryCount: tasksTable.retryCount,
       taskMaxRetries: tasksTable.maxRetries,
-      taskRetryBackoffMs: tasksTable.retryBackoffMs
-    }).from(taskRuns3).innerJoin(tasksTable, eq(taskRuns3.taskId, tasksTable.id)).where(
-      and(
-        eq(taskRuns3.status, "running"),
-        or(
-          and(
-            sql`${taskRuns3.heartbeatAt} IS NULL`,
-            sql`${taskRuns3.startedAt} < ${cutoffSec}`
-          ),
-          and(
-            sql`${taskRuns3.heartbeatAt} IS NOT NULL`,
-            sql`${taskRuns3.heartbeatAt} < ${cutoffMs}`
-          )
-        )
-      )
-    );
-    return result.map((row) => ({
+      taskRetryBackoffMs: tasksTable.retryBackoffMs,
+      taskStatus: tasksTable.status,
+      taskCwd: tasksTable.cwd
+    }).from(taskRuns3).innerJoin(tasksTable, eq(taskRuns3.taskId, tasksTable.id)).where(eq(taskRuns3.status, "running"));
+    return result.filter((row) => {
+      const heartbeatExpired = row.heartbeatAt == null ? row.startedAt == null || row.startedAt.getTime() < cutoffMs : row.heartbeatAt < cutoffMs;
+      const ownerExited = row.workerPid != null && row.workerPid > 0 && !isProcessAlive(row.workerPid);
+      return heartbeatExpired || ownerExited;
+    }).map((row) => ({
       runId: row.runId,
       taskId: row.taskId,
       childPid: row.childPid,
+      workerPid: row.workerPid,
+      launchProtocol: row.launchProtocol,
+      lockedBy: row.lockedBy,
       taskRetryCount: row.taskRetryCount ?? 0,
       taskMaxRetries: row.taskMaxRetries ?? 3,
-      taskRetryBackoffMs: row.taskRetryBackoffMs ?? 3e4
+      taskRetryBackoffMs: row.taskRetryBackoffMs ?? 3e4,
+      taskStatus: row.taskStatus,
+      taskCwd: row.taskCwd,
+      ownerAlive: row.workerPid != null && row.workerPid > 0 && isProcessAlive(row.workerPid)
+    }));
+  }
+  static async listLegacyQuarantinedRuns(heartbeatTimeoutMs = 0) {
+    const staleRuns = await this.getStaleRuns(heartbeatTimeoutMs);
+    return staleRuns.filter(
+      (row) => row.launchProtocol == null && row.childPid == null
+    ).map((row) => ({
+      runId: row.runId,
+      taskId: row.taskId,
+      taskStatus: row.taskStatus,
+      taskCwd: row.taskCwd,
+      workerPid: row.workerPid,
+      ownerAlive: row.ownerAlive
     }));
   }
+  static async abandonLegacyRun(runId) {
+    return db.transaction((tx) => {
+      const current = tx.select({
+        runId: taskRuns3.id,
+        taskId: taskRuns3.taskId,
+        runStatus: taskRuns3.status,
+        taskStatus: tasks3.status,
+        workerPid: taskRuns3.workerPid,
+        childPid: taskRuns3.childPid,
+        launchProtocol: taskRuns3.launchProtocol,
+        log: taskRuns3.log
+      }).from(taskRuns3).innerJoin(tasks3, eq(taskRuns3.taskId, tasks3.id)).where(eq(taskRuns3.id, runId)).get();
+      if (!current) return null;
+      if (current.runStatus !== "running") {
+        throw new LegacyRunAbandonConflictError(`run #${runId} \u5DF2\u4E0D\u662F running \u72B6\u6001`);
+      }
+      if (current.launchProtocol != null) {
+        throw new LegacyRunAbandonConflictError(
+          `run #${runId} \u4F7F\u7528\u672A\u77E5\u6216\u53D7\u7BA1\u534F\u8BAE ${current.launchProtocol}\uFF0C\u7981\u6B62\u4EBA\u5DE5 abandon`
+        );
+      }
+      if (current.childPid != null) {
+        throw new LegacyRunAbandonConflictError(
+          `run #${runId} \u5DF2\u8BB0\u5F55 child PID ${current.childPid}\uFF0C\u5FC5\u987B\u7531 Worker/Watchdog \u786E\u8BA4\u8FDB\u7A0B\u6811\u9000\u51FA`
+        );
+      }
+      if (current.workerPid != null && isProcessAlive(current.workerPid)) {
+        throw new LegacyRunAbandonConflictError(
+          `run #${runId} \u7684 owner PID ${current.workerPid} \u4ECD\u5B58\u6D3B`
+        );
+      }
+      if (current.taskStatus !== "cancelled") {
+        throw new LegacyRunAbandonConflictError(
+          `\u4EFB\u52A1 #${current.taskId} \u5FC5\u987B\u5148\u53D6\u6D88\u5E76\u4FDD\u6301 cancelled \u72B6\u6001`
+        );
+      }
+      const note = "\u64CD\u4F5C\u5458\u5DF2\u786E\u8BA4\u65E7\u7248\u65E0 PID \u6267\u884C\u4E0D\u5B58\u5728\uFF0C\u5E76\u901A\u8FC7 run abandon \u5173\u95ED\u9694\u79BB\u8BB0\u5F55";
+      const updated = tx.update(taskRuns3).set({
+        status: "failed",
+        finishedAt: /* @__PURE__ */ new Date(),
+        log: current.log ? `${current.log}
+${note}` : note
+      }).where(and(eq(taskRuns3.id, runId), eq(taskRuns3.status, "running"))).returning({ id: taskRuns3.id }).get();
+      if (!updated) {
+        throw new LegacyRunAbandonConflictError(`run #${runId} \u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8`);
+      }
+      return {
+        runId,
+        taskId: current.taskId,
+        runStatus: "failed",
+        taskStatus: "cancelled"
+      };
+    }, { behavior: "immediate" });
+  }
   static async getRunningRunByTaskId(taskId) {
     const result = await db.select().from(taskRuns3).where(and(eq(taskRuns3.taskId, taskId), eq(taskRuns3.status, "running"))).orderBy(desc(taskRuns3.startedAt), desc(taskRuns3.id)).limit(1);
     return result[0] || null;
@@ -5769,31 +6492,38 @@ 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 markGatewaySuccess(component) {
+  if (!state) return;
+  const now = Date.now();
+  state.lastActivityAt[component] = now;
+  state.lastSuccessAt[component] = now;
+  state.consecutiveFailures[component] = 0;
 }
-function signalSpawnedProcessTree(pid, signal) {
-  if (!isSafePid(pid)) return false;
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-pid, signal);
-      return true;
-    } catch {
-    }
-  }
-  try {
-    process.kill(pid, signal);
-    return true;
-  } catch {
-    return false;
-  }
+function markGatewayFailure(component, error) {
+  if (!state) return;
+  const now = Date.now();
+  state.lastActivityAt[component] = now;
+  state.consecutiveFailures[component] += 1;
+  state.lastError[component] = {
+    at: now,
+    message: error instanceof Error ? error.message : String(error)
+  };
 }
 
 // src/worker/index.ts
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname3, join as join2 } from "path";
+import { randomUUID } from "crypto";
 var DEFAULT_MAX_OUTPUT_CHARS = 64 * 1024;
 var FORBIDDEN_AGENT = "supertask-runner";
+function assertWorkerProcessIsolationSupported(platform = process.platform) {
+  if (platform === "win32") {
+    throw new Error(
+      "Windows Worker \u5DF2\u5B89\u5168\u7981\u7528\uFF1A\u5F53\u524D\u8FD0\u884C\u65F6\u65E0\u6CD5\u7528 Job Object \u8BC1\u660E\u6574\u4E2A OpenCode \u8FDB\u7A0B\u6811\u5DF2\u9000\u51FA"
+    );
+  }
+}
 var WorkerEngine = class {
   activeBatchIds = /* @__PURE__ */ new Set();
   runningTasks = /* @__PURE__ */ new Map();
@@ -5810,10 +6540,13 @@ var WorkerEngine = class {
     this.maxOutputChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   }
   start() {
+    assertWorkerProcessIsolationSupported();
     this.stopped = false;
     markGatewayActivity("worker");
     this.poll();
-    this.heartbeatTimer = setInterval(() => this.updateHeartbeats(), this.cfg.heartbeatIntervalMs);
+    this.heartbeatTimer = setInterval(() => {
+      this.runDetached(this.updateHeartbeats(), "worker heartbeat cycle failed");
+    }, this.cfg.heartbeatIntervalMs);
   }
   async stop(gracePeriodMs = 0) {
     this.stopped = true;
@@ -5832,14 +6565,23 @@ var WorkerEngine = class {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
     }
-    const interruptedTaskIds = [...this.runningTasks.keys()];
-    const killPromises = [];
-    for (const entry of this.runningTasks.values()) {
-      entry.shutdown = true;
-      killPromises.push(this.killEntry(entry));
-    }
-    await Promise.allSettled(killPromises);
-    return interruptedTaskIds;
+    const interrupted = [];
+    const entries = [...this.runningTasks.values()];
+    await Promise.all(entries.map(async (entry) => {
+      if (entry.settled) {
+        if (entry.settlementPromise) await entry.settlementPromise;
+        return;
+      }
+      const termination = entry.termination ?? {
+        kind: "shutdown",
+        message: "Gateway shutdown"
+      };
+      const terminated = await this.terminateEntry(entry, termination);
+      if (terminated && termination.kind === "shutdown") {
+        interrupted.push({ taskId: entry.task.id, runId: entry.runId });
+      }
+    }));
+    return interrupted;
   }
   getRunningTaskIds() {
     return [...this.runningTasks.keys()];
@@ -5847,24 +6589,40 @@ var WorkerEngine = class {
   getRunningCount() {
     return this.runningTasks.size;
   }
+  ownsRun(taskId, runId) {
+    return this.runningTasks.get(taskId)?.runId === runId;
+  }
   poll() {
     if (this.stopped) return;
     markGatewayActivity("worker");
-    this.pollCyclePromise = this.tryDispatch().finally(() => {
+    this.pollCyclePromise = this.tryDispatch().then((healthy) => {
+      if (healthy) markGatewaySuccess("worker");
+    }).catch((err) => {
+      markGatewayFailure("worker", err);
+      this.logError("worker poll failed", err);
+    }).finally(() => {
       this.pollCyclePromise = null;
       if (this.stopped) return;
       this.pollTimer = setTimeout(() => this.poll(), this.cfg.pollIntervalMs);
     });
   }
   async tryDispatch() {
+    await TaskService.resetOrphanRunningToPending();
     await this.reconcileCancelledTasks();
+    await this.reconcileQuarantinedTasks();
+    const quarantined = [...this.runningTasks.values()].filter((entry) => entry.quarantined);
+    if (quarantined.length > 0) {
+      return false;
+    }
     while (!this.stopped && this.runningTasks.size < this.cfg.maxConcurrency) {
+      const databaseRunningCount = await TaskService.countRunning();
+      if (databaseRunningCount >= this.cfg.maxConcurrency) break;
       let task;
       try {
         task = await TaskService.next({ excludedBatchIds: [...this.activeBatchIds] });
       } catch (err) {
         this.logError("task claim failed", err);
-        break;
+        throw err;
       }
       if (!task) break;
       if (this.stopped) break;
@@ -5875,12 +6633,19 @@ var WorkerEngine = class {
         this.releaseBatch(task);
         break;
       }
+      let runId = null;
       try {
+        const launchIdentity = `gateway-${process.pid}:launch:${randomUUID()}`;
         const run = await TaskRunService.create({
           taskId: task.id,
           model: this.resolveModel(task.model),
-          status: "running"
+          status: "running",
+          workerPid: process.pid,
+          lockedAt: Date.now(),
+          lockedBy: launchIdentity,
+          launchProtocol: TOKEN_GUARDIAN_LAUNCH_PROTOCOL
         });
+        runId = run.id;
         if (this.stopped) {
           await TaskRunService.fail(run.id, "Gateway shutdown before spawn");
           await TaskService.resetRunningToPending([task.id]);
@@ -5889,49 +6654,82 @@ var WorkerEngine = class {
         }
         if (task.agent === FORBIDDEN_AGENT) {
           const message = `\u7981\u6B62\u6267\u884C\u9012\u5F52 Agent: ${FORBIDDEN_AGENT}`;
-          await TaskRunService.fail(run.id, message);
-          await TaskService.fail(task.id, message, {}, { setDeadLetter: true });
+          await TaskService.failRun(task.id, run.id, message, { setDeadLetter: true });
           this.releaseBatch(task);
           continue;
         }
-        this.spawnTask(task, run.id);
+        await this.spawnTask(task, run.id, launchIdentity);
       } catch (err) {
         this.releaseBatch(task);
         const message = `Worker \u542F\u52A8\u4EFB\u52A1\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`;
         try {
-          await TaskService.fail(task.id, message);
+          if (runId == null) {
+            await TaskService.fail(task.id, message);
+          } else {
+            const failed = await TaskService.failRun(task.id, runId, message);
+            if (!failed) {
+              await TaskRunService.fail(runId, `${message}
+\u4EFB\u52A1\u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8`);
+            }
+          }
         } catch (failErr) {
           this.logError("failed to compensate task startup", failErr, task.id);
         }
         this.logError("task dispatch failed", err, task.id);
       }
     }
+    return ![...this.runningTasks.values()].some((entry) => entry.quarantined);
+  }
+  launcherEntry() {
+    const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
+    const moduleDir = dirname3(fileURLToPath3(import.meta.url));
+    const candidates = [
+      join2(moduleDir, `launcher.${extension}`),
+      join2(moduleDir, `../worker/launcher.${extension}`)
+    ];
+    const entry = candidates.find((candidate) => existsSync2(candidate));
+    if (!entry) throw new Error(`Worker launcher \u4E0D\u5B58\u5728\uFF1A${candidates.join(", ")}`);
+    return entry;
   }
-  spawnTask(task, runId) {
+  async spawnTask(task, runId, launchIdentity) {
     const model = this.resolveModel(task.model);
     const args = ["run", "--agent", task.agent, "--format", "json"];
     if (model) args.push("-m", model);
     args.push(task.prompt);
-    const child = spawn(this.opencodeBin, args, {
+    const child = spawn(process.execPath, [
+      this.launcherEntry(),
+      LAUNCH_IDENTITY_ARGUMENT,
+      launchIdentity,
+      this.opencodeBin,
+      ...args
+    ], {
       cwd: task.cwd || process.cwd(),
-      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        [MANAGED_RUN_ENV]: MANAGED_RUN_ENV_VALUE
+      },
+      stdio: ["pipe", "pipe", "pipe", "ipc"],
       detached: process.platform !== "win32"
     });
     const entry = {
       task,
       runId,
+      launchIdentity,
       child,
       output: "",
       sessionId: null,
       timeoutTimer: null,
-      shutdown: false,
+      termination: null,
+      terminationPromise: null,
+      settlementPromise: null,
+      guardianDrained: false,
+      quarantined: false,
       settled: false
     };
     this.runningTasks.set(task.id, entry);
     const handleData = (data) => {
       const text2 = data.toString();
       entry.output = (entry.output + text2).slice(-this.maxOutputChars);
-      process.stdout.write(text2);
       const match = entry.output.match(/"sessionID"\s*:\s*"(ses_[^"]+)"/);
       if (match?.[1] && match[1] !== entry.sessionId) {
         entry.sessionId = match[1];
@@ -5942,70 +6740,187 @@ var WorkerEngine = class {
     };
     child.stdout?.on("data", handleData);
     child.stderr?.on("data", handleData);
-    child.once("error", (err) => {
-      void this.finishEntry(entry, null, `\u65E0\u6CD5\u542F\u52A8 opencode\uFF1A${err.message}`);
+    child.on("message", (message) => {
+      if (isMatchingDrainProof(message, entry.launchIdentity)) {
+        entry.guardianDrained = true;
+      }
+    });
+    let spawnError = null;
+    const spawned = new Promise((resolve2, reject) => {
+      child.once("spawn", resolve2);
+      child.once("error", (error) => {
+        spawnError = error;
+        reject(error);
+      });
     });
     child.once("close", (code, signal) => {
-      const failure = code === 0 ? void 0 : `opencode \u9000\u51FA\u7801 ${code ?? "null"}${signal ? `\uFF0C\u4FE1\u53F7 ${signal}` : ""}`;
-      void this.finishEntry(entry, code, failure);
+      this.handleChildClose(entry, code, signal, spawnError);
     });
+    try {
+      await spawned;
+    } catch (error) {
+      entry.settled = true;
+      this.runningTasks.delete(task.id);
+      this.releaseBatch(task);
+      throw error;
+    }
+    const childPid = child.pid;
+    if (!childPid) {
+      entry.settled = true;
+      this.runningTasks.delete(task.id);
+      this.releaseBatch(task);
+      throw new Error("launcher \u672A\u8FD4\u56DE PID");
+    }
+    let pidRecorded = false;
+    try {
+      pidRecorded = await TaskRunService.updatePid(
+        runId,
+        process.pid,
+        childPid,
+        launchIdentity
+      ) !== null;
+    } catch (error) {
+      await this.terminateForFailure(
+        entry,
+        `\u8BB0\u5F55 Worker PID \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
+    if (!pidRecorded) {
+      await this.terminateForFailure(entry, "\u8BB0\u5F55 Worker PID \u5931\u8D25\uFF1Arun \u5DF2\u4E0D\u518D\u5904\u4E8E running \u72B6\u6001");
+      return;
+    }
+    if (!child.stdin) {
+      await this.terminateForFailure(entry, "\u653E\u884C OpenCode \u5931\u8D25\uFF1Alauncher stdin \u4E0D\u53EF\u7528");
+      return;
+    }
+    try {
+      await new Promise((resolve2, reject) => {
+        child.stdin.end("START\n", (error) => {
+          if (error) reject(error);
+          else resolve2();
+        });
+      });
+    } catch (error) {
+      await this.terminateForFailure(
+        entry,
+        `\u653E\u884C OpenCode \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
     const timeoutMs = task.timeoutMs ?? this.cfg.taskTimeoutMs;
     if (timeoutMs > 0) {
       entry.timeoutTimer = setTimeout(() => {
-        this.signalEntry(entry, "SIGKILL");
-        void this.finishEntry(entry, null, `\u4EFB\u52A1\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`);
+        this.runDetached(
+          this.terminateForFailure(entry, `\u4EFB\u52A1\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`, "SIGKILL"),
+          "timeout termination failed",
+          entry.task.id
+        );
       }, timeoutMs);
     }
-    TaskRunService.updatePid(runId, process.pid, child.pid ?? 0).catch((err) => {
-      this.signalEntry(entry, "SIGKILL");
-      void this.finishEntry(entry, null, `\u8BB0\u5F55 Worker PID \u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
-    });
   }
-  async finishEntry(entry, code, failure) {
-    if (entry.settled) return;
+  handleChildClose(entry, code, signal, spawnError) {
+    if (entry.settled || entry.termination) return;
+    if (!entry.guardianDrained) {
+      const pid = entry.child.pid;
+      const presence = pid == null ? spawnError == null ? "unknown" : "not-running" : inspectSpawnedProcessTreePresence(pid);
+      const message = "guardian \u672A\u63D0\u4F9B\u8FDB\u7A0B\u6811\u6392\u7A7A\u8BC1\u660E";
+      if (presence !== "not-running") {
+        if (entry.timeoutTimer) {
+          clearTimeout(entry.timeoutTimer);
+          entry.timeoutTimer = null;
+        }
+        entry.termination = { kind: "failure", message };
+        entry.quarantined = true;
+        markGatewayFailure(
+          "worker",
+          new Error(`${message}\uFF1B\u4EFB\u52A1 #${entry.task.id} \u4FDD\u6301\u9694\u79BB`)
+        );
+        return;
+      }
+      this.runDetached(
+        this.settleEntry(entry, null, message),
+        "task settlement failed",
+        entry.task.id
+      );
+      return;
+    }
+    const failure = code === 0 ? void 0 : `${spawnError ? "\u65E0\u6CD5\u542F\u52A8 opencode" : "opencode \u9000\u51FA\u7801"} ${spawnError?.message ?? code ?? "null"}${signal ? `\uFF0C\u4FE1\u53F7 ${signal}` : ""}`;
+    this.runDetached(
+      this.settleEntry(entry, code, failure),
+      "task settlement failed",
+      entry.task.id
+    );
+  }
+  settleEntry(entry, code, failure) {
+    if (entry.settlementPromise) return entry.settlementPromise;
+    if (entry.settled) return Promise.resolve(false);
     entry.settled = true;
     if (entry.timeoutTimer) {
       clearTimeout(entry.timeoutTimer);
       entry.timeoutTimer = null;
     }
-    try {
-      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 ? `
+    const settlement = this.commitEntry(entry, code, failure).then(() => true).catch((error) => {
+      markGatewayFailure("worker", error);
+      this.logError("task settlement failed", error, entry.task.id);
+      return false;
+    }).finally(() => {
+      this.runningTasks.delete(entry.task.id);
+      this.releaseBatch(entry.task);
+    });
+    entry.settlementPromise = settlement;
+    return settlement;
+  }
+  async commitEntry(entry, code, failure) {
+    const termination = entry.termination;
+    if (termination?.kind === "shutdown") return;
+    if (termination?.kind === "cancel") {
+      const output2 = entry.output.trim();
+      const log2 = `${termination.message}${output2 ? `
+${output2}` : ""}`;
+      await TaskRunService.fail(entry.runId, log2);
+      console.log(JSON.stringify({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "info",
+        msg: "running task cancelled",
+        taskId: entry.task.id
+      }));
+      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");
+    if (code === 0 && !failure) {
+      const completed = await TaskService.completeRun(entry.task.id, entry.runId, log);
+      if (completed) {
+        console.log(JSON.stringify({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "info",
+          msg: "task done",
+          taskId: entry.task.id
+        }));
         return;
       }
-      await TaskRunService.fail(entry.runId, 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);
+      await TaskRunService.fail(entry.runId, "\u4EFB\u52A1\u6216\u6267\u884C\u8BB0\u5F55\u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8");
+      return;
     }
+    const failed = await TaskService.failRun(entry.task.id, entry.runId, log);
+    if (!failed) {
+      await TaskRunService.fail(
+        entry.runId,
+        `${log}${log ? "\n" : ""}\u4EFB\u52A1\u72B6\u6001\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u6539\u53D8`
+      );
+      this.logError("task failure state transition rejected", failure ?? "unknown failure", entry.task.id);
+    }
+    console.error(JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "error",
+      msg: "task failed",
+      taskId: entry.task.id,
+      error: failure
+    }));
   }
   async reconcileCancelledTasks() {
     for (const entry of [...this.runningTasks.values()]) {
@@ -6017,32 +6932,18 @@ ${output}` : ""}` : output;
       }
     }
   }
-  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 reconcileQuarantinedTasks() {
+    for (const entry of [...this.runningTasks.values()]) {
+      if (!entry.quarantined || !entry.termination) continue;
+      await this.terminateEntry(entry, entry.termination);
     }
   }
+  async cancelEntry(entry) {
+    await this.terminateEntry(entry, { kind: "cancel", message: "\u4EFB\u52A1\u5DF2\u53D6\u6D88" });
+  }
   async updateHeartbeats() {
     for (const entry of this.runningTasks.values()) {
+      if (entry.quarantined) continue;
       try {
         await TaskRunService.heartbeat(entry.runId);
       } catch (err) {
@@ -6050,26 +6951,75 @@ ${output}` : ""}`;
       }
     }
   }
-  killEntry(entry) {
-    if (entry.child.exitCode !== null || entry.child.signalCode !== null) {
-      return Promise.resolve();
+  async terminateForFailure(entry, message, initialSignal = "SIGTERM") {
+    return this.terminateEntry(entry, { kind: "failure", message }, initialSignal);
+  }
+  terminateEntry(entry, termination, initialSignal = "SIGTERM") {
+    if (entry.terminationPromise) return entry.terminationPromise;
+    if (entry.settled) return entry.settlementPromise ?? Promise.resolve(false);
+    entry.termination ??= termination;
+    if (entry.timeoutTimer) {
+      clearTimeout(entry.timeoutTimer);
+      entry.timeoutTimer = null;
     }
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        this.signalEntry(entry, "SIGKILL");
-        resolve();
-      }, 5e3);
-      entry.child.once("close", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-      this.signalEntry(entry, "SIGTERM");
+    entry.quarantined = true;
+    const terminationPromise = this.completeTermination(entry, initialSignal).finally(() => {
+      if (!entry.settled && entry.terminationPromise === terminationPromise) {
+        entry.terminationPromise = null;
+      }
     });
+    entry.terminationPromise = terminationPromise;
+    return terminationPromise;
+  }
+  async completeTermination(entry, initialSignal) {
+    const termination = entry.termination;
+    if (!termination) return false;
+    try {
+      const exited = await this.killEntry(entry, initialSignal);
+      if (!exited) {
+        markGatewayFailure(
+          "worker",
+          new Error(`${termination.message}\uFF1B\u4EFB\u52A1 #${entry.task.id} \u7684\u8FDB\u7A0B\u65E0\u6CD5\u786E\u8BA4\u9000\u51FA`)
+        );
+        return false;
+      }
+      entry.quarantined = false;
+      return await this.settleEntry(
+        entry,
+        null,
+        termination.kind === "failure" ? termination.message : void 0
+      );
+    } catch (error) {
+      markGatewayFailure("worker", error);
+      this.logError("task termination failed", error, entry.task.id);
+      return false;
+    }
+  }
+  async killEntry(entry, initialSignal = "SIGTERM") {
+    if (entry.guardianDrained && (entry.child.exitCode !== null || entry.child.signalCode !== null)) return true;
+    const pid = entry.child.pid;
+    if (!pid) return false;
+    const initialResult = this.signalEntry(entry, initialSignal);
+    if (initialResult === "not-running") return true;
+    if (initialResult !== "signalled") return false;
+    if (await waitForSpawnedProcessTreeExit(pid, 2500)) return true;
+    if (initialSignal === "SIGKILL") return false;
+    if (entry.guardianDrained && (entry.child.exitCode !== null || entry.child.signalCode !== null)) return true;
+    const forcedResult = this.signalEntry(entry, "SIGKILL");
+    if (forcedResult === "not-running") return true;
+    if (forcedResult !== "signalled") return false;
+    return waitForSpawnedProcessTreeExit(pid, 2500);
   }
   signalEntry(entry, signal) {
     const pid = entry.child.pid;
-    if (!pid) return;
-    signalSpawnedProcessTree(pid, signal);
+    if (!pid) return "not-running";
+    return signalRecordedProcessTreeWithResult(
+      pid,
+      signal,
+      this.opencodeBin,
+      TOKEN_GUARDIAN_LAUNCH_PROTOCOL,
+      entry.launchIdentity
+    );
   }
   releaseBatch(task) {
     if (task.batchId) this.activeBatchIds.delete(task.batchId);
@@ -6078,6 +7028,12 @@ ${output}` : ""}`;
     if (!taskModel || taskModel === "default") return null;
     return taskModel;
   }
+  runDetached(operation, message, taskId) {
+    operation.catch((error) => {
+      markGatewayFailure("worker", error);
+      this.logError(message, error, taskId);
+    });
+  }
   logError(message, error, taskId) {
     console.error(JSON.stringify({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6089,6 +7045,7 @@ ${output}` : ""}`;
   }
 };
 export {
-  WorkerEngine
+  WorkerEngine,
+  assertWorkerProcessIsolationSupported
 };
 //# sourceMappingURL=index.js.map