@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.2

package/dist/runtime/waits.js

@@ -1,11 +1,35 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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";
-import { APPROVAL_CANCELLED_TEXT, INPUT_CANCELLED_TEXT, RUN_STOPPED_TEXT, } from "../tools/pipeline.js";
+import { EventLog } from "../conversations/event-log.js";
+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 { KERNEL_LOGGER } from "../infra/tokens.js";
+import { ApprovalsService } 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 { MAINTENANCE_QUEUE_NAME } from "./maintenance.js";
+import { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
 import { assistantIdemKey } from "./model-call.js";
-import { finishRunIn, notifyFinished } from "./run-finish.js";
-import { ACTIVE_RUN_STATUSES } from "./run-queue.js";
+import { notifyFinished, RunFinish, TERMINAL_STATUSES } from "./run-finish.js";
+import { ACTIVE_RUN_STATUSES, RunQueue } from "./run-queue.js";
+import { childResult, dispatchOfChildRun, finishedEvent } from "./subagents/child.js";
 /** 等待超时任务所在的内核维护队列（见 maintenance.ts）。 */
 export { MAINTENANCE_QUEUE_NAME };
 /** 等待超时任务的名字与 jobId（每个审批 / 输入请求一个，重复投递被 BullMQ 忽略）。 */
@@ -18,8 +42,8 @@ export const resumeJobId = (conversationId, waitId) => `run-${conversationId}-re
  * 宽限期：waiting 超过它、等待却已全部处理的运行才视为「续跑丢失」，避免与正常续跑（暂停后的复查等）竞争。
  */
 export const WAIT_SWEEP_JOB = "wait-sweep";
-export const WAIT_SWEEP_SCHEDULER_ID = "wait-sweep-every-10m";
-export const WAIT_SWEEP_EVERY_MS = 600_000;
+/** 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"];
@@ -34,19 +58,62 @@ const TIMEOUT_JOB_BACKOFF_MS = 5_000;
  * 成功者投递 jobId 为 `run-<conversationId>-resume-<waitId>` 的运行任务。人工决定、超时任务、
  * 暂停后的复查都可能调用它，谁先谁后都只有一次续跑。
  */
-export class Waits {
-    d;
-    constructor(d) {
-        this.d = d;
-        d.maintenance.handle(WAIT_TIMEOUT_JOB, (job, token) => this.process(job, token));
-        d.maintenance.schedule({
-            id: WAIT_SWEEP_SCHEDULER_ID,
-            name: WAIT_SWEEP_JOB,
-            everyMs: () => WAIT_SWEEP_EVERY_MS,
-        });
-        d.maintenance.handle(WAIT_SWEEP_JOB, async () => {
-            await this.sweep();
-        });
+let Waits = class Waits {
+    kdb;
+    eventLog;
+    approvals;
+    questions;
+    runQueue;
+    pipeline;
+    finisher;
+    checkpoints;
+    abort;
+    timeouts;
+    log;
+    txHost;
+    /** Drops the `run.orphaned` subscription (the events may outlive this instance). */
+    unsubscribe;
+    constructor(kdb, eventLog, approvals, questions, 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.
+     */
+    pipeline, finisher, 
+    /** 等待中被中止的运行删除其 checkpoint thread。 */
+    checkpoints, 
+    /**
+     * The run's stop marker (`RunAbort.requested`): between suspending and becoming `waiting` the
+     * run has no subscriber, so a stop arriving then only sits in the marker; checked once after
+     * `waiting` is set. Children are stopped through `request`.
+     */
+    abort, 
+    /** The maintenance queue: wait timeout jobs (`MaintenanceProcessor` consumes them). */
+    timeouts, events, log, txHost) {
+        this.kdb = kdb;
+        this.eventLog = eventLog;
+        this.approvals = approvals;
+        this.questions = questions;
+        this.runQueue = runQueue;
+        this.pipeline = pipeline;
+        this.finisher = finisher;
+        this.checkpoints = checkpoints;
+        this.abort = abort;
+        this.timeouts = timeouts;
+        this.log = log;
+        this.txHost = txHost;
+        // an orphaned parent run (marked failed by `ensureRun`) stops its children at once; the
+        // sweep's `sweepChildrenOfFinished` 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 })));
+    }
+    /** Unsubscribes after the stop phases: events emitted while they drain are still handled. */
+    onApplicationShutdown() {
+        this.unsubscribe();
+    }
+    /** The context's handle (the transaction of a `@Transactional` method, else the pool). */
+    get db() {
+        return this.kdb.db;
     }
     /**
      * 兜底扫描（维护队列每 10 分钟一次，防延迟任务 / 续跑丢失）。每项修复都复用常规路径，与并发的超时任务、
@@ -81,7 +148,7 @@ export class Waits {
      * 运行（置 waiting 之后到达的中止由 `POST .../abort` 看到 waiting 直接处理，两边不会都漏掉）。
      */
     async suspend(runId, conversationId, waitingFor, abort) {
-        const r = await this.d.db
+        const r = await this.db
             .updateTable("runs")
             .set({
             status: "waiting",
@@ -93,10 +160,10 @@ export class Waits {
             .where("status", "=", "running")
             .executeTakeFirst();
         if (Number(r.numUpdatedRows) === 0) {
-            this.d.log.warn("run is no longer running; not suspending", { runId });
+            this.log.warn("run is no longer running; not suspending", { runId });
             return;
         }
-        const stop = abort ?? (await this.d.abortRequested?.(runId)) ?? null;
+        const stop = abort ?? (await this.abort.requested(runId)) ?? null;
         if (stop && (await this.abortWaiting(conversationId, runId, stop.byAccountId, stop.detail))) {
             return;
         }
@@ -116,7 +183,7 @@ export class Waits {
         if (waitingFor.kind === "subagents")
             return;
         try {
-            const d = await this.d.db
+            const d = await this.db
                 .selectFrom("subagent_dispatches")
                 .select(["parent_conversation_id", "parent_run_id", "child_conversation_id"])
                 .where("child_run_id", "=", runId)
@@ -124,19 +191,19 @@ export class Waits {
             if (!d)
                 return;
             const row = waitingFor.kind === "approval"
-                ? await this.d.db
+                ? await this.db
                     .selectFrom("approvals")
                     .select(["tool_key", "expires_at"])
                     .where("id", "=", waitingFor.id)
                     .executeTakeFirst()
-                : await this.d.db
+                : await this.db
                     .selectFrom("questions")
                     .select([sql `spec->>'toolKey'`.as("tool_key"), "expires_at"])
                     .where("id", "=", waitingFor.id)
                     .executeTakeFirst();
             if (!row)
                 return;
-            await this.d.eventLog.append(d.parent_conversation_id, [
+            await this.eventLog.append(d.parent_conversation_id, [
                 {
                     type: "subagent_waiting",
                     runId: d.parent_run_id,
@@ -155,7 +222,7 @@ export class Waits {
             ]);
         }
         catch (err) {
-            this.d.log.error("cannot surface a sub-agent's wait in its parent", { runId, err });
+            this.log.error("cannot surface a sub-agent's wait in its parent", { runId, err });
         }
     }
     /**
@@ -164,7 +231,7 @@ export class Waits {
      * 投递失败 → 撤回为 waiting（等待时长已计入，重新从现在起计），之后超时任务到点会再次续跑，并抛出。
      */
     async resume(runId, waitId) {
-        const row = await this.d.db
+        const row = await this.db
             .updateTable("runs")
             .set({
             status: "queued",
@@ -197,11 +264,11 @@ export class Waits {
             return false;
         const jobId = resumeJobId(row.conversation_id, waitId);
         try {
-            await this.d.runQueue.enqueue({ runId, conversationId: row.conversation_id }, jobId);
+            await this.runQueue.enqueue({ runId, conversationId: row.conversation_id }, jobId);
         }
         catch (err) {
-            this.d.log.error("cannot enqueue resumed run; back to waiting", { runId, jobId, err });
-            await this.d.db
+            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)
@@ -223,13 +290,13 @@ export class Waits {
             // stopped child reports to the parent, and the last one resumes it. The resume tried here
             // covers a step whose children were all done already.
             if (!at) {
-                this.d.log.warn("sub-agent wait timeout without its run; ignored", { id });
+                this.log.warn("sub-agent wait timeout without its run; ignored", { id });
                 return {};
             }
             const { runId, step } = at;
-            const stopped = (await this.d.subagents?.stop(runId, null, { step, detail: "wait_timeout" })) ?? 0;
+            const stopped = await this.stopChildren(runId, null, { step, detail: "wait_timeout" });
             if (stopped > 0) {
-                this.d.log.warn("sub-agent wait timed out; stopping its sub-agents", {
+                this.log.warn("sub-agent wait timed out; stopping its sub-agents", {
                     runId,
                     id,
                     stopped,
@@ -238,7 +305,7 @@ export class Waits {
             const resumed = await this.resume(runId, id);
             return { acted: stopped > 0 || resumed };
         }
-        const r = kind === "approval" ? await this.d.approvals.expire(id) : await this.d.questions.expire(id);
+        const r = kind === "approval" ? await this.approvals.expire(id) : await this.questions.expire(id);
         if (r.outcome === "not_due" && r.record) {
             return { notDueUntil: new Date(r.record.expiresAt).getTime() };
         }
@@ -253,94 +320,93 @@ export class Waits {
      * 运行已不是 waiting（例如刚被续跑）→ 返回 false，由调用方走常规中止。
      */
     async abortWaiting(conversationId, runId, byAccountId, detail) {
-        let stopped;
-        const toSeq = await this.d.db.transaction().execute(async (t) => {
-            stopped = undefined;
-            await t
-                .selectFrom("conversations")
-                .select("id")
-                .where("id", "=", conversationId)
-                .forUpdate()
-                .executeTakeFirst();
-            const run = await t
-                .selectFrom("runs")
-                .select("status")
-                .where("id", "=", runId)
-                .where("conversation_id", "=", conversationId)
-                .forUpdate()
-                .executeTakeFirst();
-            if (run?.status !== "waiting")
-                return null;
-            await this.d.approvals.cancelPendingIn(t, runId);
-            await this.d.questions.cancelPendingIn(t, runId);
-            // 本运行全部审批 / 输入请求涉及的调用（不只刚取消的）：决定已提交、续跑尚未发生时被中止的调用同样没有结果，
-            // 一并写取消说明（已有结果的按幂等键命中、不重复）。同一调用先审批后输入，后者覆盖前者。
-            const cancelled = new Map();
-            const steps = new Set();
-            const approvals = await t
-                .selectFrom("approvals")
-                .select(["id", "call_id", "tool_key"])
-                .where("run_id", "=", runId)
-                .orderBy("created_at")
-                .execute();
-            for (const a of approvals) {
-                cancelled.set(a.call_id, { toolKey: a.tool_key, text: APPROVAL_CANCELLED_TEXT });
-                const step = await this.approvalStep(t, conversationId, a.id);
-                if (step !== null)
-                    steps.add(step);
-            }
-            const questions = await t
-                .selectFrom("questions")
-                .select(["call_id", "spec"])
-                .where("run_id", "=", runId)
-                .orderBy("created_at")
-                .execute();
-            for (const q of questions) {
-                const spec = q.spec;
-                cancelled.set(q.call_id, { toolKey: spec.toolKey ?? "", text: INPUT_CANCELLED_TEXT });
-                if (typeof spec.step === "number")
-                    steps.add(spec.step);
-            }
-            // a parent waiting on sub-agents (spec §12): its open `agent` calls get their results
-            const agents = await this.d.subagents?.stopOpenCalls?.(t, runId);
-            for (const step of agents?.steps ?? [])
-                steps.add(step);
-            const results = await this.stoppedResults(t, conversationId, runId, [...steps], cancelled, agents?.callIds);
-            if (results.length > 0)
-                await this.d.eventLog.append(conversationId, results, t);
-            stopped = agents;
-            return finishRunIn(t, this.d.eventLog, {
-                conversationId,
-                runId,
-                status: "aborted",
-                consumed: null,
-                event: {
-                    type: "run_aborted",
-                    payload: { byAccountId, reason: "user", ...(detail !== undefined && { detail }) },
-                },
-            });
-        });
+        const st = {};
+        const toSeq = await this.abortWaitingIn(conversationId, runId, byAccountId, detail, st);
+        const stopped = st.stopped;
         if (toSeq === null)
             return false;
-        await notifyFinished(this.d.eventLog, conversationId, toSeq, "aborted");
-        await this.d.checkpoints
-            ?.deleteThread(runId)
-            .catch((err) => this.d.log.warn("checkpoint delete failed", { runId, err }));
+        await notifyFinished(this.eventLog, conversationId, toSeq, "aborted");
+        await this.checkpoints
+            .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)
-        await this.d.subagents
-            ?.finished(runId)
-            .catch((err) => this.d.log.error("cannot report stopped sub-agent run", { runId, err }));
+        await this.childFinished(runId).catch((err) => this.log.error("cannot report stopped sub-agent run", { runId, err }));
         // a stopped parent stops its children (spec §12), on the parent's behalf (no account: they
         // report "stopped with this run"); the wait sweep is the backstop
-        await this.d.subagents
-            ?.stop(runId, null)
-            .catch((err) => this.d.log.error("cannot stop the sub-agents of a run", { runId, err }));
+        await this.stopChildren(runId, null).catch((err) => this.log.error("cannot stop the sub-agents of a run", { runId, err }));
         return true;
     }
+    /** {@link abortWaiting}'s transaction; the open `agent` calls it wrote go back through `st`. */
+    async abortWaitingIn(conversationId, runId, byAccountId, detail, 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)
+            .where("conversation_id", "=", conversationId)
+            .forUpdate()
+            .executeTakeFirst();
+        if (run?.status !== "waiting")
+            return null;
+        await this.approvals.cancelPendingIn(runId);
+        await this.questions.cancelPendingIn(runId);
+        // 本运行全部审批 / 输入请求涉及的调用（不只刚取消的）：决定已提交、续跑尚未发生时被中止的调用同样没有结果，
+        // 一并写取消说明（已有结果的按幂等键命中、不重复）。同一调用先审批后输入，后者覆盖前者。
+        const cancelled = new Map();
+        const steps = new Set();
+        const approvals = await t
+            .selectFrom("approvals")
+            .select(["id", "call_id", "tool_key"])
+            .where("run_id", "=", runId)
+            .orderBy("created_at")
+            .execute();
+        for (const a of approvals) {
+            cancelled.set(a.call_id, { toolKey: a.tool_key, text: APPROVAL_CANCELLED_TEXT });
+            const step = await this.approvalStep(t, conversationId, a.id);
+            if (step !== null)
+                steps.add(step);
+        }
+        const questions = await t
+            .selectFrom("questions")
+            .select(["call_id", "spec"])
+            .where("run_id", "=", runId)
+            .orderBy("created_at")
+            .execute();
+        for (const q of questions) {
+            const spec = q.spec;
+            cancelled.set(q.call_id, { toolKey: spec.toolKey ?? "", text: INPUT_CANCELLED_TEXT });
+            if (typeof spec.step === "number")
+                steps.add(spec.step);
+        }
+        // a parent waiting on sub-agents (spec §12): its open `agent` calls get their results
+        const agents = await this.pipeline.stopOpenAgentCalls(runId);
+        for (const step of agents.steps)
+            steps.add(step);
+        const results = await this.stoppedResults(t, conversationId, runId, [...steps], cancelled, agents?.callIds);
+        if (results.length > 0)
+            await this.eventLog.appendIn(conversationId, results);
+        st.stopped = agents;
+        return this.finisher.finishIn({
+            conversationId,
+            runId,
+            status: "aborted",
+            consumed: null,
+            event: {
+                type: "run_aborted",
+                payload: { byAccountId, reason: "user", ...(detail !== undefined && { detail }) },
+            },
+        });
+    }
     /** 扫描 3：运行已终态（如暂停途中失败）仍 pending 的审批 / 输入请求 → 取消（写决定 / 回答事件）。 */
     async sweepFinishedRuns() {
-        const { db } = this.d;
+        const db = this.db;
         const runs = await db
             .selectFrom("runs")
             .select(["id", "conversation_id"])
@@ -363,7 +429,7 @@ export class Waits {
                 const n = await this.cancelWaitsOfFinished(run.conversation_id, run.id);
                 if (n > 0) {
                     total += n;
-                    this.d.log.warn("wait sweep: cancelled waits of finished run", {
+                    this.log.warn("wait sweep: cancelled waits of finished run", {
                         runId: run.id,
                         conversationId: run.conversation_id,
                         count: n,
@@ -371,7 +437,7 @@ export class Waits {
                 }
             }
             catch (err) {
-                this.d.log.error("wait sweep: cannot cancel waits of finished run", { runId: run.id, err });
+                this.log.error("wait sweep: cannot cancel waits of finished run", { runId: run.id, err });
             }
         }
         return total;
@@ -381,39 +447,41 @@ export class Waits {
      * 提交后发布事件。返回取消的条数（并发的另一副本拿到锁时已无 pending → 0）。
      */
     async cancelWaitsOfFinished(conversationId, runId) {
-        const r = await this.d.db.transaction().execute(async (t) => {
-            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.d.approvals.cancelPendingIn(t, runId);
-            const q = await this.d.questions.cancelPendingIn(t, runId);
-            return a.length + q.length;
-        });
+        const r = await this.cancelWaitsOfFinishedIn(conversationId, runId);
         if (r > 0) {
-            const last = await this.d.db
+            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.d.eventLog.notify(conversationId, Number(last.seq));
+                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.d;
+        const db = this.db;
         const approvals = await db
             .selectFrom("approvals")
             .select(["id", "run_id"])
@@ -438,12 +506,12 @@ export class Waits {
         for (const w of due) {
             try {
                 const r = w.kind === "approval"
-                    ? await this.d.approvals.expire(w.id)
-                    : await this.d.questions.expire(w.id);
+                    ? await this.approvals.expire(w.id)
+                    : await this.questions.expire(w.id);
                 if (r.outcome !== "expired")
                     continue;
                 total++;
-                this.d.log.warn("wait sweep: expired overdue wait", {
+                this.log.warn("wait sweep: expired overdue wait", {
                     kind: w.kind,
                     id: w.id,
                     runId: w.runId,
@@ -452,7 +520,7 @@ export class Waits {
                     await this.resume(r.record.runId, w.id);
             }
             catch (err) {
-                this.d.log.error("wait sweep: cannot expire overdue wait", { kind: w.kind, id: w.id, err });
+                this.log.error("wait sweep: cannot expire overdue wait", { kind: w.kind, id: w.id, err });
             }
         }
         return total + (await this.sweepOverdueSubagents());
@@ -465,9 +533,7 @@ export class Waits {
      * stopped; a pass that neither stopped a child nor resumed the run is not counted.
      */
     async sweepOverdueSubagents() {
-        if (!this.d.subagents)
-            return 0;
-        const runs = await this.d.db
+        const runs = await this.db
             .selectFrom("runs")
             .select(["id"])
             .where("status", "=", "waiting")
@@ -478,7 +544,7 @@ export class Waits {
         let total = 0;
         for (const r of runs) {
             try {
-                const last = await this.d.db
+                const last = await this.db
                     .selectFrom("subagent_dispatches")
                     .select(sql `max(step)`.as("step"))
                     .where("parent_run_id", "=", r.id)
@@ -492,11 +558,11 @@ export class Waits {
                 const { acted } = await this.expire("subagents", id, { runId: r.id, step });
                 if (!acted)
                     continue;
-                this.d.log.warn("wait sweep: expired overdue wait", { kind: "subagents", id, runId: r.id });
+                this.log.warn("wait sweep: expired overdue wait", { kind: "subagents", id, runId: r.id });
                 total++;
             }
             catch (err) {
-                this.d.log.error("wait sweep: cannot expire overdue wait", {
+                this.log.error("wait sweep: cannot expire overdue wait", {
                     kind: "subagents",
                     runId: r.id,
                     err,
@@ -515,10 +581,7 @@ export class Waits {
      */
     async sweepSubagentOrphans() {
         const out = { requeued: 0, orphaned: 0 };
-        const sub = this.d.subagents;
-        if (!sub)
-            return out;
-        const runs = await this.d.db
+        const runs = await this.db
             .selectFrom("runs")
             .innerJoin("conversations as c", "c.id", "runs.conversation_id")
             .select(["runs.id", "runs.conversation_id"])
@@ -538,23 +601,23 @@ export class Waits {
             .execute();
         for (const run of runs) {
             try {
-                const r = await this.d.runQueue.repairOrphan(run.conversation_id, run.id);
+                const r = await this.runQueue.repairOrphan(run.conversation_id, run.id);
                 if (r === null)
                     continue;
                 if (r === "failed") {
                     out.orphaned++;
-                    await sub.finished(run.id);
+                    await this.childFinished(run.id);
                 }
                 else
                     out.requeued++;
-                this.d.log.warn("wait sweep: repaired orphaned sub-agent run", {
+                this.log.warn("wait sweep: repaired orphaned sub-agent run", {
                     runId: run.id,
                     conversationId: run.conversation_id,
                     outcome: r,
                 });
             }
             catch (err) {
-                this.d.log.error("wait sweep: cannot repair orphaned sub-agent run", {
+                this.log.error("wait sweep: cannot repair orphaned sub-agent run", {
                     runId: run.id,
                     err,
                 });
@@ -572,10 +635,7 @@ export class Waits {
      * are then stopped by {@link sweepChildrenOfFinished}.
      */
     async sweepOpenAgentCalls() {
-        const stopOpenCalls = this.d.subagents?.stopOpenCalls;
-        if (!stopOpenCalls)
-            return 0;
-        const agentCalls = await this.d.db
+        const agentCalls = await this.db
             .selectFrom("subagent_dispatches as sd")
             .innerJoin("runs as pr", "pr.id", "sd.parent_run_id")
             .select(["sd.parent_run_id", "sd.parent_conversation_id"])
@@ -591,48 +651,27 @@ export class Waits {
             .where(sql `NOT (sd.step = 0 AND sd.parent_call_id LIKE 'skill-%')`)
             .limit(WAIT_SWEEP_BATCH)
             .execute();
-        const forkRuns = await unreportedForkRuns(this.d.db);
+        const forkRuns = await unreportedForkRuns(this.db);
         const runs = [...agentCalls, ...forkRuns].filter((r, i, all) => all.findIndex((x) => x.parent_run_id === r.parent_run_id) === i);
         let total = 0;
         for (const r of runs) {
             try {
-                let fire;
-                const toSeq = await this.d.db.transaction().execute(async (t) => {
-                    fire = undefined;
-                    await t
-                        .selectFrom("conversations")
-                        .select("id")
-                        .where("id", "=", r.parent_conversation_id)
-                        .forUpdate()
-                        .executeTakeFirst();
-                    const run = await t
-                        .selectFrom("runs")
-                        .select("status")
-                        .where("id", "=", r.parent_run_id)
-                        .executeTakeFirst();
-                    if (run === undefined ||
-                        !TERMINAL_RUN_STATUSES.includes(run.status)) {
-                        return null;
-                    }
-                    const stopped = await stopOpenCalls(t, r.parent_run_id);
-                    if (stopped.callIds.size === 0)
-                        return null;
-                    fire = stopped.fire;
-                    return stopped.toSeq ?? null;
-                });
+                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.d.eventLog.notify(r.parent_conversation_id, toSeq);
+                    await this.eventLog.notify(r.parent_conversation_id, toSeq);
                 fire();
                 total++;
-                this.d.log.warn("wait sweep: wrote missing agent results of a finished run", {
+                this.log.warn("wait sweep: wrote missing agent results of a finished run", {
                     runId: r.parent_run_id,
                     conversationId: r.parent_conversation_id,
                 });
             }
             catch (err) {
-                this.d.log.error("wait sweep: cannot write missing agent results of a finished run", {
+                this.log.error("wait sweep: cannot write missing agent results of a finished run", {
                     runId: r.parent_run_id,
                     err,
                 });
@@ -640,15 +679,35 @@ export class Waits {
         }
         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 sub-agent runs of a parent run that finished more than the grace period ago (spec §7.5,
      * §12: a parent's terminal state stops its children; this is the backstop) → stopped.
      */
     async sweepChildrenOfFinished() {
-        const sub = this.d.subagents;
-        if (!sub)
-            return 0;
-        const parents = await this.d.db
+        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")
@@ -662,17 +721,17 @@ export class Waits {
         let total = 0;
         for (const p of parents) {
             try {
-                const n = await sub.stop(p.parent_run_id, null);
+                const n = await this.stopChildren(p.parent_run_id, null);
                 if (n === 0)
                     continue;
                 total += n;
-                this.d.log.warn("wait sweep: stopped sub-agents of a finished run", {
+                this.log.warn("wait sweep: stopped sub-agents of a finished run", {
                     runId: p.parent_run_id,
                     count: n,
                 });
             }
             catch (err) {
-                this.d.log.error("wait sweep: cannot stop sub-agents of a finished run", {
+                this.log.error("wait sweep: cannot stop sub-agents of a finished run", {
                     runId: p.parent_run_id,
                     err,
                 });
@@ -686,7 +745,7 @@ export class Waits {
      * （与人工决定 / 超时任务一致，已投递过的同一续跑被 BullMQ 去重）。
      */
     async sweepStuckRuns() {
-        const runs = await this.d.db
+        const runs = await this.db
             .selectFrom("runs")
             .select(["id", "conversation_id"])
             .where("status", "=", "waiting")
@@ -714,14 +773,14 @@ export class Waits {
                 if (!(await this.resume(run.id, waitId)))
                     continue;
                 total++;
-                this.d.log.warn("wait sweep: resumed stuck waiting run", {
+                this.log.warn("wait sweep: resumed stuck waiting run", {
                     runId: run.id,
                     conversationId: run.conversation_id,
                     waitId,
                 });
             }
             catch (err) {
-                this.d.log.error("wait sweep: cannot resume stuck waiting run", { runId: run.id, err });
+                this.log.error("wait sweep: cannot resume stuck waiting run", { runId: run.id, err });
             }
         }
         return total;
@@ -732,16 +791,16 @@ export class Waits {
      * with, so a sweep resume and a late finisher resume share one job id).
      */
     async lastWaitId(runId) {
-        const row = await this.d.db
-            .selectFrom(this.d.db
+        const row = await this.db
+            .selectFrom(this.db
             .selectFrom("approvals")
             .select(["id", "created_at"])
             .where("run_id", "=", runId)
-            .unionAll(this.d.db
+            .unionAll(this.db
             .selectFrom("questions")
             .select(["id", "created_at"])
             .where("run_id", "=", runId))
-            .unionAll(this.d.db
+            .unionAll(this.db
             .selectFrom("subagent_dispatches")
             .select(["child_run_id as id", "created_at"])
             .where("parent_run_id", "=", runId))
@@ -752,7 +811,11 @@ export class Waits {
             .executeTakeFirst();
         return row?.id ?? null;
     }
-    async process(job, token) {
+    /**
+     * A `wait-timeout` job (dispatched by `MaintenanceProcessor`): expires the wait,
+     * or delays the job again until the wait's expiry when it ran early.
+     */
+    async processTimeout(job, token) {
         const { kind, id, runId, step } = job.data;
         const at = runId !== undefined && step !== undefined ? { runId, step } : undefined;
         const r = await this.expire(kind, id, at);
@@ -767,7 +830,7 @@ export class Waits {
             ? { kind: w.kind, id: w.id, runId, step: w.step }
             : { kind: w.kind, id: w.id };
         try {
-            await this.d.maintenance.add(WAIT_TIMEOUT_JOB, data, {
+            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,
@@ -777,7 +840,7 @@ export class Waits {
             });
         }
         catch (err) {
-            this.d.log.error("cannot schedule wait timeout", { waitId: w.id, err });
+            this.log.error("cannot schedule wait timeout", { waitId: w.id, err });
         }
     }
     /**
@@ -786,7 +849,7 @@ export class Waits {
      */
     async isSettled(w, runId) {
         if (w.kind === "subagents") {
-            const active = await this.d.db
+            const active = await this.db
                 .selectFrom("subagent_dispatches as sd")
                 .innerJoin("runs as cr", "cr.id", "sd.child_run_id")
                 .select("cr.id")
@@ -796,12 +859,12 @@ export class Waits {
             return active === undefined;
         }
         const row = w.kind === "approval"
-            ? await this.d.db
+            ? await this.db
                 .selectFrom("approvals")
                 .select("status")
                 .where("id", "=", w.id)
                 .executeTakeFirst()
-            : await this.d.db
+            : await this.db
                 .selectFrom("questions")
                 .select("status")
                 .where("id", "=", w.id)
@@ -855,7 +918,111 @@ export class Waits {
         }
         return out;
     }
-}
+    /**
+     * After a child run's terminal state committed (sub-agents spec §7.3): appends
+     * `subagent_finished` to the parent log (idempotent; allowed while the parent waits, it is not
+     * model-visible) and tries {@link resume}`(parentRunId, childRunId)`. Every finishing child tries;
+     * the conditional resume lets exactly one succeed, the last to see all its siblings terminal. A
+     * run that is not a dispatched child, or not terminal yet, is left alone. A crash in between is
+     * repaired by the wait sweep and by the parent's tools node, which writes a missing
+     * `subagent_finished` itself.
+     */
+    async childFinished(childRunId) {
+        const row = await dispatchOfChildRun(this.db, childRunId);
+        if (!row)
+            return;
+        const run = await this.db
+            .selectFrom("runs")
+            .select("status")
+            .where("id", "=", childRunId)
+            .executeTakeFirst();
+        if (!run || !TERMINAL_STATUSES.has(run.status))
+            return;
+        const r = await childResult(this.eventLog, row);
+        if (!r) {
+            this.log.warn("sub-agent run is terminal without a terminal event", { childRunId });
+            return;
+        }
+        await this.eventLog.append(row.parentConversationId, [finishedEvent(row, r.finished)]);
+        await this.resume(row.parentRunId, childRunId);
+    }
+    /**
+     * Stops the active children of a parent run (sub-agents spec §12), or only those dispatched in
+     * `opts.step`: a `waiting` child through its own {@link abortWaiting}, a `queued` / `running` one
+     * that no worker holds directly (`RunQueue.abortIfOrphaned`), any other through
+     * `RunAbort.request` (the cross-replica broadcast plus the marker key, so a child that starts
+     * later still sees it), after which a child found `waiting` is stopped through `abortWaiting`
+     * too. A child stopped here is reported to the parent at once (by `abortWaiting` itself, or
+     * {@link childFinished} after `abortIfOrphaned`); one stopped by its worker is reported by that
+     * worker. Returns the number of children asked to stop.
+     *
+     * `byAccountId` is the person whose action stops them, or null when the kernel stops them on the
+     * parent's behalf; a child stopped with null reports the §4.4 "parent's stop" text.
+     */
+    async stopChildren(parentRunId, byAccountId, opts = {}) {
+        let q = this.db
+            .selectFrom("subagent_dispatches as sd")
+            .innerJoin("runs as cr", "cr.id", "sd.child_run_id")
+            .select(["sd.child_conversation_id", "sd.child_run_id", "cr.status"])
+            .where("sd.parent_run_id", "=", parentRunId)
+            .where("cr.status", "in", ACTIVE_RUN_STATUSES);
+        if (opts.step !== undefined)
+            q = q.where("sd.step", "=", opts.step);
+        const children = await q.execute();
+        for (const c of children) {
+            const conv = c.child_conversation_id;
+            const runId = c.child_run_id;
+            // abortWaiting reports the stopped child to the parent itself (childFinished)
+            if (c.status === "waiting" &&
+                (await this.abortWaiting(conv, runId, byAccountId, opts.detail))) {
+                continue;
+            }
+            if (await this.runQueue.abortIfOrphaned(conv, runId, byAccountId, opts.detail)) {
+                await this.childFinished(runId);
+                continue;
+            }
+            await this.abort.request(runId, byAccountId, opts.detail);
+            // the suspend handshake (see suspend): a child that became `waiting` after the read above
+            // may have checked the marker before it was set, so check `waiting` again after setting it
+            // (review M1)
+            const now = await this.db
+                .selectFrom("runs")
+                .select("status")
+                .where("id", "=", runId)
+                .executeTakeFirst();
+            if (now?.status === "waiting") {
+                await this.abortWaiting(conv, runId, byAccountId, opts.detail);
+            }
+        }
+        return children.length;
+    }
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], Waits.prototype, "abortWaitingIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], Waits.prototype, "cancelWaitsOfFinishedIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], Waits.prototype, "repairOpenAgentCallsIn", null);
+Waits = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(EventLog)),
+    __param(2, Inject(ApprovalsService)),
+    __param(3, Inject(QuestionsService)),
+    __param(4, Inject(RunQueue)),
+    __param(5, Inject(ToolPipeline)),
+    __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(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
@@ -881,3 +1048,59 @@ export function unreportedForkRuns(db) {
         .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 };