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

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,7 +8,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 { SkillsCatalogService } from "../skills/catalog.js";
-import { ToolPipeline } from "../tools/pipeline.js";
 import { RunAbort } from "./abort.js";
 import { KyselyCheckpointSaver } from "./checkpointer.js";
 import { ConversationLock } from "./conversation-lock.js";
@@ -17,7 +16,7 @@ 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";
@@ -66,12 +65,6 @@ 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;
     private readonly finisher;
     readonly txHost: TransactionHost;
     /** The steps' live drafts this process writes for the runs it executes. */
@@ -100,13 +93,7 @@ export declare class RunWorker {
     /** Run start's skills catalog snapshot (reads the pinned skills' bodies, phase B). */
     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, 
+    runContext: Pick<RunContextService, "record">, 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 +123,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;
     /**

package/dist/runtime/run-worker.js

@@ -25,16 +25,17 @@ 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 { 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 { 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";
@@ -86,7 +87,6 @@ let RunWorker = class RunWorker {
     models;
     skillsCatalog;
     runContext;
-    pipeline;
     finisher;
     txHost;
     drafts;
@@ -114,13 +114,7 @@ let RunWorker = class RunWorker {
     /** Run start's skills catalog snapshot (reads the pinned skills' bodies, phase B). */
     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, 
+    runContext, finisher, txHost, 
     /** The steps' live drafts this process writes for the runs it executes. */
     drafts, hooks) {
         this.kdb = kdb;
@@ -140,7 +134,6 @@ let RunWorker = class RunWorker {
         this.models = models;
         this.skillsCatalog = skillsCatalog;
         this.runContext = runContext;
-        this.pipeline = pipeline;
         this.finisher = finisher;
         this.txHost = txHost;
         this.drafts = drafts;
@@ -197,7 +190,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 +204,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 {
@@ -514,7 +509,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 +527,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";
@@ -629,17 +626,21 @@ let RunWorker = class RunWorker {
             startedAt = updated.started_at;
         }
         // 截止时间以首次开始为准：停机后在其他 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 {
@@ -693,7 +694,10 @@ let RunWorker = class RunWorker {
                     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 }),
@@ -906,7 +910,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 +918,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 +951,10 @@ 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(RunFinish)),
+    __param(20, Inject(TransactionHost)),
+    __param(21, Inject(RunDrafts)),
+    __param(22, Optional()),
+    __param(22, 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

@@ -37,12 +37,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 +66,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,7 +78,6 @@ RuntimeModule = __decorate([
             RunFinish,
             RunQueue,
             Waits,
-            DecisionResumer,
             RunControl,
             RunDrafts,
             AgentLoops,

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;

package/dist/runtime/step-log.js

@@ -17,28 +17,43 @@ import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { recordToolSpecs } from "../tools/specs.js";
 import { budgetRunOf } from "./subagents/limits.js";
+import { UsageReportJobs, UsageReportJobsModule } from "./usage-report-jobs.js";
 /**
  * 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.
  */
 let StepLog = class StepLog {
     kdb;
     eventLog;
+    usage;
     txHost;
-    constructor(kdb, eventLog, txHost) {
+    constructor(kdb, eventLog, usage, txHost) {
         this.kdb = kdb;
         this.eventLog = eventLog;
+        this.usage = usage;
         this.txHost = txHost;
     }
+    /**
+     * 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).
+     */
+    async appendReported(conversationId, events) {
+        const { events: written, fresh } = await this.eventLog.appendInReport(conversationId, events);
+        const added = written.filter((_, i) => fresh[i]);
+        await this.usage.oweEvents(conversationId, added);
+        return { written, toSeq: added.length > 0 ? Math.max(...added.map((e) => e.seq)) : 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).
      */
     async appendCounted(conversationId, counter, events) {
         const t = this.kdb.db;
@@ -51,6 +66,7 @@ let StepLog = class StepLog {
             .executeTakeFirstOrThrow();
         const written = await this.eventLog.appendIn(conversationId, events);
         const fresh = written.filter((e) => e.seq > Number(before.last_seq));
+        await this.usage.oweEvents(conversationId, fresh);
         let tokens = 0;
         for (const e of fresh)
             if (e.type === "usage")
@@ -79,6 +95,9 @@ let StepLog = class StepLog {
         return this.eventLog.appendIn(conversationId, events);
     }
 };
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], StepLog.prototype, "appendReported", null);
 __decorate([
     Transactional({ propagation: "requires_new" })
 ], StepLog.prototype, "appendCounted", null);
@@ -92,7 +111,8 @@ StepLog = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
     __param(1, Inject(EventLog)),
-    __param(2, Inject(TransactionHost))
+    __param(2, Inject(UsageReportJobs)),
+    __param(3, Inject(TransactionHost))
 ], StepLog);
 export { StepLog };
 /**
@@ -103,7 +123,7 @@ let StepLogModule = class StepLogModule {
 };
 StepLogModule = __decorate([
     Module({
-        imports: [EventLogModule],
+        imports: [EventLogModule, UsageReportJobsModule],
         providers: [StepLog],
         exports: [StepLog],
     })

package/dist/runtime/stream.controller.d.ts

@@ -2,7 +2,6 @@ import type { Logger } from "@capybara-hq/plugin-sdk";
 import type { FastifyReply, FastifyRequest } from "fastify";
 import { z } from "zod";
 import { ConversationAccess } from "../conversations/access.js";
-import { ConversationsService } from "../conversations/conversations.service.js";
 import { ApiTokenService } from "../identity/api-tokens.js";
 import { type Principal } from "../identity/principal.js";
 import { SessionService } from "../identity/sessions.js";
@@ -18,7 +17,7 @@ declare const DraftParams: z.ZodObject<{
 }, z.core.$strip>;
 /**
  * 会话事件流（SSE）：`GET /api/v1/orgs/:orgId/conversations/:id/stream?after=<seq>`，`agents.use`，只有会话所有者可用。
- * - 打开时不阻塞地调用一次 ensureRun（`ConversationsService.kickRun`），停在「运行中」的孤儿运行由此被清理；
+ * - opening it never changes run state (a read; transactional outbox spec §6);
  * - 先订阅会话频道、再回放 `after`（或优先的 `Last-Event-ID`）之后的事件：`id: <seq>` / `event: event`；
  * - after that catch-up, one `event: draft` (`data: {"runId","step","text","thinking"}`) per step of
  *   the running run whose `assistant_message` is not logged (live drafts, spec 2026-11-07 §3.2);
@@ -33,11 +32,10 @@ export declare class ConversationStreamController {
     private readonly streams;
     private readonly sessions;
     private readonly tokens;
-    private readonly conversations;
     private readonly access;
     private readonly drafts;
     private readonly log;
-    constructor(streams: ConversationStreams, sessions: SessionService, tokens: ApiTokenService, conversations: ConversationsService, access: ConversationAccess, drafts: RunDrafts, log: Pick<Logger, "warn">);
+    constructor(streams: ConversationStreams, sessions: SessionService, tokens: ApiTokenService, access: ConversationAccess, drafts: RunDrafts, log: Pick<Logger, "warn">);
     /**
      * The live drafts of one run (spec 2026-11-07 §3.2): `{ drafts: { step, text, thinking }[] }`,
      * the steps still streaming whose `assistant_message` is not logged (none once the run is no

package/dist/runtime/stream.controller.js

@@ -10,7 +10,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Controller, Get, Headers, Inject, Param, Req, Res } from "@nestjs/common";
 import { z } from "zod";
 import { ConversationAccess } from "../conversations/access.js";
-import { ConversationsService } from "../conversations/conversations.service.js";
 import { ApiError } from "../errors.js";
 import { ApiTokenService } from "../identity/api-tokens.js";
 import { credentialCheck } from "../identity/credential-check.js";
@@ -45,7 +44,7 @@ class RunDraftParamsDto extends createZodDto(DraftParams, "RunDraftParams") {
 }
 /**
  * 会话事件流（SSE）：`GET /api/v1/orgs/:orgId/conversations/:id/stream?after=<seq>`，`agents.use`，只有会话所有者可用。
- * - 打开时不阻塞地调用一次 ensureRun（`ConversationsService.kickRun`），停在「运行中」的孤儿运行由此被清理；
+ * - opening it never changes run state (a read; transactional outbox spec §6);
  * - 先订阅会话频道、再回放 `after`（或优先的 `Last-Event-ID`）之后的事件：`id: <seq>` / `event: event`；
  * - after that catch-up, one `event: draft` (`data: {"runId","step","text","thinking"}`) per step of
  *   the running run whose `assistant_message` is not logged (live drafts, spec 2026-11-07 §3.2);
@@ -60,15 +59,13 @@ let ConversationStreamController = class ConversationStreamController {
     streams;
     sessions;
     tokens;
-    conversations;
     access;
     drafts;
     log;
-    constructor(streams, sessions, tokens, conversations, access, drafts, log) {
+    constructor(streams, sessions, tokens, access, drafts, log) {
         this.streams = streams;
         this.sessions = sessions;
         this.tokens = tokens;
-        this.conversations = conversations;
         this.access = access;
         this.drafts = drafts;
         this.log = log;
@@ -131,8 +128,6 @@ let ConversationStreamController = class ConversationStreamController {
             },
         });
         reply.hijack();
-        // 可见性已通过：不阻塞地 ensureRun（清理孤儿运行、投递等待中的消息），见 ConversationsService.kickRun。
-        this.conversations.kickRun(id);
         res.on("close", () => handle.close());
         // 订阅期间客户端已断开：close 事件可能已经错过
         if (res.destroyed || !res.socket || res.socket.destroyed) {
@@ -173,9 +168,8 @@ ConversationStreamController = __decorate([
     __param(0, Inject(ConversationStreams)),
     __param(1, Inject(SessionService)),
     __param(2, Inject(ApiTokenService)),
-    __param(3, Inject(ConversationsService)),
-    __param(4, Inject(ConversationAccess)),
-    __param(5, Inject(RunDrafts)),
-    __param(6, Inject(KERNEL_LOGGER))
+    __param(3, Inject(ConversationAccess)),
+    __param(4, Inject(RunDrafts)),
+    __param(5, Inject(KERNEL_LOGGER))
 ], ConversationStreamController);
 export { ConversationStreamController };

package/dist/runtime/subagents/child.js

@@ -179,7 +179,7 @@ export async function childResult(eventLog, row, opts = {}) {
     else {
         status = "aborted";
         // §4.4: a person's stop names its account; a stop by nobody (null) is the kernel stopping the
-        // child on its parent's behalf (stopChildren with no account: the parent's end, the sweep)
+        // child on its parent's behalf (stopChildren with no account: the parent's end, its `stop-tree` job)
         abortedBy =
             terminal.payload.reason === "user" && terminal.payload.byAccountId === null
                 ? "parent"

package/dist/runtime/subagents/definition.d.ts

@@ -20,6 +20,7 @@ export declare class SubagentTypeGoneError extends Error {
 export interface EffectiveDefinition {
     definition: AgentDefinition;
     template: EventPayload<"subagent_started">["template"];
+    /** The child's step limit; 0 = no limit. */
     maxSteps: number;
     /**
      * The child's preamble, frozen into `subagent_started.preamble` (model-visible):
@@ -72,7 +73,7 @@ export interface ChildDepth {
  * - `general` / `inline` / `plugin`: the parent's definition narrowed by the template (tools by
  *   resolved key, `disallowedTools`, {@link CHILD_REMOVED_TOOLS}; policies stricter-wins; skills
  *   by its `disallowedSkills`), the template's instructions, its `skills` the child has named in
- *   the preamble to load first (general gets no line), `maxSteps = min(template ?? runtime.maxSteps, runtime.maxSteps)`, and the model tier
+ *   the preamble to load first (general gets no line), `maxSteps` = the tighter of the template's and `runtime.maxSteps` (0 = no limit), and the model tier
  *   `tier` (the call's) → the template's → `inherit`; an unmapped tier runs on the parent's model
  *   (`tierFallback`); a template `effort` is set when the resolved model declares it;
  * - `agent`: the org agent's version that passed the gates (`orgAgent`, from {@link checkOrgAgent}),

package/dist/runtime/subagents/definition.js

@@ -6,6 +6,7 @@ import { ApiError } from "../../errors.js";
 import { invocationOf, resolveSkills } from "../../skills/catalog.js";
 import { agentSkills, usableSkills } from "../../skills/usable.js";
 import { AGENT_TOOL, CHILD_REMOVED_TOOLS } from "../../tools/builtin-names.js";
+import { tightestLimit } from "../limits.js";
 import { SUBAGENT_PREAMBLE } from "./preamble.js";
 export { CHILD_REMOVED_TOOLS } from "../../tools/builtin-names.js";
 /**
@@ -222,7 +223,7 @@ function orgAgentDefinition(d, a) {
  * - `general` / `inline` / `plugin`: the parent's definition narrowed by the template (tools by
  *   resolved key, `disallowedTools`, {@link CHILD_REMOVED_TOOLS}; policies stricter-wins; skills
  *   by its `disallowedSkills`), the template's instructions, its `skills` the child has named in
- *   the preamble to load first (general gets no line), `maxSteps = min(template ?? runtime.maxSteps, runtime.maxSteps)`, and the model tier
+ *   the preamble to load first (general gets no line), `maxSteps` = the tighter of the template's and `runtime.maxSteps` (0 = no limit), and the model tier
  *   `tier` (the call's) → the template's → `inherit`; an unmapped tier runs on the parent's model
  *   (`tierFallback`); a template `effort` is set when the resolved model declares it;
  * - `agent`: the org agent's version that passed the gates (`orgAgent`, from {@link checkOrgAgent}),
@@ -293,7 +294,8 @@ export async function effectiveDefinition(d, a) {
     return {
         definition,
         template: ref,
-        maxSteps: Math.min(template?.maxSteps ?? runtimeMax, runtimeMax),
+        // the tighter of the template's and the deployment's, 0 = no limit (`runtime.maxSteps` 0)
+        maxSteps: tightestLimit(template?.maxSteps, runtimeMax) ?? 0,
         preamble: names.length === 0
             ? SUBAGENT_PREAMBLE
             : `${SUBAGENT_PREAMBLE}\n\n${loadSkillsFirstText(names)}`,