opencode-supertask 0.1.26 → 0.1.27

package/dist/plugin/supertask.js

@@ -9100,8 +9100,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static parseFileSync(filePath) {
-        const { readFileSync: readFileSync4 } = __require("fs");
-        const data = readFileSync4(filePath, "utf8");
+        const { readFileSync: readFileSync5 } = __require("fs");
+        const data = readFileSync5(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -22653,7 +22653,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join5(chunks, separator) {
+  function join6(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -22663,7 +22663,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join5;
+  sql2.join = join6;
   function identifier(value) {
     return new Name(value);
   }
@@ -24959,7 +24959,7 @@ var SQLiteSelectQueryBuilderBase = class extends TypedQueryBuilder {
     return (table, on) => {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins?.some((join5) => join5.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join6) => join6.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -25772,7 +25772,7 @@ var SQLiteUpdateBase = class extends QueryPromise {
   createJoin(joinType) {
     return (table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join5) => join5.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join6) => join6.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
@@ -26802,7 +26802,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",
@@ -26825,7 +26827,8 @@ var taskRuns = sqliteTable("task_runs", {
   lockedBy: text("locked_by"),
   heartbeatAt: integer2("heartbeat_at"),
   workerPid: integer2("worker_pid"),
-  childPid: integer2("child_pid")
+  childPid: integer2("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)
@@ -26855,7 +26858,13 @@ var taskTemplates = sqliteTable("task_templates", {
   createdAt: integer2("created_at").default(0),
   updatedAt: integer2("updated_at").default(0)
 }, (table) => [
-  index("task_templates_due_idx").on(table.enabled, table.nextRunAt, table.id)
+  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
@@ -26880,36 +26889,47 @@ function getMigrationsFolder() {
   }
   return join(__dirname2, "../../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;");
   }
-  _db = drizzle(_sqlite, { schema: schema_exports });
+}
+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 });
+  }
+  _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);
@@ -26920,6 +26940,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;
 }
@@ -26956,6 +26978,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 = [];
@@ -26966,8 +27040,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");
@@ -27019,23 +27113,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 = [
@@ -27071,27 +27196,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: isDeadLetter ? "dead_letter" : "failed",
+      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: "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({
@@ -27104,8 +27404,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;
@@ -27148,41 +27458,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)];
@@ -27247,23 +27607,129 @@ 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}`);
+    }
   }
 };
 
@@ -27294,19 +27760,17 @@ var TaskTemplateService = class {
   static async create(data) {
     this.validate(data);
     const now = Date.now();
-    const result = await db.insert(taskTemplates2).values({ ...data, createdAt: now, updatedAt: now }).returning();
-    const tmpl = result[0];
-    if (tmpl.nextRunAt == null) {
-      const nextRunAt = this.calculateNextRunAt(
-        tmpl.scheduleType,
-        tmpl
-      );
-      if (nextRunAt != null) {
-        await db.update(taskTemplates2).set({ nextRunAt }).where(eq(taskTemplates2.id, tmpl.id));
-        tmpl.nextRunAt = nextRunAt;
-      }
-    }
-    return tmpl;
+    const nextRunAt = data.nextRunAt ?? this.calculateNextRunAt(
+      data.scheduleType,
+      {
+        cronExpr: data.cronExpr ?? null,
+        intervalMs: data.intervalMs ?? null,
+        runAt: data.runAt ?? null
+      },
+      now
+    );
+    const result = await db.insert(taskTemplates2).values({ ...data, nextRunAt, createdAt: now, updatedAt: now }).returning();
+    return result[0];
   }
   static validate(data) {
     if (!data.name.trim()) throw new Error("name \u4E0D\u80FD\u4E3A\u7A7A");
@@ -27346,8 +27810,18 @@ var TaskTemplateService = class {
     return result[0] || null;
   }
   static async enable(id) {
-    const result = await db.update(taskTemplates2).set({ enabled: true, updatedAt: Date.now() }).where(eq(taskTemplates2.id, id)).returning();
-    return result[0] || null;
+    return db.transaction((tx) => {
+      const template = tx.select().from(taskTemplates2).where(eq(taskTemplates2.id, id)).limit(1).get();
+      if (!template) return null;
+      const nextRunAt = template.nextRunAt ?? this.calculateNextRunAt(
+        template.scheduleType,
+        template
+      );
+      if (nextRunAt == null) {
+        throw new Error(`\u6A21\u677F #${id} \u65E0\u6CD5\u8BA1\u7B97\u4E0B\u4E00\u6B21\u6267\u884C\u65F6\u95F4\uFF0C\u5DF2\u4FDD\u6301\u7981\u7528`);
+      }
+      return tx.update(taskTemplates2).set({ enabled: true, nextRunAt, updatedAt: Date.now() }).where(eq(taskTemplates2.id, id)).returning().get() ?? null;
+    }, { behavior: "immediate" });
   }
   static async disable(id) {
     const result = await db.update(taskTemplates2).set({ enabled: false, updatedAt: Date.now() }).where(eq(taskTemplates2.id, id)).returning();
@@ -27357,6 +27831,47 @@ var TaskTemplateService = class {
     const result = await db.delete(taskTemplates2).where(eq(taskTemplates2.id, id)).returning();
     return result.length > 0;
   }
+  static async deleteExpiredDelayed(retentionDays, shouldStop = () => false) {
+    const cutoffMs = Date.now() - retentionDays * 864e5;
+    const batchSize = 500;
+    let deletedTotal = 0;
+    while (!shouldStop()) {
+      const deleted = db.transaction((tx) => tx.delete(taskTemplates2).where(and(
+        sql`${taskTemplates2.id} IN (
+                        SELECT candidate.id
+                        FROM task_templates AS candidate
+                        WHERE candidate.schedule_type = 'delayed'
+                          AND candidate.enabled = 0
+                          AND candidate.last_run_at IS NOT NULL
+                          AND candidate.last_run_at < ${cutoffMs}
+                          AND NOT EXISTS (
+                              SELECT 1 FROM tasks AS active_task
+                              WHERE active_task.template_id = candidate.id
+                                AND (
+                                    active_task.status IN ('pending', 'running')
+                                    OR (
+                                        active_task.status = 'failed'
+                                        AND active_task.retry_count <= active_task.max_retries
+                                    )
+                                )
+                          )
+                          AND NOT EXISTS (
+                              SELECT 1
+                              FROM task_runs AS active_run
+                              INNER JOIN tasks AS run_task ON run_task.id = active_run.task_id
+                              WHERE run_task.template_id = candidate.id
+                                AND active_run.status = 'running'
+                          )
+                        ORDER BY candidate.last_run_at, candidate.id
+                        LIMIT ${batchSize}
+                    )`
+      )).returning({ id: taskTemplates2.id }).all().length, { behavior: "immediate" });
+      if (deleted === 0) break;
+      deletedTotal += deleted;
+      await Bun.sleep(0);
+    }
+    return deletedTotal;
+  }
   static calculateNextRunAt(scheduleType, template, afterMs) {
     const base = afterMs ?? Date.now();
     switch (scheduleType) {
@@ -27406,13 +27921,73 @@ function parseDuration(input) {
   return null;
 }
 
+// src/core/semver.ts
+function parseSemanticVersion(version3) {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(version3);
+  if (!match) return null;
+  const prerelease = match[4]?.split(".") ?? [];
+  if (prerelease.some((identifier) => /^\d+$/.test(identifier) && identifier.length > 1 && identifier.startsWith("0"))) {
+    return null;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease
+  };
+}
+function compareSemanticVersions(left, right) {
+  const a = parseSemanticVersion(left);
+  const b = parseSemanticVersion(right);
+  if (!a || !b) return null;
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] - b[key];
+  }
+  if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+    if (a.prerelease.length === b.prerelease.length) return 0;
+    return a.prerelease.length === 0 ? 1 : -1;
+  }
+  const identifiers = Math.max(a.prerelease.length, b.prerelease.length);
+  for (let index2 = 0; index2 < identifiers; index2 += 1) {
+    const leftIdentifier = a.prerelease[index2];
+    const rightIdentifier = b.prerelease[index2];
+    if (leftIdentifier === void 0 || rightIdentifier === void 0) {
+      return leftIdentifier === rightIdentifier ? 0 : leftIdentifier === void 0 ? -1 : 1;
+    }
+    if (leftIdentifier === rightIdentifier) continue;
+    const leftNumeric = /^\d+$/.test(leftIdentifier);
+    const rightNumeric = /^\d+$/.test(rightIdentifier);
+    if (leftNumeric && rightNumeric) return Number(leftIdentifier) - Number(rightIdentifier);
+    if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+    return leftIdentifier < rightIdentifier ? -1 : 1;
+  }
+  return 0;
+}
+function isSemanticVersion(version3) {
+  return parseSemanticVersion(version3) !== null;
+}
+
+// src/core/launch-protocol.ts
+var MANAGED_RUN_ENV = "SUPERTASK_MANAGED_RUN";
+var MANAGED_RUN_ENV_VALUE = "1";
+
 // src/daemon/pm2.ts
 import { execSync, spawnSync } from "child_process";
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname2, isAbsolute, join as join3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { Database as Database3 } from "bun:sqlite";
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { homedir as homedir3, userInfo } from "os";
+import { delimiter, dirname as dirname4, isAbsolute, join as join4, resolve } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { Database as Database4 } from "bun:sqlite";
 
 // src/gateway/config.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
@@ -27529,80 +28104,223 @@ function loadConfig(path = getConfigPath()) {
   }
 }
 
-// src/daemon/pm2.ts
-var __dirname = dirname2(fileURLToPath2(import.meta.url));
-var PROCESS_NAME = "supertask-gateway";
-var GATEWAY_LOCK_STALE_MS = 3e4;
+// src/core/package-version.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function getPackageVersion() {
-  const envVersion = process.env.npm_package_version;
-  if (envVersion) return envVersion;
+  let directory = dirname2(fileURLToPath2(import.meta.url));
+  for (let depth = 0; depth < 5; depth += 1) {
+    const packagePath = join3(directory, "package.json");
+    if (existsSync3(packagePath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(packagePath, "utf8"));
+        if (typeof pkg.version === "string") return pkg.version;
+      } catch {
+        return "0.0.0";
+      }
+    }
+    directory = dirname2(directory);
+  }
+  return "0.0.0";
+}
+
+// src/daemon/management-lock.ts
+import { Database as Database3 } from "bun:sqlite";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname3 } from "path";
+var ManagementLockBusyError = class extends Error {
+  constructor() {
+    super("Gateway management lock is busy");
+    this.name = "ManagementLockBusyError";
+  }
+};
+function isBusyError(error45) {
+  if (!(error45 instanceof Error)) return false;
+  const code = error45.code;
+  return code === "SQLITE_BUSY" || /database is locked/i.test(error45.message);
+}
+function withExclusiveManagementLock(path, timeoutMs, action) {
+  mkdirSync2(dirname3(path), { recursive: true });
+  const database = new Database3(path, { create: true });
+  const normalizedTimeout = Number.isFinite(timeoutMs) && timeoutMs >= 0 ? Math.floor(timeoutMs) : 0;
+  database.exec(`PRAGMA busy_timeout = ${normalizedTimeout}`);
   try {
-    const pkgPath = join3(__dirname, "../../package.json");
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
-  } catch {
-    return "0.0.0";
+    try {
+      database.exec("BEGIN IMMEDIATE");
+    } catch (error45) {
+      if (isBusyError(error45)) throw new ManagementLockBusyError();
+      throw error45;
+    }
+    try {
+      const result = action();
+      database.exec("COMMIT");
+      return result;
+    } catch (error45) {
+      try {
+        database.exec("ROLLBACK");
+      } catch {
+      }
+      throw error45;
+    }
+  } finally {
+    database.close();
   }
 }
+
+// src/daemon/pm2.ts
+var __dirname = dirname4(fileURLToPath3(import.meta.url));
+var PROCESS_NAME = "supertask-gateway";
+var MAC_LAUNCH_AGENT_LABEL = "com.supertask.pm2-resurrect";
+var GATEWAY_LOCK_STALE_MS = 3e4;
 function resolveGatewayEntry() {
   const override = process.env.SUPERTASK_GATEWAY_ENTRY;
   if (override) {
-    if (!existsSync3(override)) throw new Error(`[supertask] Gateway entry not found: ${override}`);
+    if (!existsSync4(override)) throw new Error(`[supertask] Gateway entry not found: ${override}`);
     return override;
   }
   const candidates = [
-    join3(__dirname, "../gateway/index.js"),
-    join3(__dirname, "../gateway/index.ts")
+    join4(__dirname, "../gateway/index.js"),
+    join4(__dirname, "../gateway/index.ts")
   ];
-  const entry = candidates.find((candidate) => existsSync3(candidate));
+  const entry = candidates.find((candidate) => existsSync4(candidate));
   if (!entry) throw new Error(`[supertask] Gateway entry not found. Checked: ${candidates.join(", ")}`);
   return entry;
 }
-function versionFile() {
-  return process.env.SUPERTASK_VERSION_FILE ?? join3(homedir3(), ".local/share/opencode/supertask-gateway-version");
+function runtimeHome(env) {
+  return resolve(env.HOME || homedir3());
+}
+function runtimePath(value, cwd) {
+  return resolve(cwd, value);
 }
-function getRunningVersion() {
+function versionFile(env = process.env, cwd = process.cwd()) {
+  return env.SUPERTASK_VERSION_FILE ? runtimePath(env.SUPERTASK_VERSION_FILE, cwd) : join4(runtimeHome(env), ".local/share/opencode/supertask-gateway-version");
+}
+function getRunningVersion(env = process.env, cwd = process.cwd()) {
   try {
-    const path = versionFile();
-    if (!existsSync3(path)) return null;
-    return readFileSync2(path, "utf-8").trim() || null;
+    const path = versionFile(env, cwd);
+    if (!existsSync4(path)) return null;
+    return readFileSync3(path, "utf-8").trim() || null;
   } catch {
     return null;
   }
 }
-function writeRunningVersion(version3) {
-  const path = versionFile();
-  mkdirSync2(dirname2(path), { recursive: true });
+function resolveRuntimeExecutable(command, env, cwd) {
+  if (isAbsolute(command) || command.includes("/")) return runtimePath(command, cwd);
+  for (const entry of (env.PATH ?? "").split(delimiter)) {
+    if (!entry) continue;
+    const candidate = resolve(cwd, entry, command);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return command;
+}
+function runtimeScope(runtime) {
+  const { cwd, env } = runtime;
+  const home = runtimeHome(env);
+  return {
+    cwd: resolve(cwd),
+    databasePath: env.SUPERTASK_DB_PATH ? runtimePath(env.SUPERTASK_DB_PATH, cwd) : join4(home, ".local/share/opencode/tasks.db"),
+    configPath: env.SUPERTASK_CONFIG_PATH ? runtimePath(env.SUPERTASK_CONFIG_PATH, cwd) : join4(home, ".config/opencode/supertask.json"),
+    opencodePath: resolveRuntimeExecutable(env.SUPERTASK_OPENCODE_BIN ?? "opencode", env, cwd),
+    home,
+    pm2Home: env.PM2_HOME ? runtimePath(env.PM2_HOME, cwd) : join4(home, ".pm2"),
+    managementLockPath: canonicalManagementLockPath(env, cwd)
+  };
+}
+function scopesMatch(left, right) {
+  return left.databasePath === right.databasePath && left.configPath === right.configPath && left.opencodePath === right.opencodePath && left.home === right.home && left.pm2Home === right.pm2Home && left.managementLockPath === right.managementLockPath;
+}
+function currentScope() {
+  return runtimeScope({ cwd: process.cwd(), env: process.env });
+}
+function writeRunningVersion(version3, env = process.env, cwd = process.cwd()) {
+  const path = versionFile(env, cwd);
+  mkdirSync3(dirname4(path), { recursive: true });
   writeFileSync(path, version3, "utf-8");
 }
-function pm2Bin() {
-  return process.env.SUPERTASK_PM2_BIN ?? (process.platform === "win32" ? "pm2.cmd" : "pm2");
+function pm2Bin(env = process.env) {
+  return env.SUPERTASK_PM2_BIN ?? (process.platform === "win32" ? "pm2.cmd" : "pm2");
 }
-function isPm2Installed() {
-  const result = spawnSync(pm2Bin(), ["--version"], {
+function pm2CommandTimeoutMs(env = process.env) {
+  const configured = Number(env.SUPERTASK_PM2_COMMAND_TIMEOUT_MS ?? 15e3);
+  return Number.isFinite(configured) && configured > 0 ? configured : 15e3;
+}
+function resolvePm2Bin() {
+  const configured = pm2Bin();
+  if (isAbsolute(configured)) return configured;
+  const result = spawnSync("which", [configured], { encoding: "utf8" });
+  const resolved = result.status === 0 ? result.stdout.trim().split("\n")[0] : "";
+  if (!resolved) throw new Error(`[supertask] \u65E0\u6CD5\u89E3\u6790 pm2 \u53EF\u6267\u884C\u6587\u4EF6: ${configured}`);
+  return resolved;
+}
+function launchAgentPath() {
+  return process.env.SUPERTASK_LAUNCH_AGENT_PATH ?? join4(runtimeHome(process.env), "Library/LaunchAgents", `${MAC_LAUNCH_AGENT_LABEL}.plist`);
+}
+function xmlUnescape(value) {
+  return value.replaceAll("&apos;", "'").replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+}
+function plistValue(contents, key) {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = contents.match(new RegExp(`<key>\\s*${escapedKey}\\s*</key>\\s*<string>([^<]*)</string>`));
+  return match?.[1] ? xmlUnescape(match[1]) : null;
+}
+function isPm2Installed(env = process.env) {
+  const result = spawnSync(pm2Bin(env), ["--version"], {
     stdio: "ignore",
-    shell: process.platform === "win32"
+    env,
+    shell: process.platform === "win32",
+    timeout: pm2CommandTimeoutMs(env),
+    killSignal: "SIGKILL"
   });
   return result.status === 0;
 }
-function pm2Exec(args) {
-  const result = spawnSync(pm2Bin(), args, {
+function resolveCommand(command) {
+  const lookup = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(lookup, [command], { encoding: "utf8" });
+  return result.status === 0 ? result.stdout.trim().split("\n")[0] || null : null;
+}
+function npmPreferredEnvironment() {
+  if (process.platform === "win32") return null;
+  const npm = resolveCommand("npm");
+  const node = resolveCommand("node");
+  if (!npm || !node) return null;
+  const command = resolvePm2Bin();
+  const path = [.../* @__PURE__ */ new Set([
+    dirname4(command),
+    dirname4(npm),
+    dirname4(node),
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin"
+  ])].join(delimiter);
+  return { command, env: { ...process.env, PATH: path } };
+}
+function pm2Exec(args, options = {}) {
+  const npmEnvironment = options.preferNpm ? npmPreferredEnvironment() : null;
+  const effectiveEnv = options.env ?? npmEnvironment?.env ?? process.env;
+  const result = spawnSync(npmEnvironment?.command ?? pm2Bin(effectiveEnv), args, {
     stdio: ["pipe", "pipe", "pipe"],
     encoding: "utf-8",
-    env: process.env,
-    shell: process.platform === "win32"
+    env: effectiveEnv,
+    shell: process.platform === "win32",
+    timeout: options.timeoutMs ?? pm2CommandTimeoutMs(effectiveEnv),
+    killSignal: "SIGKILL"
   });
   const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
   if (result.error) return { ok: false, output: result.error.message };
   return { ok: result.status === 0, output };
 }
-function requirePm2(args, action) {
-  const result = pm2Exec(args);
+function requirePm2(args, action, options = {}) {
+  const result = pm2Exec(args, options);
   if (!result.ok) throw new Error(`[supertask] ${action} failed: ${result.output || "unknown pm2 error"}`);
   return result.output;
 }
-function pm2JsonList() {
-  const output = requirePm2(["jlist"], "pm2 jlist");
+function pm2JsonList(env = process.env) {
+  const output = requirePm2(["jlist"], "pm2 jlist", { env });
   try {
     const parsed = JSON.parse(output);
     if (!Array.isArray(parsed)) throw new Error("result is not an array");
@@ -27612,15 +28330,69 @@ function pm2JsonList() {
     throw new Error(`[supertask] Invalid pm2 jlist output: ${message}`);
   }
 }
-function databasePath() {
-  return process.env.SUPERTASK_DB_PATH ?? join3(homedir3(), ".local/share/opencode/tasks.db");
+function gatewayEntryFromProcess(processInfo) {
+  const args = processInfo?.pm2_env?.args ?? processInfo?.args;
+  const candidates = Array.isArray(args) ? [...args].reverse() : typeof args === "string" ? [args] : [];
+  const savedCwd = processInfo?.pm2_env?.pm_cwd;
+  for (const candidate of candidates) {
+    const path = typeof savedCwd === "string" ? runtimePath(candidate, savedCwd) : candidate;
+    if (existsSync4(path)) return resolve(path);
+  }
+  return null;
 }
-function isGatewayReady(expectedPid) {
-  const path = databasePath();
-  if (!existsSync3(path)) return false;
+function gatewayEnvironmentFromProcess(processInfo) {
+  const saved = processInfo?.pm2_env?.env ?? processInfo?.env;
+  if (!saved) return { ...process.env };
+  const env = {};
+  for (const [key, value] of Object.entries(saved)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  return env;
+}
+function gatewayRuntimeFromProcess(processInfo) {
+  const gatewayEntry = gatewayEntryFromProcess(processInfo);
+  if (!gatewayEntry) return null;
+  const savedBunPath = processInfo?.pm2_env?.pm_exec_path ?? processInfo?.pm_exec_path;
+  const savedCwd = processInfo?.pm2_env?.pm_cwd;
+  const savedEnv = gatewayEnvironmentFromProcess(processInfo);
+  if (typeof savedBunPath !== "string" || typeof savedCwd !== "string") return null;
+  try {
+    accessSync(savedBunPath, constants.X_OK);
+    if (!statSync(savedCwd).isDirectory()) return null;
+    if (spawnSync(savedBunPath, ["--version"], {
+      stdio: "ignore",
+      env: savedEnv,
+      timeout: pm2CommandTimeoutMs(savedEnv),
+      killSignal: "SIGKILL"
+    }).status !== 0) return null;
+  } catch {
+    return null;
+  }
+  const killTimeout = processInfo?.pm2_env?.kill_timeout ?? processInfo?.kill_timeout;
+  return {
+    gatewayEntry,
+    bunPath: savedBunPath,
+    cwd: resolve(savedCwd),
+    env: savedEnv,
+    killTimeoutMs: Number.isInteger(killTimeout) && killTimeout >= 5e3 ? killTimeout : void 0
+  };
+}
+function currentGatewayRuntime(gatewayEntry = resolveGatewayEntry()) {
+  return {
+    gatewayEntry: resolve(gatewayEntry),
+    bunPath: resolve(findBunPath()),
+    cwd: process.cwd(),
+    env: { ...process.env }
+  };
+}
+function databasePath(env = process.env, cwd = process.cwd()) {
+  return env.SUPERTASK_DB_PATH ? runtimePath(env.SUPERTASK_DB_PATH, cwd) : join4(runtimeHome(env), ".local/share/opencode/tasks.db");
+}
+function isGatewayReady(expectedPid, path = databasePath()) {
+  if (!existsSync4(path)) return false;
   let database = null;
   try {
-    database = new Database3(path, { readonly: true });
+    database = new Database4(path, { readonly: true });
     const row = database.query(
       "SELECT pid, heartbeat_at, ready_at FROM gateway_lock WHERE id = 1"
     ).get();
@@ -27634,18 +28406,34 @@ function isGatewayReady(expectedPid) {
     database?.close();
   }
 }
-function readyTimeoutMs() {
-  const value = Number(process.env.SUPERTASK_GATEWAY_READY_TIMEOUT_MS ?? 3e4);
+function gatewayVersionFromLock(expectedPid, path) {
+  if (!existsSync4(path)) return void 0;
+  let database = null;
+  try {
+    database = new Database4(path, { readonly: true });
+    const row = database.query(
+      "SELECT pid, version FROM gateway_lock WHERE id = 1"
+    ).get();
+    if (!row || row.pid !== expectedPid) return void 0;
+    return row.version;
+  } catch {
+    return void 0;
+  } finally {
+    database?.close();
+  }
+}
+function readyTimeoutMs(env = process.env) {
+  const value = Number(env.SUPERTASK_GATEWAY_READY_TIMEOUT_MS ?? 3e4);
   return Number.isFinite(value) && value > 0 ? value : 3e4;
 }
-function waitForGatewayReady(pid) {
-  const deadline = Date.now() + readyTimeoutMs();
+function waitForGatewayReady(pid, path = databasePath(), env = process.env) {
+  const deadline = Date.now() + readyTimeoutMs(env);
   const sleeper = new Int32Array(new SharedArrayBuffer(4));
   while (Date.now() < deadline) {
-    if (isGatewayReady(pid)) return true;
+    if (isGatewayReady(pid, path)) return true;
     Atomics.wait(sleeper, 0, 0, 100);
   }
-  return isGatewayReady(pid);
+  return isGatewayReady(pid, path);
 }
 function findBunPath() {
   const override = process.env.SUPERTASK_BUN_BIN;
@@ -27657,12 +28445,64 @@ function findBunPath() {
     return process.execPath;
   }
 }
-function pm2StartGateway(gatewayEntry = resolveGatewayEntry()) {
-  const configuredKillTimeout = Number(process.env.SUPERTASK_PM2_KILL_TIMEOUT_MS);
-  const killTimeoutMs = Number.isInteger(configuredKillTimeout) && configuredKillTimeout >= 5e3 ? configuredKillTimeout : loadConfig().worker.shutdownGracePeriodMs + 5e3;
+function pm2MaxMemoryRestart(env = process.env) {
+  const value = env.SUPERTASK_PM2_MAX_MEMORY ?? "512M";
+  if (!/^\d+(?:K|M|G)$/i.test(value)) {
+    throw new Error("[supertask] SUPERTASK_PM2_MAX_MEMORY \u5FC5\u987B\u4F7F\u7528 512M / 1G \u8FD9\u7C7B\u683C\u5F0F");
+  }
+  return value;
+}
+function gatewayKillTimeoutMs(runtime) {
+  const shutdownGracePeriodMs = loadConfig(runtimeScope(runtime).configPath).worker.shutdownGracePeriodMs;
+  const minimumKillTimeoutMs = shutdownGracePeriodMs + 15e3;
+  const configuredValue = runtime.env.SUPERTASK_PM2_KILL_TIMEOUT_MS;
+  if (configuredValue !== void 0) {
+    const configuredKillTimeout = Number(configuredValue);
+    if (!Number.isInteger(configuredKillTimeout) || configuredKillTimeout < minimumKillTimeoutMs) {
+      throw new Error(
+        `[supertask] SUPERTASK_PM2_KILL_TIMEOUT_MS \u5FC5\u987B\u662F\u81F3\u5C11 ${minimumKillTimeoutMs} \u7684\u6574\u6570\uFF08worker shutdown grace ${shutdownGracePeriodMs}ms + 15000ms \u6536\u5C3E\u4F59\u91CF\uFF09`
+      );
+    }
+    return configuredKillTimeout;
+  }
+  return Math.max(runtime.killTimeoutMs ?? 0, minimumKillTimeoutMs);
+}
+function gatewayTerminationCommandTimeoutMs(runtime) {
+  const effectiveKillTimeoutMs = Math.max(
+    runtime.killTimeoutMs ?? 0,
+    gatewayKillTimeoutMs(runtime)
+  );
+  const minimumCommandTimeoutMs = effectiveKillTimeoutMs + 5e3;
+  const configuredValue = runtime.env.SUPERTASK_PM2_COMMAND_TIMEOUT_MS;
+  if (configuredValue !== void 0) {
+    const configuredTimeoutMs = Number(configuredValue);
+    if (!Number.isInteger(configuredTimeoutMs) || configuredTimeoutMs < minimumCommandTimeoutMs) {
+      throw new Error(
+        `[supertask] SUPERTASK_PM2_COMMAND_TIMEOUT_MS \u5FC5\u987B\u662F\u81F3\u5C11 ${minimumCommandTimeoutMs} \u7684\u6574\u6570\uFF08Gateway kill timeout ${effectiveKillTimeoutMs}ms + 5000ms PM2 \u6536\u5C3E\u4F59\u91CF\uFF09`
+      );
+    }
+    return configuredTimeoutMs;
+  }
+  return Math.max(pm2CommandTimeoutMs(runtime.env), minimumCommandTimeoutMs);
+}
+function requirePm2Termination(command, action, runtime) {
+  return requirePm2([command, PROCESS_NAME], action, {
+    env: runtime.env,
+    timeoutMs: gatewayTerminationCommandTimeoutMs(runtime)
+  });
+}
+function pm2StartGateway(runtime = currentGatewayRuntime()) {
+  try {
+    accessSync(runtime.bunPath, constants.X_OK);
+    accessSync(runtime.gatewayEntry, constants.R_OK);
+    if (!statSync(runtime.cwd).isDirectory()) throw new Error("cwd is not a directory");
+  } catch (error45) {
+    throw new Error(`[supertask] Gateway \u76EE\u6807\u8FD0\u884C\u65F6\u4E0D\u53EF\u7528: ${error45 instanceof Error ? error45.message : String(error45)}`);
+  }
+  const killTimeoutMs = gatewayKillTimeoutMs(runtime);
   requirePm2([
     "start",
-    findBunPath(),
+    runtime.bunPath,
     "--name",
     PROCESS_NAME,
     "--interpreter",
@@ -27671,43 +28511,186 @@ function pm2StartGateway(gatewayEntry = resolveGatewayEntry()) {
     "5000",
     "--max-restarts",
     "30",
+    "--max-memory-restart",
+    pm2MaxMemoryRestart(runtime.env),
     "--kill-timeout",
     String(killTimeoutMs),
+    "--cwd",
+    runtime.cwd,
     "--",
-    gatewayEntry
-  ], "pm2 start");
-  const started = pm2JsonList().find((item) => item.name === PROCESS_NAME);
+    runtime.gatewayEntry
+  ], "pm2 start", { env: runtime.env });
+  const started = pm2JsonList(runtime.env).find((item) => item.name === PROCESS_NAME);
   if (started?.pm2_env?.status !== "online") {
     throw new Error(`[supertask] Gateway did not become online (status: ${started?.pm2_env?.status ?? "missing"})`);
   }
-  if (typeof started.pid !== "number" || !waitForGatewayReady(started.pid)) {
+  const observedRuntime = gatewayRuntimeFromProcess(started);
+  if (!observedRuntime || observedRuntime.gatewayEntry !== resolve(runtime.gatewayEntry) || observedRuntime.bunPath !== runtime.bunPath || observedRuntime.cwd !== resolve(runtime.cwd) || !scopesMatch(runtimeScope(observedRuntime), runtimeScope(runtime))) {
+    throw new Error("[supertask] PM2 online \u8BB0\u5F55\u4E0E\u672C\u6B21\u542F\u52A8\u76EE\u6807\u4E0D\u4E00\u81F4\uFF0C\u5DF2\u62D2\u7EDD\u63A5\u7BA1");
+  }
+  if (typeof started.pid !== "number" || !waitForGatewayReady(started.pid, runtimeScope(runtime).databasePath, runtime.env)) {
     throw new Error("[supertask] Gateway \u8FDB\u7A0B online\uFF0C\u4F46\u672A\u5728\u9650\u5B9A\u65F6\u95F4\u5185\u5C31\u7EEA\uFF1B\u8BF7\u67E5\u770B pm2 logs supertask-gateway");
   }
 }
-function savePm2State() {
-  requirePm2(["save"], "pm2 save");
+function assertRuntimeCanControlPm2(runtime, existing) {
+  if (!existing) return;
+  if (!runtime) {
+    throw new Error(
+      "[supertask] \u65E0\u6CD5\u5B8C\u6574\u9A8C\u8BC1\u5DF2\u6709 Gateway \u7684\u5165\u53E3\u3001Bun \u548C cwd\uFF0C\u5DF2\u62D2\u7EDD\u5220\u9664\u73B0\u6709\u8FDB\u7A0B"
+    );
+  }
+  const probe = pm2Exec(["--version"], { env: runtime.env });
+  if (!probe.ok) {
+    throw new Error(
+      `[supertask] \u4FDD\u5B58\u7684 Gateway \u8FD0\u884C\u73AF\u5883\u65E0\u6CD5\u6267\u884C pm2\uFF0C\u5DF2\u62D2\u7EDD\u5220\u9664\u73B0\u6709\u8FDB\u7A0B\uFF1B\u8BF7\u5148\u4FEE\u590D PATH \u6216 SUPERTASK_PM2_BIN: ${probe.output || "pm2 unavailable"}`
+    );
+  }
+  const observed = pm2JsonList(runtime.env).find((item) => item.name === PROCESS_NAME);
+  const observedRuntime = gatewayRuntimeFromProcess(observed);
+  if (!observed || observed.pid !== existing.pid || !observedRuntime || observedRuntime.gatewayEntry !== runtime.gatewayEntry || observedRuntime.bunPath !== runtime.bunPath || observedRuntime.cwd !== runtime.cwd) {
+    throw new Error("[supertask] \u4FDD\u5B58\u7684 PM2 \u73AF\u5883\u65E0\u6CD5\u91CD\u73B0\u540C\u4E00 Gateway \u8BB0\u5F55\uFF0C\u5DF2\u62D2\u7EDD\u5220\u9664\u73B0\u6709\u8FDB\u7A0B");
+  }
+}
+function savePm2State(env = process.env) {
+  requirePm2(["save"], "pm2 save", { env });
+}
+function canonicalManagementLockPath(env = process.env, cwd = process.cwd()) {
+  const home = runtimeHome(env);
+  const pm2Home = env.PM2_HOME ? runtimePath(env.PM2_HOME, cwd) : join4(home, ".pm2");
+  return join4(pm2Home, "supertask-gateway.manage.sqlite");
+}
+function addLegacyManagementLock(paths, env, cwd) {
+  const value = env?.SUPERTASK_PM2_MANAGEMENT_LOCK;
+  if (typeof value === "string" && value.length > 0) paths.add(runtimePath(value, cwd));
+}
+function savedManagementLockPaths() {
+  const canonical = canonicalManagementLockPath();
+  const legacy = /* @__PURE__ */ new Set();
+  addLegacyManagementLock(legacy, process.env, process.cwd());
+  const pm2Home = currentScope().pm2Home;
+  try {
+    const dump = JSON.parse(readFileSync3(join4(pm2Home, "dump.pm2"), "utf8"));
+    if (Array.isArray(dump)) {
+      const gateway = dump.find((item) => item.name === PROCESS_NAME);
+      const cwd = gateway?.pm2_env?.pm_cwd;
+      if (typeof cwd === "string") {
+        addLegacyManagementLock(
+          legacy,
+          gateway?.pm2_env?.env ?? gateway?.env,
+          cwd
+        );
+      }
+    }
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    try {
+      const configured = plistValue(
+        readFileSync3(launchAgentPath(), "utf8"),
+        "SUPERTASK_PM2_MANAGEMENT_LOCK"
+      );
+      if (configured) legacy.add(resolve(configured));
+    } catch {
+    }
+  }
+  if (isPm2Installed()) {
+    const gateway = pm2JsonList().find((item) => item.name === PROCESS_NAME);
+    const cwd = gateway?.pm2_env?.pm_cwd;
+    if (typeof cwd === "string") {
+      addLegacyManagementLock(
+        legacy,
+        gateway?.pm2_env?.env ?? gateway?.env,
+        cwd
+      );
+    }
+  }
+  return [
+    canonical,
+    ...[...legacy].filter((path) => path !== canonical).sort()
+  ];
+}
+function withManagementLocks(paths, timeoutMs, action, index2 = 0) {
+  const path = paths[index2];
+  if (!path) return action();
+  return withExclusiveManagementLock(
+    path,
+    timeoutMs,
+    () => withManagementLocks(paths, timeoutMs, action, index2 + 1)
+  );
+}
+function assertMacLaunchAgentPm2HomeMatchesCurrent() {
+  if (process.platform !== "darwin") return;
+  try {
+    const configuredPm2Home = plistValue(
+      readFileSync3(launchAgentPath(), "utf8"),
+      "PM2_HOME"
+    );
+    if (!configuredPm2Home) return;
+    const installedPm2Home = resolve(configuredPm2Home);
+    const activePm2Home = currentScope().pm2Home;
+    if (installedPm2Home !== activePm2Home) {
+      throw new Error(
+        `[supertask] \u5DF2\u5B89\u88C5\u7684 macOS LaunchAgent \u4F7F\u7528 PM2_HOME=${installedPm2Home}\uFF0C\u5F53\u524D CLI \u4F7F\u7528 ${activePm2Home}\uFF1B\u4E3A\u907F\u514D\u4E24\u4E2A PM2 daemon \u540C\u65F6\u7BA1\u7406 Gateway\uFF0C\u5DF2\u62D2\u7EDD\u4FEE\u6539\u3002\u8BF7\u4F7F\u7528 PM2_HOME=${installedPm2Home} \u91CD\u65B0\u6267\u884C\u547D\u4EE4`
+      );
+    }
+  } catch (error45) {
+    if (error45 instanceof Error && error45.message.startsWith("[supertask] \u5DF2\u5B89\u88C5\u7684 macOS LaunchAgent")) {
+      throw error45;
+    }
+    if (error45.code !== "ENOENT") throw error45;
+  }
+}
+function withManagementLock(action) {
+  const paths = savedManagementLockPaths();
+  const configuredTimeout = Number(process.env.SUPERTASK_PM2_MANAGEMENT_LOCK_TIMEOUT_MS ?? 15e3);
+  const timeoutMs = Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : 15e3;
+  try {
+    return withManagementLocks(paths, timeoutMs, () => {
+      assertMacLaunchAgentPm2HomeMatchesCurrent();
+      return action();
+    });
+  } catch (error45) {
+    if (error45 instanceof ManagementLockBusyError) {
+      throw new Error("[supertask] \u53E6\u4E00\u4E2A Gateway \u7BA1\u7406\u64CD\u4F5C\u4ECD\u5728\u8FDB\u884C\uFF0C\u5DF2\u62D2\u7EDD\u5E76\u53D1\u4FEE\u6539 PM2 \u72B6\u6001");
+    }
+    throw error45;
+  }
 }
 function upgrade(target) {
+  return withManagementLock(() => upgradeUnlocked(target));
+}
+function upgradeUnlocked(target) {
   if (!isPm2Installed()) {
     throw new Error("[supertask] pm2 is not installed. Run `supertask install` first.");
   }
-  const before = getRunningVersion();
-  const oldGatewayEntry = resolveGatewayEntry();
-  const currentVersion = target?.version ?? getPackageVersion();
   const existing = pm2JsonList().find((item) => item.name === PROCESS_NAME);
-  if (existing) requirePm2(["delete", PROCESS_NAME], "pm2 delete old Gateway");
+  const oldRuntime = gatewayRuntimeFromProcess(existing) ?? (process.env.SUPERTASK_GATEWAY_ENTRY ? currentGatewayRuntime(resolveGatewayEntry()) : null);
+  const before = getRunningVersion(oldRuntime?.env ?? process.env, oldRuntime?.cwd);
+  const currentVersion = target?.version ?? getPackageVersion();
+  const targetRuntime = oldRuntime ? { ...oldRuntime, gatewayEntry: resolve(target?.gatewayEntry ?? oldRuntime.gatewayEntry) } : currentGatewayRuntime(target?.gatewayEntry ?? resolveGatewayEntry());
+  assertRuntimeCanControlPm2(oldRuntime, existing);
+  gatewayKillTimeoutMs(targetRuntime);
+  gatewayTerminationCommandTimeoutMs(targetRuntime);
+  if (existing) requirePm2Termination("delete", "pm2 delete old Gateway", oldRuntime);
   try {
-    pm2StartGateway(target?.gatewayEntry ?? oldGatewayEntry);
-    writeRunningVersion(currentVersion);
-    savePm2State();
+    pm2StartGateway(targetRuntime);
+    savePm2State(targetRuntime.env);
+    writeRunningVersion(currentVersion, targetRuntime.env, targetRuntime.cwd);
     return { before, after: currentVersion, restarted: true };
   } catch (error45) {
-    const failed = pm2JsonList().find((item) => item.name === PROCESS_NAME);
-    if (failed) requirePm2(["delete", PROCESS_NAME], "pm2 delete failed Gateway");
+    const failed = pm2JsonList(targetRuntime.env).find((item) => item.name === PROCESS_NAME);
+    if (failed) {
+      requirePm2Termination(
+        "delete",
+        "pm2 delete failed Gateway",
+        gatewayRuntimeFromProcess(failed) ?? targetRuntime
+      );
+    }
+    if (!oldRuntime) throw error45;
     try {
-      pm2StartGateway(oldGatewayEntry);
-      if (before) writeRunningVersion(before);
-      savePm2State();
+      pm2StartGateway(oldRuntime);
+      savePm2State(oldRuntime.env);
+      if (before) writeRunningVersion(before, oldRuntime.env, oldRuntime.cwd);
     } catch (rollbackError) {
       const original = error45 instanceof Error ? error45.message : String(error45);
       const rollback = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
@@ -27718,50 +28701,84 @@ function upgrade(target) {
   }
 }
 function ensureGateway() {
+  return withManagementLock(ensureGatewayUnlocked);
+}
+function ensureGatewayUnlocked() {
   if (!isPm2Installed()) {
     return { ok: false, reason: "pm2-not-installed" };
   }
   const currentVersion = getPackageVersion();
   const processList = pm2JsonList();
   const existing = processList.find((item) => item.name === PROCESS_NAME);
-  if (existing?.pm2_env?.status === "online" && typeof existing.pid === "number" && isGatewayReady(existing.pid) && getRunningVersion() === currentVersion) {
+  const oldRuntime = gatewayRuntimeFromProcess(existing);
+  if (oldRuntime && !scopesMatch(currentScope(), runtimeScope(oldRuntime))) {
+    throw new Error("[supertask] \u5F53\u524D OpenCode/CLI \u4E0E PM2 Gateway \u7684\u6570\u636E\u5E93\u3001\u914D\u7F6E\u6216 OpenCode \u53EF\u6267\u884C\u6587\u4EF6\u4F5C\u7528\u57DF\u4E0D\u4E00\u81F4\uFF0C\u5DF2\u62D2\u7EDD\u7EE7\u7EED\u5199\u5165");
+  }
+  assertRuntimeCanControlPm2(oldRuntime, existing);
+  const lockedVersion = existing && typeof existing.pid === "number" && oldRuntime ? gatewayVersionFromLock(existing.pid, runtimeScope(oldRuntime).databasePath) : void 0;
+  if (existing?.pm2_env?.status === "online" && typeof existing.pid === "number" && oldRuntime !== null && isGatewayReady(existing.pid, runtimeScope(oldRuntime).databasePath) && (lockedVersion === currentVersion || lockedVersion === void 0 && getRunningVersion(oldRuntime.env, oldRuntime.cwd) === currentVersion)) {
     return { ok: true, action: "already-running" };
   }
-  if (existing) requirePm2(["delete", PROCESS_NAME], "pm2 delete stale Gateway");
-  pm2StartGateway();
-  writeRunningVersion(currentVersion);
-  savePm2State();
+  const targetRuntime = oldRuntime ? { ...oldRuntime, gatewayEntry: resolve(resolveGatewayEntry()) } : currentGatewayRuntime();
+  const before = getRunningVersion(oldRuntime?.env ?? process.env, oldRuntime?.cwd);
+  gatewayKillTimeoutMs(targetRuntime);
+  gatewayTerminationCommandTimeoutMs(targetRuntime);
+  if (existing) requirePm2Termination("delete", "pm2 delete stale Gateway", oldRuntime);
+  try {
+    pm2StartGateway(targetRuntime);
+    savePm2State(targetRuntime.env);
+    writeRunningVersion(currentVersion, targetRuntime.env, targetRuntime.cwd);
+  } catch (error45) {
+    const failed = pm2JsonList(targetRuntime.env).find((item) => item.name === PROCESS_NAME);
+    if (failed) {
+      requirePm2Termination(
+        "delete",
+        "pm2 delete failed Gateway",
+        gatewayRuntimeFromProcess(failed) ?? targetRuntime
+      );
+    }
+    if (oldRuntime) {
+      try {
+        pm2StartGateway(oldRuntime);
+        savePm2State(oldRuntime.env);
+        if (before) writeRunningVersion(before, oldRuntime.env, oldRuntime.cwd);
+      } catch (rollbackError) {
+        const original = error45 instanceof Error ? error45.message : String(error45);
+        const rollback = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+        throw new Error(`${original}; \u65E7 Gateway \u56DE\u6EDA\u4E5F\u5931\u8D25: ${rollback}`);
+      }
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      throw new Error(`${message}; \u5DF2\u56DE\u6EDA\u5230\u65E7 Gateway`);
+    }
+    throw error45;
+  }
   return { ok: true, action: existing ? "restarted" : "started" };
 }
 
 // src/daemon/update.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var PACKAGE_NAME = "opencode-supertask";
 function pluginAt(packageDir) {
-  const packageJson = join4(packageDir, "package.json");
-  const gatewayEntry = join4(packageDir, "dist/gateway/index.js");
-  if (!existsSync4(packageJson) || !existsSync4(gatewayEntry)) return null;
+  const packageJson = join5(packageDir, "package.json");
+  const gatewayEntry = join5(packageDir, "dist/gateway/index.js");
+  if (!existsSync5(packageJson) || !existsSync5(gatewayEntry)) return null;
   try {
-    const pkg = JSON.parse(readFileSync3(packageJson, "utf8"));
+    const pkg = JSON.parse(readFileSync4(packageJson, "utf8"));
     if (pkg.name !== PACKAGE_NAME || typeof pkg.version !== "string") return null;
     return { packageDir, gatewayEntry, version: pkg.version };
   } catch {
     return null;
   }
 }
-function versionParts(version3) {
-  const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version3);
-  return match ? match.slice(1).map(Number) : null;
-}
 function cacheRoot() {
-  return process.env.SUPERTASK_OPENCODE_CACHE_DIR ?? join4(homedir4(), ".cache/opencode/packages");
+  return process.env.SUPERTASK_OPENCODE_CACHE_DIR ?? join5(homedir4(), ".cache/opencode/packages");
 }
 function installedPlugins() {
   const root = cacheRoot();
-  const packageDirs = existsSync4(root) ? readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && (entry.name === PACKAGE_NAME || entry.name.startsWith(`${PACKAGE_NAME}@`))).map((entry) => join4(root, entry.name, "node_modules", PACKAGE_NAME)) : [];
+  const packageDirs = existsSync5(root) ? readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && (entry.name === PACKAGE_NAME || entry.name.startsWith(`${PACKAGE_NAME}@`))).map((entry) => join5(root, entry.name, "node_modules", PACKAGE_NAME)) : [];
   return packageDirs.map(pluginAt).filter((plugin) => plugin !== null);
 }
 function opencodeBin() {
@@ -27795,7 +28812,7 @@ function latestVersion() {
   } catch {
     throw new Error(`[supertask] npm latest \u8FD4\u56DE\u65E0\u6CD5\u89E3\u6790: ${output || "(empty)"}`);
   }
-  if (typeof version3 !== "string" || versionParts(version3) === null) {
+  if (typeof version3 !== "string" || !isSemanticVersion(version3)) {
     throw new Error(`[supertask] npm latest \u7248\u672C\u65E0\u6548: ${String(version3)}`);
   }
   return version3;
@@ -27808,8 +28825,10 @@ function resolveInstalledVersion(expectedVersion) {
   const actual = installed.length > 0 ? installed.map((plugin) => plugin.version).join(", ") : "\u672A\u627E\u5230\u53EF\u8FD0\u884C\u7F13\u5B58";
   throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u7F13\u5B58\u7248\u672C\u4E0D\u5339\u914D\uFF1A\u671F\u671B ${expectedVersion}\uFF0C\u5B9E\u9645 ${actual}`);
 }
-function installLatestPlugin() {
-  const version3 = latestVersion();
+function installPluginVersion(version3) {
+  if (!isSemanticVersion(version3)) {
+    throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u7248\u672C\u65E0\u6548: ${version3}`);
+  }
   const result = spawnSync2(opencodeBin(), [
     "plugin",
     `${PACKAGE_NAME}@${version3}`,
@@ -27829,9 +28848,27 @@ function installLatestPlugin() {
   }
   return resolveInstalledVersion(version3);
 }
+function installLatestPlugin() {
+  return installPluginVersion(latestVersion());
+}
 
 // plugin/supertask.ts
 var _initialized = false;
+var _writeBlockedReason = null;
+function readyGatewayVersion() {
+  const lockRow = sqlite.prepare(
+    "SELECT heartbeat_at, ready_at, version FROM gateway_lock WHERE id = 1"
+  ).get();
+  return {
+    fresh: lockRow?.ready_at != null && Date.now() - lockRow.heartbeat_at < 3e4,
+    version: lockRow?.version ?? null
+  };
+}
+function shouldAttemptGatewayReplacement(pluginVersion, gatewayVersion) {
+  if (gatewayVersion === null) return true;
+  const direction = compareSemanticVersions(pluginVersion, gatewayVersion);
+  return direction !== null && direction >= 0;
+}
 function ensureInit() {
   if (_initialized) return;
   try {
@@ -27840,9 +28877,16 @@ function ensureInit() {
     console.error("[supertask] DB init failed:", err instanceof Error ? err.message : String(err));
     return;
   }
+  const expectedVersion = getPackageVersion();
+  let initialReady = { fresh: false, version: null };
   try {
-    const lockRow = sqlite.prepare("SELECT pid, heartbeat_at, ready_at FROM gateway_lock WHERE id = 1").get();
-    if (lockRow?.ready_at != null && Date.now() - lockRow.heartbeat_at < 3e4) {
+    initialReady = readyGatewayVersion();
+    if (initialReady.fresh && initialReady.version === expectedVersion) {
+      _initialized = true;
+      return;
+    }
+    if (initialReady.fresh && !shouldAttemptGatewayReplacement(expectedVersion, initialReady.version)) {
+      _writeBlockedReason = `Gateway \u7248\u672C ${initialReady.version ?? "unknown"} \u4E0E\u5F53\u524D\u63D2\u4EF6 ${expectedVersion} \u4E0D\u4E00\u81F4\uFF1B\u8BF7\u91CD\u542F OpenCode \u6216\u663E\u5F0F\u6267\u884C supertask upgrade`;
       _initialized = true;
       return;
     }
@@ -27851,13 +28895,29 @@ function ensureInit() {
   try {
     const gateway = ensureGateway();
     if (!gateway.ok) {
-      console.warn("[supertask] Gateway \u672A\u81EA\u52A8\u542F\u52A8\uFF1A\u672A\u5B89\u88C5 pm2\u3002\u8FD0\u884C `supertask install` \u542F\u7528\u5E38\u9A7B\u6267\u884C\uFF0C\u6216\u8FD0\u884C `supertask gateway` \u524D\u53F0\u542F\u52A8\u3002");
+      if (initialReady.fresh) {
+        _writeBlockedReason = `Gateway \u7248\u672C ${initialReady.version ?? "unknown"} \u4E0E\u63D2\u4EF6 ${expectedVersion} \u4E0D\u4E00\u81F4\uFF0C\u4E14\u672A\u5B89\u88C5 pm2 \u65E0\u6CD5\u5B89\u5168\u66FF\u6362`;
+      } else {
+        console.warn("[supertask] Gateway \u672A\u81EA\u52A8\u542F\u52A8\uFF1A\u672A\u5B89\u88C5 pm2\u3002\u8FD0\u884C `supertask install` \u542F\u7528\u5E38\u9A7B\u6267\u884C\uFF0C\u6216\u8FD0\u884C `supertask gateway` \u524D\u53F0\u542F\u52A8\u3002");
+      }
+    } else {
+      const current = readyGatewayVersion();
+      if (!current.fresh || current.version !== expectedVersion) {
+        _writeBlockedReason = `Gateway \u5C31\u7EEA\u7248\u672C ${current.version ?? "unknown"} \u4E0E\u63D2\u4EF6 ${expectedVersion} \u4E0D\u4E00\u81F4`;
+      }
     }
   } catch (error45) {
-    console.error("[supertask] Gateway init failed:", error45 instanceof Error ? error45.message : String(error45));
+    _writeBlockedReason = error45 instanceof Error ? error45.message : String(error45);
+    console.error("[supertask] Gateway init failed:", _writeBlockedReason);
   }
   _initialized = true;
 }
+function assertRuntimeWritable() {
+  ensureInit();
+  if (_writeBlockedReason) {
+    throw new Error(`[supertask] \u5DF2\u963B\u6B62\u961F\u5217\u5199\u5165: ${_writeBlockedReason}`);
+  }
+}
 var SYSTEM_INSTRUCTION = `
 ## SuperTask \u4EFB\u52A1\u961F\u5217\u7CFB\u7EDF
 
@@ -27895,25 +28955,25 @@ var SuperTaskPlugin = async () => {
       supertask_add: tool({
         description: "\u521B\u5EFA\u65B0\u4EFB\u52A1\u5230\u961F\u5217\u3002\u8FD4\u56DE\u4EFB\u52A1 ID\u3002\u4EFB\u52A1\u6309 urgency\u3001importance\u3001createdAt\u3001id \u7684\u987A\u5E8F\u8C03\u5EA6\u3002",
         args: {
-          name: tool.schema.string().describe("\u4EFB\u52A1\u540D\u79F0\uFF08\u4EBA\u7C7B\u53EF\u8BFB\uFF09"),
-          agent: tool.schema.string().describe("\u6267\u884C\u7684 Agent \u540D\u79F0\uFF0C\u5982 localize-gen, course-gen"),
-          prompt: tool.schema.string().describe("\u53D1\u9001\u7ED9 Agent \u7684\u5B8C\u6574\u63D0\u793A\u8BCD"),
+          name: tool.schema.string().trim().min(1).describe("\u4EFB\u52A1\u540D\u79F0\uFF08\u4EBA\u7C7B\u53EF\u8BFB\uFF09"),
+          agent: tool.schema.string().trim().min(1).describe("\u6267\u884C\u7684 Agent \u540D\u79F0\uFF0C\u5982 localize-gen, course-gen"),
+          prompt: tool.schema.string().trim().min(1).describe("\u53D1\u9001\u7ED9 Agent \u7684\u5B8C\u6574\u63D0\u793A\u8BCD"),
           model: tool.schema.string().optional().describe("\u4F7F\u7528\u7684\u6A21\u578B\uFF0C\u5982 gemini-2.5-pro"),
-          category: tool.schema.string().optional().describe("\u4EFB\u52A1\u5206\u7C7B\uFF1Atranslate/generate/review/test/general"),
-          importance: tool.schema.number().optional().describe("\u91CD\u8981\u7A0B\u5EA6 1-5\uFF085 \u6700\u91CD\u8981\uFF09"),
-          urgency: tool.schema.number().optional().describe("\u7D27\u6025\u7A0B\u5EA6 1-5\uFF085 \u6700\u7D27\u6025\uFF09"),
+          category: tool.schema.enum(["translate", "generate", "review", "test", "general"]).optional().describe("\u4EFB\u52A1\u5206\u7C7B"),
+          importance: tool.schema.number().int().min(1).max(5).optional().describe("\u91CD\u8981\u7A0B\u5EA6 1-5\uFF085 \u6700\u91CD\u8981\uFF09"),
+          urgency: tool.schema.number().int().min(1).max(5).optional().describe("\u7D27\u6025\u7A0B\u5EA6 1-5\uFF085 \u6700\u7D27\u6025\uFF09"),
           batchId: tool.schema.string().optional().describe("\u6279\u6B21 ID\uFF0C\u7528\u4E8E\u5206\u7EC4\u7BA1\u7406"),
-          dependsOn: tool.schema.number().optional().describe("\u4F9D\u8D56\u7684\u4EFB\u52A1 ID\uFF0C\u8BE5\u4EFB\u52A1\u5B8C\u6210\u540E\u624D\u4F1A\u6267\u884C"),
-          max_retries: tool.schema.number().optional().describe("\u9996\u6B21\u6267\u884C\u4E4B\u5916\u5141\u8BB8\u7684\u91CD\u8BD5\u6B21\u6570\uFF0C\u9ED8\u8BA4 3"),
-          retry_backoff_ms: tool.schema.number().optional().describe("\u91CD\u8BD5\u9000\u907F\u57FA\u7840\u95F4\u9694 ms\uFF0C\u9ED8\u8BA4 30000"),
-          timeout_ms: tool.schema.number().optional().describe("\u4EFB\u52A1\u786C\u8D85\u65F6 ms\uFF1B\u672A\u4F20\u5219\u4F7F\u7528 Gateway \u9ED8\u8BA4\u503C"),
+          dependsOn: tool.schema.number().int().positive().optional().describe("\u4F9D\u8D56\u7684\u4EFB\u52A1 ID\uFF0C\u8BE5\u4EFB\u52A1\u5B8C\u6210\u540E\u624D\u4F1A\u6267\u884C"),
+          max_retries: tool.schema.number().int().min(0).max(1e3).optional().describe("\u9996\u6B21\u6267\u884C\u4E4B\u5916\u5141\u8BB8\u7684\u91CD\u8BD5\u6B21\u6570\uFF0C\u9ED8\u8BA4 3"),
+          retry_backoff_ms: tool.schema.number().int().min(0).max(864e5).optional().describe("\u91CD\u8BD5\u9000\u907F\u57FA\u7840\u95F4\u9694 ms\uFF0C\u9ED8\u8BA4 30000"),
+          timeout_ms: tool.schema.number().int().min(1e3).max(6048e5).optional().describe("\u4EFB\u52A1\u786C\u8D85\u65F6 ms\uFF1B\u672A\u4F20\u5219\u4F7F\u7528 Gateway \u9ED8\u8BA4\u503C"),
           cwd: tool.schema.string().optional().describe(
             "(\u5DF2\u5E9F\u5F03) \u5DE5\u4F5C\u76EE\u5F55\u3002\u7CFB\u7EDF\u4F1A\u81EA\u52A8\u8BB0\u5F55\u63D0\u4EA4\u4EFB\u52A1\u65F6\u7684 opencode run \u542F\u52A8\u76EE\u5F55\u3002"
           )
         },
-        async execute(args) {
+        async execute(args, context) {
           try {
-            const submitCwd = process.cwd();
+            assertRuntimeWritable();
             const task = await TaskService.add({
               name: args.name,
               agent: args.agent,
@@ -27924,7 +28984,7 @@ var SuperTaskPlugin = async () => {
               urgency: args.urgency ?? 3,
               batchId: args.batchId,
               dependsOn: args.dependsOn,
-              cwd: submitCwd,
+              cwd: context.directory,
               maxRetries: args.max_retries,
               retryBackoffMs: args.retry_backoff_ms,
               timeoutMs: args.timeout_ms
@@ -27943,10 +29003,9 @@ var SuperTaskPlugin = async () => {
         args: {
           cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u8FD4\u56DE\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
         },
-        async execute(args) {
+        async execute(args, context) {
           try {
-            const scopeCwd = args.cwd ?? process.cwd();
-            const task = await TaskService.next({ cwd: scopeCwd });
+            const task = await TaskService.next({ cwd: context.directory });
             if (task) {
               return JSON.stringify({
                 id: task.id,
@@ -27969,85 +29028,6 @@ var SuperTaskPlugin = async () => {
           }
         }
       }),
-      // 开始执行任务
-      supertask_start: tool({
-        description: "\u6807\u8BB0\u4EFB\u52A1\u4E3A\u6B63\u5728\u6267\u884C\uFF08running\uFF09\u3002\u8BB0\u5F55\u5F00\u59CB\u65F6\u95F4\u3002",
-        args: {
-          id: tool.schema.number().describe("\u4EFB\u52A1 ID"),
-          cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u64CD\u4F5C\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
-        },
-        async execute(args) {
-          try {
-            const scopeCwd = args.cwd ?? process.cwd();
-            const task = await TaskService.start(args.id, { cwd: scopeCwd });
-            if (task) return JSON.stringify({ id: task.id, status: task.status });
-            const existing = await TaskService.getById(args.id, { cwd: scopeCwd });
-            if (!existing) return JSON.stringify({ error: "Task not found" });
-            return JSON.stringify({
-              error: "Task status does not allow start",
-              id: existing.id,
-              status: existing.status,
-              message: `Only pending or retryable failed tasks can be started; current status is '${existing.status}'.`
-            });
-          } catch (error45) {
-            return JSON.stringify({
-              error: error45 instanceof Error ? error45.message : String(error45)
-            });
-          }
-        }
-      }),
-      // 完成任务
-      supertask_done: tool({
-        description: "\u6807\u8BB0\u4EFB\u52A1\u5B8C\u6210\uFF08done\uFF09\u3002\u8BB0\u5F55\u7ED3\u675F\u65F6\u95F4\u548C\u7ED3\u679C\u65E5\u5FD7\u3002",
-        args: {
-          id: tool.schema.number().describe("\u4EFB\u52A1 ID"),
-          log: tool.schema.string().optional().describe("\u6267\u884C\u7ED3\u679C\u65E5\u5FD7"),
-          cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u64CD\u4F5C\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
-        },
-        async execute(args) {
-          try {
-            const scopeCwd = args.cwd ?? process.cwd();
-            const task = await TaskService.done(args.id, args.log, { cwd: scopeCwd });
-            if (task) {
-              return JSON.stringify({ id: task.id, status: task.status });
-            } else {
-              return JSON.stringify({ error: "Task not found" });
-            }
-          } catch (error45) {
-            return JSON.stringify({
-              error: error45 instanceof Error ? error45.message : String(error45)
-            });
-          }
-        }
-      }),
-      // 任务失败
-      supertask_fail: tool({
-        description: "\u6807\u8BB0\u4EFB\u52A1\u5931\u8D25\uFF08failed\uFF09\u3002\u8BB0\u5F55\u9519\u8BEF\u65E5\u5FD7\uFF0C\u81EA\u52A8\u589E\u52A0\u91CD\u8BD5\u8BA1\u6570\u3002",
-        args: {
-          id: tool.schema.number().describe("\u4EFB\u52A1 ID"),
-          log: tool.schema.string().optional().describe("\u9519\u8BEF\u65E5\u5FD7"),
-          cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u64CD\u4F5C\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
-        },
-        async execute(args) {
-          try {
-            const scopeCwd = args.cwd ?? process.cwd();
-            const task = await TaskService.fail(args.id, args.log, { cwd: scopeCwd });
-            if (task) {
-              return JSON.stringify({
-                id: task.id,
-                status: task.status,
-                retryCount: task.retryCount
-              });
-            } else {
-              return JSON.stringify({ error: "Task not found" });
-            }
-          } catch (error45) {
-            return JSON.stringify({
-              error: error45 instanceof Error ? error45.message : String(error45)
-            });
-          }
-        }
-      }),
       // 查看统计
       supertask_status: tool({
         description: "\u67E5\u770B\u4EFB\u52A1\u961F\u5217\u7EDF\u8BA1\u3002\u53EF\u6309\u6279\u6B21\u7B5B\u9009\u3002",
@@ -28055,10 +29035,9 @@ var SuperTaskPlugin = async () => {
           batchId: tool.schema.string().optional().describe("\u6309\u6279\u6B21\u7B5B\u9009"),
           cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u7EDF\u8BA1\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
         },
-        async execute(args) {
+        async execute(args, context) {
           try {
-            const scopeCwd = args.cwd ?? process.cwd();
-            const stats = await TaskService.stats({ batchId: args.batchId, cwd: scopeCwd });
+            const stats = await TaskService.stats({ batchId: args.batchId, cwd: context.directory });
             return JSON.stringify(stats);
           } catch (error45) {
             return JSON.stringify({
@@ -28071,22 +29050,22 @@ var SuperTaskPlugin = async () => {
       supertask_retry: tool({
         description: "\u91CD\u8BD5\u5931\u8D25\u7684\u4EFB\u52A1\u3002\u5C06 failed \u72B6\u6001\u91CD\u7F6E\u4E3A pending\uFF0C\u81EA\u52A8\u6E05\u9664\u5F00\u59CB/\u7ED3\u675F\u65F6\u95F4\u3002",
         args: {
-          id: tool.schema.number().optional().describe("\u4EFB\u52A1 ID"),
+          id: tool.schema.number().int().positive().optional().describe("\u4EFB\u52A1 ID"),
           batchId: tool.schema.string().optional().describe("\u6279\u6B21 ID\uFF08\u6279\u91CF\u91CD\u8BD5\uFF09"),
           cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u64CD\u4F5C\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
         },
-        async execute(args) {
+        async execute(args, context) {
           try {
-            const scopeCwd = args.cwd ?? process.cwd();
+            assertRuntimeWritable();
             if (args.id !== void 0) {
-              const task = await TaskService.retry(args.id, { cwd: scopeCwd });
+              const task = await TaskService.retry(args.id, { cwd: context.directory });
               if (task) {
                 return JSON.stringify({ id: task.id, status: task.status });
               } else {
                 return JSON.stringify({ error: "Task not found or not failed" });
               }
             } else if (args.batchId !== void 0) {
-              const count = await TaskService.retryBatch(args.batchId, { cwd: scopeCwd });
+              const count = await TaskService.retryBatch(args.batchId, { cwd: context.directory });
               return JSON.stringify({ retried: count, batchId: args.batchId });
             } else {
               return JSON.stringify({ error: "Please specify id or batchId" });
@@ -28102,16 +29081,15 @@ var SuperTaskPlugin = async () => {
       supertask_list: tool({
         description: "\u5217\u51FA\u6700\u8FD1\u7684\u4EFB\u52A1\u3002\u652F\u6301\u6309\u72B6\u6001\u7B5B\u9009\uFF0C\u6309\u521B\u5EFA\u65F6\u95F4\u5012\u5E8F\u3002",
         args: {
-          status: tool.schema.string().optional().describe("\u6309\u72B6\u6001\u7B5B\u9009\uFF1Apending/running/done/failed/cancelled"),
-          limit: tool.schema.number().optional().describe("\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 20"),
+          status: tool.schema.enum(["pending", "running", "done", "failed", "dead_letter", "cancelled"]).optional().describe("\u6309\u72B6\u6001\u7B5B\u9009"),
+          limit: tool.schema.number().int().min(1).max(1e3).optional().describe("\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 20"),
           cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u8FD4\u56DE\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
         },
-        async execute(args) {
+        async execute(args, context) {
           try {
-            const scopeCwd = args.cwd ?? process.cwd();
             const tasks3 = await TaskService.list({
               status: args.status,
-              cwd: scopeCwd,
+              cwd: context.directory,
               limit: args.limit ?? 20
             });
             return JSON.stringify(tasks3);
@@ -28126,13 +29104,12 @@ var SuperTaskPlugin = async () => {
       supertask_get: tool({
         description: "\u83B7\u53D6\u6307\u5B9A ID \u7684\u4EFB\u52A1\u8BE6\u60C5\u3002",
         args: {
-          id: tool.schema.number().describe("\u4EFB\u52A1 ID"),
+          id: tool.schema.number().int().positive().describe("\u4EFB\u52A1 ID"),
           cwd: tool.schema.string().optional().describe("\u9879\u76EE\u9694\u79BB\uFF1A\u4F20\u5165\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u53EA\u8FD4\u56DE\u8BE5\u9879\u76EE\u7684\u4EFB\u52A1")
         },
-        async execute(args) {
+        async execute(args, context) {
           try {
-            const scopeCwd = args.cwd ?? process.cwd();
-            const task = await TaskService.getById(args.id, { cwd: scopeCwd });
+            const task = await TaskService.getById(args.id, { cwd: context.directory });
             if (task) {
               return JSON.stringify({
                 id: task.id,
@@ -28158,13 +29135,13 @@ var SuperTaskPlugin = async () => {
       supertask_schedule: tool({
         description: "\u521B\u5EFA\u8C03\u5EA6\u6A21\u677F\uFF0C\u7528\u4E8E\u5B9A\u65F6/\u5EF6\u8FDF/\u5FAA\u73AF\u6267\u884C\u4EFB\u52A1\u3002\u652F\u6301 cron \u8868\u8FBE\u5F0F\u3001\u4E00\u6B21\u6027\u5EF6\u8FDF\u548C\u56FA\u5B9A\u95F4\u9694\u5FAA\u73AF\u3002Gateway \u4F1A\u6309\u6A21\u677F\u81EA\u52A8\u751F\u6210\u4EFB\u52A1\u5230\u961F\u5217\u3002",
         args: {
-          name: tool.schema.string().describe("\u6A21\u677F\u540D\u79F0"),
-          agent: tool.schema.string().describe("\u6267\u884C\u7684 Agent \u540D\u79F0"),
-          prompt: tool.schema.string().describe("\u53D1\u9001\u7ED9 Agent \u7684\u5B8C\u6574\u63D0\u793A\u8BCD"),
+          name: tool.schema.string().trim().min(1).describe("\u6A21\u677F\u540D\u79F0"),
+          agent: tool.schema.string().trim().min(1).describe("\u6267\u884C\u7684 Agent \u540D\u79F0"),
+          prompt: tool.schema.string().trim().min(1).describe("\u53D1\u9001\u7ED9 Agent \u7684\u5B8C\u6574\u63D0\u793A\u8BCD"),
           model: tool.schema.string().optional().describe("\u4F7F\u7528\u7684\u6A21\u578B"),
-          category: tool.schema.string().optional().describe("\u4EFB\u52A1\u5206\u7C7B\uFF1Atranslate/generate/review/test/general"),
-          importance: tool.schema.number().optional().describe("\u91CD\u8981\u7A0B\u5EA6 1-5"),
-          urgency: tool.schema.number().optional().describe("\u7D27\u6025\u7A0B\u5EA6 1-5"),
+          category: tool.schema.enum(["translate", "generate", "review", "test", "general"]).optional().describe("\u4EFB\u52A1\u5206\u7C7B"),
+          importance: tool.schema.number().int().min(1).max(5).optional().describe("\u91CD\u8981\u7A0B\u5EA6 1-5"),
+          urgency: tool.schema.number().int().min(1).max(5).optional().describe("\u7D27\u6025\u7A0B\u5EA6 1-5"),
           batchId: tool.schema.string().optional().describe("\u6A21\u677F\u751F\u6210\u7684\u4EFB\u52A1\u5F52\u5C5E\u7684\u6279\u6B21 ID"),
           schedule: tool.schema.object({
             type: tool.schema.enum(["cron", "delayed", "recurring"]).describe("\u8C03\u5EA6\u7C7B\u578B"),
@@ -28172,13 +29149,14 @@ var SuperTaskPlugin = async () => {
             delay: tool.schema.string().optional().describe("\u5EF6\u8FDF\u65F6\u95F4\uFF08delayed \u7C7B\u578B\u5FC5\u586B\uFF09\uFF0C\u53CB\u597D\u683C\u5F0F\u5982 '30s' '5min' '1h' '2d'\uFF0C\u4E5F\u652F\u6301 ISO 8601 duration \u5982 'PT30M'"),
             interval: tool.schema.string().optional().describe("\u5FAA\u73AF\u95F4\u9694\uFF08recurring \u7C7B\u578B\u5FC5\u586B\uFF09\uFF0C\u53CB\u597D\u683C\u5F0F\u5982 '1h' '30min' '5s'\uFF0C\u4E5F\u652F\u6301 ISO 8601 duration \u5982 'PT1H'")
           }).describe("\u8C03\u5EA6\u914D\u7F6E"),
-          max_instances: tool.schema.number().optional().describe("\u6700\u5927\u5E76\u53D1\u5B9E\u4F8B\u6570\uFF0C\u9ED8\u8BA4 1"),
-          max_retries: tool.schema.number().optional().describe("\u514B\u9686\u7ED9 task \u7684\u6700\u5927\u91CD\u8BD5\u6B21\u6570\uFF0C\u9ED8\u8BA4 3"),
-          retry_backoff_ms: tool.schema.number().optional().describe("\u514B\u9686\u7ED9 task \u7684\u9000\u907F\u57FA\u7840\u95F4\u9694 ms\uFF0C\u9ED8\u8BA4 30000"),
-          timeout_ms: tool.schema.number().optional().describe("\u514B\u9686\u7ED9 task \u7684\u786C\u8D85\u65F6 ms\uFF1B\u672A\u4F20\u5219\u4F7F\u7528 Gateway \u9ED8\u8BA4\u503C")
+          max_instances: tool.schema.number().int().min(1).max(1e3).optional().describe("\u6700\u5927\u5E76\u53D1\u5B9E\u4F8B\u6570\uFF0C\u9ED8\u8BA4 1"),
+          max_retries: tool.schema.number().int().min(0).max(1e3).optional().describe("\u514B\u9686\u7ED9 task \u7684\u6700\u5927\u91CD\u8BD5\u6B21\u6570\uFF0C\u9ED8\u8BA4 3"),
+          retry_backoff_ms: tool.schema.number().int().min(0).max(864e5).optional().describe("\u514B\u9686\u7ED9 task \u7684\u9000\u907F\u57FA\u7840\u95F4\u9694 ms\uFF0C\u9ED8\u8BA4 30000"),
+          timeout_ms: tool.schema.number().int().min(1e3).max(6048e5).optional().describe("\u514B\u9686\u7ED9 task \u7684\u786C\u8D85\u65F6 ms\uFF1B\u672A\u4F20\u5219\u4F7F\u7528 Gateway \u9ED8\u8BA4\u503C")
         },
-        async execute(args) {
+        async execute(args, context) {
           try {
+            assertRuntimeWritable();
             if (!args.schedule) {
               return JSON.stringify({ error: "schedule is required" });
             }
@@ -28207,7 +29185,7 @@ var SuperTaskPlugin = async () => {
               category: args.category ?? "general",
               importance: args.importance ?? 3,
               urgency: args.urgency ?? 3,
-              cwd: process.cwd(),
+              cwd: context.directory,
               batchId: args.batchId,
               scheduleType,
               cronExpr,
@@ -28236,19 +29214,47 @@ var SuperTaskPlugin = async () => {
         description: "\u5347\u7EA7 SuperTask \u63D2\u4EF6\u3002\u901A\u8FC7 OpenCode \u5237\u65B0\u63D2\u4EF6\u7F13\u5B58\uFF0C\u6821\u9A8C\u65B0\u7248\u6784\u5EFA\u4EA7\u7269\u540E\u91CD\u542F Gateway\u3002\u5F53\u7528\u6237\u8BF4'\u5347\u7EA7\u63D2\u4EF6'\u3001'\u66F4\u65B0 supertask'\u3001'upgrade'\u65F6\u4F7F\u7528\u3002",
         args: {},
         async execute() {
+          if (process.env[MANAGED_RUN_ENV] === MANAGED_RUN_ENV_VALUE) {
+            return JSON.stringify({
+              success: false,
+              error: "Gateway \u7BA1\u7406\u7684\u961F\u5217\u4EFB\u52A1\u4E0D\u80FD\u5347\u7EA7 SuperTask\uFF0C\u5426\u5219\u4F1A\u7EC8\u6B62\u627F\u8F7D\u5F53\u524D\u4EFB\u52A1\u7684 Gateway\u3002",
+              hint: "\u8BF7\u4ECE\u5916\u90E8\u7EC8\u7AEF\u6267\u884C `supertask upgrade`\uFF0C\u6216\u5728\u975E\u961F\u5217 OpenCode \u4F1A\u8BDD\u4E2D\u8C03\u7528\u5347\u7EA7\u5DE5\u5177\u3002"
+            });
+          }
           try {
             console.log("[supertask] Updating OpenCode plugin cache...");
+            const previousVersion = getPackageVersion();
             let installed;
             try {
               installed = installLatestPlugin();
             } catch (updateError) {
+              let detail = updateError instanceof Error ? updateError.message : String(updateError);
+              try {
+                installPluginVersion(previousVersion);
+              } catch (rollbackError) {
+                detail += `; OpenCode \u63D2\u4EF6\u56DE\u6EDA\u5931\u8D25: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`;
+              }
               return JSON.stringify({
                 success: false,
-                error: updateError instanceof Error ? updateError.message : String(updateError),
+                error: detail,
                 hint: "Query npm dist-tags.latest, then install that exact version with opencode plugin."
               });
             }
-            const result = upgrade(installed);
+            let result;
+            try {
+              result = upgrade(installed);
+            } catch (upgradeError) {
+              try {
+                if (previousVersion !== installed.version) {
+                  installPluginVersion(previousVersion);
+                }
+              } catch (rollbackError) {
+                const original = upgradeError instanceof Error ? upgradeError.message : String(upgradeError);
+                const rollback = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+                throw new Error(`${original}; Gateway \u5DF2\u56DE\u6EDA\uFF0C\u4F46 OpenCode \u63D2\u4EF6\u56DE\u6EDA\u5931\u8D25: ${rollback}`);
+              }
+              throw upgradeError;
+            }
             return JSON.stringify({
               success: true,
               before: result.before,
@@ -28268,6 +29274,7 @@ var SuperTaskPlugin = async () => {
   };
 };
 export {
-  SuperTaskPlugin
+  SuperTaskPlugin,
+  shouldAttemptGatewayReplacement
 };
 //# sourceMappingURL=supertask.js.map