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

package/dist/devices/devices.service.js

@@ -15,18 +15,17 @@ import { ApiError } from "../errors.js";
 import { ExtensionDisplayNames } from "../extensions/display-name.js";
 import { audit } from "../identity/audit.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
-import { afterCommit } from "../infra/database/after-commit.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 { LockService } from "../infra/lock/lock.service.js";
-import { KERNEL_LOGGER } from "../infra/tokens.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
 import { DevicePolicyService } from "../local-devices/device-policy.service.js";
 import { deviceLeaseKey } from "../local-devices/keys.js";
 import { MachinesService } from "../local-devices/machines.js";
 import { deviceFeaturesOf, localPolicyOf } from "../local-devices/policy-summary.js";
 import { readOrgSettings } from "../orgs/settings.service.js";
-import { SandboxJobs } from "../sandbox/jobs.js";
+import { oweDeviceDestroy, SandboxJobs } from "../sandbox/jobs.js";
 import { isInternalProvider, LOCAL_PROVIDER, SandboxProviders } from "../sandbox/providers.js";
 import { deviceNotFound, SandboxService } from "../sandbox/sandbox.service.js";
 import { effectiveSandboxPolicy, readDeploymentSandboxPolicy, } from "../sandbox/tiers.js";
@@ -43,8 +42,8 @@ const nameTaken = () => new ApiError("device.name_taken", "You already have a de
  * Personal devices (spec 2026-11-07-environments-design §4.2 items 7, 12, 13; §6; §9):
  * cloud ones on the deployment's sandbox provider and `device` ones on a connected machine; a
  * person's devices in an org, visible and usable only by their owner (anyone else gets
- * `device.not_found`). Deleting one soft-deletes it and destroys its instance and files in a
- * `sandbox-destroy-for` job after the commit.
+ * `device.not_found`). Deleting one soft-deletes it and owes the destruction of its instance and
+ * files (a `sandbox-destroy-for` job) in the same transaction.
  */
 let DevicesService = class DevicesService {
     db;
@@ -53,13 +52,15 @@ let DevicesService = class DevicesService {
     providers;
     sandbox;
     sandboxJobs;
+    outbox;
     access;
     displayNames;
-    log;
     locks;
     machines;
     policies;
-    constructor(db, txHost, config, providers, sandbox, sandboxJobs, access, displayNames, log, 
+    constructor(db, txHost, config, providers, sandbox, sandboxJobs, 
+    /** Owes a deleted device's destruction in the delete's transaction. */
+    outbox, access, displayNames, 
     /** Reads the device relay's lease (`online`). */
     locks, machines, policies) {
         this.db = db;
@@ -68,9 +69,9 @@ let DevicesService = class DevicesService {
         this.providers = providers;
         this.sandbox = sandbox;
         this.sandboxJobs = sandboxJobs;
+        this.outbox = outbox;
         this.access = access;
         this.displayNames = displayNames;
-        this.log = log;
         this.locks = locks;
         this.machines = machines;
         this.policies = policies;
@@ -388,9 +389,9 @@ let DevicesService = class DevicesService {
         });
     }
     /**
-     * Deletes one of the person's live devices: soft delete, its IM default row cleared, and
-     * after the commit a `sandbox-destroy-for` job (the worker waits for running commands, then
-     * destroys the instance and the files). Conversations bound to it keep pointing at it; their
+     * Deletes one of the person's live devices: soft delete, its IM default row cleared, and a
+     * `sandbox-destroy-for` job owed in the same transaction (`device-destroy-<deviceId>`; the
+     * worker waits for running commands, then destroys the instance and the files). Conversations bound to it keep pointing at it; their
      * sandbox tools then fail with `device.not_found`. A local device's machine is
      * revoked in the same transaction; after the commit it is told `stop { reason: "deleted" }`
      * (while connected) and its connection is closed.
@@ -417,15 +418,7 @@ let DevicesService = class DevicesService {
             target: id,
             detail: { name: before.name, isDefault: before.is_default, ...auditDetail },
         });
-        afterCommit(async () => {
-            try {
-                await this.sandboxJobs.destroy([id]);
-            }
-            catch (err) {
-                // the hourly destruction sweep destroys deleted devices too
-                this.log.warn("cannot schedule device destruction", { deviceId: id, err });
-            }
-        });
+        await oweDeviceDestroy(this.outbox, id, orgId);
     }
     /**
      * Disconnects the machine of one of the person's own local devices (it must sign in
@@ -1021,9 +1014,9 @@ DevicesService = __decorate([
     __param(3, Inject(SandboxProviders)),
     __param(4, Inject(SandboxService)),
     __param(5, Inject(SandboxJobs)),
-    __param(6, Inject(DeviceAccess)),
-    __param(7, Inject(ExtensionDisplayNames)),
-    __param(8, Inject(KERNEL_LOGGER)),
+    __param(6, Inject(OutboxService)),
+    __param(7, Inject(DeviceAccess)),
+    __param(8, Inject(ExtensionDisplayNames)),
     __param(9, Inject(LockService)),
     __param(10, Inject(MachinesService)),
     __param(11, Inject(DevicePolicyService))
@@ -1055,7 +1048,16 @@ const tierOrNull = (v) => v === "strict" || v === "dev" || v === "open" ? v : nu
 function sandboxChangeOf(action, at, d, by) {
     const hosts = (v) => Array.isArray(v) ? v.filter((h) => typeof h === "string") : [];
     const isolation = d.isolation === "sandbox" || d.isolation === "none" ? d.isolation : null;
-    const base = { at: at.toISOString(), add: [], remove: [], tier: null, isolation: null, by };
+    const base = {
+        at: at.toISOString(),
+        add: [],
+        remove: [],
+        tier: null,
+        isolation: null,
+        localhost: null,
+        remoteGrants: null,
+        by,
+    };
     if (action === "device.tier_changed") {
         return { ...base, kind: "tier", tier: { to: tierOrNull(d.to) }, via: "web", confirmed: true };
     }
@@ -1068,9 +1070,15 @@ function sandboxChangeOf(action, at, d, by) {
         add: hosts(d.add),
         remove: hosts(d.remove),
         // the key is there only when the change set the tier (null: follow the org's default)
-        tier: "tier" in d ? { to: tierOrNull(d.tier) } : null,
+        tier: "tier" in d
+            ? { ...("tierFrom" in d && { from: tierOrNull(d.tierFrom) }), to: tierOrNull(d.tier) }
+            : null,
         isolation,
-        via: d.via === "im" ? "im" : "web",
+        localhost: d.localhost === "on" || d.localhost === "off-proxy-detected" || d.localhost === "off"
+            ? d.localhost
+            : null,
+        remoteGrants: d.remoteGrants === "owner" || d.remoteGrants === "off" ? d.remoteGrants : null,
+        via: d.via === "im" ? "im" : d.via === "device" ? "device" : "web",
         confirmed: d.confirmed === true,
     };
 }

package/dist/errors.d.ts

@@ -225,10 +225,17 @@ export declare const ERROR_CODES: {
     readonly "plugin.upgrade_stale": 409;
     readonly "plugin.upgrade_target_invalid": 409;
     readonly "plugin.upgrade_failed": 502;
+    /**
+     * The platform's import and update imported the version but the update failed: the platform
+     * stays on its version, the imported version is in the catalog (retry with the plain update).
+     */
+    readonly "plugin.imported_not_updated": 409;
     readonly "setup.already_completed": 409;
     readonly "setup.token_invalid": 403;
     /** The admin overview's seven-day usage aggregate ran past its statement timeout (spec §5.5). */
     readonly "admin.usage_unavailable": 503;
+    /** No dead outbox row has this id (delivered, discarded, retried, or never dead). */
+    readonly "outbox.not_found": 404;
     readonly "agent.not_found": 404;
     readonly "agent.version_conflict": 409;
     /** The profile was changed since the client read it (`expectedUpdatedAt` is stale). */
@@ -319,6 +326,10 @@ export declare const ERROR_CODES: {
     readonly "attachment.too_many_pending": 429;
     readonly "sandbox.unavailable": 503;
     readonly "sandbox.busy": 409;
+    /** A cloud sandbox provider refused the device's tier (its config refuses open egress). */
+    readonly "sandbox.tier_refused": 409;
+    /** A cloud sandbox provider failed to create a device's sandbox for another reason. */
+    readonly "sandbox.create_failed": 502;
     /** A sandbox file path the kernel reads is not absolute or not under the sandbox roots. */
     readonly "sandbox.file_invalid_path": 422;
     /** No file at the sandbox path the kernel reads. */

package/dist/errors.js

@@ -225,10 +225,17 @@ export const ERROR_CODES = {
     "plugin.upgrade_stale": 409,
     "plugin.upgrade_target_invalid": 409,
     "plugin.upgrade_failed": 502,
+    /**
+     * The platform's import and update imported the version but the update failed: the platform
+     * stays on its version, the imported version is in the catalog (retry with the plain update).
+     */
+    "plugin.imported_not_updated": 409,
     "setup.already_completed": 409,
     "setup.token_invalid": 403,
     /** The admin overview's seven-day usage aggregate ran past its statement timeout (spec §5.5). */
     "admin.usage_unavailable": 503,
+    /** No dead outbox row has this id (delivered, discarded, retried, or never dead). */
+    "outbox.not_found": 404,
     "agent.not_found": 404,
     "agent.version_conflict": 409,
     /** The profile was changed since the client read it (`expectedUpdatedAt` is stale). */
@@ -319,6 +326,10 @@ export const ERROR_CODES = {
     "attachment.too_many_pending": 429,
     "sandbox.unavailable": 503,
     "sandbox.busy": 409,
+    /** A cloud sandbox provider refused the device's tier (its config refuses open egress). */
+    "sandbox.tier_refused": 409,
+    /** A cloud sandbox provider failed to create a device's sandbox for another reason. */
+    "sandbox.create_failed": 502,
     /** A sandbox file path the kernel reads is not absolute or not under the sandbox roots. */
     "sandbox.file_invalid_path": 422,
     /** No file at the sandbox path the kernel reads. */

package/dist/evals/run-replay.d.ts

@@ -1,4 +1,4 @@
-import { type ContentBlock, type Logger, type ModelUsage, type StopReason } from "@capybara-hq/plugin-sdk";
+import { type ContentBlock, type ConversationSource, type Logger, type ModelUsage, type StopReason } from "@capybara-hq/plugin-sdk";
 import { type ModelRef } from "../agents/definition.js";
 import { EventLog } from "../conversations/event-log.js";
 import type { KernelSchemaDb } from "../db/kernel-schema.js";
@@ -98,6 +98,8 @@ export interface ReplaySeed {
     evalRunId: string;
     orgId: string;
     agentId: string;
+    /** The original conversation's source: the replay offers the tools of this source. */
+    source: ConversationSource;
     accountId: string;
     conversationId: string;
     runId: string;
@@ -121,11 +123,20 @@ export interface ReplaySeed {
     runContext: {
         payload: unknown;
     } | undefined;
+    /**
+     * The original run's `plugin_context` events (memory spec §6.1), in log order, copied as is:
+     * replays never call context providers.
+     */
+    pluginContexts: {
+        payload: {
+            plugin: string;
+        };
+    }[];
 }
 /**
  * The seed of a full-run replay (C6): the `kind = 'eval'` conversation with the events before the
  * original run at their original seqs, the run row and its `run_started` (and the original
- * `skills_catalog`), in one transaction of its own.
+ * `skills_catalog`, `run_context` and `plugin_context` events), in one transaction of its own.
  */
 export declare class EvalReplaySeeder {
     private readonly db;

package/dist/evals/run-replay.js

@@ -18,7 +18,9 @@ import { ApiError } from "../errors.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 { pluginContextIdemKey } from "../runtime/context/plugin-context.js";
 import { estimateTokens } from "../runtime/context/tokens.js";
+import { runDeadline, tightestLimit } from "../runtime/limits.js";
 import { RunError } from "../runtime/model-call.js";
 import { runContextIdemKey } from "../runtime/run-context.service.js";
 import { recordedSkillForks } from "../runtime/subagents/skill-fork.js";
@@ -35,7 +37,7 @@ export class ReplayClaimLost extends Error {
 /**
  * The seed of a full-run replay (C6): the `kind = 'eval'` conversation with the events before the
  * original run at their original seqs, the run row and its `run_started` (and the original
- * `skills_catalog`), in one transaction of its own.
+ * `skills_catalog`, `run_context` and `plugin_context` events), in one transaction of its own.
  */
 let EvalReplaySeeder = class EvalReplaySeeder {
     db;
@@ -73,6 +75,7 @@ let EvalReplaySeeder = class EvalReplaySeeder {
             consumed_seq: p.consumed,
             kind: "eval",
             eval_run_id: evalRunId,
+            source: p.source,
         })
             .execute();
         for (let i = 0; i < p.seeds.length; i += SEED_BATCH) {
@@ -132,6 +135,12 @@ let EvalReplaySeeder = class EvalReplaySeeder {
                     },
                 ]
                 : []),
+            ...p.pluginContexts.map((c) => ({
+                type: "plugin_context",
+                runId,
+                idemKey: pluginContextIdemKey(runId, c.payload.plugin),
+                payload: c.payload,
+            })),
         ]);
         if (onSeeded && !(await onSeeded(conversationId)))
             throw new ReplayClaimLost();
@@ -332,6 +341,9 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
     const trigger = replayTrigger(start.payload, seeds, consumed);
     const catalog = s.events.find((e) => e.runId === s.runId && e.type === "skills_catalog" && e.seq > R);
     const runContext = s.events.find((e) => e.runId === s.runId && e.type === "run_context" && e.seq > R);
+    const pluginContexts = s.events
+        .filter((e) => e.runId === s.runId && e.type === "plugin_context" && e.seq > R)
+        .map((e) => ({ payload: e.payload }));
     // a sub-agent's case (spec §15.3) runs the effective definition frozen in its subagent_started
     // (the request renders that event's preamble and instructions; its tools come from it too), with
     // only the candidate's model and params, and the logged step limit
@@ -347,12 +359,16 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
     const forkRun = triggerEvent?.type === "user_message" &&
         triggerEvent.payload.skill !== undefined &&
         triggerEvent.payload.dispatch !== undefined;
+    // the original conversation's source (recorded in the case); a case taken before it was
+    // recorded replays as its run did by default: a web conversation, or a sub-agent's for a child
+    const source = s.source ?? (subagent === undefined ? "web" : "subagent");
     const conversationId = randomUUID();
     const runId = randomUUID();
     await d.seeder.seed({
         evalRunId,
         orgId: s.orgId,
         agentId: s.agentId,
+        source,
         accountId,
         conversationId,
         runId,
@@ -364,6 +380,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         model: agent.model,
         catalog,
         runContext,
+        pluginContexts,
     }, d.onSeeded);
     await d.hooks?.afterRunSeeded?.(evalRunId, conversationId);
     // 停止：取消 / 越限 / 熔断 / 失去认领 / 截止时间 → 中止 loop（进行中的请求立即停下，loop 以 aborted 返回）
@@ -526,16 +543,28 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         return out;
     };
     const runtime = d.config.get().runtime;
-    const deadline = Date.now() + runtime.maxRunSeconds * 1000;
+    // 0 in the config or the logged child limit = no limit there
+    const maxSteps = tightestLimit(subagent?.maxSteps, runtime.maxSteps);
+    // `runtime.maxRunSeconds` 0: no deadline and no timer
+    const deadline = runDeadline(Date.now(), runtime.maxRunSeconds);
     let deadlineHit = false;
-    const timer = setTimeout(() => {
-        deadlineHit = true;
-        stopper.abort();
-    }, Math.max(0, deadline - Date.now()));
-    timer.unref();
+    const timer = deadline === undefined
+        ? undefined
+        : setTimeout(() => {
+            deadlineHit = true;
+            stopper.abort();
+        }, Math.max(0, deadline - Date.now()));
+    timer?.unref();
     // a fork invocation's report is the recorded one: a replay never dispatches a sub-agent (A5)
     const skillForks = recordedSkillForks(eventLog, s.events.filter((e) => e.runId === s.runId));
     const loop = d.loop({ toolPipeline: pipeline, registry, skillForks, ...(media && { media }) });
+    // a replay never executes a tool, so the role only completes the context
+    const membership = await db
+        .selectFrom("memberships")
+        .select("role")
+        .where("org_id", "=", s.orgId)
+        .where("account_id", "=", accountId)
+        .executeTakeFirst();
     let outcome;
     try {
         outcome = await loop.run({
@@ -544,6 +573,10 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
             runId,
             agentId: s.agentId,
             triggerAccountId: accountId,
+            // the seeded conversation's source (the original's): its tools are the original's
+            source,
+            ownerAccountId: accountId,
+            role: membership?.role ?? "guest",
             agent,
             agentVersion: candidate.agentVersion,
             signal: loopSignal,
@@ -551,8 +584,8 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
             sink: () => { },
             pendingAbsorbable,
             limits: {
-                maxSteps: subagent === undefined ? runtime.maxSteps : Math.min(subagent.maxSteps, runtime.maxSteps),
-                deadline,
+                ...(maxSteps !== undefined && { maxSteps }),
+                ...(deadline !== undefined && { deadline }),
             },
             // replays never fire plugin hooks (the loop deps omit them too, P-18)
             conversationKind: "eval",

package/dist/evals/snapshot.d.ts

@@ -1,4 +1,4 @@
-import type { ToolSpec } from "@capybara-hq/plugin-sdk";
+import type { ConversationSource, ToolSpec } from "@capybara-hq/plugin-sdk";
 import { type AgentDefinition } from "../agents/definition.js";
 import type { ConversationEvent, ConversationEventType } from "../conversations/events.js";
 import type { KernelSchemaDb } from "../db/kernel-schema.js";
@@ -21,6 +21,12 @@ export interface CaseSnapshot {
     runId: string;
     agentId: string;
     agentVersion: number;
+    /**
+     * The original conversation's source (memory plugin spec §6.2): a full-run replay offers the
+     * tools of this source. Cases taken before it was recorded have none (replayed as `web`, or as
+     * `subagent` for a child case).
+     */
+    source?: ConversationSource;
     /** seq ≤ 该运行终态事件的 seq，按 seq 升序。 */
     events: SnapshotEvent[];
     /** 事件里各次运行（`run_started`）与本运行引用的 agent 版本 → 定义。 */

package/dist/evals/snapshot.js

@@ -17,7 +17,7 @@ const PAGE = 1000;
 export async function takeSnapshot(db, orgId, conversationId, runId, maxBytes) {
     const conv = await db
         .selectFrom("conversations")
-        .select(["agent_id", "kind"])
+        .select(["agent_id", "kind", "source"])
         .where("id", "=", conversationId)
         .where("org_id", "=", orgId)
         .executeTakeFirst();
@@ -126,6 +126,7 @@ export async function takeSnapshot(db, orgId, conversationId, runId, maxBytes) {
         runId,
         agentId: conv.agent_id,
         agentVersion: run.agent_version,
+        source: conv.source,
         events,
         definitions,
         toolSpecs,

package/dist/extensions/extensions.module.js

@@ -28,6 +28,7 @@ import { SingleProviderGuard } from "./single-provider.js";
 import { ReplicaStatusStore } from "./sources.js";
 import { ExtensionStateModule } from "./state.module.js";
 import { ExtensionAvailability } from "./unavailable.js";
+import { UsageSubscribersModule } from "./usage-subscribers.js";
 /**
  * The extensions domain: the extension host (it builds each `ctx` from the injected kernel
  * services), the package store and install records (the desired state the host converges to, one
@@ -48,6 +49,8 @@ ExtensionsModule = __decorate([
             ExtensionStateModule,
             // ctx.models: the embeddings broker (models domain, below the host through ExtensionStateModule)
             ModelsModule,
+            // the lifecycle clears the `usage.report` subscriber cache on PLUGINS_CHANGED
+            UsageSubscribersModule,
         ],
         providers: [
             PluginInstallLock,

package/dist/extensions/hooks.d.ts

@@ -1,4 +1,4 @@
-import { type AvailableHook, type HookHandler, type HookOptions, type HookPayloads, type Logger, type PolicyHook } from "@capybara-hq/plugin-sdk";
+import { type AvailableHook, type HookHandler, type HookOptions, type HookPayloads, type LIFECYCLE_HOOKS, type Logger, type PolicyHook } from "@capybara-hq/plugin-sdk";
 import type { KernelConfig } from "../config/schema.js";
 import type { LockService } from "../infra/lock/lock.service.js";
 import { type EffectiveConfig } from "./effective-config.js";
@@ -63,7 +63,16 @@ export interface HookSource {
     readonly name: string;
     readonly hooks: readonly RegisteredHook[];
     readonly inflight: InflightTracker;
+    /** The instance's platform deployment config (what lifecycle hooks are called with). */
+    readonly config?: unknown;
 }
+/** A lifecycle mount: an observe-only notice that a member, an agent or an org was removed. */
+export type LifecycleHook = (typeof LIFECYCLE_HOOKS)[number];
+/**
+ * Mounts delivered by a queue (at least once, by plugin) instead of {@link HookRegistry.run}:
+ * `usage.report` and the lifecycle mounts.
+ */
+export type QueuedHook = "usage.report" | LifecycleHook;
 /** Error text that never throws itself (a hostile `message` getter or `toString`). */
 export declare function errMsg(e: unknown): string;
 /**
@@ -166,8 +175,18 @@ export declare class HookRegistry {
         plugin: string;
         handler: HookHandler<"usage.report">;
     }[];
-    /** Runs the hooks of a mount point (see the class comment). */
-    run<K extends Exclude<AvailableHook, "usage.report">>(mount: K, payload: HookPayloads[K], signal: AbortSignal): Promise<HookOutcome>;
+    /**
+     * Lifecycle handlers by plugin name (delivered by the lifecycle queue, `lifecycle-hooks.ts`, not
+     * by {@link run}). Each call runs through the instance's `inflight.run` with the plugin's platform
+     * deployment config, never an org's copy: cleanup goes out whether or not the org's effective
+     * config is valid (or the org still exists).
+     */
+    lifecycleHandlers<K extends LifecycleHook>(mount: K): {
+        plugin: string;
+        handler: HookHandler<K>;
+    }[];
+    /** Runs the hooks of a mount point (see the class comment); queue-delivered mounts excluded. */
+    run<K extends Exclude<AvailableHook, QueuedHook>>(mount: K, payload: HookPayloads[K], signal: AbortSignal): Promise<HookOutcome>;
     /**
      * The M-1 denial: `missing` (sorted) are enabled policy plugins that are not loaded on this replica.
      * The model-visible reason is generic; the detail and a throttled warning name the plugin for the

package/dist/extensions/hooks.js

@@ -189,7 +189,21 @@ export class HookRegistry {
             }),
         }));
     }
-    /** Runs the hooks of a mount point (see the class comment). */
+    /**
+     * Lifecycle handlers by plugin name (delivered by the lifecycle queue, `lifecycle-hooks.ts`, not
+     * by {@link run}). Each call runs through the instance's `inflight.run` with the plugin's platform
+     * deployment config, never an org's copy: cleanup goes out whether or not the org's effective
+     * config is valid (or the org still exists).
+     */
+    lifecycleHandlers(mount) {
+        return this.entries(mount).map(({ src, hook }) => ({
+            plugin: src.name,
+            handler: (payload, signal) => src.inflight.run(signal, async (s) => {
+                await hook.handler(payload, s, { config: src.config });
+            }),
+        }));
+    }
+    /** Runs the hooks of a mount point (see the class comment); queue-delivered mounts excluded. */
     async run(mount, payload, signal) {
         if (signal.aborted)
             throw signal.reason;

package/dist/extensions/lifecycle-hooks.d.ts

@@ -0,0 +1,99 @@
+import type { HookPayloads } from "@capybara-hq/plugin-sdk";
+import { WorkerHost } from "@nestjs/bullmq";
+import type { Job, Worker } from "bullmq";
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
+import type { KernelLogger } from "../log.js";
+import { type LifecycleHook } from "./hooks.js";
+import { ExtensionHost } from "./host.js";
+/** Queue of lifecycle hook deliveries (no `:` in the name). */
+export declare const LIFECYCLE_QUEUE = "cap-kernel-lifecycle";
+/** The job name of every delivery (registered in `infra/outbox/registry.ts`). */
+export declare const LIFECYCLE_JOB = "lifecycle";
+/** One handler call's time limit. */
+export declare const LIFECYCLE_HOOK_TIMEOUT_MS = 5000;
+/** Job data: one mount's payload for one subscribing plugin. */
+export interface LifecycleJob<K extends LifecycleHook = LifecycleHook> {
+    mount: K;
+    plugin: string;
+    payload: HookPayloads[K];
+}
+/**
+ * The deterministic job id of one delivery: the mount, the plugin and the payload's ids (no `:`;
+ * kernel ids and plugin names carry none). Removing the same member, agent or org again while the
+ * first delivery is still owed is the same job.
+ */
+export declare function lifecycleJobId<K extends LifecycleHook>(mount: K, plugin: string, payload: HookPayloads[K]): string;
+/**
+ * Plugins that subscribe to a lifecycle mount according to deployment state: the approved
+ * permission snapshot declares the mount in `permissions.hooks`, and that approved version is the
+ * one the deployment runs: an enabled install of that version, or a replica status row (not
+ * `unloaded`) that loaded or still serves it (an upgrade pending approval keeps serving the
+ * approved version; a config-declared plugin has only replica rows). A snapshot approved for
+ * another version than the one installed or served does not count. Org enablement does not count
+ * either: cleanup concerns data the plugin already holds (memory plugin spec §6.3). Sorted by name.
+ */
+export declare function queryLifecycleSubscribers(db: KernelSchemaDb, mount: LifecycleHook): Promise<string[]>;
+/**
+ * Durable delivery of the lifecycle hooks `org.member_removed`, `agent.deleted` and `org.deleted`
+ * (memory plugin spec §6.3), so extensions reliably learn to delete the data they hold:
+ * - **Owe** ({@link recordIn}): in the transaction that removes the member, the agent or the org,
+ *   one outbox job per subscribing plugin ({@link queryLifecycleSubscribers}) on
+ *   {@link LIFECYCLE_QUEUE}, under {@link lifecycleJobId}, with no `org_id` (it is the deletion's
+ *   own cleanup work, transactional outbox spec §9); a rollback owes nothing. The outbox delivers
+ *   it to BullMQ after the commit (registry: attempts and backoff).
+ * - **Deliver** ({@link process}, worker role): the plugin's handlers loaded on this replica are
+ *   called in turn (5 s each). Not loaded on this replica -> the job fails and is retried (another
+ *   replica or a later attempt). Loaded without a handler -> dropped with a warning. Handlers get
+ *   the plugin's platform deployment config (`call.config`), never an org's copy, so an org whose
+ *   effective config is not valid still gets its cleanup. The last failed attempt logs an error.
+ * Handlers must be idempotent (a delivery may repeat when a replica dies after the call).
+ */
+export declare class LifecycleHooks {
+    private readonly kdb;
+    readonly txHost: TransactionHost;
+    private readonly outbox;
+    /** The loaded plugins' handlers (`hooks.handlers`) and whether a plugin is active here. */
+    private readonly host;
+    private readonly log;
+    constructor(kdb: KernelDb, txHost: TransactionHost, outbox: Pick<OutboxService, "add">, 
+    /** The loaded plugins' handlers (`hooks.handlers`) and whether a plugin is active here. */
+    host: Pick<ExtensionHost, "hooks" | "current">, log: KernelLogger);
+    /**
+     * Owes one delivery per subscribing plugin in the caller's transaction (`mandatory`); returns
+     * the plugins.
+     */
+    recordIn<K extends LifecycleHook>(mount: K, payload: HookPayloads[K]): Promise<string[]>;
+    /** One delivery job (the consumer {@link LifecycleHooksProcessor} calls it). */
+    process(data: LifecycleJob, stop: AbortSignal): Promise<void>;
+    /** One handler call, aborted after {@link LIFECYCLE_HOOK_TIMEOUT_MS} or when the replica stops. */
+    private call;
+    /** A job failed (the worker's `failed` event): a retry warns, the last attempt logs an error. */
+    onFailed(j: Job<LifecycleJob> | undefined, err: Error): void;
+}
+/**
+ * The consumer of {@link LIFECYCLE_QUEUE}: {@link LifecycleHooks.process}. Worker role only
+ * (`LifecycleHookWorkersModule`); built with `autorun: false`, started by the worker role after the
+ * extensions loaded.
+ */
+export declare class LifecycleHooksProcessor extends WorkerHost<Worker<LifecycleJob>> {
+    private readonly hooks;
+    private readonly log;
+    private readonly stopping;
+    constructor(hooks: LifecycleHooks, log: Pick<KernelLogger, "error">);
+    process(job: Job<LifecycleJob>): Promise<void>;
+    /** Starts consuming (worker role, after the extensions loaded). */
+    start(): void;
+    /** Aborts the calls in flight and closes the worker. */
+    close(): Promise<void>;
+    failed(job: Job<LifecycleJob> | undefined, err: Error): void;
+    error(err: Error): void;
+}
+/** Lifecycle hook delivery: owing the jobs, and the queue the outbox adds them to, on every role. */
+export declare class LifecycleHooksModule {
+}
+/** The lifecycle queue's consumer; imported only by the worker role (`WorkerModule`). */
+export declare class LifecycleHookWorkersModule {
+}