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

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

@@ -12,7 +12,6 @@ import type { AgentLoop } from "./loop.js";
 import { ProviderRegistry } from "./providers.js";
 import { StepLog } from "./step-log.js";
 import { SubagentsService } from "./subagents/subagents.service.js";
-import { UsageReporter } from "./usage-report.js";
 /**
  * Builds the agent loop a run executes (default {@link LangGraphLoop}: its checkpoints live in the
  * kernel's {@link KyselyCheckpointSaver}, so another replica resumes a crashed worker's run).
@@ -35,5 +34,5 @@ export declare class AgentLoops {
  */
 export declare class RunSteps {
     readonly deps: LoopDeps;
-    constructor(kdb: KernelDb, eventLog: EventLog, stepLog: StepLog, registry: ProviderRegistry, usageReport: UsageReporter, tools: ToolRegistry, config: KernelConfigService, log: KernelLogger, toolPipeline: ToolPipeline, host: ExtensionHost, subagents: SubagentsService, attachments: AttachmentsService);
+    constructor(kdb: KernelDb, eventLog: EventLog, stepLog: StepLog, registry: ProviderRegistry, tools: ToolRegistry, config: KernelConfigService, log: KernelLogger, toolPipeline: ToolPipeline, host: ExtensionHost, subagents: SubagentsService, attachments: AttachmentsService);
 }

package/dist/runtime/run-steps.js

@@ -21,7 +21,6 @@ import { LangGraphLoop } from "./langgraph-loop.js";
 import { ProviderRegistry } from "./providers.js";
 import { StepLog } from "./step-log.js";
 import { SubagentsService } from "./subagents/subagents.service.js";
-import { UsageReporter } from "./usage-report.js";
 /** Optional provider: the {@link AgentLoopFactory} runs use instead of the default (tests). */
 export const AGENT_LOOP_FACTORY = Symbol("AGENT_LOOP_FACTORY");
 /** The agent loops of chat runs and of eval full-run replays (one factory, one checkpoint store). */
@@ -52,7 +51,7 @@ export { AgentLoops };
  */
 let RunSteps = class RunSteps {
     deps;
-    constructor(kdb, eventLog, stepLog, registry, usageReport, tools, config, log, toolPipeline, host, subagents, attachments) {
+    constructor(kdb, eventLog, stepLog, registry, tools, config, log, toolPipeline, host, subagents, attachments) {
         this.deps = {
             get db() {
                 return kdb.db;
@@ -60,7 +59,6 @@ let RunSteps = class RunSteps {
             eventLog,
             stepLog,
             registry,
-            usageReport,
             tools,
             config,
             log,
@@ -84,13 +82,12 @@ RunSteps = __decorate([
     __param(1, Inject(EventLog)),
     __param(2, Inject(StepLog)),
     __param(3, Inject(ProviderRegistry)),
-    __param(4, Inject(UsageReporter)),
-    __param(5, Inject(ToolRegistry)),
-    __param(6, Inject(KernelConfigService)),
-    __param(7, Inject(KERNEL_LOGGER)),
-    __param(8, Inject(ToolPipeline)),
-    __param(9, Inject(ExtensionHost)),
-    __param(10, Inject(SubagentsService)),
-    __param(11, Inject(AttachmentsService))
+    __param(4, Inject(ToolRegistry)),
+    __param(5, Inject(KernelConfigService)),
+    __param(6, Inject(KERNEL_LOGGER)),
+    __param(7, Inject(ToolPipeline)),
+    __param(8, Inject(ExtensionHost)),
+    __param(9, Inject(SubagentsService)),
+    __param(10, Inject(AttachmentsService))
 ], RunSteps);
 export { RunSteps };

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

@@ -8,16 +8,17 @@ 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 { SkillsCatalogService } from "../skills/catalog.js";
-import { ToolPipeline } from "../tools/pipeline.js";
+import { ToolRegistry } from "../tools/registry.js";
 import { RunAbort } from "./abort.js";
 import { KyselyCheckpointSaver } from "./checkpointer.js";
 import { ConversationLock } from "./conversation-lock.js";
+import { PluginContextService } from "./plugin-context.service.js";
 import { ProviderRegistry } from "./providers.js";
 import { type OrgQuota } from "./quota.js";
 import { RunContextService } from "./run-context.service.js";
 import { RunDrafts } from "./run-drafts.js";
 import { RunFinish } from "./run-finish.js";
-import type { RunJobData } from "./run-jobs.js";
+import { type RunJobData } from "./run-jobs.js";
 import { RunQueue } from "./run-queue.js";
 import { AgentLoops, RunSteps } from "./run-steps.js";
 import { Waits } from "./waits.js";
@@ -33,6 +34,12 @@ export interface RunHooks {
     lockTtlMs?: number;
     /** 任务结束后的每次 ensureRun 尝试之前调用（attempt 从 0 起）；抛错即模拟该次尝试失败。 */
     beforeEnsureRun?(conversationId: string, attempt: number): Promise<void>;
+    /** Called after a run job read the run's status, before it takes the conversation lock. */
+    afterRunRead?(runId: string, conversationId: string): Promise<void>;
+    /** Called with the conversation lock held, before a queued run's `run_started` is written. */
+    beforeRunStarted?(runId: string, conversationId: string): Promise<void>;
+    /** Called with the conversation lock held, before a queued run's status becomes `running`. */
+    beforeRunning?(runId: string, conversationId: string): Promise<void>;
 }
 /** 处理函数的返回值：`ensure` 表示任务完成后再调用一次 ensureRun。 */
 export type ProcessResult = "ensure" | undefined;
@@ -66,12 +73,10 @@ export declare class RunWorker {
     private readonly skillsCatalog;
     /** Run start's run context (run context spec §5): who the agent is, the day, the person. */
     private readonly runContext;
-    /**
-     * In the terminal transaction of every run: writes its open `Agent` call results
-     * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
-     * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
-     */
-    private readonly pipeline;
+    /** Run start's plugin context (memory plugin spec §6.1): the `context@1` providers' text. */
+    private readonly pluginContext;
+    /** The run's resolved tools, for the plugin context's `tools` (chat runs with providers). */
+    private readonly tools;
     private readonly finisher;
     readonly txHost: TransactionHost;
     /** The steps' live drafts this process writes for the runs it executes. */
@@ -101,12 +106,10 @@ export declare class RunWorker {
     skillsCatalog: Pick<SkillsCatalogService, "record">, 
     /** Run start's run context (run context spec §5): who the agent is, the day, the person. */
     runContext: Pick<RunContextService, "record">, 
-    /**
-     * In the terminal transaction of every run: writes its open `Agent` call results
-     * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
-     * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
-     */
-    pipeline: Pick<ToolPipeline, "stopOpenAgentCalls">, finisher: Pick<RunFinish, "finish">, txHost: TransactionHost, 
+    /** Run start's plugin context (memory plugin spec §6.1): the `context@1` providers' text. */
+    pluginContext: Pick<PluginContextService, "record">, 
+    /** The run's resolved tools, for the plugin context's `tools` (chat runs with providers). */
+    tools: Pick<ToolRegistry, "forAgent">, finisher: Pick<RunFinish, "finish">, txHost: TransactionHost, 
     /** The steps' live drafts this process writes for the runs it executes. */
     drafts: RunDrafts, hooks?: RunHooks | undefined);
     private get db();
@@ -136,13 +139,15 @@ export declare class RunWorker {
     /**
      * After any terminal commit of a run that is not a sub-agent's (sub-agents spec §12): stops its
      * active fork invocation child on its behalf (no account); background `Agent` children keep
-     * running (agent map spec §5.4). The wait sweep is the backstop.
+     * running (agent map spec §5.4). The terminal transaction owed the same stop (`stop-tree`), the
+     * backstop when this call never happens.
      */
     private stopChildren;
     /**
      * After a sub-agent run's terminal state committed (sub-agents spec §7.3): reports it to the
      * parent. Called with any run id whose conversation may be a child; runs that were not
-     * dispatched are ignored. Errors are logged (the wait sweep repairs a missed call).
+     * dispatched are ignored. Errors are logged: the terminal transaction owed the same delivery
+     * (`deliver-to-parent`) and stop (`stop-tree`), which repair a missed call.
      */
     private childFinished;
     /**
@@ -170,6 +175,11 @@ export declare class RunWorker {
     process(job: Job<RunJobData>, token: string | undefined): Promise<ProcessResult>;
     private execute;
     private completed;
+    /**
+     * The run's extension tool keys by plugin, resolved as a chat run's first step lists them
+     * (disabled tools, org switches, the conversation's source): a provider's `tools`.
+     */
+    private pluginToolKeys;
     /**
      * When the conversation was switched to a model that no longer resolves (provider disabled,
      * model removed), writes `model_switched { model: null, effort: null, reason: "unavailable" }`

package/dist/runtime/run-worker.js

@@ -25,16 +25,19 @@ import { KernelEvents } from "../infra/events/kernel-events.js";
 import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { SkillsCatalogService } from "../skills/catalog.js";
 import { normalizeStoredDefinitionIn } from "../tools/legacy-data.js";
-import { ToolPipeline } from "../tools/pipeline.js";
+import { ToolRegistry } from "../tools/registry.js";
 import { RunAbort } from "./abort.js";
 import { KyselyCheckpointSaver } from "./checkpointer.js";
 import { ConversationLock } from "./conversation-lock.js";
+import { runDeadline, tightestLimit } from "./limits.js";
 import { RunError } from "./model-call.js";
+import { PluginContextService } from "./plugin-context.service.js";
 import { ProviderListError, ProviderRegistry } from "./providers.js";
 import { ORG_QUOTA_LEASE_MS, orgRunLimit, RUN_QUOTA } from "./quota.js";
 import { RunContextService } from "./run-context.service.js";
 import { RunDrafts, streamSink } from "./run-drafts.js";
-import { RunFinish, TERMINAL_STATUSES } from "./run-finish.js";
+import { RunFinish } from "./run-finish.js";
+import { TERMINAL_STATUSES } from "./run-jobs.js";
 import { RunQueue } from "./run-queue.js";
 import { AgentLoops, RunSteps } from "./run-steps.js";
 import { dispatchOfChildRun, rootConversationOf } from "./subagents/child.js";
@@ -63,6 +66,15 @@ async function requeue(job, token, delayMs) {
     await job.moveToDelayed(Date.now() + delayMs, token);
     throw new DelayedError();
 }
+/** An account's display name ("" when it is gone). */
+async function accountName(db, accountId) {
+    const row = await db
+        .selectFrom("accounts")
+        .select("display_name")
+        .where("id", "=", accountId)
+        .executeTakeFirst();
+    return row?.display_name ?? "";
+}
 /**
  * 运行 worker（只在含 `worker` 角色的进程消费）：领取 `cap-kernel-runs` 与 `cap-kernel-subagent-runs` 的任务
  * （两个 `@Processor`，见 run-processors.ts），取会话锁与组织配额，调用 AgentLoop，按结果写终态事件并推进
@@ -86,7 +98,8 @@ let RunWorker = class RunWorker {
     models;
     skillsCatalog;
     runContext;
-    pipeline;
+    pluginContext;
+    tools;
     finisher;
     txHost;
     drafts;
@@ -115,12 +128,10 @@ let RunWorker = class RunWorker {
     skillsCatalog, 
     /** Run start's run context (run context spec §5): who the agent is, the day, the person. */
     runContext, 
-    /**
-     * In the terminal transaction of every run: writes its open `Agent` call results
-     * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
-     * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
-     */
-    pipeline, finisher, txHost, 
+    /** Run start's plugin context (memory plugin spec §6.1): the `context@1` providers' text. */
+    pluginContext, 
+    /** The run's resolved tools, for the plugin context's `tools` (chat runs with providers). */
+    tools, finisher, txHost, 
     /** The steps' live drafts this process writes for the runs it executes. */
     drafts, hooks) {
         this.kdb = kdb;
@@ -140,7 +151,8 @@ let RunWorker = class RunWorker {
         this.models = models;
         this.skillsCatalog = skillsCatalog;
         this.runContext = runContext;
-        this.pipeline = pipeline;
+        this.pluginContext = pluginContext;
+        this.tools = tools;
         this.finisher = finisher;
         this.txHost = txHost;
         this.drafts = drafts;
@@ -197,7 +209,8 @@ let RunWorker = class RunWorker {
     /**
      * After any terminal commit of a run that is not a sub-agent's (sub-agents spec §12): stops its
      * active fork invocation child on its behalf (no account); background `Agent` children keep
-     * running (agent map spec §5.4). The wait sweep is the backstop.
+     * running (agent map spec §5.4). The terminal transaction owed the same stop (`stop-tree`), the
+     * backstop when this call never happens.
      */
     async stopChildren(runId) {
         try {
@@ -210,7 +223,8 @@ let RunWorker = class RunWorker {
     /**
      * After a sub-agent run's terminal state committed (sub-agents spec §7.3): reports it to the
      * parent. Called with any run id whose conversation may be a child; runs that were not
-     * dispatched are ignored. Errors are logged (the wait sweep repairs a missed call).
+     * dispatched are ignored. Errors are logged: the terminal transaction owed the same delivery
+     * (`deliver-to-parent`) and stop (`stop-tree`), which repair a missed call.
      */
     async childFinished(runId) {
         try {
@@ -384,9 +398,10 @@ let RunWorker = class RunWorker {
         // 运行在等人处理（例如暂停后本任务被 stalled 机制重新投递）：不执行，续跑由处理 / 超时发起的新任务负责。
         if (run.status === "waiting")
             return;
+        await this.hooks?.afterRunRead?.(runId, conversationId);
         const conv = await this.db
             .selectFrom("conversations")
-            .select(["org_id", "agent_id", "kind", "subagent_depth"])
+            .select(["org_id", "agent_id", "kind", "subagent_depth", "source", "account_id"])
             .where("id", "=", conversationId)
             .executeTakeFirst();
         if (!conv)
@@ -453,8 +468,6 @@ let RunWorker = class RunWorker {
                 delayMs = QUOTA_FULL_DELAY_MS;
             }
             else {
-                // 运行开始执行（含续跑、stalled 后接手）：通知旁路（渠道出站投递据此把输出投到 IM），失败不影响运行
-                void this.events.emit("run.started", { conversationId, runId });
                 const r = await this.execute(run, { id: conversationId, ...conv }, state).catch(async (err) => {
                     if (state.abandoned)
                         return "abandoned";
@@ -514,7 +527,8 @@ let RunWorker = class RunWorker {
         // a chat run's saved agent version, under the conversation's model switch (UI refresh B); a
         // sub-agent has none: it never takes a selection
         let saved;
-        let maxSteps = runtime.maxSteps;
+        /** The run's step limit; `undefined` = no limit (`runtime.maxSteps` 0). */
+        let maxSteps = tightestLimit(runtime.maxSteps);
         let parent;
         /** A sub-agent's name in its run context: the roster name, or the forked skill's. */
         let childName;
@@ -531,7 +545,8 @@ let RunWorker = class RunWorker {
             agent = childRunDefinition(await normalizeStoredDefinitionIn(this.db, conv.org_id, started.payload.definition), trigger?.type === "user_message" && trigger.seq === Number(run.trigger_seq)
                 ? trigger.payload.dispatch?.narrowed
                 : undefined);
-            maxSteps = Math.min(started.payload.maxSteps, runtime.maxSteps);
+            // the tighter of the logged limit and the deployment's (0 in either = no limit there)
+            maxSteps = tightestLimit(started.payload.maxSteps, runtime.maxSteps);
             childName = started.payload.template.invokedSkill?.name ?? started.payload.agentType;
             const row = await dispatchOfChildRun(this.db, runId);
             const otherAgent = started.payload.template.source === "agent";
@@ -577,6 +592,14 @@ let RunWorker = class RunWorker {
             saved = await normalizeStoredDefinitionIn(this.db, conv.org_id, version.definition);
             agent = saved;
         }
+        // the trigger account's role, read once per run for the plugin context and plugin tool
+        // handlers (memory plugin spec §6.2); an account no longer in the org counts as a guest
+        const role = (await this.db
+            .selectFrom("memberships")
+            .select("role")
+            .where("org_id", "=", conv.org_id)
+            .where("account_id", "=", run.trigger_account_id)
+            .executeTakeFirst())?.role ?? "guest";
         let startedAt = run.started_at;
         // The model / effort switch in effect (UI refresh B): the latest `model_switched` before this
         // run's `run_started`, read under the conversation lock when the run starts, so a replay
@@ -588,9 +611,14 @@ let RunWorker = class RunWorker {
         }
         if (run.status === "queued" || startedAt === null) {
             if (!existingStart) {
+                await this.hooks?.beforeRunStarted?.(runId, conversationId);
                 if (saved !== undefined)
                     await this.fallBackIfUnavailable(conv.org_id, conversationId, runId, saved);
                 const started = await this.appendRunStarted(conversationId, run, agent, saved);
+                // the status was read before the conversation lock: a stop that ended the run meanwhile
+                // (a queued run's direct abort, an orphan abort) wins, and the run never starts
+                if (started.terminal)
+                    return "finished";
                 agent = started.agent;
                 const toSeq = started.toSeq;
                 if (toSeq !== undefined)
@@ -620,26 +648,58 @@ let RunWorker = class RunWorker {
                     },
                 }),
             });
+            // plugin context (memory plugin spec §6.1): after the run context, still before the run is
+            // running; the providers are asked outside any transaction, a chat run only
+            await this.pluginContext.record({
+                orgId: conv.org_id,
+                conversationId,
+                runId,
+                agentId: conv.agent_id,
+                agentName: agent.name,
+                ownerAccountId: conv.account_id,
+                // only a chat run asks the providers
+                ownerName: conv.kind === "chat" ? await accountName(this.db, conv.account_id) : "",
+                triggerAccountId: run.trigger_account_id,
+                source: conv.source,
+                role,
+                kind: conv.kind,
+                toolKeysByPlugin: () => this.pluginToolKeys(conv, agent),
+                // the run's own abort watch starts with its execution below: until then, the shutdown
+                signal: state.shutdown.signal,
+            });
+            await this.hooks?.beforeRunning?.(runId, conversationId);
+            // never over a terminal status: a run finished meanwhile stays finished
             const updated = await this.db
                 .updateTable("runs")
                 .set({ status: "running", started_at: sql `COALESCE(started_at, now())` })
                 .where("id", "=", runId)
+                .where("status", "in", ["queued", "running"])
                 .returning("started_at")
-                .executeTakeFirstOrThrow();
+                .executeTakeFirst();
+            if (updated === undefined)
+                return "finished";
             startedAt = updated.started_at;
         }
+        // the run executes (a first start, a resume, a stalled takeover): a hint to the side paths (the
+        // channel outbound delivers its output to IM), after the start went through, never for a run a
+        // stop ended first; a failure does not affect the run
+        void this.events.emit("run.started", { conversationId, runId });
         // 截止时间以首次开始为准：停机后在其他 worker 续跑也不重新计时；等人处理的时长（waited_ms）不计入。
-        const deadline = startedAt.getTime() + Number(run.waited_ms) + runtime.maxRunSeconds * 1000;
+        // `runtime.maxRunSeconds` 0: no deadline, no timer (the run ends when the model stops or is stopped)
+        const deadline = runDeadline(startedAt.getTime() + Number(run.waited_ms), runtime.maxRunSeconds);
         const ac = new AbortController();
         let abortedBy;
         let abortDetail;
         let deadlineHit = false;
-        const deadlineTimer = setTimeout(() => {
-            deadlineHit = true;
-            ac.abort();
-        }, Math.max(0, deadline - Date.now()));
+        const deadlineTimer = deadline === undefined
+            ? undefined
+            : setTimeout(() => {
+                deadlineHit = true;
+                ac.abort();
+            }, Math.max(0, deadline - Date.now()));
         state.stopTimers = () => {
-            clearTimeout(deadlineTimer);
+            if (deadlineTimer !== undefined)
+                clearTimeout(deadlineTimer);
         };
         let unwatch;
         try {
@@ -687,13 +747,19 @@ let RunWorker = class RunWorker {
                     runId,
                     agentId: conv.agent_id,
                     triggerAccountId: run.trigger_account_id,
+                    source: conv.source,
+                    ownerAccountId: conv.account_id,
+                    role,
                     agent,
                     agentVersion: run.agent_version,
                     signal: ac.signal,
                     shutdown: state.shutdown.signal,
                     sink: this.sinkFor(conversationId),
                     pendingAbsorbable,
-                    limits: { maxSteps, deadline },
+                    limits: {
+                        ...(maxSteps !== undefined && { maxSteps }),
+                        ...(deadline !== undefined && { deadline }),
+                    },
                     // a sub-agent's conversation fires hooks like a chat, with `parent` set (spec §11)
                     conversationKind: conv.kind === "eval" ? "eval" : conv.kind === "subagent" ? "subagent" : "chat",
                     ...(parent !== undefined && { parent }),
@@ -784,6 +850,28 @@ let RunWorker = class RunWorker {
         // a completed run enqueues the conversation's title job (never throws)
         void this.titles.maybeEnqueue(conversationId);
     }
+    /**
+     * The run's extension tool keys by plugin, resolved as a chat run's first step lists them
+     * (disabled tools, org switches, the conversation's source): a provider's `tools`.
+     */
+    async pluginToolKeys(conv, agent) {
+        const { tools } = await this.tools.forAgent(conv.org_id, {
+            disabledTools: agent.disabledTools,
+            subagentTools: agent.subagentTools,
+            subagents: agent.subagents,
+            sandboxConversationId: conv.id,
+            source: conv.source,
+        });
+        const out = new Map();
+        for (const t of tools) {
+            if (t.source.kind !== "plugin")
+                continue;
+            const keys = out.get(t.source.plugin) ?? [];
+            keys.push(t.key);
+            out.set(t.source.plugin, keys);
+        }
+        return out;
+    }
     /**
      * When the conversation was switched to a model that no longer resolves (provider disabled,
      * model removed), writes `model_switched { model: null, effort: null, reason: "unavailable" }`
@@ -830,6 +918,17 @@ let RunWorker = class RunWorker {
             .where("id", "=", conversationId)
             .forUpdate()
             .execute();
+        // the run's status again under the locks (conversation, then run, as `RunFinish.finishIn`):
+        // the job read it before taking the conversation lock, and a stop may have ended it since
+        const row = await t
+            .selectFrom("runs")
+            .select("status")
+            .where("id", "=", run.id)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!row || TERMINAL_STATUSES.has(row.status)) {
+            return { toSeq: undefined, agent: current, terminal: true };
+        }
         const agent = saved !== undefined
             ? effectiveDefinition(saved, await readSelection(t, conversationId))
             : current;
@@ -906,7 +1005,7 @@ let RunWorker = class RunWorker {
      * 提交后发布会话通知，然后调用测试钩子。返回终态事件 seq；运行已是终态 → null。
      */
     async finish(conversationId, runId, status, consumed, event, hook = true, floorToTrigger = true) {
-        let fire = () => { };
+        // the terminal transaction also writes the run's open fork report and cancels its waits
         const toSeq = await this.finisher.finish({
             conversationId,
             runId,
@@ -914,12 +1013,7 @@ let RunWorker = class RunWorker {
             consumed,
             event,
             floorToTrigger,
-            beforeTerminal: async () => {
-                fire = (await this.pipeline.stopOpenAgentCalls(runId)).fire;
-            },
         });
-        if (toSeq !== null)
-            fire();
         if (hook)
             await this.hooks?.beforeRelease?.(runId, conversationId);
         return toSeq;
@@ -952,11 +1046,12 @@ RunWorker = __decorate([
     __param(16, Inject(ProviderRegistry)),
     __param(17, Inject(SkillsCatalogService)),
     __param(18, Inject(RunContextService)),
-    __param(19, Inject(ToolPipeline)),
-    __param(20, Inject(RunFinish)),
-    __param(21, Inject(TransactionHost)),
-    __param(22, Inject(RunDrafts)),
-    __param(23, Optional()),
-    __param(23, Inject(RUN_HOOKS))
+    __param(19, Inject(PluginContextService)),
+    __param(20, Inject(ToolRegistry)),
+    __param(21, Inject(RunFinish)),
+    __param(22, Inject(TransactionHost)),
+    __param(23, Inject(RunDrafts)),
+    __param(24, Optional()),
+    __param(24, Inject(RUN_HOOKS))
 ], RunWorker);
 export { RunWorker };

package/dist/runtime/runtime.module.d.ts

@@ -1,8 +1,7 @@
 /**
  * The run runtime: the conversation run lock, this process's event streams, the run queue and its
- * worker (consumed through `RuntimeWorkersModule`'s processors), the waits (their sweep is the
- * worker role's `WaitSweepJob`), run
- * stops, the checkpoints, the org quotas, the step writes and the agent loops. The model provider
+ * worker (consumed through `RuntimeWorkersModule`'s processors), the waits (a run nobody runs is
+ * the worker role's `RunOrphanCheck`'s to repair), run stops, the checkpoints, the org quotas, the step writes and the agent loops. The model provider
  * registry, the sub-agent dispatch, `usage.report` and the titles have modules of their own (the
  * tools, models and conversations domains import them without the runtime).
  */

package/dist/runtime/runtime.module.js

@@ -23,6 +23,7 @@ import { RunAbort } from "./abort.js";
 import { KyselyCheckpointSaver } from "./checkpointer.js";
 import { ConversationLock } from "./conversation-lock.js";
 import { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
+import { PluginContextService } from "./plugin-context.service.js";
 import { ProvidersModule } from "./providers.js";
 import { EVAL_QUOTA, EVAL_QUOTA_PREFIX, OrgQuota, RUN_QUOTA, RUN_QUOTA_PREFIX } from "./quota.js";
 import { RunContextService } from "./run-context.service.js";
@@ -37,12 +38,11 @@ import { StepLogModule } from "./step-log.js";
 import { ConversationStreams } from "./stream.js";
 import { SubagentsModule } from "./subagents/subagents.service.js";
 import { UsageReportModule } from "./usage-report.js";
-import { DecisionResumer, Waits } from "./waits.js";
+import { Waits } from "./waits.js";
 /**
  * The run runtime: the conversation run lock, this process's event streams, the run queue and its
- * worker (consumed through `RuntimeWorkersModule`'s processors), the waits (their sweep is the
- * worker role's `WaitSweepJob`), run
- * stops, the checkpoints, the org quotas, the step writes and the agent loops. The model provider
+ * worker (consumed through `RuntimeWorkersModule`'s processors), the waits (a run nobody runs is
+ * the worker role's `RunOrphanCheck`'s to repair), run stops, the checkpoints, the org quotas, the step writes and the agent loops. The model provider
  * registry, the sub-agent dispatch, `usage.report` and the titles have modules of their own (the
  * tools, models and conversations domains import them without the runtime).
  */
@@ -67,7 +67,8 @@ RuntimeModule = __decorate([
             BackgroundModule,
             // a scheduled task's run follows its kernel run's end (`RunFinish`)
             ScheduledTaskTrackerModule,
-            // the producer side of `wait-timeout` jobs (`MaintenanceProcessor` consumes them)
+            // the maintenance queue's handle: the outbox delivers the `wait-timeout` jobs the waits owe
+            // (`MaintenanceProcessor` consumes them)
             QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),
         ],
         providers: [
@@ -78,12 +79,12 @@ RuntimeModule = __decorate([
             RunFinish,
             RunQueue,
             Waits,
-            DecisionResumer,
             RunControl,
             RunDrafts,
             AgentLoops,
             RunSteps,
             RunContextService,
+            PluginContextService,
             RunWorker,
             // a finished background task wakes an idle conversation (background Bash spec §3)
             BackgroundWake,

package/dist/runtime/step-log.d.ts

@@ -4,26 +4,38 @@ import type { ConversationEvent } from "../conversations/events.js";
 import { audit } from "../identity/audit.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
+import { UsageReportJobs } from "./usage-report-jobs.js";
 /** An audit row written with the events (`identity/audit.ts`). */
 export type StepAuditEntry = Parameters<typeof audit>[1];
 /**
  * The writes of a run step that go to the event log together with another row, each in a
  * transaction of its own (the caller notifies the log after the commit): a model call with the
- * tool definitions it sent, a denial with its audit row, and a sub-agent's usage counted on its
- * parent run. The step functions (`model-call.ts`, `hook-calls.ts`) reach it through their deps.
+ * tool definitions it sent, a denial with its audit row, usage events with their owed
+ * `usage.report` deliveries (transactional outbox spec §8.1), and a sub-agent's usage counted on
+ * its parent run. The step functions (`model-call.ts`, `hook-calls.ts`) reach it through their deps.
  */
 export declare class StepLog {
     private readonly kdb;
     private readonly eventLog;
+    private readonly usage;
     readonly txHost: TransactionHost;
-    constructor(kdb: KernelDb, eventLog: EventLog, txHost: TransactionHost);
+    constructor(kdb: KernelDb, eventLog: EventLog, usage: Pick<UsageReportJobs, "oweEvents">, txHost: TransactionHost);
+    /**
+     * Appends events and owes the `usage.report` delivery of the `usage` events it newly wrote, in
+     * one transaction. Returns what was written (hits included) and the highest new seq (null:
+     * nothing new).
+     */
+    appendReported(conversationId: string, events: AppendEvent[]): Promise<{
+        written: ConversationEvent[];
+        toSeq: number | null;
+    }>;
     /**
      * Appends events of a sub-agent's run and adds the tokens of the usage events it newly wrote to
      * the `subagent_tokens_used` of the tree's budget run (sub-agents spec §8.3, agent map spec §6:
      * the whole tree counts on one run): `counter.budgetRunId`, the run's own window
      * (`SubagentParent.budgetRunId`), else the parent run's ({@link budgetRunOf}). A usage event
      * already in the log (an idempotent hit after a crash) adds nothing, so each call counts exactly
-     * once. Returns what was written (hits included) and the highest new seq (null: nothing new).
+     * once; the new usage events' `usage.report` deliveries are owed in the same transaction. Returns what was written (hits included) and the highest new seq (null: nothing new).
      */
     appendCounted(conversationId: string, counter: {
         parentRunId: string;