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

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

@@ -0,0 +1,10 @@
+/**
+ * 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
+ * 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).
+ */
+export declare class RuntimeModule {
+}

package/dist/runtime/runtime.module.js

@@ -0,0 +1,112 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from "@nestjs/common";
+import { ConversationAccessModule } from "../conversations/access.js";
+import { AttachmentsModule } from "../conversations/attachments.module.js";
+import { EventLogModule } from "../conversations/event-log.js";
+import { TitlesModule } from "../conversations/titles.js";
+import { ExtensionsModule } from "../extensions/extensions.module.js";
+import { IdentityModule } from "../identity/identity.module.js";
+import { LockService } from "../infra/lock/lock.service.js";
+import { QueueModule } from "../infra/queue/queue.module.js";
+import { REDIS } from "../infra/tokens.js";
+import { SkillsModule } from "../skills/skills.module.js";
+import { ToolsModule } from "../tools/tools.module.js";
+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 { ProvidersModule } from "./providers.js";
+import { EVAL_QUOTA, EVAL_QUOTA_PREFIX, OrgQuota, RUN_QUOTA, RUN_QUOTA_PREFIX } from "./quota.js";
+import { RunControl } from "./run-control.js";
+import { RunFinish } from "./run-finish.js";
+import { RunJobsModule } from "./run-jobs.js";
+import { RunQueue } from "./run-queue.js";
+import { AgentLoops, RunSteps } from "./run-steps.js";
+import { RunWorker } from "./run-worker.js";
+import { StepLog } 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";
+/**
+ * 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
+ * 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).
+ */
+let RuntimeModule = class RuntimeModule {
+};
+RuntimeModule = __decorate([
+    Module({
+        imports: [
+            EventLogModule,
+            ConversationAccessModule,
+            AttachmentsModule,
+            ExtensionsModule,
+            IdentityModule,
+            SkillsModule,
+            ToolsModule,
+            ProvidersModule,
+            RunJobsModule,
+            SubagentsModule,
+            UsageReportModule,
+            TitlesModule,
+            // the producer side of `wait-timeout` jobs (`MaintenanceProcessor` consumes them)
+            QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),
+        ],
+        providers: [
+            ConversationLock,
+            ConversationStreams,
+            RunAbort,
+            KyselyCheckpointSaver,
+            RunFinish,
+            StepLog,
+            RunQueue,
+            Waits,
+            DecisionResumer,
+            RunControl,
+            AgentLoops,
+            RunSteps,
+            RunWorker,
+            // one quota per key prefix (the org run quota, the org eval quota)
+            {
+                provide: RUN_QUOTA,
+                inject: [REDIS, LockService],
+                useFactory: (redis, locks) => new OrgQuota(redis, RUN_QUOTA_PREFIX, locks),
+            },
+            {
+                provide: EVAL_QUOTA,
+                inject: [REDIS, LockService],
+                useFactory: (redis, locks) => new OrgQuota(redis, EVAL_QUOTA_PREFIX, locks),
+            },
+        ],
+        exports: [
+            ConversationLock,
+            ConversationStreams,
+            RunAbort,
+            KyselyCheckpointSaver,
+            RunFinish,
+            StepLog,
+            RunQueue,
+            Waits,
+            RunControl,
+            AgentLoops,
+            RunSteps,
+            RunWorker,
+            RUN_QUOTA,
+            EVAL_QUOTA,
+            ProvidersModule,
+            SubagentsModule,
+            UsageReportModule,
+            TitlesModule,
+        ],
+    })
+], RuntimeModule);
+export { RuntimeModule };

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

@@ -0,0 +1,40 @@
+import type { ToolSpec } from "@capybara-hq/plugin-sdk";
+import { type AppendEvent, EventLog } from "../conversations/event-log.js";
+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";
+/** 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.
+ */
+export declare class StepLog {
+    private readonly kdb;
+    private readonly eventLog;
+    readonly txHost: TransactionHost;
+    constructor(kdb: KernelDb, eventLog: EventLog, txHost: TransactionHost);
+    /**
+     * Appends events of a sub-agent's run and adds the tokens of the usage events it newly wrote to
+     * the parent run's `subagent_tokens_used` (sub-agents spec §8.3): 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).
+     */
+    appendCounted(conversationId: string, parentRunId: string, events: AppendEvent[]): Promise<{
+        written: ConversationEvent[];
+        toSeq: number | null;
+    }>;
+    /** Appends events with their audit row (a hook denial). */
+    appendAudited(conversationId: string, events: AppendEvent[], entry: StepAuditEntry): Promise<ConversationEvent[]>;
+    /**
+     * Appends a `model_call` with the tool definitions its request sent, stored by fingerprint in
+     * `tool_specs` in the same transaction (a request can be rebuilt from the log and the specs).
+     */
+    appendWithSpecs(conversationId: string, specs: readonly {
+        specHash: string;
+        spec: ToolSpec;
+    }[], events: AppendEvent[]): Promise<ConversationEvent[]>;
+}

package/dist/runtime/step-log.js

@@ -0,0 +1,94 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { sql } from "kysely";
+import { EventLog } from "../conversations/event-log.js";
+import { usageTokens } from "../evals/budget.js";
+import { audit } from "../identity/audit.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { recordToolSpecs } from "../tools/specs.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.
+ */
+let StepLog = class StepLog {
+    kdb;
+    eventLog;
+    txHost;
+    constructor(kdb, eventLog, txHost) {
+        this.kdb = kdb;
+        this.eventLog = eventLog;
+        this.txHost = txHost;
+    }
+    /**
+     * Appends events of a sub-agent's run and adds the tokens of the usage events it newly wrote to
+     * the parent run's `subagent_tokens_used` (sub-agents spec §8.3): 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).
+     */
+    async appendCounted(conversationId, parentRunId, events) {
+        const t = this.kdb.db;
+        // the conversation row lock the append takes anyway, taken first to read the seq before it
+        const before = await t
+            .selectFrom("conversations")
+            .select("last_seq")
+            .where("id", "=", conversationId)
+            .forUpdate()
+            .executeTakeFirstOrThrow();
+        const written = await this.eventLog.appendIn(conversationId, events);
+        const fresh = written.filter((e) => e.seq > Number(before.last_seq));
+        let tokens = 0;
+        for (const e of fresh)
+            if (e.type === "usage")
+                tokens += usageTokens(e.payload);
+        if (tokens > 0) {
+            await t
+                .updateTable("runs")
+                .set({ subagent_tokens_used: sql `subagent_tokens_used + ${tokens}` })
+                .where("id", "=", parentRunId)
+                .execute();
+        }
+        return { written, toSeq: fresh.length > 0 ? Math.max(...fresh.map((e) => e.seq)) : null };
+    }
+    /** Appends events with their audit row (a hook denial). */
+    async appendAudited(conversationId, events, entry) {
+        const out = await this.eventLog.appendIn(conversationId, events);
+        await audit(this.kdb.db, entry);
+        return out;
+    }
+    /**
+     * Appends a `model_call` with the tool definitions its request sent, stored by fingerprint in
+     * `tool_specs` in the same transaction (a request can be rebuilt from the log and the specs).
+     */
+    async appendWithSpecs(conversationId, specs, events) {
+        await recordToolSpecs(this.kdb.db, specs);
+        return this.eventLog.appendIn(conversationId, events);
+    }
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], StepLog.prototype, "appendCounted", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], StepLog.prototype, "appendAudited", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], StepLog.prototype, "appendWithSpecs", null);
+StepLog = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(EventLog)),
+    __param(2, Inject(TransactionHost))
+], StepLog);
+export { StepLog };

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

@@ -1,12 +1,11 @@
-import { type OnModuleDestroy } from "@nestjs/common";
 import type { FastifyReply, FastifyRequest } from "fastify";
 import { z } from "zod";
-import type { ConversationsService } from "../conversations/conversations.service.js";
-import type { ApiTokenService } from "../identity/api-tokens.js";
+import { ConversationsService } from "../conversations/conversations.service.js";
+import { ApiTokenService } from "../identity/api-tokens.js";
 import { type Principal } from "../identity/principal.js";
-import type { SessionService } from "../identity/sessions.js";
+import { SessionService } from "../identity/sessions.js";
 import { type OrgContext } from "../orgs/org.guard.js";
-import type { ConversationStreams } from "./stream.js";
+import { ConversationStreams } from "./stream.js";
 declare const StreamQuery: z.ZodObject<{
     after: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strip>;
@@ -21,14 +20,12 @@ declare const StreamQuery: z.ZodObject<{
  * - 用 `@Res()` + `reply.hijack()` 直接写原始响应，绕开 Nest / Fastify 的响应处理与缓冲。
  *   代理（Web 层）需透传 `x-accel-buffering: no`、`cache-control: no-cache`。
  */
-export declare class ConversationStreamController implements OnModuleDestroy {
+export declare class ConversationStreamController {
     private readonly streams;
     private readonly sessions;
     private readonly tokens;
     private readonly conversations;
     constructor(streams: ConversationStreams, sessions: SessionService, tokens: ApiTokenService, conversations: ConversationsService);
     stream(principal: Principal, org: OrgContext, id: string, q: z.infer<typeof StreamQuery>, lastEventId: string | undefined, req: FastifyRequest, reply: FastifyReply): Promise<void>;
-    /** 停机：关闭本进程的全部流，否则 HTTP 关闭要等到这些长连接超时。 */
-    onModuleDestroy(): void;
 }
 export {};

package/dist/runtime/stream.controller.js

@@ -7,14 +7,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Controller, Get, Headers, Inject, Param, Query, Req, Res, } from "@nestjs/common";
+import { Controller, Get, Headers, Inject, Param, Req, Res } from "@nestjs/common";
 import { z } from "zod";
+import { ConversationsService } from "../conversations/conversations.service.js";
 import { ApiError } from "../errors.js";
-import { API_TOKENS, CONVERSATION_STREAMS, CONVERSATIONS, SESSIONS } from "../http/tokens.js";
-import { ZodPipe } from "../http/zod.pipe.js";
+import { ApiTokenService } from "../identity/api-tokens.js";
 import { credentialCheck } from "../identity/credential-check.js";
 import { CurrentPrincipal, requireUser } from "../identity/principal.js";
+import { SessionService } from "../identity/sessions.js";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { ConversationStreams } from "./stream.js";
 const BEARER_RE = /^Bearer\s+(\S+)$/i;
 const StreamQuery = z.object({
     after: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
@@ -28,6 +32,8 @@ function parseLastEventId(v) {
     }
     return n;
 }
+class ConversationStreamQueryDto extends createZodDto(StreamQuery, "ConversationStreamQuery") {
+}
 /**
  * 会话事件流（SSE）：`GET /api/v1/orgs/:orgId/conversations/:id/stream?after=<seq>`，`agents.use`，只有会话所有者可用。
  * - 打开时不阻塞地调用一次 ensureRun（`ConversationsService.kickRun`），停在「运行中」的孤儿运行由此被清理；
@@ -96,10 +102,6 @@ let ConversationStreamController = class ConversationStreamController {
         res.flushHeaders();
         handle.begin();
     }
-    /** 停机：关闭本进程的全部流，否则 HTTP 关闭要等到这些长连接超时。 */
-    onModuleDestroy() {
-        this.streams.closeAll();
-    }
 };
 __decorate([
     Get(":id/stream"),
@@ -107,16 +109,16 @@ __decorate([
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("id")),
-    __param(3, Query(new ZodPipe(StreamQuery))),
+    __param(3, ZQuery(ConversationStreamQueryDto)),
     __param(4, Headers("last-event-id")),
     __param(5, Req()),
     __param(6, Res())
 ], ConversationStreamController.prototype, "stream", null);
 ConversationStreamController = __decorate([
     Controller("api/v1/orgs/:orgId/conversations"),
-    __param(0, Inject(CONVERSATION_STREAMS)),
-    __param(1, Inject(SESSIONS)),
-    __param(2, Inject(API_TOKENS)),
-    __param(3, Inject(CONVERSATIONS))
+    __param(0, Inject(ConversationStreams)),
+    __param(1, Inject(SessionService)),
+    __param(2, Inject(ApiTokenService)),
+    __param(3, Inject(ConversationsService))
 ], ConversationStreamController);
 export { ConversationStreamController };

package/dist/runtime/stream.d.ts

@@ -1,7 +1,9 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { KernelConfig } from "../config/schema.js";
-import { type EventLog } from "../conversations/event-log.js";
+import { ConversationAccess } from "../conversations/access.js";
+import { EventLog } from "../conversations/event-log.js";
 import type { CredentialCheck } from "../identity/credential-check.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { GracefulShutdown } from "../infra/lifecycle/graceful-shutdown.service.js";
 /** 一次 SSE 连接的输出端（由 HTTP 层包装原始响应）。 */
 export interface SseOutput {
     write(chunk: string): void;
@@ -21,7 +23,7 @@ export interface ConversationStreamsDeps {
     bus: StreamBus;
     /** 轻量可见性判定：连接建立时与每 `sseRecheckMs` 复核一次。 */
     access(orgId: string, conversationId: string, viewerAccountId: string): Promise<boolean>;
-    config: () => KernelConfig;
+    config: Pick<KernelConfigService, "get">;
     log: Pick<Logger, "warn">;
 }
 export interface StreamParams {
@@ -48,16 +50,32 @@ export interface StreamHandle {
  * （订阅、心跳与复核定时器）。
  */
 export declare class ConversationStreams {
-    private readonly d;
     private readonly active;
-    constructor(d: ConversationStreamsDeps);
+    /** Set by {@link closeAll}: streams opened afterwards end as soon as they begin. */
+    private closing;
+    private readonly d;
+    /**
+     * Closes the streams when the shutdown begins (readiness answers 503 from that moment) and
+     * latches: streams opened afterwards end at once, so the HTTP phase of the stop never waits on
+     * an event stream. Without `GracefulShutdown` (a standalone HTTP application, tests only) the
+     * streams end with their connections.
+     */
+    constructor(eventLog: Pick<EventLog, "readAfter">, bus: StreamBus, access: Pick<ConversationAccess, "isAccessible">, config: Pick<KernelConfigService, "get">, log: Pick<Logger, "warn">, shutdown?: Pick<GracefulShutdown, "signal">);
     /**
      * 复核凭据与可见性，并先订阅会话频道（之后再回放，避免遗漏两者之间提交的事件）。
      * 凭据失效 → 对应的 `auth.*`；不可见 → `conversation.not_found`；订阅失败照常抛出。此时尚未写任何响应，调用方可以按普通错误返回。
      */
     open(p: StreamParams, out: SseOutput): Promise<StreamHandle>;
-    /** 关闭本进程的全部流（停机时调用）。 */
+    /**
+     * Closes every stream of this process (at shutdown) and latches: a stream opened afterwards ends
+     * right after its headers, so a reconnecting client cannot hold the HTTP close open.
+     */
     closeAll(): void;
     /** 当前打开的流数（测试用）。 */
     get size(): number;
 }
+/**
+ * The handle of a stream opened after shutdown began: `begin` (the headers are written) ends the
+ * response at once; the client reconnects with `Last-Event-ID`, to a replica that is still ready.
+ */
+export declare function endedStream(out: SseOutput): StreamHandle;

package/dist/runtime/stream.js

@@ -1,5 +1,19 @@
-import { CONVERSATION_CHANGES, conversationTopic, } from "../conversations/event-log.js";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable, Optional } from "@nestjs/common";
+import { ConversationAccess } from "../conversations/access.js";
+import { CONVERSATION_CHANGES, conversationTopic, EventLog, } from "../conversations/event-log.js";
 import { ApiError } from "../errors.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { GracefulShutdown } from "../infra/lifecycle/graceful-shutdown.service.js";
+import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { isUiBusMessage, uiFrame } from "../ui/registry.js";
 /** 补读事件的分页大小。 */
 const PAGE = 500;
@@ -46,11 +60,29 @@ const eventFrame = (e) => `id: ${e.seq}\nevent: event\ndata: ${JSON.stringify(e)
  * 跨副本的数据只经 PG（事件日志）与内核 bus（`conv.<id>`）流动，进程内只保存连接本身的资源
  * （订阅、心跳与复核定时器）。
  */
-export class ConversationStreams {
-    d;
+let ConversationStreams = class ConversationStreams {
     active = new Set();
-    constructor(d) {
-        this.d = d;
+    /** Set by {@link closeAll}: streams opened afterwards end as soon as they begin. */
+    closing = false;
+    d;
+    /**
+     * Closes the streams when the shutdown begins (readiness answers 503 from that moment) and
+     * latches: streams opened afterwards end at once, so the HTTP phase of the stop never waits on
+     * an event stream. Without `GracefulShutdown` (a standalone HTTP application, tests only) the
+     * streams end with their connections.
+     */
+    constructor(eventLog, bus, access, config, log, shutdown) {
+        this.d = {
+            eventLog,
+            bus,
+            access: (orgId, conversationId, viewer) => access.isAccessible(orgId, conversationId, viewer),
+            config,
+            log,
+        };
+        if (shutdown?.signal.aborted)
+            this.closeAll();
+        else
+            shutdown?.signal.addEventListener("abort", () => this.closeAll(), { once: true });
     }
     /**
      * 复核凭据与可见性，并先订阅会话频道（之后再回放，避免遗漏两者之间提交的事件）。
@@ -60,6 +92,8 @@ export class ConversationStreams {
         const denied = await authorize(this.d, p);
         if (denied !== null)
             throw new ApiError(denied, DENIAL_MESSAGES[denied] ?? "Access denied");
+        if (this.closing)
+            return endedStream(out);
         const conn = new Connection(this.d, p, out, () => this.active.delete(conn));
         this.active.add(conn);
         try {
@@ -69,10 +103,19 @@ export class ConversationStreams {
             conn.close();
             throw e;
         }
+        // closeAll ran while subscribing: the connection is closed, the response must still end
+        if (this.closing) {
+            conn.close();
+            return endedStream(out);
+        }
         return conn;
     }
-    /** 关闭本进程的全部流（停机时调用）。 */
+    /**
+     * Closes every stream of this process (at shutdown) and latches: a stream opened afterwards ends
+     * right after its headers, so a reconnecting client cannot hold the HTTP close open.
+     */
     closeAll() {
+        this.closing = true;
         for (const c of [...this.active])
             c.close();
     }
@@ -80,6 +123,34 @@ export class ConversationStreams {
     get size() {
         return this.active.size;
     }
+};
+ConversationStreams = __decorate([
+    Injectable(),
+    __param(0, Inject(EventLog)),
+    __param(1, Inject(KERNEL_BUS)),
+    __param(2, Inject(ConversationAccess)),
+    __param(3, Inject(KernelConfigService)),
+    __param(4, Inject(KERNEL_LOGGER)),
+    __param(5, Optional()),
+    __param(5, Inject(GracefulShutdown))
+], ConversationStreams);
+export { ConversationStreams };
+/**
+ * The handle of a stream opened after shutdown began: `begin` (the headers are written) ends the
+ * response at once; the client reconnects with `Last-Event-ID`, to a replica that is still ready.
+ */
+export function endedStream(out) {
+    return {
+        begin: () => {
+            try {
+                out.end();
+            }
+            catch {
+                // the connection is already gone
+            }
+        },
+        close: () => { },
+    };
 }
 class Connection {
     d;
@@ -117,7 +188,7 @@ class Connection {
         if (this.closed)
             return;
         this.begun = true;
-        const { sseHeartbeatMs, sseRecheckMs } = this.d.config().runtime;
+        const { sseHeartbeatMs, sseRecheckMs } = this.d.config.get().runtime;
         this.timers.push(setInterval(() => this.write(": ping\n\n"), sseHeartbeatMs), setInterval(() => void this.recheck(), sseRecheckMs));
         this.openGate();
     }

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

@@ -1,10 +1,6 @@
-import type { Logger } from "@capybara-hq/plugin-sdk";
 import type { AppendEvent, EventLog } from "../../conversations/event-log.js";
 import type { EventPayload } from "../../conversations/events.js";
-import type { KernelDb } from "../../db/kernel-schema.js";
-import type { RunAbort, RunAbortDetail } from "../abort.js";
-import { type RunQueue } from "../run-queue.js";
-import type { Waits } from "../waits.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 /** Idempotency key of the parent's `subagent_finished` event. */
 export declare const finishedIdemKey: (childRunId: string) => string;
 /** A dispatch row, by its child run. */
@@ -16,9 +12,9 @@ export interface DispatchRow {
     childRunId: string;
 }
 /** The dispatch that started `childRunId`, or null (not a sub-agent run). */
-export declare function dispatchOfChildRun(db: KernelDb, childRunId: string): Promise<DispatchRow | null>;
+export declare function dispatchOfChildRun(db: KernelSchemaDb, childRunId: string): Promise<DispatchRow | null>;
 /** The dispatch of the parent call `(runId, callId)`, or null (not dispatched yet). */
-export declare function dispatchOfCall(db: KernelDb, runId: string, callId: string): Promise<DispatchRow | null>;
+export declare function dispatchOfCall(db: KernelSchemaDb, runId: string, callId: string): Promise<DispatchRow | null>;
 /**
  * The tool result of a finished child run (spec §4.4) and its `subagent_finished` payload, from
  * the child's log only: the status from its terminal event, the reply from its last
@@ -41,40 +37,3 @@ opts?: {
 } | null>;
 /** The parent's `subagent_finished` event for a finished child (idempotent by its key). */
 export declare const finishedEvent: (row: DispatchRow, finished: EventPayload<"subagent_finished">) => AppendEvent;
-export interface ChildDeps {
-    db: KernelDb;
-    eventLog: EventLog;
-    waits: Pick<Waits, "resume">;
-    log: Pick<Logger, "warn">;
-}
-/**
- * After a child run's terminal state committed (spec §7.3): appends `subagent_finished` to the
- * parent log (idempotent; allowed while the parent waits, it is not model-visible) and tries
- * `Waits.resume(parentRunId, childRunId)`. Every finishing child tries; the conditional resume lets
- * exactly one succeed, the last to see all its siblings terminal. A run that is not a dispatched
- * child, or not terminal yet, is left alone. A crash in between is repaired by the wait sweep and
- * by the parent's tools node, which writes a missing `subagent_finished` itself.
- */
-export declare function onChildFinished(d: ChildDeps, childRunId: string): Promise<void>;
-export interface StopChildrenDeps extends ChildDeps {
-    waits: Pick<Waits, "resume" | "abortWaiting">;
-    runQueue: Pick<RunQueue, "abortIfOrphaned">;
-    abort: Pick<RunAbort, "request">;
-}
-/**
- * Stops the active children of a parent run (sub-agents spec §12), or only those dispatched in
- * `opts.step`: a `waiting` child through its own `abortWaiting`, a `queued` / `running` one that
- * no worker holds directly (`abortIfOrphaned`), any other through `RunAbort.request` (the
- * cross-replica broadcast plus the marker key, so a child that starts later still sees it), after
- * which a child found `waiting` is stopped through `abortWaiting` too. A child stopped here is
- * reported to the parent at once (by `abortWaiting` itself, or {@link onChildFinished} after
- * `abortIfOrphaned`); one stopped by its worker is reported by that worker. Returns the number of
- * children asked to stop.
- *
- * `byAccountId` is the person whose action stops them, or null when the kernel stops them on the
- * parent's behalf; a child stopped with null reports the §4.4 "parent's stop" text.
- */
-export declare function stopChildren(d: StopChildrenDeps, parentRunId: string, byAccountId: string | null, opts?: {
-    step?: number;
-    detail?: RunAbortDetail;
-}): Promise<number>;