@capybara-hq/kernel 0.1.0-rc.25 → 0.1.0-rc.27

package/dist/runtime/run-finish.d.ts

@@ -58,8 +58,8 @@ export declare class RunFinish {
      * invocation gets its report (`pairStoppedForks`; an `Agent` call has its result from its
      * dispatch), so no terminal path leaves an open call. After it, the stops and the delivery the
      * run's end causes are owed here (runtime/subagents/tree-jobs.ts), the caller still doing them
-     * right after its commit: `stop-tree` when an active fork child remains or a sub-agent run a
-     * person stopped has sub-agents below it, `deliver-to-parent` for a sub-agent's run. The
+     * right after its commit: `stop-tree` when an active fork child remains or a run a person
+     * stopped (a root's or a sub-agent's) has sub-agents below it, `deliver-to-parent` for a sub-agent's run. The
      * delivery is a job, not written here: this transaction holds the child's conversation and run
      * rows, and the parent's conversation row comes first in the dispatch's lock order (parent
      * conversation, parent run, budget run, child conversation).

package/dist/runtime/run-finish.js

@@ -63,8 +63,8 @@ let RunFinish = class RunFinish {
      * invocation gets its report (`pairStoppedForks`; an `Agent` call has its result from its
      * dispatch), so no terminal path leaves an open call. After it, the stops and the delivery the
      * run's end causes are owed here (runtime/subagents/tree-jobs.ts), the caller still doing them
-     * right after its commit: `stop-tree` when an active fork child remains or a sub-agent run a
-     * person stopped has sub-agents below it, `deliver-to-parent` for a sub-agent's run. The
+     * right after its commit: `stop-tree` when an active fork child remains or a run a person
+     * stopped (a root's or a sub-agent's) has sub-agents below it, `deliver-to-parent` for a sub-agent's run. The
      * delivery is a job, not written here: this transaction holds the child's conversation and run
      * rows, and the parent's conversation row comes first in the dispatch's lock order (parent
      * conversation, parent run, budget run, child conversation).
@@ -102,9 +102,14 @@ let RunFinish = class RunFinish {
         const [ev] = await this.eventLog.appendIn(a.conversationId, [
             { ...a.event, runId: a.runId, idemKey: `${a.event.type}:${a.runId}` },
         ]);
+        // a root run a person stopped holds the root's tree (agent map spec §6, acceptance
+        // 2026-11-13): marked with its terminal state, under the same row lock, so no wake decided
+        // after this commit starts the root from a sub-agent's delivery
+        const holdTree = conv?.kind === "chat" && personStopped(a.event);
         await t
             .updateTable("conversations")
             .set({
+            ...(holdTree && { tree_stopped_at: sql `now()` }),
             consumed_seq: a.floorToTrigger === false
                 ? sql `GREATEST(consumed_seq, ${a.consumed ?? 0}::bigint)`
                 : sql `GREATEST(consumed_seq, ${a.consumed ?? 0}::bigint, (SELECT r.trigger_seq FROM capybara.runs r WHERE r.id = ${a.runId}))`,
@@ -145,8 +150,8 @@ let RunFinish = class RunFinish {
             .where("cr.status", "in", ACTIVE_RUN_STATUSES)
             .limit(1)
             .executeTakeFirst();
-        const stoppedWithChildren = kind === "subagent" &&
-            personStopped(a.event) &&
+        // a root's too (agent map spec §6, changed in acceptance 2026-11-13)
+        const stoppedWithChildren = personStopped(a.event) &&
             (await t
                 .selectFrom("conversations")
                 .select("id")
@@ -186,8 +191,8 @@ RunFinish = __decorate([
 ], RunFinish);
 export { RunFinish };
 /**
- * A `run_aborted` a person caused (an account and no `detail`): a sub-agent run stopped that way
- * stops its descendants (`Waits.stopDescendantsOfStopped`, agent map spec §6).
+ * A `run_aborted` a person caused (an account and no `detail`): a run stopped that way stops its
+ * descendants (`Waits.stopDescendantsOfStopped`, agent map spec §6; a root's, those of its windows).
  */
 function personStopped(event) {
     if (event.type !== "run_aborted")

package/dist/runtime/run-jobs.d.ts

@@ -15,10 +15,7 @@ export declare const SUBAGENT_RUN_QUEUE_NAME = "cap-kernel-subagent-runs";
 export declare const runQueueNameFor: (kind: ConversationKind) => typeof RUN_QUEUE_NAME | typeof SUBAGENT_RUN_QUEUE_NAME;
 /** 未结束的运行状态（waiting：等人处理审批 / 输入请求，没有任务、不占会话锁与配额）。 */
 export declare const ACTIVE_RUN_STATUSES: readonly ["queued", "running", "waiting"];
-/** 运行的终态。 */
-export type TerminalStatus = "completed" | "failed" | "aborted";
-/** The terminal run statuses (here, not in `run-finish.ts`, which the sub-agent modules import). */
-export declare const TERMINAL_STATUSES: ReadonlySet<string>;
+export { TERMINAL_STATUSES, type TerminalStatus } from "./run-status.js";
 /**
  * Locks a run's approval and input request rows (`FOR UPDATE`, in id order) in the caller's
  * transaction, after its conversation row and before its run row: the one lock order of every path
@@ -89,7 +86,27 @@ export declare class RunJobs {
     owe(data: RunJobData, jobId: string, kind: ConversationKind, orgId: string): Promise<boolean>;
     /** {@link oweEnsureRun} in the caller's transaction. */
     oweEnsureRun(conversationId: string, seq: number | string, orgId: string): Promise<boolean>;
+    /**
+     * Owes the delayed `bg-wake` job at the end of the conversation's wake window in the caller's
+     * transaction (the `ensureRun` that decided `later`): one job per conversation and window end
+     * ({@link bgWakeJobId}), so finishes inside one window share it; `retry` > 0 is a job that fired
+     * before its window ended. The relay adds it with the remaining delay (a row due later skips the
+     * fast path); `runAt` carries {@link WAKE_JOB_MARGIN_MS}, since the window is read on the
+     * database's clock and the delay runs on this process's and Redis's. Every `ensureRun` inside the
+     * window (each append that calls it) owes it again: a no-op while the row is pending, and once it
+     * was delivered a new row whose add BullMQ dedupes by the job id while the delayed job exists.
+     */
+    oweBgWake(conversationId: string, w: {
+        windowEnd: number;
+        delayMs: number;
+    }, retry: number, orgId: string): Promise<boolean>;
 }
+/**
+ * Margin added to the delayed wake job: its window is read on the database's clock, the delay runs
+ * on this process's and Redis's, so the job does not usually fire just before the window ends (one
+ * that does reschedules itself under its next retry id, `bgWakeJobId`).
+ */
+export declare const WAKE_JOB_MARGIN_MS = 1000;
 /**
  * What {@link RunResume.resumeIn} found: `queued`, the run was waiting on nothing else and now is
  * queued with its resume job owed; `still-running`, the run has not reached `waiting` yet (its

package/dist/runtime/run-jobs.js

@@ -10,6 +10,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { getQueueToken } from "@nestjs/bullmq";
 import { Inject, Injectable, Module } from "@nestjs/common";
 import { sql } from "kysely";
+import { BG_WAKE_JOB, bgWakeJobId } from "../background/wake-rules.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";
@@ -29,12 +30,8 @@ export const SUBAGENT_RUN_QUEUE_NAME = "cap-kernel-subagent-runs";
 export const runQueueNameFor = (kind) => kind === "subagent" ? SUBAGENT_RUN_QUEUE_NAME : RUN_QUEUE_NAME;
 /** 未结束的运行状态（waiting：等人处理审批 / 输入请求，没有任务、不占会话锁与配额）。 */
 export const ACTIVE_RUN_STATUSES = ["queued", "running", "waiting"];
-/** The terminal run statuses (here, not in `run-finish.ts`, which the sub-agent modules import). */
-export const TERMINAL_STATUSES = new Set([
-    "completed",
-    "failed",
-    "aborted",
-]);
+// The terminal run statuses (here, not in `run-finish.ts`, which the sub-agent modules import)
+export { TERMINAL_STATUSES } from "./run-status.js";
 /**
  * Locks a run's approval and input request rows (`FOR UPDATE`, in id order) in the caller's
  * transaction, after its conversation row and before its run row: the one lock order of every path
@@ -144,6 +141,26 @@ let RunJobs = class RunJobs {
     oweEnsureRun(conversationId, seq, orgId) {
         return oweEnsureRun(this.outbox, conversationId, seq, orgId);
     }
+    /**
+     * Owes the delayed `bg-wake` job at the end of the conversation's wake window in the caller's
+     * transaction (the `ensureRun` that decided `later`): one job per conversation and window end
+     * ({@link bgWakeJobId}), so finishes inside one window share it; `retry` > 0 is a job that fired
+     * before its window ended. The relay adds it with the remaining delay (a row due later skips the
+     * fast path); `runAt` carries {@link WAKE_JOB_MARGIN_MS}, since the window is read on the
+     * database's clock and the delay runs on this process's and Redis's. Every `ensureRun` inside the
+     * window (each append that calls it) owes it again: a no-op while the row is pending, and once it
+     * was delivered a new row whose add BullMQ dedupes by the job id while the delayed job exists.
+     */
+    oweBgWake(conversationId, w, retry, orgId) {
+        return this.outbox.add({
+            queue: MAINTENANCE_QUEUE_NAME,
+            name: BG_WAKE_JOB,
+            jobId: bgWakeJobId(conversationId, w.windowEnd, retry),
+            data: { conversationId, ...(retry > 0 && { retry }) },
+            runAt: new Date(Date.now() + w.delayMs + WAKE_JOB_MARGIN_MS),
+            orgId,
+        });
+    }
 };
 RunJobs = __decorate([
     Injectable(),
@@ -153,6 +170,12 @@ RunJobs = __decorate([
     __param(3, Inject(OutboxService))
 ], RunJobs);
 export { RunJobs };
+/**
+ * Margin added to the delayed wake job: its window is read on the database's clock, the delay runs
+ * on this process's and Redis's, so the job does not usually fire just before the window ends (one
+ * that does reschedules itself under its next retry id, `bgWakeJobId`).
+ */
+export const WAKE_JOB_MARGIN_MS = 1000;
 /**
  * The resume of a waiting run (transactional outbox spec §6 "Resumes and timeouts", "Decisions
  * resume in their own transaction"), in the caller's transaction. A decision (approvals, questions,

package/dist/runtime/run-orphan-check.job.d.ts

@@ -13,7 +13,7 @@ import { RunFinish } from "./run-finish.js";
 import { RunJobs } from "./run-jobs.js";
 import { RunQueue } from "./run-queue.js";
 import { Waits } from "./waits.js";
-/** The check's `@LockedInterval` job name (its run lock key is the default `cron:run-orphan-check`). */
+/** The check's `@LockedInterval` job name (its run lock key: `cron:run-orphan-check`). */
 export declare const RUN_ORPHAN_CHECK_JOB = "run-orphan-check";
 /** The check's period: a fixed constant, not a config field. */
 export declare const RUN_ORPHAN_CHECK_PERIOD_MS = 60000;
@@ -55,7 +55,10 @@ export interface OrphanCandidate {
 /**
  * One page of the active runs of chat and sub-agent conversations in `statuses` that entered their
  * state more than `minAgeMs` ago, by (state start, id), after `after` (an eval's hidden
- * conversation drives its runs itself).
+ * conversation drives its runs itself). A deleted org's runs are never candidates, running ones
+ * included: its deletion purged its owed jobs on purpose, so their absence is no lost job and
+ * nothing is re-added, and the org's data is invisible from then on, so a running orphan is left
+ * as it is rather than failed.
  */
 export declare function orphanCandidates(db: KernelSchemaDb, statuses: readonly ("queued" | "running")[], minAgeMs: number, limit: number, after?: Pick<OrphanCandidate, "since" | "runId">): Promise<OrphanCandidate[]>;
 /**
@@ -65,12 +68,12 @@ export declare function orphanCandidates(db: KernelSchemaDb, statuses: readonly
  */
 export declare function jobInOutbox(db: KernelSchemaDb, queue: string, jobId: string): Promise<boolean>;
 /**
- * The `queued` runs (in their state for over `minAgeMs`) whose job is neither in the outbox
- * (owed, or dead) nor in BullMQ (`jobExists`), and that are still queued after both looks: the run
- * queue lost their jobs. The outbox is read before BullMQ (a row is deleted only after its job was added) and the
- * run again after both (a job that finished took its run out of `queued` first), so a run in
- * flight is never reported. The `run-orphan-check` uses it; so does the dual-replica test harness,
- * which asserts at its teardown that the kernel left none (`minAgeMs` 0).
+ * The `queued` runs (in their state for over `minAgeMs`) whose job is neither in the outbox (owed,
+ * or dead) nor in BullMQ (`jobExists`), and that are still queued after both looks: the run queue
+ * lost their jobs. The outbox is read before BullMQ (a row is deleted only after its job was added)
+ * and the run again after both (a job that finished took its run out of `queued` first), so a run
+ * in flight is never reported. The `run-orphan-check` uses it; so does the dual-replica test
+ * harness, which asserts at its teardown that the kernel left none (`minAgeMs` 0).
  */
 export declare function queuedRunsWithoutJob(db: KernelSchemaDb, jobExists: (queue: string, jobId: string) => Promise<boolean>, opts: {
     minAgeMs: number;
@@ -85,9 +88,9 @@ export declare function queuedRunsWithoutJob(db: KernelSchemaDb, jobExists: (que
  *   `run.orphaned` (its terminal transaction cancels its waits and owes what every run end owes),
  *   then, after the commit, its checkpoints are dropped, its fork child stopped (`run.orphaned`), a
  *   sub-agent's failure delivered to its parent at once and the conversation's next run started.
- * - `queued`, with no outbox row either (pending or dead): a canary. Every queued run has its job owed in its
- *   own transaction, so this means Redis lost data. It is logged as an error, counted for the admin
- *   overview ({@link QueueLostJobs}) and its job owed again so the run is not stuck.
+ * - `queued`, with no outbox row either (pending or dead): a canary. Every queued run has its job
+ *   owed in its own transaction, so this means Redis lost data. It is logged as an error, counted
+ *   for the admin overview ({@link QueueLostJobs}) and its job owed again so the run is not stuck.
  * Redis is read before each repair's transaction, which then re-reads the run under its
  * conversation row lock and acts only if it is still in the same state since the same time. Read
  * paths never repair runs.

package/dist/runtime/run-orphan-check.job.js

@@ -25,7 +25,7 @@ import { notifyFinished, RunFinish } from "./run-finish.js";
 import { RunJobs, runJobId, runQueueNameFor } from "./run-jobs.js";
 import { RunQueue } from "./run-queue.js";
 import { Waits } from "./waits.js";
-/** The check's `@LockedInterval` job name (its run lock key is the default `cron:run-orphan-check`). */
+/** The check's `@LockedInterval` job name (its run lock key: `cron:run-orphan-check`). */
 export const RUN_ORPHAN_CHECK_JOB = "run-orphan-check";
 /** The check's period: a fixed constant, not a config field. */
 export const RUN_ORPHAN_CHECK_PERIOD_MS = 60_000;
@@ -49,12 +49,16 @@ const SINCE = sql `GREATEST(COALESCE(r.queued_at, r.created_at), COALESCE(r.star
 /**
  * One page of the active runs of chat and sub-agent conversations in `statuses` that entered their
  * state more than `minAgeMs` ago, by (state start, id), after `after` (an eval's hidden
- * conversation drives its runs itself).
+ * conversation drives its runs itself). A deleted org's runs are never candidates, running ones
+ * included: its deletion purged its owed jobs on purpose, so their absence is no lost job and
+ * nothing is re-added, and the org's data is invisible from then on, so a running orphan is left
+ * as it is rather than failed.
  */
 export async function orphanCandidates(db, statuses, minAgeMs, limit, after) {
     let q = db
         .selectFrom("runs as r")
         .innerJoin("conversations as c", "c.id", "r.conversation_id")
+        .innerJoin("orgs as o", "o.id", "c.org_id")
         .select([
         "r.id",
         "r.conversation_id",
@@ -67,6 +71,7 @@ export async function orphanCandidates(db, statuses, minAgeMs, limit, after) {
     ])
         .where("r.status", "in", statuses)
         .where("c.kind", "in", ["chat", "subagent"])
+        .where("o.deleted_at", "is", null)
         .where(SINCE, "<", sql `now() - ${minAgeMs}::integer * interval '1 millisecond'`);
     if (after !== undefined) {
         q = q.where(sql `(${SINCE}, r.id) > (${after.since}::timestamptz, ${after.runId})`);
@@ -110,12 +115,12 @@ async function* candidatePages(db, statuses, minAgeMs) {
     }
 }
 /**
- * The `queued` runs (in their state for over `minAgeMs`) whose job is neither in the outbox
- * (owed, or dead) nor in BullMQ (`jobExists`), and that are still queued after both looks: the run
- * queue lost their jobs. The outbox is read before BullMQ (a row is deleted only after its job was added) and the
- * run again after both (a job that finished took its run out of `queued` first), so a run in
- * flight is never reported. The `run-orphan-check` uses it; so does the dual-replica test harness,
- * which asserts at its teardown that the kernel left none (`minAgeMs` 0).
+ * The `queued` runs (in their state for over `minAgeMs`) whose job is neither in the outbox (owed,
+ * or dead) nor in BullMQ (`jobExists`), and that are still queued after both looks: the run queue
+ * lost their jobs. The outbox is read before BullMQ (a row is deleted only after its job was added)
+ * and the run again after both (a job that finished took its run out of `queued` first), so a run
+ * in flight is never reported. The `run-orphan-check` uses it; so does the dual-replica test
+ * harness, which asserts at its teardown that the kernel left none (`minAgeMs` 0).
  */
 export async function queuedRunsWithoutJob(db, jobExists, opts) {
     const out = [];
@@ -146,9 +151,9 @@ export async function queuedRunsWithoutJob(db, jobExists, opts) {
  *   `run.orphaned` (its terminal transaction cancels its waits and owes what every run end owes),
  *   then, after the commit, its checkpoints are dropped, its fork child stopped (`run.orphaned`), a
  *   sub-agent's failure delivered to its parent at once and the conversation's next run started.
- * - `queued`, with no outbox row either (pending or dead): a canary. Every queued run has its job owed in its
- *   own transaction, so this means Redis lost data. It is logged as an error, counted for the admin
- *   overview ({@link QueueLostJobs}) and its job owed again so the run is not stuck.
+ * - `queued`, with no outbox row either (pending or dead): a canary. Every queued run has its job
+ *   owed in its own transaction, so this means Redis lost data. It is logged as an error, counted
+ *   for the admin overview ({@link QueueLostJobs}) and its job owed again so the run is not stuck.
  * Redis is read before each repair's transaction, which then re-reads the run under its
  * conversation row lock and acts only if it is still in the same state since the same time. Read
  * paths never repair runs.

package/dist/runtime/run-queue.d.ts

@@ -1,5 +1,4 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { Queue } from "bullmq";
 import { EventLog } from "../conversations/event-log.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
@@ -32,14 +31,10 @@ export declare class RunQueue {
     private readonly log;
     readonly txHost: TransactionHost;
     private readonly config;
-    /** The producer side of the delayed `bg-wake` job (`MaintenanceProcessor` consumes it). */
-    private readonly maintenance;
     private readonly ensureFails;
     constructor(kdb: KernelDb, eventLog: EventLog, lock: Pick<ConversationLock, "holder">, jobs: RunJobs, finisher: Pick<RunFinish, "finishIn">, 
     /** An orphan aborted directly loses its checkpoint thread (thread_id = runId). */
-    checkpoints: Pick<KyselyCheckpointSaver, "deleteThread">, log: Pick<Logger, "error" | "warn">, txHost: TransactionHost, config: KernelConfigService, 
-    /** The producer side of the delayed `bg-wake` job (`MaintenanceProcessor` consumes it). */
-    maintenance: Pick<Queue, "add">, ensureFails?: () => boolean);
+    checkpoints: Pick<KyselyCheckpointSaver, "deleteThread">, log: Pick<Logger, "error" | "warn">, txHost: TransactionHost, config: KernelConfigService, ensureFails?: () => boolean);
     private get db();
     /**
      * 有未消费的用户消息（最新 user_message 的 seq > `consumed_seq`）、会话锁无人持有、
@@ -51,7 +46,7 @@ export declare class RunQueue {
      * once it is sent; with no head either, a wake-eligible finished background task or sub-agent
      * delivery (background Bash spec §3, agent map spec §5.3, {@link wakeDecisionIn}): the run is
      * then attributed to the event's trigger account and joins the tree's budget window, and an
-     * event inside the wake window schedules the delayed `bg-wake` job instead. A sub-agent's
+     * event inside the wake window owes the delayed `bg-wake` job instead. A sub-agent's
      * conversation is only woken this way ({@link childWakeIn}).
      *
      * An active run (queued, running or waiting) is left alone: a run nobody runs any more is the
@@ -77,8 +72,9 @@ export declare class RunQueue {
     private jobIdFor;
     /**
      * Owes the new run's job in {@link ensureRunIn}'s transaction, before its run row is written.
-     * False (logged): the same job id is still owed, so the caller writes no run (a second run of
-     * one trigger; the conversation's unique active run makes this a should-not-happen).
+     * False (logged): the same job id is still owed, so the caller writes no run. A later run of the
+     * same trigger has its own `<runJobId>-<n>` ({@link jobIdFor}), so this is a should-not-happen
+     * (the conversation has one active run at a time).
      */
     private oweJob;
     /**
@@ -89,15 +85,17 @@ export declare class RunQueue {
      * racing the run's end starts a new run, never lost); and it is woken by its own background
      * task's finish or a delivery from its own sub-agent, under the same rules as a chat
      * conversation. Neither happens once its last run was stopped (`aborted`): a stopped sub-agent is
-     * started again only by its parent. Both read the queue and the trigger account's access on the root
-     * of its tree; a message needs no wake setting and has no wake window. The run counts against
-     * the root's budget window and runs on the sub-agent queue under `runJobId(child, boundary
-     * seq)`. An active run is never started past (one nobody runs is the `run-orphan-check`'s).
+     * started again only by its parent; nor while a person's stop of the root holds the tree
+     * (`conversations.tree_stopped_at`, cleared by the root's next run). Both read the queue and the
+     * trigger account's access on the root of its tree; a message needs no wake setting and has no
+     * wake window. The run counts against the root's budget window and runs on the sub-agent queue
+     * under `runJobId(child, boundary seq)`. An active run is never started past (one nobody runs is
+     * the `run-orphan-check`'s).
      */
     private childWakeIn;
     /**
-     * The newest unconsumed message of an idle sub-agent (a `SendMessage` its last run did not absorb)
-     * as a run boundary, or null: none; the root's queue is paused or the root deleted (the
+     * The newest unconsumed message of an idle sub-agent (a `SendMessage` its last run did not
+     * absorb) as a run boundary, or null: none; the root's queue is paused or the root deleted (the
      * message waits for the unpause, {@link wakeHeldTree}); or its author can no longer send to the
      * root (it waits for a later run). The caller already refused a stopped sub-agent (last run
      * `aborted`): a message that reached it while running and then stopped is parked, and the next
@@ -126,13 +124,6 @@ export declare class RunQueue {
      * with their org and newest seq. Reads only (no row locks).
      */
     private heldTree;
-    /**
-     * Schedules the delayed `bg-wake` job at the end of the conversation's wake window (after the
-     * commit): one job per conversation and window end, so finishes inside one window share it. It
-     * calls {@link ensureRun}, which wakes the conversation if a finish is still unconsumed. A failed
-     * enqueue is logged: the next message, run end or page opening re-derives the wake.
-     */
-    private scheduleWake;
     /**
      * Owes the ensure-run backstop of `conversationId` in the caller's transaction
      * ({@link oweEnsureRun}): `seq` is the event the transaction wrote, `orgId` the conversation's.
@@ -141,8 +132,8 @@ export declare class RunQueue {
     /**
      * Stops an orphaned run directly (`POST .../abort`, a tree stop): a `running` run whose
      * conversation lock is free and whose BullMQ job is gone hears no stop broadcast, so its
-     * `run_aborted` is written here (status aborted, `consumed_seq` at least to its trigger): true. Not
-     * an orphan (someone runs it; a queued run's job is owed, or lost and re-added by the
+     * `run_aborted` is written here (status aborted, `consumed_seq` at least to its trigger): true.
+     * Not an orphan (someone runs it; a queued run's job is owed, or lost and re-added by the
      * `run-orphan-check`, whose worker then sees the stop marker) or already finished: false, and the
      * caller broadcasts the stop.
      */
@@ -150,14 +141,15 @@ export declare class RunQueue {
     private abortOrphanIn;
     /**
      * Ends a `queued` run in PG before any worker started it (an offboarded member's run, ruling
-     * R27): with the conversation lock free, under the conversation row lock, a run still `queued`
-     * is finished `aborted` with `run_aborted` (`consumed_seq` at least to its trigger), so a job
-     * that runs later finds it finished and starts nothing. True when it did; false when a worker
-     * holds the conversation or is in the middle of the run's first start (`run_started` written,
+     * R27): with the conversation lock free, under the conversation row lock, a run still `queued` is
+     * finished `aborted` with `run_aborted` (`consumed_seq` at least to its trigger), so a job that
+     * runs later finds it finished and starts nothing. True when it did; false when a worker holds
+     * the conversation or is in the middle of the run's first start (`run_started` written,
      * `started_at` not yet set; it hears the stop), or the run is no longer queued. A run resumed
-     * from `waiting` to `queued` is ended like a new one. The caller writes the stop marker first, so a worker that takes the
-     * conversation meanwhile still stops; a worker that read the run before this commit re-checks it
-     * under the row locks before its `run_started` and never moves it back to `running`.
+     * from `waiting` to `queued` is ended like a new one. The caller writes the stop marker first, so
+     * a worker that takes the conversation meanwhile still stops; a worker that read the run before
+     * this commit re-checks it under the row locks before its `run_started` and never moves it back
+     * to `running`.
      */
     abortQueued(conversationId: string, runId: string, byAccountId: string | null): Promise<boolean>;
     private abortQueuedIn;