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

package/dist/runtime/subagents/org-agents.js

@@ -1,4 +1,4 @@
-import { isAgentVisibleTo } from "../../agents/agents.service.js";
+import { isAgentVisibleTo } from "../../agents/agent-lookup.js";
 import { normalizeStoredDefinition } from "../../agents/definition.js";
 import { audit } from "../../identity/audit.js";
 /**

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

@@ -1,5 +1,5 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { KernelDb } from "../../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 /** A finished step of a sub-agent run, as the loop reports it. */
 export interface SubagentStep {
     /** The parent conversation, whose topic gets the message. */
@@ -10,7 +10,7 @@ export interface SubagentStep {
     step: number;
 }
 export interface SubagentProgressDeps {
-    db: KernelDb;
+    db: KernelSchemaDb;
     bus: {
         publish(topic: string, payload: unknown): Promise<void>;
     };

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

@@ -1,5 +1,5 @@
 import type { AgentDefinition } from "../../agents/definition.js";
-import type { KernelDb } from "../../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 /**
  * The sub-agent roster of an agent version (phase C, spec §4.3, §5.1): the agent types its `agent`
  * tool offers, in the order the description lists them.
@@ -31,7 +31,7 @@ export declare const templateType: (plugin: string, name: string) => string;
  * since the save are skipped; allowlisted org agents stay listed (the dispatch checks their gates
  * and refuses with the §4.5 text), with `agentName` only while the agent is live.
  */
-export declare function resolveRoster(db: KernelDb, orgId: string, parent: Pick<AgentDefinition, "subagents">): Promise<RosterEntry[]>;
+export declare function resolveRoster(db: KernelSchemaDb, orgId: string, parent: Pick<AgentDefinition, "subagents">): Promise<RosterEntry[]>;
 /**
  * The roster entry for a requested `subagent_type`: an exact type first; else a bare `<name>`
  * matches the plugin template `<plugin>:<name>` when exactly one has it (as Claude Code accepts
@@ -48,7 +48,7 @@ export declare const isGeneralAlias: (agent: string) => boolean;
  * the type is one the parent's `agent` tool offers (`general-purpose` is not when
  * `subagents.general === false`, which does not block a person's fork invocation).
  */
-export declare function resolveSkillForkType(db: KernelDb, orgId: string, parent: Pick<AgentDefinition, "subagents">, agent: string | undefined, plugin: string | undefined): Promise<{
+export declare function resolveSkillForkType(db: KernelSchemaDb, orgId: string, parent: Pick<AgentDefinition, "subagents">, agent: string | undefined, plugin: string | undefined): Promise<{
     agentType: string;
     unknown?: string;
     inRoster: boolean;

package/dist/runtime/subagents/roster.js

@@ -1,4 +1,4 @@
-import { SUBAGENT_ROSTER_MAX } from "../../agents/agents.service.js";
+import { SUBAGENT_ROSTER_MAX } from "../../agents/definition.js";
 import { loadTemplates } from "../../agents/templates.js";
 export const ROSTER_DESCRIPTION_MAX = 1024;
 /** The description of `general-purpose` in the roster (spec §4.3, model-visible). */

package/dist/runtime/subagents/skill-fork.d.ts

@@ -1,10 +1,9 @@
-import type { Transaction } from "kysely";
 import type { EventLog } from "../../conversations/event-log.js";
 import type { ConversationEvent, EventPayload } from "../../conversations/events.js";
-import type { KernelDatabase } from "../../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 import { ApiError } from "../../errors.js";
 import type { SkillInvoker } from "../../skills/invoke.js";
-import type { LoopContext, WaitingFor } from "../loop.js";
+import { type LoopContext, type WaitingFor } from "../loop.js";
 import { type DispatchDeps } from "./dispatch.js";
 /**
  * Forked skills (phase D spec §6): a person's invocation of a `context: fork` skill starts its own
@@ -15,7 +14,6 @@ import { type DispatchDeps } from "./dispatch.js";
  * sweep) pairs a fork invocation without a report ({@link pairStoppedForks}), so the log never holds
  * a fork lead whose report is missing before the next model call.
  */
-type KernelTrx = Transaction<KernelDatabase>;
 /** The dispatch's parent call id (no `:`; there is no tool call). */
 export declare const skillCallId: (seq: number) => string;
 /** Idempotency key of a fork invocation's report (one per invocation, whatever the run). */
@@ -109,15 +107,16 @@ export declare const recordedSkillForks: (eventLog: Pick<EventLog, "append" | "f
     payload: unknown;
 }[]) => SkillForks;
 /**
- * In the transaction `t` of a run's terminal path (or the wait sweep): the run's fork invocation
+ * In the transaction of a run's terminal path (or the wait sweep): the run's fork invocation
  * (its trigger message, by the run boundary) without a report gets one now: the ended child's
  * result (and the parent's missing `subagent_finished`), {@link AGENT_STOPPED_WITH_RUN_TEXT} for a
  * child still active (the caller stops it after its commit, as for `agent` calls), or
  * {@link FORK_NOT_STARTED_TEXT} when nothing was dispatched. Returns the call ids written
  * (`skill-<seq>`) and the highest seq; the caller notifies after its commit.
  */
-export declare function pairStoppedForks(t: KernelTrx, eventLog: EventLog, runId: string): Promise<{
+export declare function pairStoppedForks(
+/** The caller's transaction (the context's handle). */
+t: KernelSchemaDb, eventLog: EventLog, runId: string): Promise<{
     callIds: string[];
     toSeq: number | null;
 }>;
-export {};

package/dist/runtime/subagents/skill-fork.js

@@ -1,9 +1,18 @@
 import { ApiError } from "../../errors.js";
 import { AGENT_STOPPED_WITH_RUN_TEXT } from "../../tools/builtins/agent.js";
-import { subagentsWait } from "../../tools/pipeline.js";
+import { subagentsWait } from "../loop.js";
 import { TERMINAL_STATUSES } from "../run-finish.js";
 import { childResult, dispatchOfCall, finishedEvent } from "./child.js";
 import { dispatchSubagent } from "./dispatch.js";
+/**
+ * Forked skills (phase D spec §6): a person's invocation of a `context: fork` skill starts its own
+ * run (the run boundary, {@link forkBoundary}), whose `prepare` node dispatches the sub-agent
+ * through phase C's `dispatchSubagent` before any model call and waits on it like an `agent` call
+ * (`subagents` wait `sa-<runId>-0`). When the child has ended, `prepare` appends the model-visible
+ * `skill_fork_result` and the parent's model answers. Every terminal path of the run (and the wait
+ * sweep) pairs a fork invocation without a report ({@link pairStoppedForks}), so the log never holds
+ * a fork lead whose report is missing before the next model call.
+ */
 /** The dispatch's parent call id (no `:`; there is no tool call). */
 export const skillCallId = (seq) => `skill-${seq}`;
 /** Idempotency key of a fork invocation's report (one per invocation, whatever the run). */
@@ -146,7 +155,7 @@ export async function advanceSkillForks(d, a) {
 }
 const suspend = (d, ctx) => ({
     kind: "suspend",
-    waitingFor: subagentsWait(ctx.runId, FORK_STEP, d.config()),
+    waitingFor: subagentsWait(ctx.runId, FORK_STEP, d.config.get()),
 });
 /** The live handler for the loop (`LoopDeps.skillForks`). */
 export const liveSkillForks = (d) => ({
@@ -178,14 +187,16 @@ export const recordedSkillForks = (eventLog, recorded) => ({
     },
 });
 /**
- * In the transaction `t` of a run's terminal path (or the wait sweep): the run's fork invocation
+ * In the transaction of a run's terminal path (or the wait sweep): the run's fork invocation
  * (its trigger message, by the run boundary) without a report gets one now: the ended child's
  * result (and the parent's missing `subagent_finished`), {@link AGENT_STOPPED_WITH_RUN_TEXT} for a
  * child still active (the caller stops it after its commit, as for `agent` calls), or
  * {@link FORK_NOT_STARTED_TEXT} when nothing was dispatched. Returns the call ids written
  * (`skill-<seq>`) and the highest seq; the caller notifies after its commit.
  */
-export async function pairStoppedForks(t, eventLog, runId) {
+export async function pairStoppedForks(
+/** The caller's transaction (the context's handle). */
+t, eventLog, runId) {
     const none = { callIds: [], toSeq: null };
     const run = await t
         .selectFrom("runs as r")
@@ -254,6 +265,6 @@ export async function pairStoppedForks(t, eventLog, runId) {
             events.push(finishedEvent(row, ended.finished));
         events.push(reportEvent(runId, seq, forkReportText(skill.name, ended ? ended.content : AGENT_STOPPED_WITH_RUN_TEXT), row));
     }
-    const out = await eventLog.append(conversationId, events, t);
+    const out = await eventLog.appendIn(conversationId, events);
     return { callIds: [callId], toSeq: Math.max(...out.map((e) => e.seq)) };
 }

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

@@ -0,0 +1,40 @@
+import type { ExtensionContext } from "@capybara-hq/plugin-sdk";
+import { EventLog } from "../../conversations/event-log.js";
+import { KernelConfigService } from "../../infra/config/kernel-config.service.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { TransactionHost } from "../../infra/database/transaction-host.js";
+import type { KernelLogger } from "../../log.js";
+import { ModelPurposesService } from "../../models/purposes.js";
+import { SkillInvoker } from "../../skills/invoke.js";
+import { ProviderRegistry } from "../providers.js";
+import { RunJobs } from "../run-jobs.js";
+import { type ChildWriter, type DispatchArgs, type DispatchCommit, type DispatchOutcome, type DispatchPlan } from "./dispatch.js";
+import { type SubagentStep } from "./progress.js";
+import { type SkillForkDeps, type SkillForks } from "./skill-fork.js";
+/**
+ * Sub-agents (phase C, spec §7) and forked skills (phase D): the `agent` tool's dispatch (the
+ * tool pipeline calls {@link dispatch}), a run's fork invocation ({@link skillForks}, the loop's
+ * `prepare`) and a child step's progress on the parent's stream ({@link progress}). Child runs go
+ * to the sub-agent run queue through {@link RunJobs}. The child lifecycle after dispatch (a
+ * finished child resumes its parent, a stopped parent stops its children) is the waits'
+ * (`Waits.childFinished` / `stopChildren`).
+ */
+export declare class SubagentsService {
+    private readonly bus;
+    private readonly log;
+    readonly txHost: TransactionHost;
+    /** The dispatch's dependencies (`dispatch.ts`, `skill-fork.ts`). */
+    readonly deps: SkillForkDeps;
+    /** The live fork handler of the loop (`LoopDeps.skillForks`). */
+    readonly skillForks: SkillForks;
+    constructor(kdb: KernelDb, eventLog: EventLog, purposes: ModelPurposesService, registry: ProviderRegistry, config: KernelConfigService, jobs: RunJobs, invoker: SkillInvoker, bus: ExtensionContext["bus"], log: KernelLogger, txHost: TransactionHost);
+    /** Dispatches the sub-agent of one `agent` call (`dispatchSubagent`). */
+    dispatch(a: DispatchArgs): Promise<DispatchOutcome>;
+    /** The dispatch's writes in a transaction of their own (see `commitDispatchIn`). */
+    commitDispatch(a: DispatchArgs, plan: DispatchPlan, child: ChildWriter): Promise<DispatchCommit | null>;
+    /** A sub-agent's finished step on its parent's stream (sub-agents spec §14.2). Never throws. */
+    progress(s: SubagentStep): Promise<void>;
+}
+/** Sub-agent dispatch (the tools domain's `agent` tool and the run loop use it). */
+export declare class SubagentsModule {
+}

package/dist/runtime/subagents/subagents.service.js

@@ -0,0 +1,101 @@
+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, Module } from "@nestjs/common";
+import { EventLog, EventLogModule } from "../../conversations/event-log.js";
+import { KernelConfigService } from "../../infra/config/kernel-config.service.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 { KERNEL_BUS, KERNEL_LOGGER } from "../../infra/tokens.js";
+import { ModelsModule } from "../../models/models.module.js";
+import { ModelPurposesService } from "../../models/purposes.js";
+import { SkillInvoker } from "../../skills/invoke.js";
+import { SkillsModule } from "../../skills/skills.module.js";
+import { ProviderRegistry, ProvidersModule } from "../providers.js";
+import { RunJobs, RunJobsModule } from "../run-jobs.js";
+import { commitDispatchIn, dispatchSubagent, } from "./dispatch.js";
+import { publishSubagentProgress } from "./progress.js";
+import { liveSkillForks } from "./skill-fork.js";
+/**
+ * Sub-agents (phase C, spec §7) and forked skills (phase D): the `agent` tool's dispatch (the
+ * tool pipeline calls {@link dispatch}), a run's fork invocation ({@link skillForks}, the loop's
+ * `prepare`) and a child step's progress on the parent's stream ({@link progress}). Child runs go
+ * to the sub-agent run queue through {@link RunJobs}. The child lifecycle after dispatch (a
+ * finished child resumes its parent, a stopped parent stops its children) is the waits'
+ * (`Waits.childFinished` / `stopChildren`).
+ */
+let SubagentsService = class SubagentsService {
+    bus;
+    log;
+    txHost;
+    /** The dispatch's dependencies (`dispatch.ts`, `skill-fork.ts`). */
+    deps;
+    /** The live fork handler of the loop (`LoopDeps.skillForks`). */
+    skillForks;
+    constructor(kdb, eventLog, purposes, registry, config, jobs, invoker, bus, log, txHost) {
+        this.bus = bus;
+        this.log = log;
+        this.txHost = txHost;
+        this.deps = {
+            get db() {
+                return kdb.db;
+            },
+            eventLog,
+            purposes,
+            registry,
+            config,
+            enqueue: (data, jobId, kind) => jobs.enqueue(data, jobId, kind),
+            log,
+            invoker,
+            commitDispatch: (a, plan, child) => this.commitDispatch(a, plan, child),
+        };
+        this.skillForks = liveSkillForks(this.deps);
+    }
+    /** Dispatches the sub-agent of one `agent` call (`dispatchSubagent`). */
+    dispatch(a) {
+        return dispatchSubagent(this.deps, a);
+    }
+    /** The dispatch's writes in a transaction of their own (see `commitDispatchIn`). */
+    commitDispatch(a, plan, child) {
+        return commitDispatchIn(this.deps, a, plan, child);
+    }
+    /** A sub-agent's finished step on its parent's stream (sub-agents spec §14.2). Never throws. */
+    progress(s) {
+        return publishSubagentProgress({ db: this.deps.db, bus: this.bus, log: this.log }, s);
+    }
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], SubagentsService.prototype, "commitDispatch", null);
+SubagentsService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(EventLog)),
+    __param(2, Inject(ModelPurposesService)),
+    __param(3, Inject(ProviderRegistry)),
+    __param(4, Inject(KernelConfigService)),
+    __param(5, Inject(RunJobs)),
+    __param(6, Inject(SkillInvoker)),
+    __param(7, Inject(KERNEL_BUS)),
+    __param(8, Inject(KERNEL_LOGGER)),
+    __param(9, Inject(TransactionHost))
+], SubagentsService);
+export { SubagentsService };
+/** Sub-agent dispatch (the tools domain's `agent` tool and the run loop use it). */
+let SubagentsModule = class SubagentsModule {
+};
+SubagentsModule = __decorate([
+    Module({
+        imports: [EventLogModule, ModelsModule, ProvidersModule, RunJobsModule, SkillsModule],
+        providers: [SubagentsService],
+        exports: [SubagentsService],
+    })
+], SubagentsModule);
+export { SubagentsModule };

package/dist/runtime/usage-report.d.ts

@@ -1,7 +1,11 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { KernelConfig } from "../config/schema.js";
-import type { KernelDb } from "../db/kernel-schema.js";
-import { type HookRegistry } from "../extensions/hooks.js";
+import { Job, type Queue, type Worker } from "bullmq";
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import { ExtensionHost } from "../extensions/host.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { LockService } from "../infra/lock/lock.service.js";
+import type { KernelLogger } from "../log.js";
 /** Queue of `usage.report` deliveries (no `:` in the name). */
 export declare const USAGE_REPORT_QUEUE = "cap-kernel-usage-report";
 /** One job per `usage` event (no `:`: conversation ids are UUIDs, seq is a number). */
@@ -23,10 +27,17 @@ export interface UsageReportJob {
 export declare const USAGE_REPORT_ATTEMPTS = 6;
 /** Retry backoff: 2 s, doubling (2, 4, 8, 16, 32 s). */
 export declare const USAGE_REPORT_BACKOFF_MS = 2000;
-/** Maintenance job of the sweeper (no `:`), its scheduler id and period. */
+/** The delivery retry policy of {@link UsageReporter}: attempts and the first exponential backoff. */
+export interface UsageReportRetry {
+    attempts: number;
+    backoffMs: number;
+}
+/** Optional provider: the {@link UsageReportRetry} instead of the defaults above (tests). */
+export declare const USAGE_REPORT_RETRY: unique symbol;
+/** The sweeper's cron job name (no `:`; every minute, once across replicas). */
 export declare const USAGE_SWEEP_JOB = "usage-report-sweep";
-export declare const USAGE_SWEEP_SCHEDULER_ID = "usage-report-sweep-every";
-export declare const USAGE_SWEEP_EVERY_MS = 60000;
+/** The maintenance scheduler the sweep ran on before it became a `@LockedCron` (retired). */
+export { USAGE_SWEEP_SCHEDULER_ID } from "./job-ids.js";
 /** The sweep leaves the newest events to the fast path (and to transactions still committing). */
 export declare const USAGE_SWEEP_LAG_MS = 30000;
 /**
@@ -35,45 +46,13 @@ export declare const USAGE_SWEEP_LAG_MS = 30000;
  * (`hooks.usageReportKeepHours` ≥ 1 h), so re-enqueued events dedupe on the kept job.
  */
 export declare const USAGE_SWEEP_OVERLAP_MS: number;
-export interface UsageReporterDeps {
-    db: KernelDb;
-    redisUrl: string;
-    /**
-     * The host's registry: handlers of the current local plugin generations (through inflight.run), and
-     * `has("usage.report")`, the in-process check that lets `enqueue` skip all I/O without handlers.
-     */
-    hooks: Pick<HookRegistry, "handlers" | "has">;
-    /**
-     * Whether the plugin's current instance is active on this replica (I-2): an active instance that
-     * registered no `usage.report` handler is not a subscriber, and its target is dropped. Absent: never.
-     */
-    isActive?(plugin: string): boolean;
-    /**
-     * Of these plugins, the ones no replica can serve right now (I-2): replicas report them (live
-     * `extension_replica_status` rows) and none has them loaded. Their targets are dropped at once instead
-     * of failing every attempt. See {@link queryUnservable}. Absent: none.
-     */
-    unservable?(plugins: readonly string[]): Promise<Set<string>>;
-    /**
-     * Plugins that subscribe to `usage.report`, from deployment state (approved manifests in PG), not from this replica's loaded handlers. With `orgId`: only those the
-     * organization enabled. See {@link queryUsageSubscribers}.
-     */
-    subscribers(orgId?: string): Promise<Set<string>>;
-    config: () => KernelConfig;
-    log: Logger;
-    /** Tests: retry policy (defaults {@link USAGE_REPORT_ATTEMPTS} / {@link USAGE_REPORT_BACKOFF_MS}). */
-    retry?: {
-        attempts: number;
-        backoffMs: number;
-    };
-}
 /**
  * Plugins that subscribe to `usage.report` according to deployment state: an approved permission
  * snapshot that declares the `usage.report` hook, for a plugin the deployment still knows: an enabled
  * install, or a config-declared plugin with a replica status row that is not `unloaded`. With `orgId`, only plugins
  * the organization enabled (org config rows and required bootstrap plugins).
  */
-export declare function queryUsageSubscribers(db: KernelDb, orgId?: string): Promise<Set<string>>;
+export declare function queryUsageSubscribers(db: KernelSchemaDb, orgId?: string): Promise<Set<string>>;
 /**
  * Of `plugins`, those that are **definitely** unservable right now (I-2, N-3): live replicas report
  * them (a `extension_replica_status` row with a heartbeat newer than `staleSeconds`), no live row is
@@ -82,7 +61,7 @@ export declare function queryUsageSubscribers(db: KernelDb, orgId?: string): Pro
  * reconcile). A plugin with no live row at all is unknown too (slow to load, or a host without a
  * status store). Unknown plugins are never listed.
  */
-export declare function queryUnservable(db: KernelDb, plugins: readonly string[], staleSeconds: number): Promise<Set<string>>;
+export declare function queryUnservable(db: KernelSchemaDb, plugins: readonly string[], staleSeconds: number): Promise<Set<string>>;
 /**
  * The next `pending` set (m-2 fence): plugins that failed now, narrowed to what the stored job data
  * still lists. A plugin another (stalled-over) execution already delivered never comes back.
@@ -118,14 +97,50 @@ export declare function narrowPending(stored: readonly string[] | undefined, fai
  * Single-step eval replays and judge requests log no usage: not reported (M7).
  */
 export declare class UsageReporter {
-    private readonly d;
-    private queue;
-    private queueConn;
+    private readonly kdb;
+    private readonly queue;
+    /**
+     * The host's hook registry: handlers of the current local plugin generations (through
+     * inflight.run), and `has("usage.report")`, the in-process check that lets `enqueue` skip all
+     * I/O without handlers; and whether a plugin's current instance is active here.
+     */
+    private readonly host;
+    private readonly config;
+    /** The warning throttle's markers (`capk:usage-warn:<plugin>:<kind>`, SET NX PX). */
+    private readonly locks;
+    private readonly log;
+    private readonly retry;
     private worker;
-    private workerConn;
     private closed;
     private readonly stopping;
-    constructor(d: UsageReporterDeps);
+    constructor(kdb: KernelDb, queue: Queue<UsageReportJob>, 
+    /**
+     * The host's hook registry: handlers of the current local plugin generations (through
+     * inflight.run), and `has("usage.report")`, the in-process check that lets `enqueue` skip all
+     * I/O without handlers; and whether a plugin's current instance is active here.
+     */
+    host: Pick<ExtensionHost, "hooks" | "current">, config: Pick<KernelConfigService, "get">, 
+    /** The warning throttle's markers (`capk:usage-warn:<plugin>:<kind>`, SET NX PX). */
+    locks: Pick<LockService, "lease">, log: Logger, retry?: UsageReportRetry);
+    private get db();
+    private get hooks();
+    /**
+     * Whether the plugin's current instance is active on this replica (I-2): an active instance that
+     * registered no `usage.report` handler is not a subscriber, and its target is dropped.
+     */
+    isActive(plugin: string): boolean;
+    /**
+     * Of these plugins, the ones no replica can serve right now (I-2): replicas report them (live
+     * `extension_replica_status` rows) and none has them loaded. Their targets are dropped at once
+     * instead of failing every attempt. See {@link queryUnservable}.
+     */
+    unservable(plugins: readonly string[]): Promise<Set<string>>;
+    /**
+     * Plugins that subscribe to `usage.report`, from deployment state (approved manifests in PG),
+     * not from this replica's loaded handlers. With `orgId`: only those the organization enabled.
+     * See {@link queryUsageSubscribers}.
+     */
+    subscribers(orgId?: string): Promise<Set<string>>;
     private jobOpts;
     /**
      * Enqueues the delivery of one `usage` event. Returns without a job when no plugin subscribes.
@@ -140,11 +155,20 @@ export declare class UsageReporter {
     sweep(opts?: {
         now?: number;
     }): Promise<number>;
-    /** Starts the worker (worker role only). Job lock and stalled detection follow the run queue. */
-    startWorker(): void;
-    /** Stops the worker (in-flight calls are aborted, their jobs requeued) and the queue. */
+    /**
+     * Starts consuming (worker role only): `worker` is the `@Processor` worker of
+     * {@link USAGE_REPORT_QUEUE} (built with the run queue's job lock and stalled detection).
+     */
+    startWorker(worker: Worker<UsageReportJob>): void;
+    /** The worker's `error` event. */
+    onError(err: Error): void;
+    /** A job failed (the worker's `failed` event): logs retries and the final failure. */
+    onFailed(j: Job<UsageReportJob> | undefined, err: Error): void;
+    /**
+     * Stops: no more enqueues, in-flight calls are aborted (their jobs requeued) and the worker
+     * closes. The queue itself closes with the application.
+     */
     stop(): Promise<void>;
-    private getQueue;
     /** The payload of one usage event, read from the log; null when the event no longer exists. */
     private payloadOf;
     /**
@@ -153,11 +177,29 @@ export declare class UsageReporter {
      * dropped can stay, so a plugin another execution delivered never comes back.
      */
     private writePending;
-    private process;
-    /** {@link UsageReporterDeps.unservable}; a lookup failure counts as "unknown" (keep retrying). */
-    private unservable;
+    /** One delivery job (the `@Processor` of {@link USAGE_REPORT_QUEUE} calls it). */
+    process(j: Job<UsageReportJob>, token: string | undefined): Promise<void>;
+    /** {@link unservable}; a lookup failure counts as "unknown" (keep retrying). */
+    private unservableOrNone;
     /** Logs a warning at most once per plugin and kind per minute (Redis key with a TTL). */
     private warnOnce;
     /** One handler call with its own signal (timeout or replica stop aborts it); rejects on either. */
     private call;
 }
+/**
+ * The usage sweeper (R13), every minute, once across replicas: {@link UsageReporter.sweep}.
+ * Replaces the maintenance scheduler `usage-report-sweep-every` (retired at worker start).
+ */
+export declare class UsageSweepJob {
+    private readonly reporter;
+    readonly lockService: LockService;
+    readonly log: KernelLogger;
+    constructor(reporter: Pick<UsageReporter, "sweep">, lockService: LockService, log: KernelLogger);
+    run(): Promise<void>;
+}
+/**
+ * `usage.report` delivery: the producer on every role; the consumer and the sweep ({@link UsageSweepJob})
+ * on the worker role (`WorkerModule`).
+ */
+export declare class UsageReportModule {
+}