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

package/dist/config/schema.js

@@ -22,8 +22,6 @@ function isValidMasterKey(value) {
  * 插件名同清单规则（不能是 `local`），租户 id 非空、不含空白；与 identity/external.ts 的身份源键规则一致。
  */
 const TRUSTED_SOURCE_RE = /^(?!local:)[a-z0-9][a-z0-9._-]{0,213}:\S{1,256}$/;
-/** `runtime.maxRunSeconds` 的默认值。 */
-export const DEFAULT_MAX_RUN_SECONDS = 900;
 /** `sandbox.limits.maxCommandSeconds` 的默认值。 */
 export const DEFAULT_MAX_COMMAND_SECONDS = 7200;
 /** access token 寿命上限（秒）；会话吊销标记的 TTL 按它计算，与实例当前配置无关。 */
@@ -573,9 +571,11 @@ export const KernelConfigSchema = z.object({
         maxSteps: z
             .number()
             .int()
-            .positive()
-            .default(50)
-            .meta(meta({ description: "Maximum model steps per agent run before the final wrap-up" })),
+            .nonnegative()
+            .default(0)
+            .meta(meta({
+            description: "Maximum model steps per agent run before the final wrap-up; 0 (the default) means no limit: a run goes on until the model stops calling tools or someone stops it",
+        })),
         wakeOnBackgroundTask: z
             .boolean()
             .default(true)
@@ -585,10 +585,10 @@ export const KernelConfigSchema = z.object({
         maxRunSeconds: z
             .number()
             .int()
-            .positive()
-            .default(DEFAULT_MAX_RUN_SECONDS)
+            .nonnegative()
+            .default(0)
             .meta(meta({
-            description: "Maximum wall-clock duration of one agent run in seconds (time spent waiting for people is not counted). Sandbox commands are limited to the time left in the run, so agents that need long commands need maxRunSeconds >= sandbox.limits.maxCommandSeconds",
+            description: "Maximum wall-clock duration of one agent run in seconds (time spent waiting for people is not counted); 0 (the default) means no limit. With a limit, sandbox commands are limited to the time left in the run, so agents that need long commands need maxRunSeconds >= sandbox.limits.maxCommandSeconds; without one, commands are limited only by sandbox.limits.maxCommandSeconds and the tool timeouts",
         })),
         streamIdleMs: z
             .number()
@@ -669,9 +669,9 @@ export const KernelConfigSchema = z.object({
         })),
     })
         .default({
-        maxSteps: 50,
+        maxSteps: 0,
         wakeOnBackgroundTask: true,
-        maxRunSeconds: DEFAULT_MAX_RUN_SECONDS,
+        maxRunSeconds: 0,
         streamIdleMs: 60000,
         maxOutputTokens: 16000,
         compactionThreshold: 0.8,
@@ -1178,7 +1178,7 @@ export const KernelConfigSchema = z.object({
                 .positive()
                 .default(DEFAULT_MAX_COMMAND_SECONDS)
                 .meta(meta({
-                description: "Longest a single sandbox command may run, in seconds. A command also stops when its run is about to reach runtime.maxRunSeconds, so long commands need runtime.maxRunSeconds >= maxCommandSeconds (a startup warning is logged otherwise)",
+                description: "Longest a single sandbox command may run, in seconds. When runtime.maxRunSeconds is set (not 0), a command also stops when its run is about to reach it, so long commands need runtime.maxRunSeconds >= maxCommandSeconds (a startup warning is logged otherwise)",
             })),
             suspendAfterIdleMinutes: z
                 .number()
@@ -1246,27 +1246,29 @@ export const KernelConfigSchema = z.object({
             .object({
             max: z
                 .enum(["strict", "dev", "open"])
-                .default("dev")
+                .optional()
                 .meta(meta({
                 hot: true,
-                description: "Highest sandbox tier any organization may reach: strict (the allowlist only), dev (adds devHosts and local development affordances) or open (any public host); organizations and devices choose at most this",
+                description: "Highest sandbox tier any organization may reach: strict (the allowlist only), dev (adds devHosts and local development affordances) or open (any public host); organizations and devices choose at most this. Unset: the super admin's choice in the admin console, else dev; set here, it is read-only there",
             })),
             default: z
                 .enum(["strict", "dev", "open"])
-                .default("dev")
+                .optional()
                 .meta(meta({
                 hot: true,
-                description: "Sandbox tier of a device whose owner chose none, unless its organization sets its own default; at most sandbox.tiers.max",
+                description: "Sandbox tier of a device whose owner chose none, unless its organization sets its own default; at most sandbox.tiers.max. Unset: the super admin's choice in the admin console, else dev; set here, it is read-only there",
             })),
             allowUnsandboxed: z
                 .boolean()
-                .default(true)
+                .optional()
                 .meta(meta({
                 hot: true,
-                description: "Whether a local device may run commands without a sandbox (its owner's local choice); it only applies where the organization's ceiling is open, and an organization may forbid it",
+                description: "Whether a local device may run commands without a sandbox (its owner's local choice); it only applies where the organization's ceiling is open, and an organization may forbid it. Unset: the super admin's choice in the admin console, else true; set here, it is read-only there",
             })),
         })
-            .refine((t) => tierAtMost(t.default, t.max), {
+            // both set here: the default may not be above the max (a max from the admin console
+            // caps a default set here instead, see sandbox/platform-tiers.ts)
+            .refine((t) => t.default === undefined || t.max === undefined || tierAtMost(t.default, t.max), {
             message: "sandbox.tiers.default must not be above sandbox.tiers.max",
             path: ["default"],
         })
@@ -1441,15 +1443,6 @@ export const KernelConfigSchema = z.object({
             .meta(meta({
             description: "usage.report delivery jobs one worker replica processes at the same time",
         })),
-        usageReportKeepHours: z
-            .number()
-            .int()
-            .min(1)
-            .max(720)
-            .default(24)
-            .meta(meta({
-            description: "Hours a finished usage.report job is kept in Redis so re-enqueueing the same usage event (resumed step, sweeper) is deduplicated; at least 1, well above the sweeper's 10-minute overlap",
-        })),
     })
         .prefault({}),
     log: z

package/dist/conversations/agent-tree.d.ts

@@ -44,3 +44,19 @@ export interface AgentTreeNode {
  * check of the root.
  */
 export declare function readAgentTree(db: KernelSchemaDb, orgId: string, rootId: string): Promise<AgentTreeNode | null>;
+/** One sub-agent a conversation dispatched, as `TaskList` lists it. */
+export interface ChildAgent {
+    /** The child conversation's id: the agentId the parent saw. */
+    id: string;
+    /** The dispatched description (the child's title when no dispatch event has one). */
+    description: string;
+    /** The latest run's status; `queued` before the first run is recorded. */
+    status: "queued" | "running" | "waiting" | "completed" | "failed" | "aborted";
+    /** When the latest run ended; null while it is active. */
+    finishedAt: Date | null;
+}
+/**
+ * The sub-agents `parentId` of org `orgId` dispatched itself (not their own sub-agents), oldest
+ * first: live sub-agent conversations with a dispatch row, as {@link readAgentTree} counts them.
+ */
+export declare function readChildAgents(db: KernelSchemaDb, orgId: string, parentId: string): Promise<ChildAgent[]>;

package/dist/conversations/agent-tree.js

@@ -90,3 +90,39 @@ function toNode(r, isRoot) {
     };
 }
 const modelOf = (m) => m ? { provider: m.provider, model: m.model } : null;
+/**
+ * The sub-agents `parentId` of org `orgId` dispatched itself (not their own sub-agents), oldest
+ * first: live sub-agent conversations with a dispatch row, as {@link readAgentTree} counts them.
+ */
+export async function readChildAgents(db, orgId, parentId) {
+    const { rows } = await sql `
+    SELECT c.id, c.title,
+      (SELECT e.payload->>'description' FROM capybara.conversation_events e
+        WHERE e.conversation_id = c.parent_conversation_id AND e.type = 'subagent_dispatched'
+          AND e.payload->>'subagentId' = c.id
+        ORDER BY e.seq DESC LIMIT 1) AS description,
+      latest.status AS last_status, latest.finished_at AS last_finished_at
+    FROM capybara.conversations c
+    LEFT JOIN LATERAL (
+      SELECT r.status, r.finished_at FROM capybara.runs r
+      WHERE r.conversation_id = c.id
+      ORDER BY r.created_at DESC, r.id DESC
+      LIMIT 1
+    ) latest ON true
+    WHERE c.parent_conversation_id = ${parentId} AND c.org_id = ${orgId}
+      AND c.kind = 'subagent' AND c.deleted_at IS NULL
+      AND EXISTS (
+        SELECT 1 FROM capybara.subagent_dispatches sd WHERE sd.child_conversation_id = c.id
+      )
+    ORDER BY c.created_at, c.id
+  `.execute(db);
+    return rows.map((r) => {
+        const status = r.last_status ?? "queued";
+        return {
+            id: r.id,
+            description: r.description ?? r.title ?? "",
+            status,
+            finishedAt: ACTIVE.has(status) ? null : (r.last_finished_at ?? null),
+        };
+    });
+}

package/dist/conversations/conversations.service.d.ts

@@ -7,7 +7,6 @@ import { ConversationDevices, type NewConversationDevice } from "../devices/conv
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
-import type { KernelLogger } from "../log.js";
 import { ProviderRegistry } from "../runtime/providers.js";
 import type { ScheduleMarker } from "../schedules/types.js";
 import { type RenderedInvocation, SkillInvoker } from "../skills/invoke.js";
@@ -118,10 +117,30 @@ export interface ReplySkips {
 export declare const NO_REPLY_SKIPS: ReplySkips;
 /** 会话服务用到的运行控制：投递运行（RunQueue）与跨副本中止（RunAbort）。 */
 export interface RunControl {
-    /** 有未消费的消息且没有进行中的运行时投递一轮运行；返回 runId 或 null。 */
-    ensureRun(conversationId: string): Promise<string | null>;
+    /**
+     * The direct `ensureRun` after a commit that owes the ensure-run backstop: a failure is logged,
+     * never thrown (transactional outbox spec §6).
+     */
+    ensureRunAfterCommit(conversationId: string): Promise<void>;
+    /**
+     * Owes the ensure-run backstop in the caller's transaction (transactional outbox spec §6): `seq`
+     * is the event it wrote (or the conversation's newest), `orgId` the conversation's.
+     */
+    oweEnsureRun(conversationId: string, seq: number | string, orgId: string): Promise<boolean>;
     /** After a root's queue was unpaused: the wakes it held for its tree (agent map spec §5.3). */
     wakeHeldTree(rootId: string): Promise<void>;
+    /**
+     * In the transaction that may release a root's hold: owes the ensure-run backstop of each
+     * sub-agent {@link wakeHeldTree} wakes after the commit (transactional outbox spec §6).
+     */
+    oweHeldTreeIn(rootId: string): Promise<void>;
+    /**
+     * In a decision's transaction, after its decided rows: resumes the waiting run when it waits on
+     * nothing else (lock order: conversations, decided rows, runs).
+     */
+    resumeIn(runId: string, waitId: string): Promise<unknown>;
+    /** In a root's delete transaction: owes the stop of its sub-agent tree (`stop-tree`). */
+    oweStopDeletedTree(conversationId: string, byAccountId: string | null, orgId: string): Promise<boolean>;
     /**
      * 运行是孤儿（会话锁空闲、任务已不存在，没有 worker 会收到中止广播）时直接把它写成 aborted，返回 true；
      * 否则返回 false。
@@ -222,7 +241,6 @@ export declare class ConversationsService {
     private readonly runs;
     /** Resolves a switched-to model and its declared parameters (UI refresh B). */
     private readonly providers;
-    private readonly log;
     /** Reads `@` resources with the sender's credentials. */
     private readonly content;
     /** Binds uploaded files to the conversation in the message's transaction. */
@@ -243,7 +261,7 @@ export declare class ConversationsService {
     /** Starts and stops the conversation's runs. */
     runs: RunControl, 
     /** Resolves a switched-to model and its declared parameters (UI refresh B). */
-    providers: Pick<ProviderRegistry, "resolve">, log: Pick<KernelLogger, "warn">, 
+    providers: Pick<ProviderRegistry, "resolve">, 
     /** Reads `@` resources with the sender's credentials. */
     content: Pick<ConnectorContent, "resolveAttachments">, 
     /** Binds uploaded files to the conversation in the message's transaction. */
@@ -258,11 +276,6 @@ export declare class ConversationsService {
     questions: Pick<QuestionsService, "skipPendingIn">, 
     /** ... and its pending network asks (network ask-to-allow spec §6.7). */
     approvals: Pick<ApprovalsService, "skipNetworkIn">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost);
-    /**
-     * 不阻塞地调用一次 `ensureRun`（打开 SSE、读事件时）：它幂等，并顺带清理孤儿运行，
-     * 会话不会因为某次运行结束后的投递失败而永远停在「运行中」。失败只记日志。
-     */
-    kickRun(conversationId: string): void;
     /**
      * Creates an empty conversation bound to its device (`pick`, see
      * {@link ConversationDevices.forNew}); an agent the account cannot use →
@@ -297,6 +310,11 @@ export declare class ConversationsService {
      * the other conversation is never returned).
      */
     private findCreated;
+    /**
+     * The direct `ensureRun` after a message's commit ({@link RunControl.ensureRunAfterCommit}): a
+     * failure never fails the request, since the message's transaction owes the ensure-run backstop.
+     */
+    private startRun;
     private rowView;
     /**
      * Renames a conversation (owner only, as {@link get}): `title_source = 'manual'`, so the title
@@ -399,12 +417,15 @@ export declare class ConversationsService {
      * only after an access check.
      */
     sandboxConversationOf(orgId: string, conversationId: string): Promise<string>;
-    /** 读事件（先做 `get` 的可见性判定）；顺带不阻塞地 {@link kickRun}。 */
+    /**
+     * 读事件（先做 `get` 的可见性判定）. A read never changes run state (transactional outbox spec
+     * §6): a run nobody runs is the `run-orphan-check`'s to repair.
+     */
     listEvents(orgId: string, conversationId: string, viewerAccountId: string, afterSeq: number, limit: number): Promise<ConversationEvent[]>;
     /**
      * The turn-aligned page of events before `beforeSeq` (`null`: the log's last page), with how
      * many runs started before it ({@link EventLog.readTurnPageBefore}; history paging spec §2).
-     * Visibility as {@link get}; kicks a stalled run as {@link listEvents} does.
+     * Visibility as {@link get}; a read only, as {@link listEvents}.
      */
     listEventsBefore(orgId: string, conversationId: string, viewerAccountId: string, beforeSeq: number | null, limit: number): Promise<{
         events: ConversationEvent[];
@@ -413,7 +434,8 @@ export declare class ConversationsService {
     /**
      * 追加一条用户消息；带 `clientMessageId` 时重复提交返回同一事件。写入后调用 `ensureRun`：
      * 没有进行中的运行时投递一轮；运行中则由当前运行在步骤间隙吸收，或在它结束时再次 `ensureRun`。
-     * 投递失败时抛错（消息已写入；客户端带同一 `clientMessageId` 重试会再次触发投递）。
+     * A failed `ensureRun` is logged, not thrown: the message's transaction owes the ensure-run
+     * backstop, which starts the run once the queue is reachable (transactional outbox spec §6).
      *
      * `attachments`（`@` 资源引用）：内核以发送者的凭据读取资源（打码、限长），作为用户文本之后的额外文本块写入同一条
      * user_message，并在 `payload.attachments` 记录元数据（第 i 个附件对应 `content[i + 1]`）。读取失败整条不写。
@@ -452,6 +474,13 @@ export declare class ConversationsService {
      * conversations (network ask-to-allow spec §6.7). The queue's "send now" uses it as the direct
      * send does; announce after the commit with {@link announceSkipped}. `toSeq` is the highest seq
      * written in this conversation (null: none).
+     *
+     * Lock order: this (root) conversation (the caller's), its pending questions, the sub-agents'
+     * conversations with a pending network ask (id order), the asks themselves (the root's and the
+     * sub-agents'), and only then the run rows, as each skipped wait's run resumes in this
+     * transaction. Every run row comes after every conversation and decided row (ruling R19); a
+     * sub-agent's conversation comes after the root's questions, which only this path locks with a
+     * sub-agent conversation after them.
      */
     skipWaitsIn(conversationId: string, accountId: string, messageSeq: number): Promise<{
         skipped: ReplySkips;
@@ -460,7 +489,8 @@ export declare class ConversationsService {
     /**
      * After the commit: announces each skipped question (`question.answered`, outcome `skipped`) and
      * network ask (`approval.decided`, status `skipped`; a sub-agent's conversation is notified
-     * first), so its run resumes (waits) and its IM card updates (channel jobs).
+     * first) as domain events with no kernel subscriber: the IM card updates are owed by the skips'
+     * appends (transactional outbox spec §8.1); the run resumed in the message's transaction.
      */
     announceSkipped(skipped: ReplySkips): Promise<void>;
     /**

package/dist/conversations/conversations.service.js

@@ -19,7 +19,6 @@ 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 { KERNEL_LOGGER } from "../infra/tokens.js";
 import { ProviderRegistry } from "../runtime/providers.js";
 import { RunControl as RunControlService } from "../runtime/run-control.js";
 import { rootConversationOf } from "../runtime/subagents/child.js";
@@ -130,7 +129,6 @@ let ConversationsService = class ConversationsService {
     access;
     runs;
     providers;
-    log;
     content;
     attachments;
     invoker;
@@ -144,7 +142,7 @@ let ConversationsService = class ConversationsService {
     /** Starts and stops the conversation's runs. */
     runs, 
     /** Resolves a switched-to model and its declared parameters (UI refresh B). */
-    providers, log, 
+    providers, 
     /** Reads `@` resources with the sender's credentials. */
     content, 
     /** Binds uploaded files to the conversation in the message's transaction. */
@@ -165,7 +163,6 @@ let ConversationsService = class ConversationsService {
         this.access = access;
         this.runs = runs;
         this.providers = providers;
-        this.log = log;
         this.content = content;
         this.attachments = attachments;
         this.invoker = invoker;
@@ -176,15 +173,6 @@ let ConversationsService = class ConversationsService {
         this.events = events;
         this.txHost = txHost;
     }
-    /**
-     * 不阻塞地调用一次 `ensureRun`（打开 SSE、读事件时）：它幂等，并顺带清理孤儿运行，
-     * 会话不会因为某次运行结束后的投递失败而永远停在「运行中」。失败只记日志。
-     */
-    kickRun(conversationId) {
-        this.runs
-            .ensureRun(conversationId)
-            .catch((err) => this.log.warn("ensureRun on conversation open failed", { conversationId, err }));
-    }
     /**
      * Creates an empty conversation bound to its device (`pick`, see
      * {@link ConversationDevices.forNew}); an agent the account cannot use →
@@ -237,7 +225,7 @@ let ConversationsService = class ConversationsService {
             return raced;
         }
         await this.eventLog.notify(id, written.seq);
-        await this.runs.ensureRun(id);
+        await this.startRun(id);
         return { conversation: await this.rowView(id), event: written, events: all, created: true };
     }
     /** The conversation row and its first message (undefined: a concurrent retry committed first). */
@@ -292,9 +280,16 @@ let ConversationsService = class ConversationsService {
             return null;
         // what the first send wrote: the log from its start up to the message
         const events = (await this.eventLog.readAfter(row.id, 0, event.seq)).filter((e) => e.seq <= event.seq);
-        await this.runs.ensureRun(row.id);
+        await this.startRun(row.id);
         return { conversation: toView(row), event, events, created: false };
     }
+    /**
+     * The direct `ensureRun` after a message's commit ({@link RunControl.ensureRunAfterCommit}): a
+     * failure never fails the request, since the message's transaction owes the ensure-run backstop.
+     */
+    startRun(conversationId) {
+        return this.runs.ensureRunAfterCommit(conversationId);
+    }
     async rowView(id) {
         return toView(await this.db
             .selectFrom("conversations")
@@ -352,7 +347,7 @@ let ConversationsService = class ConversationsService {
             if (!(e instanceof ApiError && e.code === "run.not_active"))
                 throw e;
         }
-        await this.markDeleted(conversationId);
+        await this.markDeleted(orgId, conversationId, accountId);
         // after the mark, so no finish or delivery of the stops below can start a run on the deleted
         // root (`ensureRun` refuses it). The sandbox's tasks stop first, so the sub-agents' tasks end
         // as a deletion; the tree stop then only stops a task a sub-agent started in between
@@ -362,13 +357,15 @@ let ConversationsService = class ConversationsService {
         await this.runs.stopTree(conversationId, accountId, { includeSelf: false });
         await this.eventLog.publishChanged(conversationId, "deleted");
     }
-    // the publish happens after the commit, in the caller
-    async markDeleted(conversationId) {
+    // the publish happens after the commit, in the caller; the tree stop after it is owed here
+    // (transactional outbox spec §6), so a process that dies before it still stops the tree
+    async markDeleted(orgId, conversationId, accountId) {
         await this.db
             .updateTable("conversations")
             .set({ deleted_at: sql `now()` })
             .where("id", "=", conversationId)
             .execute();
+        await this.runs.oweStopDeletedTree(conversationId, accountId, orgId);
         // Queued messages must not start a run on a deleted conversation
         await this.db
             .deleteFrom("conversation_queue")
@@ -681,26 +678,28 @@ let ConversationsService = class ConversationsService {
             return conversationId;
         return rootConversationOf(this.db.db, row.parent_conversation_id);
     }
-    /** 读事件（先做 `get` 的可见性判定）；顺带不阻塞地 {@link kickRun}。 */
+    /**
+     * 读事件（先做 `get` 的可见性判定）. A read never changes run state (transactional outbox spec
+     * §6): a run nobody runs is the `run-orphan-check`'s to repair.
+     */
     async listEvents(orgId, conversationId, viewerAccountId, afterSeq, limit) {
         await this.get(orgId, conversationId, viewerAccountId);
-        this.kickRun(conversationId);
         return this.eventLog.readAfter(conversationId, afterSeq, limit);
     }
     /**
      * The turn-aligned page of events before `beforeSeq` (`null`: the log's last page), with how
      * many runs started before it ({@link EventLog.readTurnPageBefore}; history paging spec §2).
-     * Visibility as {@link get}; kicks a stalled run as {@link listEvents} does.
+     * Visibility as {@link get}; a read only, as {@link listEvents}.
      */
     async listEventsBefore(orgId, conversationId, viewerAccountId, beforeSeq, limit) {
         await this.get(orgId, conversationId, viewerAccountId);
-        this.kickRun(conversationId);
         return this.eventLog.readTurnPageBefore(conversationId, beforeSeq, limit, EVENTS_TURN_EXTEND);
     }
     /**
      * 追加一条用户消息；带 `clientMessageId` 时重复提交返回同一事件。写入后调用 `ensureRun`：
      * 没有进行中的运行时投递一轮；运行中则由当前运行在步骤间隙吸收，或在它结束时再次 `ensureRun`。
-     * 投递失败时抛错（消息已写入；客户端带同一 `clientMessageId` 重试会再次触发投递）。
+     * A failed `ensureRun` is logged, not thrown: the message's transaction owes the ensure-run
+     * backstop, which starts the run once the queue is reachable (transactional outbox spec §6).
      *
      * `attachments`（`@` 资源引用）：内核以发送者的凭据读取资源（打码、限长），作为用户文本之后的额外文本块写入同一条
      * user_message，并在 `payload.attachments` 记录元数据（第 i 个附件对应 `content[i + 1]`）。读取失败整条不写。
@@ -719,7 +718,7 @@ let ConversationsService = class ConversationsService {
             input.clientMessageId !== undefined) {
             const existing = await this.eventLog.findByIdem(conversationId, userMessageIdemKey(input.clientMessageId));
             if (existing) {
-                await this.runs.ensureRun(conversationId);
+                await this.startRun(conversationId);
                 return existing;
             }
         }
@@ -750,7 +749,7 @@ let ConversationsService = class ConversationsService {
                 .execute();
             await this.eventLog.publishChanged(conversationId, "archived");
         }
-        await this.runs.ensureRun(conversationId);
+        await this.startRun(conversationId);
         return event;
     }
     /**
@@ -812,10 +811,19 @@ let ConversationsService = class ConversationsService {
      * conversations (network ask-to-allow spec §6.7). The queue's "send now" uses it as the direct
      * send does; announce after the commit with {@link announceSkipped}. `toSeq` is the highest seq
      * written in this conversation (null: none).
+     *
+     * Lock order: this (root) conversation (the caller's), its pending questions, the sub-agents'
+     * conversations with a pending network ask (id order), the asks themselves (the root's and the
+     * sub-agents'), and only then the run rows, as each skipped wait's run resumes in this
+     * transaction. Every run row comes after every conversation and decided row (ruling R19); a
+     * sub-agent's conversation comes after the root's questions, which only this path locks with a
+     * sub-agent conversation after them.
      */
     async skipWaitsIn(conversationId, accountId, messageSeq) {
         const q = await this.questions.skipPendingIn(conversationId, accountId, messageSeq);
         const n = await this.approvals.skipNetworkIn(conversationId, accountId);
+        for (const w of [...q.records, ...n.records])
+            await this.runs.resumeIn(w.runId, w.id);
         const here = n.seqs.get(conversationId);
         const toSeq = q.toSeq === null && here === undefined ? null : Math.max(q.toSeq ?? 0, here ?? 0);
         return { skipped: { questions: q.records, network: n.records, seqs: n.seqs }, toSeq };
@@ -823,7 +831,8 @@ let ConversationsService = class ConversationsService {
     /**
      * After the commit: announces each skipped question (`question.answered`, outcome `skipped`) and
      * network ask (`approval.decided`, status `skipped`; a sub-agent's conversation is notified
-     * first), so its run resumes (waits) and its IM card updates (channel jobs).
+     * first) as domain events with no kernel subscriber: the IM card updates are owed by the skips'
+     * appends (transactional outbox spec §8.1); the run resumed in the message's transaction.
      */
     async announceSkipped(skipped) {
         for (const q of skipped.questions) {
@@ -877,6 +886,10 @@ let ConversationsService = class ConversationsService {
         events.push(this.userMessage(accountId, input, extra, blocks, invoked, context, internal.schedule));
         const { events: written, fresh } = await this.eventLog.appendInReport(conversationId, events);
         const message = written.at(-1);
+        // the run this message starts is owed with it: the direct ensureRun after the commit may never
+        // happen (the process died) or fail (transactional outbox spec §6)
+        if (fresh.at(-1) === true)
+            await this.runs.oweEnsureRun(conversationId, message.seq, orgId);
         const skips = fresh.at(-1) === true
             ? await this.skipWaitsIn(conversationId, accountId, message.seq)
             : { skipped: NO_REPLY_SKIPS, toSeq: null };
@@ -995,13 +1008,15 @@ let ConversationsService = class ConversationsService {
             throw new ApiError("run.not_active", "No active run to abort");
         const runs = this.runs;
         // 等待中：直接结束；没成功（刚被续跑、已回到 queued）则按下面的常规路径中止。
+        // the stop's terminal transaction owed the ensure-run backstop; the direct call starts what
+        // waited for the stopped run now
         if (run.status === "waiting" && (await runs.abortWaiting(conversationId, run.id, accountId))) {
-            this.kickRun(conversationId);
+            await runs.ensureRunAfterCommit(conversationId);
             return run.id;
         }
         // 孤儿运行没有 worker 在听中止广播：直接写成 aborted，之后再看有没有等待中的消息要起新一轮。
         if (await runs.abortIfOrphaned(conversationId, run.id, accountId)) {
-            this.kickRun(conversationId);
+            await runs.ensureRunAfterCommit(conversationId);
             return run.id;
         }
         await runs.requestAbort(run.id, accountId);
@@ -1034,15 +1049,14 @@ ConversationsService = __decorate([
     __param(3, Inject(ConversationAccess)),
     __param(4, Inject(RunControlService)),
     __param(5, Inject(ProviderRegistry)),
-    __param(6, Inject(KERNEL_LOGGER)),
-    __param(7, Inject(ConnectorContent)),
-    __param(8, Inject(AttachmentsService)),
-    __param(9, Inject(SkillInvoker)),
-    __param(10, Inject(BackgroundTaskStopper)),
-    __param(11, Inject(ConversationDevices)),
-    __param(12, Inject(QuestionsService)),
-    __param(13, Inject(ApprovalsService)),
-    __param(14, Inject(KernelEvents)),
-    __param(15, Inject(TransactionHost))
+    __param(6, Inject(ConnectorContent)),
+    __param(7, Inject(AttachmentsService)),
+    __param(8, Inject(SkillInvoker)),
+    __param(9, Inject(BackgroundTaskStopper)),
+    __param(10, Inject(ConversationDevices)),
+    __param(11, Inject(QuestionsService)),
+    __param(12, Inject(ApprovalsService)),
+    __param(13, Inject(KernelEvents)),
+    __param(14, Inject(TransactionHost))
 ], ConversationsService);
 export { ConversationsService };

package/dist/conversations/event-log.d.ts

@@ -1,6 +1,6 @@
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
-import { KernelEvents } from "../infra/events/kernel-events.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
 import type { KernelLogger } from "../log.js";
 import { type ConversationEvent, type ConversationEventType } from "./events.js";
 /** 事件日志依赖的总线：内核 bus（命名空间 `kernel`）。 */
@@ -74,17 +74,17 @@ export type ConversationChange = (typeof CONVERSATION_CHANGES)[number];
  * seq 由 `conversations.last_seq` 在会话行锁内连续分配（多副本并发写同一会话时串行化）；
  * 幂等键的「先查后写」也在同一把行锁内完成。
  *
- * Every published advance (`notify`) is also announced in-process as `conversation.event-appended`
- * on {@link KernelEvents} (the channel outbound delivery enqueues from it), on this replica, right
- * after the bus publish, in append order.
+ * An append to a conversation with a channel target (`channel_deliveries`, read with the row lock)
+ * owes the conversation's IM delivery in the append's transaction (transactional outbox spec
+ * §8.1); a conversation without one writes nothing more.
  */
 export declare class EventLog {
     private readonly db;
     private readonly bus;
     private readonly log;
-    private readonly events;
+    private readonly outbox;
     readonly txHost: TransactionHost;
-    constructor(db: KernelDb, bus: EventBus, log: Pick<KernelLogger, "warn">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost);
+    constructor(db: KernelDb, bus: EventBus, log: Pick<KernelLogger, "warn">, outbox: Pick<OutboxService, "add">, txHost: TransactionHost);
     /**
      * 追加事件，返回与输入一一对应的事件（幂等命中的为已有事件）。
      * 自开一个独立事务（`requires_new`，与调用方的事务无关），提交后发布 `conv.<id>`。
@@ -107,10 +107,7 @@ export declare class EventLog {
         fresh: boolean[];
     }>;
     private appendOwn;
-    /**
-     * 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。Then announces
-     * it in-process (`conversation.event-appended`); a failing subscriber is logged by KernelEvents.
-     */
+    /** 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。 */
     notify(conversationId: string, toSeq: number): Promise<void>;
     /**
      * Publishes a `changed` frame on the conversation topic (rename, generated title, selection, ...).