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

package/dist/infra/throttler/throttler.guard.js

@@ -0,0 +1,68 @@
+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 { applyDecorators, Inject, Injectable, SetMetadata, UseGuards, } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import { getOptionsToken, getStorageToken, ThrottlerGuard, } from "@nestjs/throttler";
+import { ApiError } from "../../errors.js";
+import { NAMED_THROTTLERS } from "./named-throttlers.js";
+const THROTTLED = "kernel:throttled";
+/** The throttler names selected for the route `context` runs (empty: none, the guard passes). */
+export function selectedThrottlers(context) {
+    return (Reflect.getMetadata(THROTTLED, context.getHandler()) ??
+        Reflect.getMetadata(THROTTLED, context.getClass()) ??
+        []);
+}
+/**
+ * Opts a route (or controller) in to the named throttlers `names` (see `NAMED_THROTTLERS`).
+ * Throttling is per-route opt-in because the kernel limits only credential-checking routes today;
+ * health, SSE and extension routes stay unlimited.
+ */
+export const Throttled = (...names) => {
+    for (const n of names) {
+        if (!NAMED_THROTTLERS.some((t) => t.name === n))
+            throw new Error(`unknown throttler "${n}"`);
+    }
+    return applyDecorators(SetMetadata(THROTTLED, names), UseGuards(KernelThrottlerGuard));
+};
+/**
+ * `@nestjs/throttler`'s guard with the kernel's error contract: the first named throttler of the
+ * route at its limit answers 429 `auth.rate_limited` with its own message and `retry-after`
+ * (seconds, 1..window), as the credential routes answer; no `x-ratelimit-*` headers (the
+ * kernel sends none today). Which throttlers apply to a route is chosen by `@Throttled`; they are
+ * counted one after another in `NAMED_THROTTLERS` order (table order is check order). Fail-open on
+ * Redis errors (see `RedisThrottlerStorage`). For credential checks use `CredentialThrottler`.
+ */
+let KernelThrottlerGuard = class KernelThrottlerGuard extends ThrottlerGuard {
+    constructor(options, storage, reflector) {
+        super(options, storage, reflector);
+    }
+    async handleRequest(props) {
+        const { context, limit, ttl, throttler, blockDuration, getTracker, generateKey } = props;
+        const http = context.switchToHttp();
+        const name = throttler.name ?? "default";
+        const tracker = await getTracker(http.getRequest(), context);
+        const key = generateKey(context, tracker, name);
+        const r = await this.storageService.increment(key, ttl, limit, blockDuration, name);
+        if (!r.isBlocked)
+            return true;
+        http.getResponse().header("retry-after", String(r.timeToBlockExpire));
+        const known = NAMED_THROTTLERS.find((t) => t.name === name);
+        if (!known)
+            throw new Error(`unknown throttler "${name}"`);
+        throw new ApiError("auth.rate_limited", known.message);
+    }
+};
+KernelThrottlerGuard = __decorate([
+    Injectable(),
+    __param(0, Inject(getOptionsToken())),
+    __param(1, Inject(getStorageToken())),
+    __param(2, Inject(Reflector))
+], KernelThrottlerGuard);
+export { KernelThrottlerGuard };

package/dist/infra/throttler/throttler.module.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Two limiters share the named-throttler table and the Redis storage, with opposite failure modes:
+ * - `@Throttled` (`KernelThrottlerGuard`): plain per-route limits, counted before the handler,
+ *   FAIL-OPEN on Redis errors (octok's rule: a Redis blip must not 5xx every limited route).
+ * - `CredentialThrottler`: called inside a handler for credential checks, all-or-nothing across
+ *   keys, FAIL-CLOSED on Redis errors (an attacker must not get unlimited guesses by making Redis
+ *   fail).
+ *
+ * Global: `@nestjs/throttler` over the Redis storage with the kernel's named throttlers, and the
+ * guard behind `@Throttled(...)`. The storage is injectable as `ThrottlerStorage`;
+ * `CredentialThrottler` casts it to `RedisThrottlerStorage` for its multi-key `reserve` /
+ * `succeeded`.
+ */
+export declare class KernelThrottlerModule {
+}

package/dist/infra/throttler/throttler.module.js

@@ -0,0 +1,53 @@
+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 { Global, Module } from "@nestjs/common";
+import { ThrottlerModule } from "@nestjs/throttler";
+import { KERNEL_LOGGER, REDIS } from "../tokens.js";
+import { CredentialThrottler } from "./credential-throttler.js";
+import { NAMED_THROTTLERS, throttlerKey } from "./named-throttlers.js";
+import { RedisThrottlerStorage } from "./redis-throttler-storage.js";
+import { KernelThrottlerGuard, selectedThrottlers } from "./throttler.guard.js";
+/**
+ * Two limiters share the named-throttler table and the Redis storage, with opposite failure modes:
+ * - `@Throttled` (`KernelThrottlerGuard`): plain per-route limits, counted before the handler,
+ *   FAIL-OPEN on Redis errors (octok's rule: a Redis blip must not 5xx every limited route).
+ * - `CredentialThrottler`: called inside a handler for credential checks, all-or-nothing across
+ *   keys, FAIL-CLOSED on Redis errors (an attacker must not get unlimited guesses by making Redis
+ *   fail).
+ *
+ * Global: `@nestjs/throttler` over the Redis storage with the kernel's named throttlers, and the
+ * guard behind `@Throttled(...)`. The storage is injectable as `ThrottlerStorage`;
+ * `CredentialThrottler` casts it to `RedisThrottlerStorage` for its multi-key `reserve` /
+ * `succeeded`.
+ */
+let KernelThrottlerModule = class KernelThrottlerModule {
+};
+KernelThrottlerModule = __decorate([
+    Global(),
+    Module({
+        imports: [
+            ThrottlerModule.forRootAsync({
+                inject: [REDIS, KERNEL_LOGGER],
+                useFactory: (redis, log) => ({
+                    storage: new RedisThrottlerStorage(redis, log),
+                    setHeaders: false,
+                    throttlers: NAMED_THROTTLERS.map((t) => ({
+                        name: t.name,
+                        limit: t.limit,
+                        ttl: t.ttl,
+                        getTracker: (req) => t.getTracker(req),
+                        generateKey: (_ctx, tracker, name) => throttlerKey(name, tracker),
+                        skipIf: (ctx) => !selectedThrottlers(ctx).includes(t.name),
+                    })),
+                }),
+            }),
+        ],
+        providers: [KernelThrottlerGuard, CredentialThrottler],
+        exports: [KernelThrottlerGuard, CredentialThrottler],
+    })
+], KernelThrottlerModule);
+export { KernelThrottlerModule };

package/dist/infra/tokens.d.ts

@@ -0,0 +1,15 @@
+/** Injection tokens of the global infra modules. */
+/** The process logger (`KernelLogger`). */
+export declare const KERNEL_LOGGER: unique symbol;
+/** The startup input of `KernelConfigService`: `{ config, env }`. */
+export declare const KERNEL_CONFIG_INPUT: unique symbol;
+/** The Kysely pool, untyped (`Kysely<any>`); infra only, services inject `KernelDb`. */
+export declare const KERNEL_POOL: unique symbol;
+/** The main ioredis connection (lazy: connects on first command or an explicit `connect()`). */
+export declare const REDIS: unique symbol;
+/** The shared bus subscriber connection (`BusSubscriber` with `close()`). */
+export declare const REDIS_SUBSCRIBER: unique symbol;
+/** The kernel bus (`createBus(..., "kernel")`, `ExtensionContext["bus"]`). */
+export declare const KERNEL_BUS: unique symbol;
+/** The master keyring (`createKeyring` over `masterKey` / `masterKeyPrevious`). */
+export declare const KEYRING: unique symbol;

package/dist/infra/tokens.js

@@ -0,0 +1,15 @@
+/** Injection tokens of the global infra modules. */
+/** The process logger (`KernelLogger`). */
+export const KERNEL_LOGGER = Symbol("KERNEL_LOGGER");
+/** The startup input of `KernelConfigService`: `{ config, env }`. */
+export const KERNEL_CONFIG_INPUT = Symbol("KERNEL_CONFIG_INPUT");
+/** The Kysely pool, untyped (`Kysely<any>`); infra only, services inject `KernelDb`. */
+export const KERNEL_POOL = Symbol("KERNEL_POOL");
+/** The main ioredis connection (lazy: connects on first command or an explicit `connect()`). */
+export const REDIS = Symbol("REDIS");
+/** The shared bus subscriber connection (`BusSubscriber` with `close()`). */
+export const REDIS_SUBSCRIBER = Symbol("REDIS_SUBSCRIBER");
+/** The kernel bus (`createBus(..., "kernel")`, `ExtensionContext["bus"]`). */
+export const KERNEL_BUS = Symbol("KERNEL_BUS");
+/** The master keyring (`createKeyring` over `masterKey` / `masterKeyPrevious`). */
+export const KEYRING = Symbol("KEYRING");

package/dist/infra/validation/create-zod-dto.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+/** A class carrying a zod schema; the global validation pipe validates parameters typed with one. */
+export interface ZodDtoClass<S extends z.ZodType = z.ZodType> {
+    new (): z.infer<S>;
+    readonly schema: S;
+    /** The name the swagger document lists the schema under. */
+    readonly dtoName: string | undefined;
+    /** The schema as JSON Schema (input side: what a client sends). */
+    jsonSchema(): Record<string, unknown>;
+}
+/** Every DTO created so far (the swagger document lists the named ones). */
+export declare function registeredZodDtos(): readonly ZodDtoClass[];
+/**
+ * Creates a DTO class from a zod schema (nestjs-zod does not support Nest 12, so the kernel has its
+ * own, same shape as octok's `createI18nZodDto`). Use it as the metatype of `@Body()`, `@Query()`
+ * or `@Param()`: `class CreateX extends createZodDto(schema, "CreateX") {}`. The instance type is
+ * the schema's output type.
+ */
+export declare function createZodDto<S extends z.ZodType>(schema: S, name?: string): ZodDtoClass<S>;
+/** The DTO's schema when `metatype` is one, else undefined. */
+export declare function zodSchemaOf(metatype: unknown): z.ZodType | undefined;
+/** What `@ZBody` / `@ZQuery` / `@ZParam` hand to the global pipe as the argument's `data`. */
+export declare function isZodDto(value: unknown): value is ZodDtoClass;

package/dist/infra/validation/create-zod-dto.js

@@ -0,0 +1,35 @@
+// Ported from octok-platform libs/common/src/validation/create-i18n-zod-dto.ts (owner-approved, 2026-10-28).
+import { z } from "zod";
+const registry = new Set();
+/** Every DTO created so far (the swagger document lists the named ones). */
+export function registeredZodDtos() {
+    return [...registry];
+}
+/**
+ * Creates a DTO class from a zod schema (nestjs-zod does not support Nest 12, so the kernel has its
+ * own, same shape as octok's `createI18nZodDto`). Use it as the metatype of `@Body()`, `@Query()`
+ * or `@Param()`: `class CreateX extends createZodDto(schema, "CreateX") {}`. The instance type is
+ * the schema's output type.
+ */
+export function createZodDto(schema, name) {
+    class ZodDto {
+        static schema = schema;
+        static dtoName = name;
+        static jsonSchema() {
+            return z.toJSONSchema(schema, { io: "input", unrepresentable: "any" });
+        }
+    }
+    registry.add(ZodDto);
+    return ZodDto;
+}
+/** The DTO's schema when `metatype` is one, else undefined. */
+export function zodSchemaOf(metatype) {
+    if (typeof metatype !== "function")
+        return undefined;
+    const s = metatype.schema;
+    return s instanceof z.ZodType ? s : undefined;
+}
+/** What `@ZBody` / `@ZQuery` / `@ZParam` hand to the global pipe as the argument's `data`. */
+export function isZodDto(value) {
+    return zodSchemaOf(value) !== undefined;
+}

package/dist/infra/validation/parse-with-zod.d.ts

@@ -0,0 +1,7 @@
+import type { z } from "zod";
+/**
+ * Parses `value` with a zod schema and returns the output (transforms and defaults applied); a
+ * failure throws `validation_failed` whose details list each issue's path and message. The
+ * implementation behind the global `ZodValidationPipe`.
+ */
+export declare function parseWithZod<S extends z.ZodType>(schema: S, value: unknown): z.infer<S>;

package/dist/infra/validation/parse-with-zod.js

@@ -0,0 +1,12 @@
+import { ApiError } from "../../errors.js";
+/**
+ * Parses `value` with a zod schema and returns the output (transforms and defaults applied); a
+ * failure throws `validation_failed` whose details list each issue's path and message. The
+ * implementation behind the global `ZodValidationPipe`.
+ */
+export function parseWithZod(schema, value) {
+    const r = schema.safeParse(value);
+    if (r.success)
+        return r.data;
+    throw new ApiError("validation_failed", "Request validation failed", r.error.issues.map((i) => ({ path: i.path.map(String).join("."), message: i.message })));
+}

package/dist/infra/validation/validation.module.d.ts

@@ -0,0 +1,3 @@
+/** Registers the global zod validation pipe. */
+export declare class ValidationModule {
+}

package/dist/infra/validation/validation.module.js

@@ -0,0 +1,16 @@
+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 { APP_PIPE } from "@nestjs/core";
+import { ZodValidationPipe } from "./zod-validation.pipe.js";
+/** Registers the global zod validation pipe. */
+let ValidationModule = class ValidationModule {
+};
+ValidationModule = __decorate([
+    Module({ providers: [{ provide: APP_PIPE, useClass: ZodValidationPipe }] })
+], ValidationModule);
+export { ValidationModule };

package/dist/infra/validation/zod-params.d.ts

@@ -0,0 +1,7 @@
+import type { ZodDtoClass } from "./create-zod-dto.js";
+/** The request body, validated against the DTO's schema; the parameter is the schema's output. */
+export declare const ZBody: (dto: ZodDtoClass) => ParameterDecorator;
+/** The query string, validated against the DTO's schema; each property is a swagger query parameter. */
+export declare const ZQuery: (dto: ZodDtoClass) => ParameterDecorator;
+/** The path parameters, validated against the DTO's schema; each property is a swagger path parameter. */
+export declare const ZParam: (dto: ZodDtoClass) => ParameterDecorator;

package/dist/infra/validation/zod-params.js

@@ -0,0 +1,42 @@
+import { createParamDecorator } from "@nestjs/common";
+import { ApiBody, ApiParam, ApiQuery } from "@nestjs/swagger";
+// esbuild, tsx and the kernel's own tsc build emit no decorator metadata, so a parameter's type is
+// never visible to a pipe or to @nestjs/swagger. These decorators name the DTO explicitly: they
+// pass the raw request part through, hand the DTO to the global ZodValidationPipe as the argument's
+// `data`, and describe the parameter to swagger on the method.
+const part = (key) => createParamDecorator((_dto, ctx) => ctx.switchToHttp().getRequest()[key]);
+const body = part("body");
+const query = part("query");
+const params = part("params");
+function onMethod(decorators, target, key) {
+    if (key === undefined)
+        return;
+    const desc = Object.getOwnPropertyDescriptor(target, key);
+    if (desc === undefined)
+        return;
+    for (const d of decorators)
+        d(target, key, desc);
+}
+function perProperty(dto, make) {
+    const js = dto.jsonSchema();
+    const required = new Set(js.required ?? []);
+    return Object.entries(js.properties ?? {}).map(([name, schema]) => make({ name, required: required.has(name), schema }));
+}
+/** The request body, validated against the DTO's schema; the parameter is the schema's output. */
+export const ZBody = (dto) => (target, key, index) => {
+    body(dto)(target, key, index);
+    const schema = dto.dtoName === undefined
+        ? dto.jsonSchema()
+        : { $ref: `#/components/schemas/${dto.dtoName}` };
+    onMethod([ApiBody({ schema: schema })], target, key);
+};
+/** The query string, validated against the DTO's schema; each property is a swagger query parameter. */
+export const ZQuery = (dto) => (target, key, index) => {
+    query(dto)(target, key, index);
+    onMethod(perProperty(dto, ApiQuery), target, key);
+};
+/** The path parameters, validated against the DTO's schema; each property is a swagger path parameter. */
+export const ZParam = (dto) => (target, key, index) => {
+    params(dto)(target, key, index);
+    onMethod(perProperty(dto, ApiParam), target, key);
+};

package/dist/infra/validation/zod-validation.pipe.d.ts

@@ -0,0 +1,11 @@
+import { type ArgumentMetadata, type PipeTransform } from "@nestjs/common";
+/**
+ * Global pipe (`APP_PIPE`): validates the arguments declared with `@ZBody(Dto)` / `@ZQuery(Dto)` /
+ * `@ZParam(Dto)` (the DTO arrives as `metadata.data`; a parameter whose metatype is a DTO, where
+ * the build emits decorator metadata, is validated too) and returns the parse output (transforms
+ * and defaults applied). Failures are `validation_failed` ({@link parseWithZod}). Any
+ * other argument (primitives, the raw request, other custom decorators) passes untouched.
+ */
+export declare class ZodValidationPipe implements PipeTransform {
+    transform(value: unknown, metadata: ArgumentMetadata): unknown;
+}

package/dist/infra/validation/zod-validation.pipe.js

@@ -0,0 +1,31 @@
+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;
+};
+// Ported from octok-platform libs/common/src/validation (owner-approved, 2026-10-28).
+import { Injectable } from "@nestjs/common";
+import { zodSchemaOf } from "./create-zod-dto.js";
+import { parseWithZod } from "./parse-with-zod.js";
+/**
+ * Global pipe (`APP_PIPE`): validates the arguments declared with `@ZBody(Dto)` / `@ZQuery(Dto)` /
+ * `@ZParam(Dto)` (the DTO arrives as `metadata.data`; a parameter whose metatype is a DTO, where
+ * the build emits decorator metadata, is validated too) and returns the parse output (transforms
+ * and defaults applied). Failures are `validation_failed` ({@link parseWithZod}). Any
+ * other argument (primitives, the raw request, other custom decorators) passes untouched.
+ */
+let ZodValidationPipe = class ZodValidationPipe {
+    transform(value, metadata) {
+        const schema = metadata.type === "custom"
+            ? zodSchemaOf(metadata.data)
+            : metadata.type === "body" || metadata.type === "query" || metadata.type === "param"
+                ? zodSchemaOf(metadata.metatype)
+                : undefined;
+        return schema === undefined ? value : parseWithZod(schema, value);
+    }
+};
+ZodValidationPipe = __decorate([
+    Injectable()
+], ZodValidationPipe);
+export { ZodValidationPipe };

package/dist/kernel.d.ts

@@ -1,251 +1,18 @@
-import { type BootstrapManifest, type ExtensionContext } from "@capybara-hq/plugin-sdk";
-import { CatalogService } from "./catalog/catalog.service.js";
-import { MarketplacesService } from "./catalog/marketplaces.service.js";
-import { PluginImport } from "./catalog/plugin-import.js";
-import { ChannelConnections } from "./channels/connections.service.js";
-import { ChannelInbound } from "./channels/inbound.js";
-import { ChannelOutbound } from "./channels/outbound.js";
-import { type ConfigSource } from "./config/load.js";
-import { type KernelConfig } from "./config/schema.js";
-import { type ConfigSourceKind } from "./config/sources.js";
-import { AttachmentsService } from "./conversations/attachments.service.js";
-import { EventLog } from "./conversations/event-log.js";
-import type { EvalReplayHooks } from "./evals/run-replay.js";
-import { ExtensionAdminOps } from "./extensions/admin-ops.js";
-import { ExtensionAdmin } from "./extensions/admin-view.js";
+import type { KernelConfig } from "./config/schema.js";
 import type { PendingExtension } from "./extensions/approvals.js";
-import { ExtensionBlobs } from "./extensions/blobs.js";
-import { BootstrapService } from "./extensions/bootstrap.js";
-import { ExtensionDeploymentConfigService } from "./extensions/deployment-config.js";
-import { ExtensionHost } from "./extensions/host.js";
-import { ExtensionInstalls } from "./extensions/installs.js";
-import { ExtensionLifecycle } from "./extensions/lifecycle.js";
-import { OrgExtensionConfigs } from "./extensions/org-config.js";
-import { type KernelHttp } from "./http/app.js";
-import { IdentityBinding } from "./identity/binding.js";
-import { ExternalIdentities } from "./identity/external.js";
-import { SsoFlow } from "./identity/sso.js";
-import type { KernelLogger } from "./log.js";
-import { PricesService } from "./models/prices.js";
-import { ModelPurposesService } from "./models/purposes.js";
-import { DirectorySync } from "./orgs/directory-sync.js";
-import { Offboarding } from "./orgs/offboarding.js";
-import { RunAbort } from "./runtime/abort.js";
-import { ConversationLock } from "./runtime/conversation-lock.js";
-import { type LoopDeps } from "./runtime/langgraph-loop.js";
-import type { AgentLoop } from "./runtime/loop.js";
-import { Maintenance } from "./runtime/maintenance.js";
-import { ProviderRegistry } from "./runtime/providers.js";
-import { OrgQuota } from "./runtime/quota.js";
-import { RunQueue } from "./runtime/run-queue.js";
-import { type RunHooks } from "./runtime/run-worker.js";
-import { UsageReporter } from "./runtime/usage-report.js";
-import { Waits } from "./runtime/waits.js";
-import { SandboxService } from "./sandbox/sandbox.service.js";
-import { SkillChangesService } from "./skills/changes.service.js";
-import { SkillsService } from "./skills/skills.service.js";
-import { StorageService } from "./storage/storage.service.js";
-import { ApprovalsService } from "./tools/approvals.service.js";
-import { ConnectorContent } from "./tools/connector-content.js";
-import { Credentials } from "./tools/credentials.js";
-import { ToolDrift } from "./tools/drift.js";
-import { ToolOutputs } from "./tools/outputs.js";
-import { ToolPipeline } from "./tools/pipeline.js";
-import { QuestionsService } from "./tools/questions.service.js";
-import { ToolRegistry } from "./tools/registry.js";
 /**
- * 内核迁移目录。src/ 与 dist/ 都在包根下一层，所以统一指向 `<包根>/src/migrations`：
- * 用 tsx 从源码运行与运行 tsc 产物时解析到同一个目录（SQL 文件不进 dist，随包发布 src/migrations）。
+ * The kernel migrations directory. `src/` and `dist/` are both one level below the package root,
+ * so this always points at `<package root>/src/migrations`: running from source with tsx and
+ * running the tsc output resolve to the same directory (the SQL files are not copied into dist;
+ * the package ships `src/migrations`).
  */
 export declare const KERNEL_MIGRATIONS_DIR: string;
-/** 内核 PG schema。 */
+/** The kernel's PG schema. */
 export declare const KERNEL_SCHEMA = "capybara";
 /**
- * 停机分阶段预算：每阶段实际等待 `min(阶段预算, 总剩余)`，按顺序为
- * migrate（中止进行中的内核迁移并等其会话结束）2s → http 10s → runs 10s → plugins 5s，合计 27s，
- * 余下 3s 给 bus / redis / pg 收尾（这三步共享总剩余）。
- * http 阶段是一个截止时间：先等进行中的监听完成（否则关闭会与监听交错留下端口），再关闭 HTTP，
- * 两步共用这 10s；到点仍未关完就强制断开所有连接。
- * runs 阶段（从原插件阶段的 15s 中划出 10s）：本进程的运行收到停机信号，在下一个步骤边界停下、
- * 任务回到队列；超出预算的运行交给 BullMQ stalled 机制由其他 worker 续跑（spec 8.5）。
- * 因此任一前序阶段卡死时，插件队列仍至少有 5s 排空，总时长不超过 30s。
- */
-export declare const STOP_BUDGET_MS: {
-    readonly migrate: 2000;
-    readonly http: 10000;
-    readonly runs: 10000;
-    readonly plugins: 5000;
-};
-/** 运行编排相关的内核服务（后续任务的 loop / SSE 使用）。 */
-export interface KernelRuns {
-    readonly eventLog: EventLog;
-    readonly registry: ProviderRegistry;
-    readonly queue: RunQueue;
-    readonly lock: ConversationLock;
-    readonly quota: OrgQuota;
-    readonly abort: RunAbort;
-    /** 构造 loop 用的依赖（单步模型调用 + 工具执行管线）。 */
-    readonly stepDeps: LoopDeps;
-    /** 运行等待人处理：续跑、超时、等待中中止。 */
-    readonly waits: Waits;
-    /** 内核维护队列（等待超时、输出存档清理等）。 */
-    readonly maintenance: Maintenance;
-}
-/** 工具相关的内核服务。 */
-export interface KernelTools {
-    readonly registry: ToolRegistry;
-    readonly credentials: Credentials;
-    /** 输出存档（超大工具结果）。 */
-    readonly outputs: ToolOutputs;
-    /** 工具执行管线（tools 节点使用）。 */
-    readonly pipeline: ToolPipeline;
-    /** 工具调用审批与「以后都允许」授权。 */
-    readonly approvals: ApprovalsService;
-    /** 工具调用的输入请求（回答后续跑）。 */
-    readonly questions: QuestionsService;
-    /** 工具定义漂移检测（周期扫描、list_changed、手动刷新）。 */
-    readonly drift: ToolDrift;
-    /** 连接器的 prompts / resources（斜杠命令、@ 资源引用与消息附件）。 */
-    readonly connectorContent: ConnectorContent;
-}
-/** 外部身份相关的内核服务（渠道运行时、通讯录同步与 HTTP 共用）。 */
-export interface KernelIdentity {
-    /** 外部身份 ↔ 账号（登录、渠道入站、通讯录共用 `(source, externalId)` 键）。 */
-    readonly external: ExternalIdentities;
-    /** IM 身份的一次性绑定链接。 */
-    readonly binding: IdentityBinding;
-    /** 第三方登录（`identity-source@1`）。 */
-    readonly sso: SsoFlow;
-    /** 成员离职处理（移出、离开、通讯录同步共用）。 */
-    readonly offboarding: Offboarding;
-    /** 通讯录同步（`directory@1`：每小时扫描、手动、`directory_changed` 提示）。 */
-    readonly directory: DirectorySync;
-}
-/** 渠道运行时（连接、入站、出站投递）。 */
-export interface KernelChannels {
-    /** 组织的渠道连接（CRUD、运行时配置、出站会话 `outbound` / `send`）。 */
-    readonly connections: ChannelConnections;
-    /** 出站投递与入站任务（队列 `cap-kernel-channels`；worker 角色消费）。 */
-    readonly outbound: ChannelOutbound;
-    /** 入站事件：`onEvent`（插件 `connect` 的回调，去重并入队）与 `handle`（worker 上处理入站任务）。 */
-    readonly inbound: ChannelInbound;
-}
-/** 运行中的内核实例。 */
-export interface Kernel {
-    /** 内核 HTTP：进程内注入请求、列出路由。 */
-    readonly http: KernelHttp;
-    readonly host: ExtensionHost;
-    /** usage.report delivery (fast path, sweeper and, on the worker role, the worker). */
-    readonly usageReport: UsageReporter;
-    /** This process's replica id (`<hostname>-<pid>-<6 random chars>`, written to `extension_replica_status`). */
-    readonly replicaId: string;
-    /** 插件包的导入（上传 / npm）与安装记录。 */
-    readonly extensionInstalls: ExtensionInstalls;
-    /** 部署级插件后台：列表、状态与网页批准权限。 */
-    readonly extensionAdmin: ExtensionAdmin;
-    /** 部署级插件的安装 / 启用 / 停用 / 卸载（只写期望状态并发布 `kernel.plugins.changed`）。 */
-    readonly extensionAdminOps: ExtensionAdminOps;
-    /** 本副本的插件生命周期：订阅 bus 并 reconcile 到 PG 期望状态（C16）。 */
-    readonly extensionLifecycle: ExtensionLifecycle;
-    /** 内容寻址的插件包存储（对象存储或 PG）。 */
-    readonly extensionBlobs: ExtensionBlobs;
-    /** The enterprise catalog: items and imports (plugins / connector templates / skills). */
-    readonly catalog: CatalogService;
-    /** Enterprise import of plugins (plugin tgz files): prepare / confirm and staging cleanup. */
-    readonly pluginImport: PluginImport;
-    /** The bootstrap step (package ecosystem spec §7); `start()` runs it when given `bootstrap`. */
-    readonly bootstrap: BootstrapService;
-    /** Marketplaces: official / enterprise marketplaces and their refresh. */
-    readonly marketplaces: MarketplacesService;
-    /** 部署级插件配置（PG，文件 / 环境变量里有的字段只读；C10）。 */
-    readonly extensionDeploymentConfigs: ExtensionDeploymentConfigService;
-    /** 组织级插件启用状态与配置（密钥字段加密存储）。 */
-    readonly orgExtensionConfigs: OrgExtensionConfigs;
-    /** 内核总线（命名空间 `kernel`）。 */
-    readonly bus: ExtensionContext["bus"];
-    /** 运行编排服务。 */
-    readonly runs: KernelRuns;
-    /** 工具注册表与连接器凭据。 */
-    readonly tools: KernelTools;
-    /** 外部身份、绑定、第三方登录与离职处理。 */
-    readonly identity: KernelIdentity;
-    /** 渠道连接与入站。 */
-    readonly channels: KernelChannels;
-    /**
-     * 对象存储（`object-store@1` 提供方之上的前缀隔离，内核用 `kernel(orgId)`）；
-     * 没有提供方时 `available` 为 false，各方法 reject `storage.unavailable`。
-     */
-    readonly storage: StorageService;
-    /** 对话附件（上传、finalize、绑定、取字节、过期清理）。 */
-    readonly attachments: AttachmentsService;
-    /** 技能库（组织技能的上传、版本、列表与软删除）。 */
-    readonly skills: SkillsService;
-    /** agent 自写技能（`skill_write`）与共享 agent 的技能变更审批（R4）。 */
-    readonly skillChanges: SkillChangesService;
-    /** 模型价格表（PG `model_prices`，成本读时计算）。 */
-    readonly prices: PricesService;
-    /** 模型用途映射（部署默认 + 组织覆盖；评委用途 `eval`）。 */
-    readonly purposes: ModelPurposesService;
-    /**
-     * 按对话的沙箱（`sandbox@1` 提供方之上：懒创建、锁、休眠与销毁）；
-     * 没有提供方时 `available` 为 false，使用时抛 `sandbox.unavailable`（503）。
-     */
-    readonly sandbox: SandboxService;
-    readonly log: KernelLogger;
-    /** 当前生效的配置（热更新只替换 `hot` 字段）。 */
-    readonly config: KernelConfig;
-    /**
-     * 实际监听的端口；尚未 start 或已 stop 时为 undefined。
-     * 所有角色都监听：worker-only 只暴露 `/healthz` 与 `/readyz`（供 K8s 探针）。
-     */
-    readonly port: number | undefined;
-    start(): Promise<void>;
-    /** 优雅停机：幂等，总时长不超过 30s。 */
-    stop(): Promise<void>;
-}
-/** createKernel 的可选项。 */
-export interface KernelOptions {
-    /** 配置来源；提供 `watch` 时启用热更新。 */
-    source?: ConfigSource;
-    /** 解析插件裸包名的目录，默认 `process.cwd()`；相对路径按当前 cwd 解析。 */
-    resolveFrom?: string;
-    /** Defaults to a logger built from `config.log` and `config.roles` (createConfiguredLogger). */
-    logger?: KernelLogger;
-    /** 热更新时与来源原始值合并的环境变量，默认 `process.env`。 */
-    env?: NodeJS.ProcessEnv;
-    /**
-     * 运行使用的 AgentLoop 工厂（测试用）。默认是 {@link LangGraphLoop}：checkpoint 存在内核的
-     * `KyselyCheckpointSaver`，worker 崩溃后其他副本从 checkpoint 续跑。
-     */
-    loop?: (deps: LoopDeps) => AgentLoop;
-    /** 运行 worker 的测试钩子。 */
-    runHooks?: RunHooks;
-    /** 评测整轮回放的测试钩子。 */
-    evalHooks?: EvalReplayHooks;
-    /**
-     * The bootstrap step (package ecosystem spec §7, startup bootstrap spec). When given, `start()`
-     * runs it (see `extensions/bootstrap.ts`) before loading extensions unless it is already done for
-     * the manifest, and refuses to start when it cannot complete a required entry. `dir`: the
-     * optional offline directory whose `*.tgz` files are matched to the entries by sha512 (a missing
-     * directory is an empty one); entries without a matching file are downloaded from
-     * `packages.npmRegistry`. Omitted: no bootstrap step (tests, unless they ask for it).
-     */
-    bootstrap?: {
-        dir?: string;
-    };
-    /** The bootstrap manifest; default the `bootstrap.json` shipped with the kernel package. */
-    bootstrapManifest?: BootstrapManifest;
-    /**
-     * Where each extension deployment config field of the startup config comes from (the
-     * `extensionConfigSources` returned by `loadConfigWithSources`); these fields are read-only in the
-     * admin console (D8). When omitted it is derived from `config.extensionConfig`: fields present in
-     * the environment are `env`, the rest take the `CAPYBARA_CONFIG_SOURCE` kind (file / nacos).
-     */
-    extensionConfigSources?: Record<string, Record<string, ConfigSourceKind>>;
-}
-/**
- * 运行内核迁移与所有已配置插件的迁移（不调用插件 setup，不连接 Redis）。
- * 权限待批准的插件不迁移（`extensionPermissions.autoApprove` 时除外），经 `opts.onPending` 报告。
+ * Runs the kernel migrations and those of every configured extension (no extension `setup`, no
+ * Redis connection). Extensions whose permissions await approval are not migrated (unless
+ * `extensionPermissions.autoApprove`); they are reported through `opts.onPending`.
  */
 export declare function migrateAll(config: KernelConfig, opts?: {
     resolveFrom?: string;
@@ -255,5 +22,3 @@ export declare function migrateAll(config: KernelConfig, opts?: {
     plugin?: string;
     applied: string[];
 }[]>;
-/** 构建内核：创建连接（Redis 惰性连接）、插件宿主与 HTTP 应用；`start()` 才真正连接、迁移、加载插件与监听。 */
-export declare function createKernel(config: KernelConfig, opts?: KernelOptions): Promise<Kernel>;