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

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

@@ -1,20 +1,17 @@
-import type { Logger } from "@capybara-hq/plugin-sdk";
-import { type OnApplicationShutdown } from "@nestjs/common";
-import type { JobsOptions, Queue } from "bullmq";
-import type { KernelSchemaDb } from "../db/kernel-schema.js";
-import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import type { ConversationEvent } from "../conversations/events.js";
+import { UsageSubscribers } from "../extensions/usage-subscribers.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
-import { KernelEvents } from "../infra/events/kernel-events.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
 /**
- * The producer half of `usage.report` delivery for `model_usage` rows, and the queue's ids and job
- * options shared with the reporter (`usage-report.ts`). The `ctx.models` broker sits below the
- * extension host and must not register a queue there (CLI contexts that build the extensions
- * module never connect to Redis eagerly), so it only announces a row (`model_usage.recorded`) and
- * {@link ModelUsageJobs} enqueues it here.
+ * The producer half of `usage.report` delivery, and the queue's ids shared with the reporter
+ * (`usage-report.ts`): a delivery is owed in the transaction that writes the usage it reports
+ * (transactional outbox spec §8.1). It registers no queue (the outbox dispatcher adds the job), so
+ * the `ctx.models` broker below the extension host and the step writes can use it.
  */
 /** Queue of `usage.report` deliveries (no `:` in the name). */
 export declare const USAGE_REPORT_QUEUE = "cap-kernel-usage-report";
-/** The job name of every delivery. */
+/** The job name of every delivery (its outbox registry entry holds the job options). */
 export declare const USAGE_REPORT_JOB = "usage-report";
 /** One job per `usage` event (no `:`: conversation ids are UUIDs, seq is a number). */
 export declare const usageReportJobId: (conversationId: string, seq: number) => string;
@@ -42,47 +39,25 @@ export type UsageReportJob = ({
      */
     dropped?: Record<string, string>;
 };
-/** First attempt plus 5 retries (F11). */
-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;
-/** The delivery retry policy: 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 options of one delivery job: its id, the retry policy and the retention of finished jobs. */
-export declare function usageReportJobOpts(jobId: string, retry: UsageReportRetry, keepHours: number): JobsOptions;
-/**
- * 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: KernelSchemaDb, orgId?: string): Promise<Set<string>>;
 /**
- * Enqueues the `usage.report` delivery of `model_usage` rows on `model_usage.recorded` (fast path;
- * the reporter's sweep re-enqueues rows still unreported, so a lost event or enqueue is caught up).
+ * Owes `usage.report` deliveries in the caller's transaction, only while the deployment has a
+ * subscriber ({@link UsageSubscribers}): usage written while no plugin subscribes is never
+ * reported.
  */
-export declare class ModelUsageJobs implements OnApplicationShutdown {
+export declare class UsageReportJobs {
     private readonly kdb;
-    private readonly queue;
-    private readonly config;
-    private readonly log;
-    private readonly retry;
-    private readonly unsubscribe;
-    /** Set at shutdown: a late event enqueues nothing (the sweep offers the row later). */
-    private closed;
-    constructor(kdb: KernelDb, queue: Queue<UsageReportJob>, config: Pick<KernelConfigService, "get">, log: Logger, retry: UsageReportRetry | undefined, events: KernelEvents);
-    onApplicationShutdown(): void;
+    private readonly outbox;
+    private readonly subscribers;
+    readonly txHost: TransactionHost;
+    constructor(kdb: KernelDb, outbox: Pick<OutboxService, "add">, subscribers: Pick<UsageSubscribers, "any">, txHost: TransactionHost);
     /**
-     * Enqueues the delivery of one row (job `usage-model-<rowId>`). Without any subscriber nothing is
-     * enqueued (the sweep marks the row). Never throws: a failure only logs; the sweep catches up.
+     * Owes the delivery of every `usage` event among `events` (the events this transaction wrote
+     * to the conversation's log), job `usage-<conversationId>-<seq>`.
      */
-    enqueue(usageId: string): Promise<void>;
+    oweEvents(conversationId: string, events: readonly ConversationEvent[]): Promise<void>;
+    /** Owes the delivery of one `model_usage` row (job `usage-model-<rowId>`). */
+    oweModelUsage(usageId: string, orgId: string): Promise<void>;
 }
-/** The usage report queue and its `model_usage` producer (no dependency on the extension host). */
+/** The usage report producer (no queue, no dependency on the extension host). */
 export declare class UsageReportJobsModule {
 }

package/dist/runtime/usage-report-jobs.js

@@ -7,152 +7,100 @@ 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 { getQueueToken } from "@nestjs/bullmq";
-import { Inject, Injectable, Module, Optional } from "@nestjs/common";
-import { sql } from "kysely";
-import { enabledExtensionsQuery } from "../extensions/enabled.js";
-import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { Inject, Injectable, Module } from "@nestjs/common";
+import { UsageSubscribers, UsageSubscribersModule } from "../extensions/usage-subscribers.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
-import { KernelEvents } from "../infra/events/kernel-events.js";
-import { QueueModule } from "../infra/queue/queue.module.js";
-import { KERNEL_LOGGER } from "../infra/tokens.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
 /**
- * The producer half of `usage.report` delivery for `model_usage` rows, and the queue's ids and job
- * options shared with the reporter (`usage-report.ts`). The `ctx.models` broker sits below the
- * extension host and must not register a queue there (CLI contexts that build the extensions
- * module never connect to Redis eagerly), so it only announces a row (`model_usage.recorded`) and
- * {@link ModelUsageJobs} enqueues it here.
+ * The producer half of `usage.report` delivery, and the queue's ids shared with the reporter
+ * (`usage-report.ts`): a delivery is owed in the transaction that writes the usage it reports
+ * (transactional outbox spec §8.1). It registers no queue (the outbox dispatcher adds the job), so
+ * the `ctx.models` broker below the extension host and the step writes can use it.
  */
 /** Queue of `usage.report` deliveries (no `:` in the name). */
 export const USAGE_REPORT_QUEUE = "cap-kernel-usage-report";
-/** The job name of every delivery. */
+/** The job name of every delivery (its outbox registry entry holds the job options). */
 export const USAGE_REPORT_JOB = "usage-report";
 /** One job per `usage` event (no `:`: conversation ids are UUIDs, seq is a number). */
 export const usageReportJobId = (conversationId, seq) => `usage-${conversationId}-${seq}`;
 /** One job per `model_usage` row (spec B §5.4; row ids are UUIDs, so no clash with the above). */
 export const modelUsageJobId = (usageId) => `usage-model-${usageId}`;
-/** First attempt plus 5 retries (F11). */
-export const USAGE_REPORT_ATTEMPTS = 6;
-/** Retry backoff: 2 s, doubling (2, 4, 8, 16, 32 s). */
-export const USAGE_REPORT_BACKOFF_MS = 2000;
-/** Optional provider: the {@link UsageReportRetry} instead of the defaults above (tests). */
-export const USAGE_REPORT_RETRY = Symbol("USAGE_REPORT_RETRY");
-/** Failed jobs (given up) are kept for inspection, at most {@link KEEP_FAILED_MAX} of them. */
-const KEEP_FAILED_S = 7 * 86_400;
-/** Upper bound on kept failed jobs (I-2): a long outage of a billing endpoint cannot grow Redis. */
-const KEEP_FAILED_MAX = 100_000;
 /**
- * Upper bound on kept finished jobs (Redis memory). At the default retention it only bites above
- * ~1.1 usage events per second sustained for a day; dedupe needs the jobs only for the sweeper overlap.
+ * Owes `usage.report` deliveries in the caller's transaction, only while the deployment has a
+ * subscriber ({@link UsageSubscribers}): usage written while no plugin subscribes is never
+ * reported.
  */
-const KEEP_COMPLETED_MAX = 100_000;
-/** The options of one delivery job: its id, the retry policy and the retention of finished jobs. */
-export function usageReportJobOpts(jobId, retry, keepHours) {
-    return {
-        jobId,
-        attempts: retry.attempts,
-        backoff: { type: "exponential", delay: retry.backoffMs },
-        removeOnComplete: { age: keepHours * 3600, count: KEEP_COMPLETED_MAX },
-        removeOnFail: { age: KEEP_FAILED_S, count: KEEP_FAILED_MAX },
-    };
-}
-/**
- * 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 async function queryUsageSubscribers(db, orgId) {
-    let q = db
-        .selectFrom("extension_permission_snapshots as s")
-        .select("s.plugin")
-        .where(sql `s.permissions -> 'permissions' -> 'hooks' ? 'usage.report'`)
-        .where((eb) => eb.or([
-        eb.exists(eb
-            .selectFrom("extension_installs as i")
-            .select(sql `1`.as("one"))
-            .whereRef("i.name", "=", "s.plugin")
-            .where("i.desired_state", "=", "enabled")),
-        // config-declared plugins still declared (and not unloaded) on some replica; installs are
-        // covered by desired_state above (their replica rows linger as `unloaded` when disabled)
-        eb.exists(eb
-            .selectFrom("extension_replica_status as r")
-            .select(sql `1`.as("one"))
-            .whereRef("r.plugin", "=", "s.plugin")
-            .where("r.source", "=", "config")
-            .where("r.state", "<>", "unloaded")),
-    ]));
-    if (orgId !== undefined) {
-        q = q.where("s.plugin", "in", enabledExtensionsQuery(db, orgId));
-    }
-    return new Set((await q.execute()).map((r) => r.plugin));
-}
-/**
- * Enqueues the `usage.report` delivery of `model_usage` rows on `model_usage.recorded` (fast path;
- * the reporter's sweep re-enqueues rows still unreported, so a lost event or enqueue is caught up).
- */
-let ModelUsageJobs = class ModelUsageJobs {
+let UsageReportJobs = class UsageReportJobs {
     kdb;
-    queue;
-    config;
-    log;
-    retry;
-    unsubscribe;
-    /** Set at shutdown: a late event enqueues nothing (the sweep offers the row later). */
-    closed = false;
-    constructor(kdb, queue, config, log, retry = {
-        attempts: USAGE_REPORT_ATTEMPTS,
-        backoffMs: USAGE_REPORT_BACKOFF_MS,
-    }, events) {
+    outbox;
+    subscribers;
+    txHost;
+    constructor(kdb, outbox, subscribers, txHost) {
         this.kdb = kdb;
-        this.queue = queue;
-        this.config = config;
-        this.log = log;
-        this.retry = retry;
-        this.unsubscribe = events.on("model_usage.recorded", ({ id }) => this.enqueue(id));
-    }
-    onApplicationShutdown() {
-        this.closed = true;
-        this.unsubscribe();
+        this.outbox = outbox;
+        this.subscribers = subscribers;
+        this.txHost = txHost;
     }
     /**
-     * Enqueues the delivery of one row (job `usage-model-<rowId>`). Without any subscriber nothing is
-     * enqueued (the sweep marks the row). Never throws: a failure only logs; the sweep catches up.
+     * Owes the delivery of every `usage` event among `events` (the events this transaction wrote
+     * to the conversation's log), job `usage-<conversationId>-<seq>`.
      */
-    async enqueue(usageId) {
-        if (this.closed)
+    async oweEvents(conversationId, events) {
+        const usage = events.filter((e) => e.type === "usage");
+        if (usage.length === 0 || !(await this.subscribers.any()))
             return;
-        try {
-            if ((await queryUsageSubscribers(this.kdb.db)).size === 0)
-                return;
-            await this.queue.add(USAGE_REPORT_JOB, { usageId }, usageReportJobOpts(modelUsageJobId(usageId), this.retry, this.config.get().hooks.usageReportKeepHours));
-        }
-        catch (err) {
-            this.log.warn("cannot enqueue model usage report", { usageId, err });
+        const conv = await this.kdb.db
+            .selectFrom("conversations")
+            .select("org_id")
+            .where("id", "=", conversationId)
+            .executeTakeFirst();
+        for (const e of usage) {
+            await this.outbox.add({
+                queue: USAGE_REPORT_QUEUE,
+                name: USAGE_REPORT_JOB,
+                jobId: usageReportJobId(conversationId, e.seq),
+                data: { conversationId, seq: e.seq },
+                ...(conv !== undefined && { orgId: conv.org_id }),
+            });
         }
     }
+    /** Owes the delivery of one `model_usage` row (job `usage-model-<rowId>`). */
+    async oweModelUsage(usageId, orgId) {
+        if (!(await this.subscribers.any()))
+            return;
+        await this.outbox.add({
+            queue: USAGE_REPORT_QUEUE,
+            name: USAGE_REPORT_JOB,
+            jobId: modelUsageJobId(usageId),
+            data: { usageId },
+            orgId,
+        });
+    }
 };
-ModelUsageJobs = __decorate([
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], UsageReportJobs.prototype, "oweEvents", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], UsageReportJobs.prototype, "oweModelUsage", null);
+UsageReportJobs = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
-    __param(1, Inject(getQueueToken(USAGE_REPORT_QUEUE))),
-    __param(2, Inject(KernelConfigService)),
-    __param(3, Inject(KERNEL_LOGGER)),
-    __param(4, Optional()),
-    __param(4, Inject(USAGE_REPORT_RETRY)),
-    __param(5, Inject(KernelEvents))
-], ModelUsageJobs);
-export { ModelUsageJobs };
-/** The usage report queue's registration, shared by the producer and the reporter's module. */
-const USAGE_REPORT_QUEUE_MODULE = QueueModule.registerQueue(USAGE_REPORT_QUEUE);
-/** The usage report queue and its `model_usage` producer (no dependency on the extension host). */
+    __param(1, Inject(OutboxService)),
+    __param(2, Inject(UsageSubscribers)),
+    __param(3, Inject(TransactionHost))
+], UsageReportJobs);
+export { UsageReportJobs };
+/** The usage report producer (no queue, no dependency on the extension host). */
 let UsageReportJobsModule = class UsageReportJobsModule {
 };
 UsageReportJobsModule = __decorate([
     Module({
-        imports: [USAGE_REPORT_QUEUE_MODULE],
-        providers: [ModelUsageJobs],
-        exports: [ModelUsageJobs, USAGE_REPORT_QUEUE_MODULE],
+        imports: [UsageSubscribersModule],
+        providers: [UsageReportJobs],
+        exports: [UsageReportJobs],
     })
 ], UsageReportJobsModule);
 export { UsageReportJobsModule };

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

@@ -5,21 +5,9 @@ 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";
-import { type UsageReportJob, type UsageReportRetry } from "./usage-report-jobs.js";
-export { ModelUsageJobs, modelUsageJobId, queryUsageSubscribers, USAGE_REPORT_ATTEMPTS, USAGE_REPORT_BACKOFF_MS, USAGE_REPORT_QUEUE, USAGE_REPORT_RETRY, type UsageReportJob, UsageReportJobsModule, type UsageReportRetry, usageReportJobId, } from "./usage-report-jobs.js";
-/** The sweeper's cron job name (no `:`; every minute, once across replicas). */
-export declare const USAGE_SWEEP_JOB = "usage-report-sweep";
-/** 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;
-/**
- * Each sweep re-scans this far behind the watermark: events whose transaction committed after a
- * previous sweep passed their `created_at` are still found. Far inside the dedupe window
- * (`hooks.usageReportKeepHours` ≥ 1 h), so re-enqueued events dedupe on the kept job.
- */
-export declare const USAGE_SWEEP_OVERLAP_MS: number;
+import { type UsageReportJob } from "./usage-report-jobs.js";
+export { queryUsageSubscribers } from "../extensions/usage-subscribers.js";
+export { modelUsageJobId, USAGE_REPORT_JOB, USAGE_REPORT_QUEUE, type UsageReportJob, UsageReportJobs, UsageReportJobsModule, usageReportJobId, } from "./usage-report-jobs.js";
 /**
  * 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
@@ -35,14 +23,16 @@ export declare function queryUnservable(db: KernelSchemaDb, plugins: readonly st
  */
 export declare function narrowPending(stored: readonly string[] | undefined, failed: readonly string[]): string[];
 /**
- * Reliable `usage.report` delivery (F11, P-17, R13). Every `usage` event written to the event log (chat
- * runs and full-run eval replays) is delivered at least once to every subscribing plugin.
- * - **Fast path:** `model-call` enqueues job `usage-<conversationId>-<seq>` right after writing the event
- *   (never awaited; an enqueue failure only logs). Skipped without I/O when this replica has no
- *   `usage.report` handler (M-2); the sweeper then offers the event.
- * - **Sweeper (R13):** a maintenance job (once across replicas, every minute) re-enqueues the `usage`
- *   events in `[watermark - 10 min, now - 30 s]` with the same job ids, so a lost fast-path enqueue is
- *   caught up and duplicates dedupe on the kept job (`hooks.usageReportKeepHours`).
+ * Reliable `usage.report` delivery (F11, P-17, transactional outbox spec §8.1). Every `usage` event
+ * written to the event log (chat runs and full-run eval replays) is delivered at least once to every
+ * subscribing plugin.
+ * - **Owed with the usage:** the transaction that writes a `usage` event (`StepLog`'s step writes, a
+ *   title's writes) or a `model_usage` row also writes the outbox row of job
+ *   `usage-<conversationId>-<seq>` / `usage-model-<rowId>` (`UsageReportJobs`), while the deployment
+ *   has at least one subscriber (`UsageSubscribers`: from PG, whatever this replica loaded; cached
+ *   30 s per replica, cleared on `PLUGINS_CHANGED`). The outbox fast path adds the job after the
+ *   commit and the relay catches up what it did not. Usage written while no plugin subscribed is
+ *   never reported: a subscription starts when the plugin is enabled.
  * - **Worker** (worker role, `hooks.usageReportConcurrency` per replica): reads the payload from the log
  *   at execution time (the `usage` event, the conversation with `kind`, the run). On the first attempt
  *   the targets are the deployment's subscribers the organization enabled (I-2: not this replica's
@@ -54,49 +44,45 @@ export declare function narrowPending(stored: readonly string[] | undefined, fai
  *   once (I-2). A drop (N-3) is never silent: after delivering to the other targets the job ends
  *   failed with an `UnrecoverableError` whose failedReason names the dropped plugins, plus a
  *   throttled warning. Plugins the organization disabled by delivery time are dropped silently (not
- *   targets any more). The final failure logs an error (no audit); failed jobs are kept 7 days, at
- *   most 100 000. Each call runs through the instance's `inflight.run`, limited by `hooks.timeoutMs`;
- *   when this replica stops, in-flight calls are aborted and the job goes back to the queue without
- *   using up an attempt.
+ *   targets any more). The final failure logs an error (no audit); finished jobs are kept a day and
+ *   failed jobs 7 days, at most 100 000 each (the outbox registry's `usage-report` options). Each
+ *   call runs through the instance's `inflight.run`, limited by `hooks.timeoutMs`; when this
+ *   replica stops, in-flight calls are aborted and the job goes back to the queue without using up
+ *   an attempt.
  * Handlers must be idempotent by `eventId` (`<conversationId>/<seq>`, or a `model_usage` row id).
  * Nothing is written to the event log (never model-visible). Compaction calls log usage too (`purpose: "compaction"`) and are reported,
  * as are conversation title calls (`purpose: "title"`, no run: `runId` is "") and `WebFetch`
  * extraction calls (`purpose: "web_fetch"`).
  * Single-step eval replays and judge requests log no usage: not reported (M7).
  * - **Model usage outside conversations** (spec B §5.4): each `ctx.models.embed` call writes a
- *   `model_usage` row; on its `model_usage.recorded` event `ModelUsageJobs` (`usage-report-jobs.ts`)
- *   enqueues job `usage-model-<rowId>` (only while some plugin subscribes); the payload
+ *   `model_usage` row and owes job `usage-model-<rowId>` with it; the payload
  *   (`purpose: "embedding"`, `eventId` = the row id, the calling `extension`, no conversation fields)
  *   is read from the row when the job runs, and the row's `reported_at` is set once nothing is left
- *   to deliver; a job that gives up after its last attempt sets `report_failed_at`. The sweep
- *   re-enqueues recent rows that are neither (see {@link sweep}).
+ *   to deliver; a job that gives up after its last attempt sets `report_failed_at`.
  */
 export declare class UsageReporter {
     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.
+     * inflight.run); 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 closed;
     private readonly stopping;
     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.
+     * inflight.run); 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);
+    locks: Pick<LockService, "lease">, log: Logger);
     private get db();
     private get hooks();
     /**
@@ -116,30 +102,6 @@ export declare class UsageReporter {
      * 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.
-     * Never throws: an enqueue failure (e.g. a Redis hiccup) only logs a warning; the sweeper catches up.
-     */
-    enqueue(conversationId: string, seq: number): Promise<void>;
-    /**
-     * One sweep (R13): re-enqueues the `usage` events created in `[watermark - overlap, now - lag]` in
-     * pages, then advances the watermark to `now - lag`. With no subscriber it only advances. The first
-     * sweep starts at `now - lag - overlap`. Also re-enqueues the `model_usage` rows of the same
-     * window that are neither reported nor given up (spec B §5.4),
-     * or, with no subscriber, marks those rows reported (nobody to deliver to). Returns the number of
-     * events and rows offered to the queue.
-     */
-    sweep(opts?: {
-        now?: number;
-    }): Promise<number>;
-    /**
-     * The `model_usage` half of {@link sweep}: rows neither reported nor given up that occurred in
-     * the same window as the events (`[watermark - overlap, to]`), oldest first. Bounded like the
-     * event sweep, so a row whose job failed for good is never offered again, even after its failed
-     * job left Redis (no repeated backlog, no second delivery to plugins already served).
-     */
-    private sweepModelUsage;
     /**
      * 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).
@@ -150,8 +112,8 @@ export declare class UsageReporter {
     /** 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.
+     * Stops: in-flight calls are aborted (their jobs requeued) and the worker closes. The queue
+     * itself closes with the application.
      */
     stop(): Promise<void>;
     /** The payload of a job: a `usage` event's or a `model_usage` row's; null when it is gone. */
@@ -163,7 +125,7 @@ export declare class UsageReporter {
     private payloadOfUsage;
     /** A `model_usage` job is done (delivered, or nothing left to deliver to): marks the row. */
     private markReported;
-    /** A `model_usage` job gave up after its last attempt: the sweep never offers the row again. */
+    /** A `model_usage` job gave up after its last attempt: the row records it. */
     private markFailed;
     /** The payload of one usage event, read from the log; null when the event no longer exists. */
     private payloadOf;
@@ -183,19 +145,8 @@ export declare class UsageReporter {
     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`).
+ * `usage.report` delivery: the producer (`UsageReportJobs`) and the queue on every role; the
+ * consumer's `@Processor` on the worker role (`WorkerModule`).
  */
 export declare class UsageReportModule {
 }