@capybara-hq/kernel 0.1.0-rc.19 → 0.1.0-rc.20

package/dist/platform/ops/admin-items.ops.js

@@ -0,0 +1,278 @@
+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 { ToolError } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { AdminAgentListQuery, AdminConnectorListQuery, AgentIdParams, ConnectorIdParams, ConnectorStatusBody, } from "../../admin/admin-items.schemas.js";
+import { AdminAgents } from "../../agents/admin-agents.js";
+import { AgentsService } from "../../agents/agents.service.js";
+import { ApiError } from "../../errors.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { MembersService } from "../../orgs/members.service.js";
+import { rootConversationOf } from "../../runtime/subagents/child.js";
+import { AdminConnectors } from "../../tools/admin-connectors.js";
+import { ConnectorsService } from "../../tools/connectors.service.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { viaAgent } from "./errors.js";
+import { named, orElse } from "./summary.js";
+/**
+ * Refusal of an item another org owns: the tool's results enter this org's event log, where
+ * another org's items do not belong (Platform tool spec §6.1, §14.5 item 1).
+ */
+export const OTHER_ORG_ITEM = "This belongs to another organization; the Platform tool acts only on this conversation's organization. Use the admin console.";
+const AgentIdInput = AgentIdParams.strict();
+const ConnectorIdInput = ConnectorIdParams.strict();
+/**
+ * The super admin's agent and connector operations of the `Platform` tool (admin agents and
+ * connectors spec §4.5): the admin console's views and writes, run through the same services as
+ * the routes. Unlike the console they cover only the conversation's org: lists filter to it, and
+ * reads and writes of another org's item are refused (Platform tool spec §6.1). The owner transfer
+ * is excluded (human-only, as the org's own transfer route).
+ */
+let AdminItemsOperations = class AdminItemsOperations {
+    registry;
+    adminAgents;
+    agents;
+    adminConnectors;
+    connectors;
+    members;
+    kdb;
+    constructor(registry, adminAgents, agents, adminConnectors, connectors, members, kdb) {
+        this.registry = registry;
+        this.adminAgents = adminAgents;
+        this.agents = agents;
+        this.adminConnectors = adminConnectors;
+        this.connectors = connectors;
+        this.members = members;
+        this.kdb = kdb;
+    }
+    /** The agent's admin detail when it is the conversation org's; else {@link OTHER_ORG_ITEM}. */
+    async agentOf(agentId, ctx) {
+        const agent = await this.adminAgents.get(agentId);
+        if (agent.orgId !== ctx.orgId)
+            throw new ToolError(OTHER_ORG_ITEM);
+        return agent;
+    }
+    /** The connector's admin detail when it is the conversation org's; else {@link OTHER_ORG_ITEM}. */
+    async connectorOf(connectorId, ctx) {
+        const connector = await this.adminConnectors.get(connectorId);
+        if (connector.orgId !== ctx.orgId)
+            throw new ToolError(OTHER_ORG_ITEM);
+        return connector;
+    }
+    /** A precheck from a read: its `ApiError` code, or `notFound` for another org's item. */
+    async precheck(read, notFound) {
+        try {
+            await read();
+            return { ok: true };
+        }
+        catch (e) {
+            if (e instanceof ToolError)
+                return { ok: false, code: notFound, message: e.message };
+            if (e instanceof ApiError)
+                return { ok: false, code: e.code, message: e.message };
+            throw e;
+        }
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "admin.agents-list",
+                description: "List this org's agents as the admin console shows them (super admin): private ones too, with owner, visibility, whether the agent needs a new owner and the template it was created from. q searches the name; pages by limit (default 50), pass the returned next as after. Other orgs' agents are only in the admin console.",
+                input: AdminAgentListQuery.pick({ q: true, after: true, limit: true }).strict(),
+                example: { limit: 50 },
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/agents"],
+                confirm: "read",
+                run: (input, ctx) => this.adminAgents.list({ ...input, orgId: ctx.orgId }),
+            }),
+            defineOperation({
+                id: "admin.agent-get",
+                description: "Read one agent of this org as the admin console shows it (super admin): its definition with the instructions in full, members, profile with quick action labels, versions count, the skills and connectors it uses by name. Never its conversations or credentials.",
+                input: AgentIdInput,
+                example: { agentId: "7c1a5b0e-9a53-4c6b-8d64-2f5a1b0c3e77" },
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/agents/:agentId"],
+                confirm: "read",
+                errors: [{ code: "agent.not_found", next: "Check the agent id with admin.agents-list." }],
+                run: async (input, ctx) => ({ agent: await this.agentOf(input.agentId, ctx) }),
+            }),
+            defineOperation({
+                id: "admin.agent-delete",
+                description: "Delete an agent of this org on the platform's behalf (super admin), whoever owns it: its conversations stay readable but it can no longer be used, its eval runs stop and its pending skill changes are cancelled. The org's audit log records that the platform acted. The agent you are running as cannot be deleted.",
+                input: AgentIdInput,
+                example: { agentId: "7c1a5b0e-9a53-4c6b-8d64-2f5a1b0c3e77" },
+                authz: { superAdmin: true },
+                mirrors: ["DELETE /api/v1/admin/agents/:agentId"],
+                confirm: "platform",
+                errors: [
+                    { code: "agent.not_found", next: "Check the agent id with admin.agents-list." },
+                    {
+                        code: "agent.delete_current",
+                        next: "This is the agent you are running as: ask the person to delete it in the admin console, or delete a different agent.",
+                    },
+                ],
+                precheck: async (i, ctx) => {
+                    // the run's agent is the root conversation's: a sub-agent runs under its parent's agent
+                    const rootId = await rootConversationOf(this.kdb.db, ctx.conversationId);
+                    const root = await this.kdb.db
+                        .selectFrom("conversations")
+                        .select("agent_id")
+                        .where("id", "=", rootId)
+                        .executeTakeFirst();
+                    if (i.agentId === ctx.agentId || i.agentId === root?.agent_id) {
+                        return {
+                            ok: false,
+                            code: "agent.delete_current",
+                            message: "The agent you are running as cannot be deleted from here.",
+                        };
+                    }
+                    return this.precheck(() => this.agentOf(i.agentId, ctx), "agent.not_found");
+                },
+                summary: async (i, ctx) => {
+                    const n = await orElse(async () => named((await this.agentOf(i.agentId, ctx)).name), i.agentId);
+                    return {
+                        zh: `以平台身份删除智能体「${n}」；它的对话仍可查看，但不能再使用`,
+                        en: `Delete agent "${n}" on the platform's behalf; its conversations stay readable but it can no longer be used`,
+                    };
+                },
+                run: async (input, ctx) => {
+                    await this.agentOf(input.agentId, ctx);
+                    await this.agents.softDeleteAsPlatform(input.agentId, { accountId: ctx.actorAccountId }, viaAgent("admin.agent-delete", ctx));
+                    return { id: input.agentId, deleted: true };
+                },
+            }),
+            defineOperation({
+                id: "admin.connectors-list",
+                description: "List this org's connectors as the admin console shows them (super admin): name, protocol, status, tool count, who created it and from which template. Never an endpoint, credential or whether anyone has one. status and q (name search) filter; pages by limit (default 50), pass the returned next as after. Other orgs' connectors are only in the admin console.",
+                input: AdminConnectorListQuery.pick({
+                    status: true,
+                    q: true,
+                    after: true,
+                    limit: true,
+                }).strict(),
+                example: { limit: 50 },
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/connectors"],
+                confirm: "read",
+                run: (input, ctx) => this.adminConnectors.list({ ...input, orgId: ctx.orgId }),
+            }),
+            defineOperation({
+                id: "admin.connector-get",
+                description: "Read one connector of this org as the admin console shows it (super admin): its endpoint with large fields as size and hash only, the auth type and who holds the credential (the org or each person), and its tools with their state and default policy. Never a credential, token or secret, nor whether any member has one.",
+                input: ConnectorIdInput,
+                example: { connectorId: "5d2e8f1a-0b3c-4d5e-8f9a-1b2c3d4e5f60" },
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/connectors/:connectorId"],
+                confirm: "read",
+                errors: [
+                    {
+                        code: "connector.not_found",
+                        next: "Check the connector id with admin.connectors-list.",
+                    },
+                ],
+                run: async (input, ctx) => ({
+                    connector: await this.connectorOf(input.connectorId, ctx),
+                }),
+            }),
+            defineOperation({
+                id: "admin.connector-set-status",
+                description: "Disable or enable a connector of this org on the platform's behalf (super admin): status disabled takes its tools away from every agent until it is enabled again. Its endpoint and auth stay the org's to edit. The org's audit log records that the platform acted.",
+                input: z
+                    .object({
+                    connectorId: ConnectorIdParams.shape.connectorId,
+                    status: ConnectorStatusBody.shape.status,
+                })
+                    .strict(),
+                example: {
+                    connectorId: "5d2e8f1a-0b3c-4d5e-8f9a-1b2c3d4e5f60",
+                    status: "disabled",
+                },
+                authz: { superAdmin: true },
+                mirrors: ["PATCH /api/v1/admin/connectors/:connectorId"],
+                confirm: "platform",
+                errors: [
+                    {
+                        code: "connector.not_found",
+                        next: "Check the connector id with admin.connectors-list.",
+                    },
+                ],
+                precheck: (i, ctx) => this.precheck(() => this.connectorOf(i.connectorId, ctx), "connector.not_found"),
+                summary: async (i, ctx) => {
+                    const n = await orElse(async () => named((await this.connectorOf(i.connectorId, ctx)).name), i.connectorId);
+                    return i.status === "disabled"
+                        ? {
+                            zh: `以平台身份停用连接器「${n}」；智能体将失去其工具，直到重新启用`,
+                            en: `Disable connector "${n}" on the platform's behalf; agents lose its tools until it is enabled again`,
+                        }
+                        : {
+                            zh: `以平台身份启用连接器「${n}」`,
+                            en: `Enable connector "${n}" on the platform's behalf`,
+                        };
+                },
+                run: async (input, ctx) => {
+                    await this.connectorOf(input.connectorId, ctx);
+                    await this.connectors.setStatusAsPlatform(input.connectorId, input.status, { accountId: ctx.actorAccountId }, viaAgent("admin.connector-set-status", ctx));
+                    return { connector: await this.adminConnectors.get(input.connectorId) };
+                },
+            }),
+            defineOperation({
+                id: "admin.connector-delete",
+                description: "Delete a connector of this org on the platform's behalf (super admin): its credentials are deleted too and agents that use it lose its tools. Creating it again needs its credentials entered on the web. The org's audit log records that the platform acted.",
+                input: ConnectorIdInput,
+                example: { connectorId: "5d2e8f1a-0b3c-4d5e-8f9a-1b2c3d4e5f60" },
+                authz: { superAdmin: true },
+                mirrors: ["DELETE /api/v1/admin/connectors/:connectorId"],
+                confirm: "platform",
+                errors: [
+                    {
+                        code: "connector.not_found",
+                        next: "Check the connector id with admin.connectors-list.",
+                    },
+                ],
+                precheck: (i, ctx) => this.precheck(() => this.connectorOf(i.connectorId, ctx), "connector.not_found"),
+                summary: async (i, ctx) => {
+                    const n = await orElse(async () => named((await this.connectorOf(i.connectorId, ctx)).name), i.connectorId);
+                    return {
+                        zh: `以平台身份删除连接器「${n}」及其全部凭据；使用它的智能体将失去其工具`,
+                        en: `Delete connector "${n}" and all its credentials on the platform's behalf; agents that use it lose its tools`,
+                    };
+                },
+                run: async (input, ctx) => {
+                    await this.connectorOf(input.connectorId, ctx);
+                    await this.connectors.removeAsPlatform(input.connectorId, { accountId: ctx.actorAccountId }, viaAgent("admin.connector-delete", ctx));
+                    return { id: input.connectorId, deleted: true };
+                },
+            }),
+            defineOperation({
+                id: "admin.org-members",
+                description: "List the members of this conversation's org as the admin console reads them (super admin): account id, display name, email, role, when they joined and whether the account is the org's anonymous guest.",
+                input: z.object({}).strict(),
+                example: {},
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/orgs/:orgId/members"],
+                confirm: "read",
+                run: async (_input, ctx) => ({ members: await this.members.list(ctx.orgId) }),
+            }),
+        ]);
+    }
+};
+AdminItemsOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(AdminAgents)),
+    __param(2, Inject(AgentsService)),
+    __param(3, Inject(AdminConnectors)),
+    __param(4, Inject(ConnectorsService)),
+    __param(5, Inject(MembersService)),
+    __param(6, Inject(KernelDb))
+], AdminItemsOperations);
+export { AdminItemsOperations };

package/dist/platform/ops/admin.ops.d.ts

@@ -1,29 +1,25 @@
 import { type OnModuleInit } from "@nestjs/common";
-import { CatalogRequestsService } from "../../catalog/requests.service.js";
-import { ExtensionAdmin } from "../../extensions/admin-view.js";
+import { AdminHealthService } from "../../admin/health.service.js";
+import { AdminOverviewService } from "../../admin/overview.service.js";
+import { PlatformAuditService } from "../../admin/platform-audit.service.js";
+import { AdminUsageService } from "../../admin/usage.service.js";
 import { ExtensionDisplayNames } from "../../extensions/display-name.js";
 import { ExtensionRegistry } from "../../extensions/registry.js";
-import { AccountsService } from "../../identity/accounts.js";
 import { SettingsService } from "../../identity/settings.js";
 import { ModelEnablement } from "../../models/enablement.js";
 import { PricesService } from "../../models/prices.js";
 import { ModelPurposesService } from "../../models/purposes.js";
-import { OrgsService } from "../../orgs/orgs.service.js";
 import { ProviderRegistry } from "../../runtime/providers.js";
 import { ThemesService } from "../../themes/themes.service.js";
 import { PlatformOperations } from "../registry.js";
 /**
- * Admin console operations of the `Platform` tool (spec §14.2): the dashboard totals, the
+ * Admin console operations of the `Platform` tool (spec §14.2): the dashboard numbers and attention lists, the platform audit log, the
  * deployment settings, and the platform's models (the model catalog with the platform's disabled
  * list, the price table, the default model per purpose). Super admin only, through their own
  * private agent. The per-org overrides of models and purposes are the org's own pages.
  */
 export declare class AdminOperations implements OnModuleInit {
     private readonly registry;
-    private readonly extensions;
-    private readonly orgs;
-    private readonly accounts;
-    private readonly catalogRequests;
     private readonly settings;
     private readonly providers;
     private readonly displayNames;
@@ -32,7 +28,11 @@ export declare class AdminOperations implements OnModuleInit {
     private readonly prices;
     private readonly purposes;
     private readonly themes;
-    constructor(registry: PlatformOperations, extensions: ExtensionAdmin, orgs: OrgsService, accounts: AccountsService, catalogRequests: CatalogRequestsService, settings: SettingsService, providers: ProviderRegistry, displayNames: ExtensionDisplayNames, extensionRegistry: ExtensionRegistry, enablement: ModelEnablement, prices: PricesService, purposes: ModelPurposesService, themes: ThemesService);
+    private readonly audit;
+    private readonly overview;
+    private readonly health;
+    private readonly usage;
+    constructor(registry: PlatformOperations, settings: SettingsService, providers: ProviderRegistry, displayNames: ExtensionDisplayNames, extensionRegistry: ExtensionRegistry, enablement: ModelEnablement, prices: PricesService, purposes: ModelPurposesService, themes: ThemesService, audit: PlatformAuditService, overview: AdminOverviewService, health: AdminHealthService, usage: AdminUsageService);
     private assertProvider;
     onModuleInit(): void;
 }

package/dist/platform/ops/admin.ops.js

@@ -10,20 +10,21 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Inject, Injectable } from "@nestjs/common";
 import { z } from "zod";
 import { DeploymentSettingsBody, PurposeParams } from "../../admin/admin.schemas.js";
-import { CatalogRequestsService } from "../../catalog/requests.service.js";
+import { AuditListQuery } from "../../admin/audit.schemas.js";
+import { AdminHealthService } from "../../admin/health.service.js";
+import { UsageQuery } from "../../admin/overview.schemas.js";
+import { AdminOverviewService } from "../../admin/overview.service.js";
+import { PlatformAuditService } from "../../admin/platform-audit.service.js";
+import { AdminUsageService } from "../../admin/usage.service.js";
 import { ApiError } from "../../errors.js";
-import { ExtensionAdmin } from "../../extensions/admin-view.js";
 import { ExtensionDisplayNames } from "../../extensions/display-name.js";
-import { extensionNeedsAction } from "../../extensions/permission-view.js";
 import { ExtensionRegistry } from "../../extensions/registry.js";
-import { AccountsService } from "../../identity/accounts.js";
 import { DEPLOYMENT_SETTINGS_PATCH, SettingsService } from "../../identity/settings.js";
 import { ModelDisabledPatch, ModelProviderParams } from "../../models/enablement.controller.js";
 import { ModelEnablement } from "../../models/enablement.js";
 import { MODEL_PRICE_PUT, PricesService } from "../../models/prices.js";
 import { purposeTargetOf } from "../../models/purposes.controller.js";
 import { ModelPurposesService, PURPOSE_PUT, withDeclaredByNames } from "../../models/purposes.js";
-import { OrgsService } from "../../orgs/orgs.service.js";
 import { ProviderRegistry } from "../../runtime/providers.js";
 import { ThemesService } from "../../themes/themes.service.js";
 import { defineOperation } from "../operation.js";
@@ -46,18 +47,49 @@ const SettingsInput = DEPLOYMENT_SETTINGS_PATCH.pick({
 const ProviderId = ModelProviderParams.shape.provider.describe("The model provider (models.platform-list), e.g. the plugin name of its extension.");
 /** `provider/model` of a purpose target, or null. */
 const refOf = (t) => t === null ? null : `${t.model.provider}/${t.model.model}`;
+/** The attention lists as compact rows (`next`: the admin console page that fixes it). */
+function attentionRows(a) {
+    return {
+        items: [
+            ...a.extensions.map((e) => ({
+                kind: "extension",
+                id: e.name,
+                name: localized(e.displayName, e.name).en,
+                state: e.status,
+                reason: e.reason,
+                next: `Fix it on the extension's page in the admin console (/admin/extensions/${e.name}).`,
+            })),
+            ...a.updates.map((u) => ({
+                kind: "update",
+                id: u.itemId,
+                name: localized(u.displayName, u.name).en,
+                state: "newer_in_marketplace",
+                reason: `${u.version} -> ${u.marketplaceVersion}`,
+                next: `Upgrade it on the plugin's page in the admin console (/admin/plugins/${u.itemId}); a newer version is never imported automatically.`,
+            })),
+            ...a.providers.map((p) => ({
+                kind: "provider",
+                id: p.plugin,
+                name: localized(p.displayName, p.plugin).en,
+                state: p.problem === "list_failed" ? "error" : "ok",
+                reason: p.problem,
+                next: p.problem === "list_failed"
+                    ? `Check the provider's deployment config and connection on its extension page (/admin/extensions/${p.plugin}); the models page (/admin/models) shows the list.`
+                    : "The provider lists no chat model that is switched on: switch one on in the admin console (/admin/models) or check the provider's config.",
+            })),
+        ],
+        more: a.more,
+        unavailable: a.unavailable,
+    };
+}
 /**
- * Admin console operations of the `Platform` tool (spec §14.2): the dashboard totals, the
+ * Admin console operations of the `Platform` tool (spec §14.2): the dashboard numbers and attention lists, the platform audit log, the
  * deployment settings, and the platform's models (the model catalog with the platform's disabled
  * list, the price table, the default model per purpose). Super admin only, through their own
  * private agent. The per-org overrides of models and purposes are the org's own pages.
  */
 let AdminOperations = class AdminOperations {
     registry;
-    extensions;
-    orgs;
-    accounts;
-    catalogRequests;
     settings;
     providers;
     displayNames;
@@ -66,12 +98,12 @@ let AdminOperations = class AdminOperations {
     prices;
     purposes;
     themes;
-    constructor(registry, extensions, orgs, accounts, catalogRequests, settings, providers, displayNames, extensionRegistry, enablement, prices, purposes, themes) {
+    audit;
+    overview;
+    health;
+    usage;
+    constructor(registry, settings, providers, displayNames, extensionRegistry, enablement, prices, purposes, themes, audit, overview, health, usage) {
         this.registry = registry;
-        this.extensions = extensions;
-        this.orgs = orgs;
-        this.accounts = accounts;
-        this.catalogRequests = catalogRequests;
         this.settings = settings;
         this.providers = providers;
         this.displayNames = displayNames;
@@ -80,6 +112,10 @@ let AdminOperations = class AdminOperations {
         this.prices = prices;
         this.purposes = purposes;
         this.themes = themes;
+        this.audit = audit;
+        this.overview = overview;
+        this.health = health;
+        this.usage = usage;
     }
     assertProvider(provider) {
         if (!this.extensionRegistry.list("model-provider").some((e) => e.plugin === provider)) {
@@ -90,26 +126,59 @@ let AdminOperations = class AdminOperations {
         this.registry.register([
             defineOperation({
                 id: "admin.overview",
-                description: "The admin console's dashboard totals (super admin): extensions that need the super admin's action, catalog requests waiting for deployment, and the numbers of orgs and accounts.",
+                description: "The admin console's dashboard numbers (super admin): orgs, accounts and attentionTotal, everything waiting for a super admin (the platform inbox total plus the extensions, plugin updates and model providers admin.attention lists); partial is true when one of those lists could not be read right now (attentionTotal then leaves it out).",
                 input: z.object({}).strict(),
                 example: {},
                 authz: { superAdmin: true },
                 mirrors: ["GET /api/v1/admin/overview"],
                 confirm: "read",
-                run: async () => {
-                    const [plugins, orgs, accounts, catalogRequestsPending] = await Promise.all([
-                        this.extensions.list(),
-                        this.orgs.listAll(),
-                        this.accounts.count(),
-                        this.catalogRequests.countPendingDeployment(),
-                    ]);
-                    return {
-                        extensionsNeedingAction: plugins.filter((p) => extensionNeedsAction(p.status)).length,
-                        catalogRequestsPending,
-                        orgs: orgs.length,
-                        accounts,
-                    };
-                },
+                run: () => this.overview.stats(),
+            }),
+            defineOperation({
+                id: "admin.attention",
+                description: "What needs the super admin besides the platform inbox (super admin), one compact row each (kind, id, name, state, reason, next step): extensions (reason config, load_failed, approval, dependency, conflict, converging or legacy_format), platform plugins with a newer marketplace version (reason names both versions) and model providers (reason list_failed or no_chat_model). Each kind lists at most 20 rows; more counts the rest per kind. unavailable names a kind that could not be read right now (try again later). The platform inbox itself is inbox.platform-list.",
+                input: z.object({}).strict(),
+                example: {},
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/overview/attention"],
+                confirm: "read",
+                run: async () => attentionRows(await this.overview.attention()),
+            }),
+            defineOperation({
+                id: "admin.health",
+                description: 'How the platform runs right now (super admin), to answer "is the worker up, is the run queue backing up": kernel.version; replicas (live kernel processes: id, roles, version, startedAt) and roles (live replicas per role: api serves requests, worker runs conversations and jobs, gateway holds channel and device connections; 0 workers means no run starts); queues (per kernel queue, e.g. cap-kernel-runs: waiting, active, delayed, failed and failedLastDay, counts only); channels (online, offline: active long connections no replica holds, webhook, disabled, error); devices (online / local); sandboxes (running, suspended, running per provider). unavailable names a source that did not answer (redis or database); its numbers are then null. Failure details are in the kernel logs, not here.',
+                input: z.object({}).strict(),
+                example: {},
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/overview/health"],
+                confirm: "read",
+                run: () => this.health.read(),
+            }),
+            defineOperation({
+                id: "admin.usage",
+                description: "What the platform used over the last 7 days (super admin): today and the 6 days before, as calendar days in tz (an IANA zone such as Asia/Shanghai; use the person's own zone). days has one entry per day, oldest first: runs (every run, sub-agent and eval replay runs included), tokens (input, output, cacheRead, cacheWrite of every model call, and embedding) and cost. cost is an estimate from the model prices the super admin entered (models.prices), in currency; it is null when tokens were used and none of them had a price, and costPartial is true when some tokens had no price (the costs then count only the priced ones). orgs lists the 10 orgs that used the most tokens (runs, tokens, cost each); otherOrgs sums the rest (count, runs, tokens, cost). Totals only: never per account, agent or conversation. The answer may be up to 5 minutes old. admin.usage_unavailable means the database took too long: try again later.",
+                input: UsageQuery.strict(),
+                example: { tz: "Asia/Shanghai" },
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/overview/usage"],
+                confirm: "read",
+                errors: [
+                    {
+                        code: "admin.usage_unavailable",
+                        next: "The usage numbers took too long to compute; try again in a few minutes.",
+                    },
+                ],
+                run: (input) => this.usage.week(input.tz),
+            }),
+            defineOperation({
+                id: "admin.audit",
+                description: "The platform-level audit log (super admin), newest first: deployment settings, accounts, marketplaces, catalog imports and scope, extensions, model prices and purposes, setup. Each event has its id, time, actor (id, name, email; null for the kernel itself), viaToken (done with a personal access token), viaAgent (done through the Platform tool), action and target; never the event's details, and never an org's own events. limit is 1 to 100 (default 20); pages by keyset: pass the returned next as params.after (null: no more).",
+                input: AuditListQuery.strict(),
+                example: { limit: 20 },
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/audit"],
+                confirm: "read",
+                run: (input) => this.audit.list(input),
             }),
             defineOperation({
                 id: "admin.settings",
@@ -412,17 +481,17 @@ let AdminOperations = class AdminOperations {
 AdminOperations = __decorate([
     Injectable(),
     __param(0, Inject(PlatformOperations)),
-    __param(1, Inject(ExtensionAdmin)),
-    __param(2, Inject(OrgsService)),
-    __param(3, Inject(AccountsService)),
-    __param(4, Inject(CatalogRequestsService)),
-    __param(5, Inject(SettingsService)),
-    __param(6, Inject(ProviderRegistry)),
-    __param(7, Inject(ExtensionDisplayNames)),
-    __param(8, Inject(ExtensionRegistry)),
-    __param(9, Inject(ModelEnablement)),
-    __param(10, Inject(PricesService)),
-    __param(11, Inject(ModelPurposesService)),
-    __param(12, Inject(ThemesService))
+    __param(1, Inject(SettingsService)),
+    __param(2, Inject(ProviderRegistry)),
+    __param(3, Inject(ExtensionDisplayNames)),
+    __param(4, Inject(ExtensionRegistry)),
+    __param(5, Inject(ModelEnablement)),
+    __param(6, Inject(PricesService)),
+    __param(7, Inject(ModelPurposesService)),
+    __param(8, Inject(ThemesService)),
+    __param(9, Inject(PlatformAuditService)),
+    __param(10, Inject(AdminOverviewService)),
+    __param(11, Inject(AdminHealthService)),
+    __param(12, Inject(AdminUsageService))
 ], AdminOperations);
 export { AdminOperations };

package/dist/platform/ops/agent-skills.ops.d.ts

@@ -1,21 +1,47 @@
 import { type OnModuleInit } from "@nestjs/common";
 import { AgentsService } from "../../agents/agents.service.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { SandboxFileReader } from "../../sandbox/sandbox-file-reader.js";
+import { AgentSkillsService } from "../../skills/agent-skills.service.js";
 import { SkillChangesService } from "../../skills/changes.service.js";
 import { SkillInvoker } from "../../skills/invoke.js";
 import { SkillsService } from "../../skills/skills.service.js";
 import { PlatformOperations } from "../registry.js";
 /**
  * The skills of one agent and the skill change inbox detail (`Platform` tool, spec §14): reads of
- * the agent's own skills and of the invocable ones, detaching a skill, and the detail of a pending
- * skill change as the inbox shows it. Deciding a change stays `human-only`.
+ * the agent's own skills and of the invocable ones, registering, deleting and sharing a skill,
+ * and the detail of a skill change request as the inbox shows it. Deciding a request stays
+ * `human-only` (org admins on the web).
  */
 export declare class AgentSkillsOperations implements OnModuleInit {
     private readonly registry;
     private readonly agents;
     private readonly skills;
     private readonly changes;
+    private readonly agentSkills;
     private readonly invoker;
-    constructor(registry: PlatformOperations, agents: AgentsService, skills: SkillsService, changes: SkillChangesService, invoker: SkillInvoker);
+    private readonly files;
+    private readonly db;
+    constructor(registry: PlatformOperations, agents: AgentsService, skills: SkillsService, changes: SkillChangesService, agentSkills: AgentSkillsService, invoker: SkillInvoker, files: SandboxFileReader, db: KernelDb);
+    /**
+     * Class of registering a skill on the run's agent: `personal` on a private agent the actor owns
+     * whose `skills.writePolicy` is not `ask`; otherwise `org` (asked every time, never remembered).
+     * Also `org` when the registration may apply a version to a shared org skill at once (the actor
+     * is an org admin maintaining one; the package name is not known before the card).
+     */
+    private registerClass;
+    /**
+     * The refusals read before anything touches the sandbox (the reader checks only the device):
+     * a sub-agent conversation, then an actor who is not the agent's current owner.
+     */
+    private registerCheck;
+    /**
+     * The refusals of sharing read before the card: a sub-agent conversation, an actor who is not
+     * the agent's current owner, a skill that is not one of the agent's own.
+     */
+    private shareCheck;
+    /** The file count of a registered version (null for a proposal or when the row is gone). */
+    private filesOf;
     /** Class of deleting a skill: your own private agent is personal; a shared agent is the org's. */
     private deleteClass;
     /** The route's refusals, read before the card: a visible agent, owned by the actor, with the skill. */