@capybara-hq/kernel 0.1.0-rc.23 → 0.1.0-rc.24

package/dist/runtime/waits.js

@@ -7,7 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { getQueueToken } from "@nestjs/bullmq";
 import { Inject, Injectable } from "@nestjs/common";
 import { DelayedError } from "bullmq";
 import { sql } from "kysely";
@@ -18,18 +17,18 @@ import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
-import { LockService } from "../infra/lock/lock.service.js";
-import { LockedCron } from "../infra/schedule/locked-cron.decorator.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { ApprovalsService, NETWORK_ASK_CANCELLED_NOTE, } from "../tools/approvals.service.js";
 import { APPROVAL_CANCELLED_TEXT, INPUT_CANCELLED_TEXT, RUN_STOPPED_TEXT, ToolPipeline, } from "../tools/pipeline.js";
 import { QuestionsService } from "../tools/questions.service.js";
 import { RunAbort } from "./abort.js";
 import { KyselyCheckpointSaver } from "./checkpointer.js";
-import { subagentsWaitId, subagentWaitingIdemKey } from "./loop.js";
+import { subagentWaitingIdemKey } from "./loop.js";
 import { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
 import { assistantIdemKey } from "./model-call.js";
-import { notifyFinished, RunFinish, TERMINAL_STATUSES } from "./run-finish.js";
+import { notifyFinished, RunFinish } from "./run-finish.js";
+import { lockWaitRowsIn, RunResume, resumeJobId, TERMINAL_STATUSES } from "./run-jobs.js";
 import { ACTIVE_RUN_STATUSES, RunQueue } from "./run-queue.js";
 import { childResult, deliveryRowOfChildRun, finishedEvent, rootSurfaceOf, } from "./subagents/child.js";
 import { SubagentDeliveries } from "./subagents/deliveries.js";
@@ -38,28 +37,18 @@ export { MAINTENANCE_QUEUE_NAME };
 /** 等待超时任务的名字与 jobId（每个审批 / 输入请求一个，重复投递被 BullMQ 忽略）。 */
 export const WAIT_TIMEOUT_JOB = "wait-timeout";
 export const waitTimeoutJobId = (waitId) => `wait-timeout-${waitId}`;
-/** 续跑任务的 jobId：与按消息生成的 `run-<conversationId>-<seq>` 不冲突，同一等待只会续跑一次。 */
-export const resumeJobId = (conversationId, waitId) => `run-${conversationId}-resume-${waitId}`;
+/** A resumed run's job id (`run-<conversationId>-resume-<waitId>`; `RunResume` owes it). */
+export { resumeJobId };
 /**
- * 等待兜底扫描（Task 22）：任务名、job scheduler id（不含 `:`）、周期、宽限期与每类每次最多处理的条数。
- * 宽限期：waiting 超过它、等待却已全部处理的运行才视为「续跑丢失」，避免与正常续跑（暂停后的复查等）竞争。
- */
-export const WAIT_SWEEP_JOB = "wait-sweep";
-/** The maintenance scheduler the sweep ran on before it became a `@LockedCron` (retired). */
-export { WAIT_SWEEP_SCHEDULER_ID } from "./job-ids.js";
-export const WAIT_SWEEP_GRACE_MS = 60_000;
-export const WAIT_SWEEP_BATCH = 500;
-const TERMINAL_RUN_STATUSES = ["completed", "failed", "aborted"];
-/** 超时任务处理出错（如 PG 暂不可用）时的重试。 */
-const TIMEOUT_JOB_ATTEMPTS = 5;
-const TIMEOUT_JOB_BACKOFF_MS = 5_000;
-/**
- * 运行等待人处理（spec 4.4 / Task 9）：暂停、续跑、超时与中止。状态全部在 PG（`runs.status = 'waiting'`、
- * `approvals` / `questions` 行），延迟与重试走 BullMQ（维护队列的 `wait-timeout` 任务），没有进程内状态。
+ * Runs waiting for a person (spec 4.4 / Task 9): suspend, resume, timeout and stop. All state is in
+ * PG (`runs.status = 'waiting'`, the `approvals` / `questions` rows); delays and retries are BullMQ
+ * jobs (the maintenance queue's `wait-timeout`) owed through the outbox; no in-process state.
  *
- * 只续跑一次：`resume` 是一条条件更新 `waiting → queued`（且该运行已没有 pending 的等待），并发调用只有一个成功，
- * 成功者投递 jobId 为 `run-<conversationId>-resume-<waitId>` 的运行任务。人工决定、超时任务、
- * 暂停后的复查都可能调用它，谁先谁后都只有一次续跑。
+ * One resume only: a resume locks the run row and moves it `waiting → queued` only when it waits on
+ * nothing else, owing the run job `run-<conversationId>-resume-<waitId>` in the same transaction
+ * (transactional outbox spec §6). A decision does it in its own transaction
+ * (`RunResume.resumeIn`); the timeout job, the suspend's re-check and a fork child's finish
+ * through {@link resume}. Whichever comes first, the run resumes once.
  */
 let Waits = class Waits {
     kdb;
@@ -71,15 +60,17 @@ let Waits = class Waits {
     finisher;
     checkpoints;
     abort;
-    timeouts;
-    events;
+    outbox;
+    resumes;
     log;
     background;
     deliveries;
     txHost;
     /** Drops the `run.orphaned` subscription (the events may outlive this instance). */
     unsubscribe;
-    constructor(kdb, eventLog, approvals, questions, runQueue, 
+    constructor(kdb, eventLog, approvals, questions, 
+    /** Stops a queued or running sub-agent no worker holds directly ({@link stopRun}). */
+    runQueue, 
     /**
      * Writes, in the caller's transaction, the results of a stopped run's open `Agent` calls;
      * `fire` runs their observe hooks after the commit.
@@ -93,8 +84,10 @@ let Waits = class Waits {
      * `waiting` is set. Children are stopped through `request`.
      */
     abort, 
-    /** The maintenance queue: wait timeout jobs (`MaintenanceProcessor` consumes them). */
-    timeouts, events, log, 
+    /** Owes the wait timeout jobs (`MaintenanceProcessor` consumes them) with the suspend. */
+    outbox, 
+    /** The resume of a waiting run, in the caller's transaction ({@link resume}). */
+    resumes, events, log, 
     /** Stops a finished sub-agent run's background tasks ({@link childFinished}). */
     background, 
     /** Delivers a background child's finish to its parent ({@link childFinished}). */
@@ -108,15 +101,15 @@ let Waits = class Waits {
         this.finisher = finisher;
         this.checkpoints = checkpoints;
         this.abort = abort;
-        this.timeouts = timeouts;
-        this.events = events;
+        this.outbox = outbox;
+        this.resumes = resumes;
         this.log = log;
         this.background = background;
         this.deliveries = deliveries;
         this.txHost = txHost;
-        // an orphaned parent run (marked failed by `ensureRun`) stops its fork child at once
-        // (background children keep running, agent map spec §5.4); the sweep's
-        // `sweepForkChildrenOfFinished` is the backstop
+        // an orphaned parent run (failed by the `run-orphan-check`) stops its fork child at once
+        // (background children keep running, agent map spec §5.4); the `stop-tree` job its terminal
+        // transaction owed is the backstop
         this.unsubscribe = events.on("run.orphaned", ({ runId }) => this.stopChildren(runId, null)
             .then(() => { })
             .catch((err) => this.log.error("cannot stop the sub-agents of an orphaned run", { runId, err })));
@@ -130,55 +123,18 @@ let Waits = class Waits {
         return this.kdb.db;
     }
     /**
-     * 兜底扫描（维护队列每 10 分钟一次，防延迟任务 / 续跑丢失）。每项修复都复用常规路径，与并发的超时任务、
-     * 人工决定、其他副本的扫描竞争时由行锁与条件更新保证只生效一次；每项生效的修复记一行 warn（只含 id）。
-     * 顺序：先取消终态运行的等待（这些不该再按超时处理），再处理过期的等待，最后续跑「续跑丢失」的运行。
-     * 单项失败只记日志，不影响其他项。
-     */
-    async sweep() {
-        const out = {
-            expired: 0,
-            resumed: 0,
-            cancelled: 0,
-            repaired: 0,
-            requeued: 0,
-            orphaned: 0,
-            stopped: 0,
-            delivered: 0,
-            restarted: 0,
-        };
-        out.cancelled = await this.sweepFinishedRuns();
-        out.expired = await this.sweepOverdue();
-        Object.assign(out, await this.sweepSubagentOrphans());
-        out.repaired = await this.sweepOpenAgentCalls();
-        out.stopped =
-            (await this.sweepForkChildrenOfFinished()) + (await this.sweepTreesOfDeletedRoots());
-        out.delivered = await this.sweepUndelivered();
-        out.restarted = await this.sweepParkedMessages();
-        out.resumed = await this.sweepStuckRuns();
-        return out;
-    }
-    /**
-     * loop 返回 `suspended` 之后（worker 已释放会话锁与配额）：条件更新 `running → waiting`（记 `waiting_since`），
-     * 投递延迟到 `expiresAt` 的超时任务，再复查一次等待是否已被处理——处理者的 `resume` 可能发生在本次置 waiting
-     * 之前（那时条件更新不成立），复查保证这种情况下仍会续跑。
-     * 运行已不是 running（例如已被其他路径结束）→ 什么都不做。
-     * 暂停时已收到用户中止（`abort`），或置 waiting 之后补查到中止标记 → 直接按 {@link abortWaiting} 取消等待并结束
-     * 运行（置 waiting 之后到达的中止由 `POST .../abort` 看到 waiting 直接处理，两边不会都漏掉）。
+     * After the loop returned `suspended` (the worker released the conversation lock and the quota):
+     * in one transaction the conditional `running → waiting` (recording `waiting_since`) and the
+     * wait's timeout job (`runAt` = `expiresAt`); then a re-check whether the wait is already
+     * settled: a decision that came while the run was still `running` did not resume it, so the
+     * re-check does.
+     * A run no longer running (ended by another path) → nothing.
+     * A stop received while suspending (`abort`), or found in the stop marker after `waiting` is set
+     * → the wait is cancelled and the run ended as {@link abortWaiting} does (a stop arriving after
+     * `waiting` is set is handled by `POST .../abort`, which sees `waiting`; neither side misses it).
      */
     async suspend(runId, conversationId, waitingFor, abort) {
-        const r = await this.db
-            .updateTable("runs")
-            .set({
-            status: "waiting",
-            waiting_since: sql `now()`,
-            // a sub-agents wait has no row of its own: its expiry lives on the run, for the sweep
-            wait_expires_at: waitingFor.kind === "subagents" ? new Date(waitingFor.expiresAt) : null,
-        })
-            .where("id", "=", runId)
-            .where("status", "=", "running")
-            .executeTakeFirst();
-        if (Number(r.numUpdatedRows) === 0) {
+        if (!(await this.suspendIn(runId, waitingFor))) {
             this.log.warn("run is no longer running; not suspending", { runId });
             return;
         }
@@ -187,10 +143,37 @@ let Waits = class Waits {
             return;
         }
         await this.surfaceInRoot(runId, conversationId, waitingFor);
-        await this.scheduleTimeout(waitingFor, runId);
+        // A decision that locked the run while it was still `running` wrote nothing to it
+        // (`RunResume.resumeIn`: "still-running"); its row lock held this suspend's update until it
+        // committed, so this read, a new statement after that commit, sees the decided wait.
         if (await this.isSettled(waitingFor, runId))
             await this.resume(runId, waitingFor.id);
     }
+    /**
+     * {@link suspend}'s transaction: the conditional `running → waiting` and the wait's timeout job
+     * owed with it ({@link oweTimeout}). False when the run was no longer running (nothing written).
+     */
+    async suspendIn(runId, waitingFor) {
+        const row = await this.db
+            .updateTable("runs")
+            .set({
+            status: "waiting",
+            waiting_since: sql `now()`,
+            // a sub-agents wait has no row of its own: its expiry is kept on the run (its timeout job
+            // carries the run and step)
+            wait_expires_at: waitingFor.kind === "subagents" ? new Date(waitingFor.expiresAt) : null,
+        })
+            .from("conversations")
+            .whereRef("conversations.id", "=", "runs.conversation_id")
+            .where("runs.id", "=", runId)
+            .where("runs.status", "=", "running")
+            .returning("conversations.org_id")
+            .executeTakeFirst();
+        if (!row)
+            return false;
+        await this.oweTimeout(waitingFor, runId, row.org_id);
+        return true;
+    }
     /**
      * A sub-agent's run waits for an approval or an input (sub-agents spec §9): appends
      * `subagent_waiting` to the **root** conversation of its tree, whatever its depth (agent map spec
@@ -255,59 +238,12 @@ let Waits = class Waits {
         }
     }
     /**
-     * 续跑：一条条件更新 `waiting → queued`（且该运行没有 pending 的审批 / 输入请求），把本次等待时长累加进
-     * `waited_ms`，记下续跑任务的 jobId；成功（只有一个调用方）则投递运行任务并返回 true。
-     * 投递失败 → 撤回为 waiting（等待时长已计入，重新从现在起计），之后超时任务到点会再次续跑，并抛出。
+     * Resumes the run in its own transaction (`RunResume.resumeIn`: locks the run row and, when it
+     * is `waiting` on nothing else, sets it `queued` and owes its resume job); true when this call
+     * queued it. The wait timeout, the suspend's re-check and a fork child's finish use it; the decisions call `RunResume.resumeIn` in their own transactions.
      */
     async resume(runId, waitId) {
-        const row = await this.db
-            .updateTable("runs")
-            .set({
-            status: "queued",
-            queued_at: sql `now()`,
-            job_id: sql `'run-' || conversation_id || '-resume-' || ${waitId}::text`,
-            waited_ms: sql `waited_ms + COALESCE(floor(extract(epoch FROM now() - waiting_since) * 1000), 0)::bigint`,
-            waiting_since: null,
-            wait_expires_at: null,
-        })
-            .where("id", "=", runId)
-            .where("status", "=", "waiting")
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("approvals")
-            .select(sql `1`.as("one"))
-            .where("approvals.run_id", "=", runId)
-            .where("approvals.status", "=", "pending"))))
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("questions")
-            .select(sql `1`.as("one"))
-            .where("questions.run_id", "=", runId)
-            .where("questions.status", "=", "pending"))))
-            // a fork invocation's sub-agent (phase D; agent map spec §5.4: background `Agent`
-            // children never hold their parent run) is no longer active
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("subagent_dispatches as sd")
-            .innerJoin("runs as cr", "cr.id", "sd.child_run_id")
-            .select(sql `1`.as("one"))
-            .where("sd.parent_run_id", "=", runId)
-            .where("sd.for_skill", "=", true)
-            .where("cr.status", "in", ACTIVE_RUN_STATUSES))))
-            .returning(["conversation_id"])
-            .executeTakeFirst();
-        if (!row)
-            return false;
-        const jobId = resumeJobId(row.conversation_id, waitId);
-        try {
-            await this.runQueue.enqueue({ runId, conversationId: row.conversation_id }, jobId);
-        }
-        catch (err) {
-            this.log.error("cannot enqueue resumed run; back to waiting", { runId, jobId, err });
-            await this.db
-                .updateTable("runs")
-                .set({ status: "waiting", waiting_since: sql `now()`, job_id: null, queued_at: null })
-                .where("id", "=", runId)
-                .where("status", "=", "queued")
-                .where("job_id", "=", jobId)
-                .execute();
-            throw err;
-        }
-        return true;
+        return (await this.resumes.resumeIn(runId, waitId)) === "queued";
     }
     /**
      * 超时（`wait-timeout` 任务）：仍 pending 且已到期 → 置 expired 并写决定 / 回答事件；随后（无论本次是否生效）
@@ -360,10 +296,12 @@ let Waits = class Waits {
             .deleteThread(runId)
             .catch((err) => this.log.warn("checkpoint delete failed", { runId, err }));
         stopped?.fire();
-        // a stopped sub-agent reports to its parent now, not at the next sweep (a no-op for other runs)
+        // a stopped sub-agent reports to its parent now, not when the owed `deliver-to-parent` job
+        // runs (a no-op for other runs)
         await this.childFinished(runId).catch((err) => this.log.error("cannot report stopped sub-agent run", { runId, err }));
         // a stopped run stops its fork child (spec §12), on its behalf (no account: it reports
-        // "stopped with this run"); background children keep running; the wait sweep is the backstop
+        // "stopped with this run"); background children keep running; the `stop-tree` job the
+        // terminal transaction owed is the backstop
         await this.stopChildren(runId, null).catch((err) => this.log.error("cannot stop the sub-agents of a run", { runId, err }));
         return true;
     }
@@ -376,6 +314,7 @@ let Waits = class Waits {
             .where("id", "=", conversationId)
             .forUpdate()
             .executeTakeFirst();
+        await lockWaitRowsIn(t, runId);
         const run = await t
             .selectFrom("runs")
             .select("status")
@@ -444,561 +383,6 @@ let Waits = class Waits {
             },
         });
     }
-    /** 扫描 3：运行已终态（如暂停途中失败）仍 pending 的审批 / 输入请求 → 取消（写决定 / 回答事件）。 */
-    async sweepFinishedRuns() {
-        const db = this.db;
-        const runs = await db
-            .selectFrom("runs")
-            .select(["id", "conversation_id"])
-            .where("status", "in", TERMINAL_RUN_STATUSES)
-            .where(({ or, exists, selectFrom }) => or([
-            exists(selectFrom("approvals")
-                .select(sql `1`.as("one"))
-                .whereRef("approvals.run_id", "=", "runs.id")
-                .where("approvals.status", "=", "pending")),
-            exists(selectFrom("questions")
-                .select(sql `1`.as("one"))
-                .whereRef("questions.run_id", "=", "runs.id")
-                .where("questions.status", "=", "pending")),
-        ]))
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        let total = 0;
-        for (const run of runs) {
-            try {
-                const n = await this.cancelWaitsOfFinished(run.conversation_id, run.id);
-                if (n > 0) {
-                    total += n;
-                    this.log.warn("wait sweep: cancelled waits of finished run", {
-                        runId: run.id,
-                        conversationId: run.conversation_id,
-                        count: n,
-                    });
-                }
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot cancel waits of finished run", { runId: run.id, err });
-            }
-        }
-        return total;
-    }
-    /**
-     * 同一事务里锁会话行与运行行（与 {@link abortWaiting} 同序），运行仍是终态时取消其 pending 等待；
-     * 提交后发布事件。返回取消的条数（并发的另一副本拿到锁时已无 pending → 0）。
-     */
-    async cancelWaitsOfFinished(conversationId, runId) {
-        const r = await this.cancelWaitsOfFinishedIn(conversationId, runId);
-        if (r > 0) {
-            const last = await this.db
-                .selectFrom("conversation_events")
-                .select(sql `max(seq)`.as("seq"))
-                .where("conversation_id", "=", conversationId)
-                .executeTakeFirst();
-            if (last?.seq != null)
-                await this.eventLog.notify(conversationId, Number(last.seq));
-        }
-        return r;
-    }
-    async cancelWaitsOfFinishedIn(conversationId, runId) {
-        const t = this.db;
-        await t
-            .selectFrom("conversations")
-            .select("id")
-            .where("id", "=", conversationId)
-            .forUpdate()
-            .executeTakeFirst();
-        const run = await t
-            .selectFrom("runs")
-            .select("status")
-            .where("id", "=", runId)
-            .forUpdate()
-            .executeTakeFirst();
-        if (!run || !TERMINAL_RUN_STATUSES.includes(run.status))
-            return 0;
-        const a = await this.approvals.cancelPendingIn(runId);
-        const q = await this.questions.cancelPendingIn(runId);
-        return a.length + q.length;
-    }
-    /** 扫描 1：`expires_at < now()` 仍 pending 的审批 / 输入请求 → 与超时任务同一路径（置 expired、写事件、续跑）。 */
-    async sweepOverdue() {
-        const db = this.db;
-        const approvals = await db
-            .selectFrom("approvals")
-            .select(["id", "run_id"])
-            .where("status", "=", "pending")
-            .where("expires_at", "<", sql `now()`)
-            .orderBy("expires_at")
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        const questions = await db
-            .selectFrom("questions")
-            .select(["id", "run_id"])
-            .where("status", "=", "pending")
-            .where("expires_at", "<", sql `now()`)
-            .orderBy("expires_at")
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        const due = [
-            ...approvals.map((a) => ({ kind: "approval", id: a.id, runId: a.run_id })),
-            ...questions.map((q) => ({ kind: "input", id: q.id, runId: q.run_id })),
-        ];
-        let total = 0;
-        for (const w of due) {
-            try {
-                const r = w.kind === "approval"
-                    ? await this.approvals.expire(w.id)
-                    : await this.questions.expire(w.id);
-                if (r.outcome !== "expired")
-                    continue;
-                total++;
-                this.log.warn("wait sweep: expired overdue wait", {
-                    kind: w.kind,
-                    id: w.id,
-                    runId: w.runId,
-                });
-                if (r.record)
-                    await this.resume(r.record.runId, w.id);
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot expire overdue wait", { kind: w.kind, id: w.id, err });
-            }
-        }
-        return total + (await this.sweepOverdueSubagents());
-    }
-    /**
-     * Sub-agents waits past their `runs.wait_expires_at` (their timeout job was lost): expired the
-     * way the timeout job would ({@link expire}: the fork invocation's active child stops as
-     * `timed out`, the parent resumes once it is done). Only fork invocations wait (agent map spec
-     * §5.4); their step is the run's fork dispatch step. A run stays here until its children have
-     * stopped; a pass that neither stopped a child nor resumed the run is not counted.
-     */
-    async sweepOverdueSubagents() {
-        const runs = await this.db
-            .selectFrom("runs")
-            .select(["id"])
-            .where("status", "=", "waiting")
-            .where("wait_expires_at", "<", sql `now()`)
-            .orderBy("wait_expires_at")
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        let total = 0;
-        for (const r of runs) {
-            try {
-                const last = await this.db
-                    .selectFrom("subagent_dispatches")
-                    .select(sql `max(step)`.as("step"))
-                    .where("parent_run_id", "=", r.id)
-                    .where("for_skill", "=", true)
-                    .executeTakeFirst();
-                if (last?.step == null)
-                    continue;
-                const step = Number(last.step);
-                const id = subagentsWaitId(r.id, step);
-                // children asked to stop may take a while to end, so the same wait can come back on the
-                // next sweep: only a pass that stopped a child or resumed the run counts and logs (M3)
-                const { acted } = await this.expire("subagents", id, { runId: r.id, step });
-                if (!acted)
-                    continue;
-                this.log.warn("wait sweep: expired overdue wait", { kind: "subagents", id, runId: r.id });
-                total++;
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot expire overdue wait", {
-                    kind: "subagents",
-                    runId: r.id,
-                    err,
-                });
-            }
-        }
-        return total;
-    }
-    /**
-     * Sub-agent runs nobody will run (spec §7.5; `RunQueue.repairOrphan`, the same orphan test as
-     * `ensureRun`, which never runs for a child): `queued` past the grace period without a job → enqueued
-     * again (the dispatch committed, its enqueue was lost); `running` without job and lock → failed
-     * `run.orphaned` and reported to the parent, which then resumes. Also a chat run left `queued`
-     * by a resume whose enqueue was lost (final review m8): enqueued again under its resume job id
-     * (`ensureRun` would only repair it at the conversation's next message).
-     */
-    async sweepSubagentOrphans() {
-        const out = { requeued: 0, orphaned: 0 };
-        const runs = await this.db
-            .selectFrom("runs")
-            .innerJoin("conversations as c", "c.id", "runs.conversation_id")
-            .select(["runs.id", "runs.conversation_id"])
-            .where((eb) => eb.or([
-            eb.and([eb("c.kind", "=", "subagent"), eb("runs.status", "in", ["queued", "running"])]),
-            // a parent (or any chat run) set `queued` by Waits.resume whose replica died before its
-            // queue.add: child completions make that a frequent cross-replica resume (m8); its job
-            // id is the resume job id recorded with the update
-            eb.and([
-                eb("c.kind", "=", "chat"),
-                eb("runs.status", "=", "queued"),
-                eb("runs.job_id", "like", "run-%-resume-%"),
-            ]),
-        ]))
-            .where(sql `COALESCE(runs.queued_at, runs.created_at)`, "<", sql `now() - ${WAIT_SWEEP_GRACE_MS}::integer * interval '1 millisecond'`)
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        for (const run of runs) {
-            try {
-                const r = await this.runQueue.repairOrphan(run.conversation_id, run.id);
-                if (r === null)
-                    continue;
-                if (r === "failed") {
-                    out.orphaned++;
-                    await this.childFinished(run.id);
-                }
-                else
-                    out.requeued++;
-                this.log.warn("wait sweep: repaired orphaned sub-agent run", {
-                    runId: run.id,
-                    conversationId: run.conversation_id,
-                    outcome: r,
-                });
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot repair orphaned sub-agent run", {
-                    runId: run.id,
-                    err,
-                });
-            }
-        }
-        return out;
-    }
-    /**
-     * Idle sub-agent conversations (no active run, not deleted) with a message newer than what they
-     * consumed, written past the grace period and within the last day: a `SendMessage` that reached a
-     * run after its last model call is started by that run's post-job `ensureRun`
-     * (`RunQueue.childWakeIn`), which a replica dying after the terminal commit skips. Re-derived with
-     * the same `ensureRun` (its rules decide: a paused root starts nothing). A sub-agent whose last
-     * run was stopped (`aborted`) can never start from a message, so it is left out here, and the
-     * newest conversations come first (active within the last day), so parked messages that cannot
-     * start never fill the batch. Returns how many runs started.
-     */
-    async sweepParkedMessages() {
-        const rows = await this.db
-            .selectFrom("conversations as c")
-            .select("c.id")
-            .where("c.kind", "=", "subagent")
-            .where("c.deleted_at", "is", null)
-            // every append bumps `updated_at`: a message of the last day implies it (an index-friendly
-            // bound before the event lookups)
-            .where("c.updated_at", ">", sql `now() - interval '1 day'`)
-            .where((eb) => sql `(
-            SELECT r.status FROM capybara.runs r WHERE r.conversation_id = ${eb.ref("c.id")}
-            ORDER BY r.created_at DESC, r.id DESC LIMIT 1
-          ) IS DISTINCT FROM 'aborted'`)
-            .where(({ exists, selectFrom }) => exists(selectFrom("conversation_events as e")
-            .select(sql `1`.as("one"))
-            .whereRef("e.conversation_id", "=", "c.id")
-            .where("e.type", "=", "user_message")
-            .whereRef("e.seq", ">", "c.consumed_seq")
-            .where("e.created_at", "<", sql `now() - ${WAIT_SWEEP_GRACE_MS}::integer * interval '1 millisecond'`)
-            .where("e.created_at", ">", sql `now() - interval '1 day'`)))
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("runs as r")
-            .select(sql `1`.as("one"))
-            .whereRef("r.conversation_id", "=", "c.id")
-            .where("r.status", "in", ACTIVE_RUN_STATUSES))))
-            .orderBy("c.updated_at", "desc")
-            .orderBy("c.id")
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        let n = 0;
-        for (const c of rows) {
-            try {
-                if ((await this.runQueue.ensureRun(c.id)) === null)
-                    continue;
-                n++;
-                this.log.warn("wait sweep: started a sub-agent's parked message", { conversationId: c.id });
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot start a sub-agent's parked message", {
-                    conversationId: c.id,
-                    err,
-                });
-            }
-        }
-        return n;
-    }
-    /**
-     * Finished runs (past the grace period, within the last day) triggered by a fork invocation that
-     * has no report ({@link unreportedForkRuns}): a terminal path that skipped
-     * `stopOpenAgentCalls`, such as an old replica's abort, would otherwise leave a fork lead without
-     * its report. Each is repaired under the conversation row lock with the normal
-     * `stopOpenAgentCalls` (an ended child gives its result, an active one the stopped text;
-     * idempotency keys make it safe against the regular paths); an active fork child is then stopped
-     * by {@link sweepForkChildrenOfFinished}. An `Agent` call has its result from its dispatch (agent
-     * map spec §4.1).
-     */
-    async sweepOpenAgentCalls() {
-        const runs = await unreportedForkRuns(this.db);
-        let total = 0;
-        for (const r of runs) {
-            try {
-                const st = {};
-                const toSeq = await this.repairOpenAgentCallsIn(r.parent_conversation_id, r.parent_run_id, st);
-                const fire = st.fire;
-                if (fire === undefined)
-                    continue;
-                if (toSeq !== null)
-                    await this.eventLog.notify(r.parent_conversation_id, toSeq);
-                fire();
-                total++;
-                this.log.warn("wait sweep: wrote the missing fork report of a finished run", {
-                    runId: r.parent_run_id,
-                    conversationId: r.parent_conversation_id,
-                });
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot write the missing fork report of a finished run", {
-                    runId: r.parent_run_id,
-                    err,
-                });
-            }
-        }
-        return total;
-    }
-    /** One run's repair of {@link sweepOpenAgentCalls}; its observe hooks go back through `st`. */
-    async repairOpenAgentCallsIn(conversationId, runId, st) {
-        const t = this.db;
-        await t
-            .selectFrom("conversations")
-            .select("id")
-            .where("id", "=", conversationId)
-            .forUpdate()
-            .executeTakeFirst();
-        const run = await t
-            .selectFrom("runs")
-            .select("status")
-            .where("id", "=", runId)
-            .executeTakeFirst();
-        if (run === undefined || !TERMINAL_RUN_STATUSES.includes(run.status)) {
-            return null;
-        }
-        const stopped = await this.pipeline.stopOpenAgentCalls(runId);
-        if (stopped.callIds.size === 0)
-            return null;
-        st.fire = stopped.fire;
-        return stopped.toSeq ?? null;
-    }
-    /**
-     * Active fork sub-agent runs (phase D, `for_skill`) of a parent run that finished more than the
-     * grace period ago (§12: the run's terminal state stops its fork child and reports it stopped;
-     * this is the backstop) → stopped. Background `Agent` children of a finished run are the normal
-     * case and keep running (agent map spec §5.4).
-     */
-    async sweepForkChildrenOfFinished() {
-        const parents = await this.db
-            .selectFrom("subagent_dispatches as sd")
-            .innerJoin("runs as cr", "cr.id", "sd.child_run_id")
-            .innerJoin("runs as pr", "pr.id", "sd.parent_run_id")
-            .select("sd.parent_run_id")
-            .distinct()
-            .where("sd.for_skill", "=", true)
-            .where("cr.status", "in", ACTIVE_RUN_STATUSES)
-            .where("pr.status", "in", TERMINAL_RUN_STATUSES)
-            .where("pr.finished_at", "<", sql `now() - ${WAIT_SWEEP_GRACE_MS}::integer * interval '1 millisecond'`)
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        let total = 0;
-        for (const p of parents) {
-            try {
-                const n = await this.stopChildren(p.parent_run_id, null);
-                if (n === 0)
-                    continue;
-                total += n;
-                this.log.warn("wait sweep: stopped the fork sub-agent of a finished run", {
-                    runId: p.parent_run_id,
-                    count: n,
-                });
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot stop the fork sub-agent of a finished run", {
-                    runId: p.parent_run_id,
-                    err,
-                });
-            }
-        }
-        return total;
-    }
-    /**
-     * Active sub-agent runs with a deleted ancestor (agent map spec §10: deleting the root stops the
-     * whole tree; the delete's own {@link stopTree} is the normal path, this the backstop for a crash
-     * between marking the root deleted and stopping its tree, or a dispatch that raced it) → stopped
-     * on the deleter's behalf (no account). No grace period: nothing in a deleted tree should run.
-     */
-    async sweepTreesOfDeletedRoots() {
-        const r = await sql `
-      WITH RECURSIVE up(run_id, conversation_id, status, ancestor, n) AS (
-        SELECT r.id, r.conversation_id, r.status, c.parent_conversation_id, 1
-        FROM capybara.runs r JOIN capybara.conversations c ON c.id = r.conversation_id
-        WHERE r.status IN ('queued', 'running', 'waiting') AND c.kind = 'subagent'
-          AND c.parent_conversation_id IS NOT NULL
-        UNION ALL
-        SELECT up.run_id, up.conversation_id, up.status, c.parent_conversation_id, up.n + 1
-        FROM up JOIN capybara.conversations c ON c.id = up.ancestor
-        WHERE c.deleted_at IS NULL AND c.parent_conversation_id IS NOT NULL AND up.n < 16
-      )
-      SELECT DISTINCT up.run_id, up.conversation_id, up.status
-      FROM up JOIN capybara.conversations a ON a.id = up.ancestor
-      WHERE a.deleted_at IS NOT NULL
-      LIMIT ${WAIT_SWEEP_BATCH}`.execute(this.db);
-        let total = 0;
-        for (const run of r.rows) {
-            try {
-                // already asked to stop (a worker holds it and stops it at its next check): not again
-                if (run.status === "running" && (await this.abort.requested(run.run_id)) !== null)
-                    continue;
-                await this.stopRun(run.conversation_id, run.run_id, run.status, null);
-                total++;
-                this.log.warn("wait sweep: stopped a sub-agent run of a deleted conversation's tree", {
-                    runId: run.run_id,
-                });
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot stop a sub-agent run of a deleted tree", {
-                    runId: run.run_id,
-                    err,
-                });
-            }
-        }
-        return total;
-    }
-    /**
-     * Background sub-agent runs that finished more than the grace period ago (within the last day)
-     * whose parent has no `subagent_finished` for them (agent map spec §10: the finisher died after
-     * the child's terminal commit; the finish path writes `subagent_finished` and the delivery in one
-     * transaction) → {@link childFinished}, idempotent against a late finisher. Keyed on the child
-     * run, so a run nobody dispatched (a wake run, §5.3) is repaired too, and on
-     * `subagent_finished`, not on the delivery, so a child that finished before background
-     * dispatch (its result was the `Agent` call's, its `subagent_finished` written then) is never
-     * delivered a second time. Fork invocations' runs, a run without a terminal event in its log
-     * (nothing to deliver), a conversation never dispatched and a child whose parent conversation
-     * was deleted are skipped; only a written delivery counts.
-     */
-    async sweepUndelivered() {
-        const runs = await this.db
-            .selectFrom("runs as cr")
-            .innerJoin("conversations as cc", "cc.id", "cr.conversation_id")
-            .innerJoin("conversations as pc", "pc.id", "cc.parent_conversation_id")
-            .select("cr.id as child_run_id")
-            .where("cc.kind", "=", "subagent")
-            .where("pc.deleted_at", "is", null)
-            .where("cr.status", "in", TERMINAL_RUN_STATUSES)
-            .where("cr.finished_at", "<", sql `now() - ${WAIT_SWEEP_GRACE_MS}::integer * interval '1 millisecond'`)
-            .where("cr.finished_at", ">", sql `now() - interval '1 day'`)
-            .where(({ exists, selectFrom }) => exists(selectFrom("subagent_dispatches as sd")
-            .select(sql `1`.as("one"))
-            .whereRef("sd.child_conversation_id", "=", "cc.id")))
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("subagent_dispatches as fd")
-            .select(sql `1`.as("one"))
-            .whereRef("fd.child_run_id", "=", "cr.id")
-            .where("fd.for_skill", "=", true))))
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("conversation_events as e")
-            .select(sql `1`.as("one"))
-            .whereRef("e.conversation_id", "=", "pc.id")
-            .where("e.idem_key", "=", sql `'subagent_finished:' || cr.id`))))
-            .where(({ exists, selectFrom }) => exists(selectFrom("conversation_events as t")
-            .select(sql `1`.as("one"))
-            .whereRef("t.conversation_id", "=", "cc.id")
-            .whereRef("t.run_id", "=", "cr.id")
-            .where("t.type", "in", ["run_finished", "run_failed", "run_aborted"])))
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        let total = 0;
-        for (const r of runs) {
-            try {
-                if (!(await this.childFinished(r.child_run_id)))
-                    continue;
-                total++;
-                this.log.warn("wait sweep: delivered the finish of a sub-agent run", {
-                    childRunId: r.child_run_id,
-                });
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot deliver the finish of a sub-agent run", {
-                    childRunId: r.child_run_id,
-                    err,
-                });
-            }
-        }
-        return total;
-    }
-    /**
-     * 扫描 2：waiting 超过宽限期、却已没有 pending 等待的运行（决定提交后进程崩溃、续跑投递失败回滚等）→
-     * {@link resume}（条件更新 `waiting → queued` + 投递）。续跑任务的 jobId 用该运行最近一次等待的 id
-     * （与人工决定 / 超时任务一致，已投递过的同一续跑被 BullMQ 去重）。
-     */
-    async sweepStuckRuns() {
-        const runs = await this.db
-            .selectFrom("runs")
-            .select(["id", "conversation_id"])
-            .where("status", "=", "waiting")
-            .where("waiting_since", "<", sql `now() - ${WAIT_SWEEP_GRACE_MS}::integer * interval '1 millisecond'`)
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("approvals")
-            .select(sql `1`.as("one"))
-            .whereRef("approvals.run_id", "=", "runs.id")
-            .where("approvals.status", "=", "pending"))))
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("questions")
-            .select(sql `1`.as("one"))
-            .whereRef("questions.run_id", "=", "runs.id")
-            .where("questions.status", "=", "pending"))))
-            // the resume condition's third clause: a run with an active fork child is not stuck
-            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("subagent_dispatches as sd")
-            .innerJoin("runs as cr", "cr.id", "sd.child_run_id")
-            .select(sql `1`.as("one"))
-            .whereRef("sd.parent_run_id", "=", "runs.id")
-            .where("sd.for_skill", "=", true)
-            .where("cr.status", "in", ACTIVE_RUN_STATUSES))))
-            .limit(WAIT_SWEEP_BATCH)
-            .execute();
-        let total = 0;
-        for (const run of runs) {
-            try {
-                const waitId = (await this.lastWaitId(run.id)) ?? run.id;
-                if (!(await this.resume(run.id, waitId)))
-                    continue;
-                total++;
-                this.log.warn("wait sweep: resumed stuck waiting run", {
-                    runId: run.id,
-                    conversationId: run.conversation_id,
-                    waitId,
-                });
-            }
-            catch (err) {
-                this.log.error("wait sweep: cannot resume stuck waiting run", { runId: run.id, err });
-            }
-        }
-        return total;
-    }
-    /**
-     * The id of the run's latest wait (by creation time): an approval, an input request or a fork
-     * invocation's dispatch, whose wait id is its child run id (the id the child's finisher resumes
-     * with, so a sweep resume and a late finisher resume share one job id).
-     */
-    async lastWaitId(runId) {
-        const row = await this.db
-            .selectFrom(this.db
-            .selectFrom("approvals")
-            .select(["id", "created_at"])
-            .where("run_id", "=", runId)
-            .unionAll(this.db
-            .selectFrom("questions")
-            .select(["id", "created_at"])
-            .where("run_id", "=", runId))
-            .unionAll(this.db
-            .selectFrom("subagent_dispatches")
-            .select(["child_run_id as id", "created_at"])
-            .where("parent_run_id", "=", runId)
-            .where("for_skill", "=", true))
-            .as("w"))
-            .select("w.id")
-            .orderBy("w.created_at", "desc")
-            .limit(1)
-            .executeTakeFirst();
-        return row?.id ?? null;
-    }
     /**
      * A `wait-timeout` job (dispatched by `MaintenanceProcessor`): expires the wait,
      * or delays the job again until the wait's expiry when it ran early.
@@ -1012,24 +396,22 @@ let Waits = class Waits {
             throw new DelayedError();
         }
     }
-    /** 投递超时任务（延迟到 expiresAt）。失败只记日志：人工处理仍可续跑，只是不会自动超时。 */
-    async scheduleTimeout(w, runId) {
+    /**
+     * Owes the wait's timeout job (`wait-timeout-<waitId>`, `runAt` = the wait's deadline) in the
+     * suspend's transaction (transactional outbox spec §6 "Resumes and timeouts").
+     */
+    async oweTimeout(w, runId, orgId) {
         const data = w.kind === "subagents" && w.step !== undefined
             ? { kind: w.kind, id: w.id, runId, step: w.step }
             : { kind: w.kind, id: w.id };
-        try {
-            await this.timeouts.add(WAIT_TIMEOUT_JOB, data, {
-                jobId: waitTimeoutJobId(w.id),
-                delay: Math.max(0, new Date(w.expiresAt).getTime() - Date.now()),
-                attempts: TIMEOUT_JOB_ATTEMPTS,
-                backoff: { type: "exponential", delay: TIMEOUT_JOB_BACKOFF_MS },
-                removeOnComplete: true,
-                removeOnFail: true,
-            });
-        }
-        catch (err) {
-            this.log.error("cannot schedule wait timeout", { waitId: w.id, err });
-        }
+        await this.outbox.add({
+            queue: MAINTENANCE_QUEUE_NAME,
+            name: WAIT_TIMEOUT_JOB,
+            jobId: waitTimeoutJobId(w.id),
+            data,
+            runAt: new Date(w.expiresAt),
+            orgId,
+        });
     }
     /**
      * Whether the wait is over: an approval or input request is no longer pending (decided, expired
@@ -1116,7 +498,8 @@ let Waits = class Waits {
      * `subagent_finished` (idempotent; not model-visible) and tries
      * {@link resume}`(parentRunId, childRunId)`, which succeeds once its parent run waits on nothing
      * else. A run of a conversation never dispatched, or not terminal yet, is left alone. A crash in
-     * between is repaired by the wait sweep (the orphan repair calls this again). A fork child's
+     * between is repaired by the `deliver-to-parent` job its terminal transaction owed (the
+     * `run-orphan-check` calls this too). A fork child's
      * running background tasks the terminal run started are then stopped (not those of a later run);
      * a stopped background child's are all stopped, whichever of its runs started them; a background
      * child that ended on its own keeps them, and their finish wakes it (agent map spec §5.3). True
@@ -1244,13 +627,8 @@ let Waits = class Waits {
             .execute()).sort((a, b) => (level.get(a.conversation_id) ?? 0) - (level.get(b.conversation_id) ?? 0));
         for (const r of runs) {
             try {
-                if (await this.stopRun(r.conversation_id, r.id, r.status, byAccountId)) {
-                    // its approval / question cards changed (RunControl.abortWaiting's event)
-                    await this.events.emit("run.wait-stopped", {
-                        conversationId: r.conversation_id,
-                        runId: r.id,
-                    });
-                }
+                // a stopped wait's card updates are owed by its transaction's appends (outbox spec §8.1)
+                await this.stopRun(r.conversation_id, r.id, r.status, byAccountId);
             }
             catch (err) {
                 this.log.error("cannot stop a sub-agent run of the tree", { runId: r.id, err });
@@ -1321,13 +699,13 @@ let Waits = class Waits {
 };
 __decorate([
     Transactional({ propagation: "requires_new" })
-], Waits.prototype, "abortWaitingIn", null);
+], Waits.prototype, "suspendIn", null);
 __decorate([
-    Transactional({ propagation: "requires_new" })
-], Waits.prototype, "cancelWaitsOfFinishedIn", null);
+    Transactional()
+], Waits.prototype, "resume", null);
 __decorate([
     Transactional({ propagation: "requires_new" })
-], Waits.prototype, "repairOpenAgentCallsIn", null);
+], Waits.prototype, "abortWaitingIn", null);
 Waits = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
@@ -1339,92 +717,12 @@ Waits = __decorate([
     __param(6, Inject(RunFinish)),
     __param(7, Inject(KyselyCheckpointSaver)),
     __param(8, Inject(RunAbort)),
-    __param(9, Inject(getQueueToken(MAINTENANCE_QUEUE_NAME))),
-    __param(10, Inject(KernelEvents)),
-    __param(11, Inject(KERNEL_LOGGER)),
-    __param(12, Inject(BackgroundTaskStopper)),
-    __param(13, Inject(SubagentDeliveries)),
-    __param(14, Inject(TransactionHost))
+    __param(9, Inject(OutboxService)),
+    __param(10, Inject(RunResume)),
+    __param(11, Inject(KernelEvents)),
+    __param(12, Inject(KERNEL_LOGGER)),
+    __param(13, Inject(BackgroundTaskStopper)),
+    __param(14, Inject(SubagentDeliveries)),
+    __param(15, Inject(TransactionHost))
 ], Waits);
 export { Waits };
-/**
- * Phase D: finished chat runs (past the grace period, within the last day) triggered by a fork
- * invocation that has no report (dispatched or not); the wait sweep writes it
- * (`pairStoppedForks`).
- */
-export function unreportedForkRuns(db) {
-    return (db
-        .selectFrom("runs as r")
-        .innerJoin("conversation_events as m", (j) => j.onRef("m.conversation_id", "=", "r.conversation_id").onRef("m.seq", "=", "r.trigger_seq"))
-        // a sub-agent's task message carries the skill record too: chat conversations only (I1)
-        .innerJoin("conversations as c", "c.id", "r.conversation_id")
-        .select(["r.id as parent_run_id", "r.conversation_id as parent_conversation_id"])
-        .where("c.kind", "=", "chat")
-        .where("r.status", "in", TERMINAL_RUN_STATUSES)
-        .where("r.finished_at", "<", sql `now() - ${WAIT_SWEEP_GRACE_MS}::integer * interval '1 millisecond'`)
-        .where("r.finished_at", ">", sql `now() - interval '1 day'`)
-        .where("m.type", "=", "user_message")
-        .where(sql `m.payload -> 'skill' ->> 'mode' = 'fork'`)
-        .where(({ not, exists, selectFrom }) => not(exists(selectFrom("conversation_events as e")
-        .select(sql `1`.as("one"))
-        .whereRef("e.conversation_id", "=", "r.conversation_id")
-        .where("e.idem_key", "=", sql `'skill_fork_result:' || r.trigger_seq`))))
-        .limit(WAIT_SWEEP_BATCH)
-        .execute());
-}
-/**
- * A decided approval / answered question resumes the waiting run on this replica (domain events,
- * spec §3b; the wait sweep resumes a run whose resume was lost). Its IM delivery follows the same
- * events (`ChannelJobs`).
- */
-let DecisionResumer = class DecisionResumer {
-    unsubscribe;
-    constructor(waits, events) {
-        this.unsubscribe = [
-            events.on("approval.decided", async (a) => {
-                await waits.resume(a.runId, a.id);
-            }),
-            events.on("question.answered", async (q) => {
-                await waits.resume(q.runId, q.id);
-            }),
-        ];
-    }
-    /** Unsubscribes after the stop phases: events emitted while they drain are still handled. */
-    onApplicationShutdown() {
-        for (const off of this.unsubscribe)
-            off();
-    }
-};
-DecisionResumer = __decorate([
-    Injectable(),
-    __param(0, Inject(Waits)),
-    __param(1, Inject(KernelEvents))
-], DecisionResumer);
-export { DecisionResumer };
-/**
- * The wait sweep, every 10 minutes, once across replicas: {@link Waits.sweep}. Replaces
- * the maintenance scheduler `wait-sweep-every-10m` (retired at worker start).
- */
-let WaitSweepJob = class WaitSweepJob {
-    waits;
-    lockService;
-    log;
-    constructor(waits, lockService, log) {
-        this.waits = waits;
-        this.lockService = lockService;
-        this.log = log;
-    }
-    async run() {
-        await this.waits.sweep();
-    }
-};
-__decorate([
-    LockedCron("*/10 * * * *", { name: WAIT_SWEEP_JOB })
-], WaitSweepJob.prototype, "run", null);
-WaitSweepJob = __decorate([
-    Injectable(),
-    __param(0, Inject(Waits)),
-    __param(1, Inject(LockService)),
-    __param(2, Inject(KERNEL_LOGGER))
-], WaitSweepJob);
-export { WaitSweepJob };