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

package/dist/platform/ops/requests.ops.js

@@ -0,0 +1,153 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { CatalogRequestsService } from "../../catalog/requests.service.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { asToolError, viaAgent } from "./errors.js";
+import { Cursor, pageOf, startOf } from "./paging.js";
+const Note = z.string().max(1000);
+/** A request as the requester reads it (no org name: it is this org's). */
+const view = (r) => ({
+    id: r.id,
+    kind: r.kind,
+    status: r.status,
+    item: r.item,
+    entry: r.entry,
+    agent: r.agent,
+    note: r.note,
+    reason: r.reason,
+    decidedAt: r.decidedAt,
+    createdAt: r.createdAt,
+});
+/**
+ * Request operations of the `Platform` tool (spec §7): a member asks the org admins to switch a
+ * plugin on, an org admin asks the super admin for access to a plugin or for an import from a
+ * marketplace. Deciding a request is human-only (spec §6.4) and not offered.
+ */
+let RequestsOperations = class RequestsOperations {
+    registry;
+    requests;
+    constructor(registry, requests) {
+        this.registry = registry;
+        this.requests = requests;
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "requests.list-mine",
+                description: "List the requests you made in this org, pending and decided, newest first: what was asked (a plugin, a marketplace entry, an agent's connectors), the status and a rejection's reason. Pages by 50: pass the returned next as params.cursor.",
+                input: z.object({ cursor: Cursor.optional() }).strict(),
+                example: {},
+                authz: { orgAction: "catalog.request" },
+                mirrors: [],
+                confirm: "read",
+                run: async (input, ctx) => {
+                    const mine = await this.requests.listForRequester(ctx.orgId, ctx.actorAccountId);
+                    return pageOf(mine.map(view), startOf(input.cursor), 50);
+                },
+            }),
+            defineOperation({
+                id: "requests.create",
+                description: 'Ask for a plugin: kind "enable" asks the org admins to switch on a plugin that is off in this org (members and up); kind "access" asks the super admin to offer this org a plugin it sees as not_offered (org admins). Take the plugin id and state from plugins.list. An optional note says why.',
+                input: z
+                    .object({
+                    itemId: z.string().min(1).max(100),
+                    kind: z.enum(["enable", "access"]),
+                    note: Note.optional(),
+                })
+                    .strict(),
+                example: {
+                    itemId: "3f1c2a9e-5b7d-4e21-9c0a-1d2e3f4a5b6c",
+                    kind: "enable",
+                    note: "Our team needs it for the weekly report.",
+                },
+                authz: { orgAction: "catalog.request" },
+                mirrors: ["POST /api/v1/orgs/:orgId/catalog/:itemId/requests"],
+                confirm: "personal",
+                errors: [
+                    {
+                        code: "catalog.request_pending",
+                        next: "The org already has a pending request of this kind for the plugin; nothing to do but wait.",
+                    },
+                    {
+                        code: "catalog.request_invalid",
+                        next: 'The plugin\'s state does not fit the kind: "enable" needs state off, "access" needs not_offered. Check plugins.list.',
+                    },
+                    {
+                        code: "forbidden",
+                        next: 'Only org admins can ask for access; ask an org admin, or use kind "enable".',
+                    },
+                ],
+                summary: (i) => i.kind === "enable"
+                    ? {
+                        zh: `申请在本组织启用插件 ${i.itemId}`,
+                        en: `Request that plugin ${i.itemId} be enabled in the org`,
+                    }
+                    : {
+                        zh: `向超级管理员申请插件 ${i.itemId} 的使用权`,
+                        en: `Request access to plugin ${i.itemId} from the super admin`,
+                    },
+                run: async (input, ctx) => asToolError(async () => ({
+                    request: view(await this.requests.requestItem(ctx.orgId, ctx.actorAccountId, input.itemId, { kind: input.kind, ...(input.note !== undefined && { note: input.note }) }, { auditDetail: viaAgent("requests.create", ctx) })),
+                })),
+            }),
+            defineOperation({
+                id: "requests.create-import",
+                description: "Ask the super admin to import a plugin from a marketplace into the platform catalog (org admins, when the platform lets orgs browse): the marketplaceId, name and version from marketplaces.entries, and an optional note.",
+                input: z
+                    .object({
+                    marketplaceId: z.string().min(1).max(100),
+                    name: z.string().min(1).max(214),
+                    version: z.string().min(1).max(100),
+                    note: Note.optional(),
+                })
+                    .strict(),
+                example: { marketplaceId: "official", name: "github", version: "1.4.0" },
+                authz: { orgAction: "catalog.decide" },
+                mirrors: ["POST /api/v1/orgs/:orgId/marketplace-requests"],
+                confirm: "org",
+                errors: [
+                    {
+                        code: "catalog.marketplace_browse_disabled",
+                        next: "The platform does not let orgs request imports; ask the super admin directly.",
+                    },
+                    {
+                        code: "catalog.request_invalid",
+                        next: 'The plugin is in the catalog already: use requests.create with kind "access" or "enable".',
+                    },
+                    {
+                        code: "catalog.request_pending",
+                        next: "A request for this entry is pending already; wait for the super admin.",
+                    },
+                ],
+                summary: (i) => ({
+                    zh: `申请从市场导入插件 ${i.name} ${i.version}`,
+                    en: `Request the import of plugin ${i.name} ${i.version} from a marketplace`,
+                }),
+                run: async (input, ctx) => asToolError(async () => ({
+                    request: view(await this.requests.requestImport(ctx.orgId, ctx.actorAccountId, {
+                        marketplaceId: input.marketplaceId,
+                        name: input.name,
+                        version: input.version,
+                        ...(input.note !== undefined && { note: input.note }),
+                    }, { auditDetail: viaAgent("requests.create-import", ctx) })),
+                })),
+            }),
+        ]);
+    }
+};
+RequestsOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(CatalogRequestsService))
+], RequestsOperations);
+export { RequestsOperations };

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

@@ -0,0 +1,4 @@
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
+import type { OrgRole } from "../../orgs/roles.js";
+/** The account's role in the org, read now; null when it is not a member. */
+export declare function roleOf(db: KernelSchemaDb, orgId: string, accountId: string): Promise<OrgRole | null>;

package/dist/platform/ops/role.js

@@ -0,0 +1,10 @@
+/** The account's role in the org, read now; null when it is not a member. */
+export async function roleOf(db, orgId, accountId) {
+    const m = await db
+        .selectFrom("memberships")
+        .select("role")
+        .where("org_id", "=", orgId)
+        .where("account_id", "=", accountId)
+        .executeTakeFirst();
+    return m?.role ?? null;
+}

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

@@ -0,0 +1,13 @@
+import { type OnModuleInit } from "@nestjs/common";
+import { SkillsService } from "../../skills/skills.service.js";
+import { PlatformOperations } from "../registry.js";
+/**
+ * Skill library operations of the `Platform` tool (spec §7). The skill body can be long; `get`
+ * returns it whole because reading it is the point of the call.
+ */
+export declare class SkillsOperations implements OnModuleInit {
+    private readonly registry;
+    private readonly skills;
+    constructor(registry: PlatformOperations, skills: SkillsService);
+    onModuleInit(): void;
+}

package/dist/platform/ops/skills.ops.js

@@ -0,0 +1,98 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { SkillsService } from "../../skills/skills.service.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { asToolError, viaAgent } from "./errors.js";
+const NoInput = z.object({}).strict();
+const SkillId = z.object({ skillId: z.string().min(1).max(100) }).strict();
+/**
+ * Skill library operations of the `Platform` tool (spec §7). The skill body can be long; `get`
+ * returns it whole because reading it is the point of the call.
+ */
+let SkillsOperations = class SkillsOperations {
+    registry;
+    skills;
+    constructor(registry, skills) {
+        this.registry = registry;
+        this.skills = skills;
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "skills.list",
+                description: "List the skills the org can use, org skills and platform skills switched on in it. Each entry has an id, name, description, current version and where it came from.",
+                input: NoInput,
+                example: {},
+                authz: { orgAction: "skills.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId/skills"],
+                confirm: "read",
+                run: async (_input, ctx) => ({ skills: await this.skills.list(ctx.orgId) }),
+            }),
+            defineOperation({
+                id: "skills.get",
+                description: "Read one skill: its description, versions, file list and the current SKILL.md body. Takes the skill id from skills.list.",
+                input: SkillId,
+                example: { skillId: "0b9f2c4e-1d3a-4c55-9e0a-7a2f6d1c8b11" },
+                authz: { orgAction: "skills.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId/skills/:id"],
+                confirm: "read",
+                run: async (input, ctx) => asToolError(() => this.skills.get(ctx.orgId, input.skillId)),
+            }),
+            defineOperation({
+                id: "skills.create",
+                description: "Create an org skill from text: a name, a one-line description of when to use it, and the SKILL.md body. A skill of that name must not exist yet. Uploads of packages are done on the web.",
+                input: z
+                    .object({
+                    name: z.string().min(1).max(64),
+                    description: z.string().min(1).max(1024),
+                    body: z.string().min(1).max(100_000),
+                    shareable: z.boolean().optional(),
+                })
+                    .strict(),
+                example: {
+                    name: "weekly-report",
+                    description: "Use when asked to write the weekly status report.",
+                    body: "# Steps\n\n1. Collect this week's updates.\n2. Write the report.",
+                },
+                authz: { orgAction: "skills.manage" },
+                mirrors: ["POST /api/v1/orgs/:orgId/skills"],
+                confirm: "org",
+                errors: [
+                    {
+                        code: "skill.name_exists",
+                        next: "A skill of that name exists: pick another name, or read the existing one with skills.get.",
+                    },
+                ],
+                summary: (i) => i.shareable === true
+                    ? {
+                        zh: `新建组织技能「${i.name}」（可共享给其他组织）`,
+                        en: `Create org skill "${i.name}" (shared with other orgs)`,
+                    }
+                    : { zh: `新建组织技能「${i.name}」`, en: `Create org skill "${i.name}"` },
+                run: async (input, ctx) => asToolError(() => this.skills.createFromText(ctx.orgId, ctx.actorAccountId, {
+                    name: input.name,
+                    description: input.description,
+                    body: input.body,
+                    ...(input.shareable !== undefined && { shareable: input.shareable }),
+                    auditDetail: viaAgent("skills.create", ctx),
+                })),
+            }),
+        ]);
+    }
+};
+SkillsOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(SkillsService))
+], SkillsOperations);
+export { SkillsOperations };

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

@@ -0,0 +1,10 @@
+import type { LocalizedName } from "@capybara-hq/plugin-sdk";
+/** A name as a card summary quotes it: clipped to {@link NAME_MAX}. */
+export declare const named: (s: string) => string;
+/** A display name in both languages, clipped; `fallback` (the plain name) for a missing one. */
+export declare const localized: (n: LocalizedName | null | undefined, fallback: string) => {
+    zh: string;
+    en: string;
+};
+/** The value of `read`, or `fallback` when the read throws (a summary never fails on a name). */
+export declare function orElse<T>(read: () => Promise<T>, fallback: T): Promise<T>;

package/dist/platform/ops/summary.js

@@ -0,0 +1,18 @@
+/** Longest name quoted in a card summary (a name is set by people, and by agents through tools). */
+const NAME_MAX = 80;
+/** A name as a card summary quotes it: clipped to {@link NAME_MAX}. */
+export const named = (s) => (s.length > NAME_MAX ? `${s.slice(0, NAME_MAX)}…` : s);
+/** A display name in both languages, clipped; `fallback` (the plain name) for a missing one. */
+export const localized = (n, fallback) => ({
+    zh: named(n?.zh ?? fallback),
+    en: named(n?.en ?? fallback),
+});
+/** The value of `read`, or `fallback` when the read throws (a summary never fails on a name). */
+export async function orElse(read, fallback) {
+    try {
+        return await read();
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/platform/platform-ops.module.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The `Platform` tool's operations (ruling P2): one provider per domain, each registering its
+ * operations into `PlatformOperations` from `onModuleInit`. It imports the domain modules, which
+ * `PlatformModule` itself must not.
+ */
+export declare class PlatformOpsModule {
+}

package/dist/platform/platform-ops.module.js

@@ -0,0 +1,55 @@
+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 { AgentsModule } from "../agents/agents.module.js";
+import { CatalogModule } from "../catalog/catalog.module.js";
+import { ExtensionsModule } from "../extensions/extensions.module.js";
+import { OrgsModule } from "../orgs/orgs.module.js";
+import { SkillsModule } from "../skills/skills.module.js";
+import { ToolsModule } from "../tools/tools.module.js";
+import { AgentTemplatesOperations } from "./ops/agent-templates.ops.js";
+import { AgentsOperations } from "./ops/agents.ops.js";
+import { ConnectorsOperations } from "./ops/connectors.ops.js";
+import { ExtensionsOperations } from "./ops/extensions.ops.js";
+import { MarketplacesOperations } from "./ops/marketplaces.ops.js";
+import { PlatformOperationsProvider } from "./ops/platform.ops.js";
+import { PluginsOperations } from "./ops/plugins.ops.js";
+import { RequestsOperations } from "./ops/requests.ops.js";
+import { SkillsOperations } from "./ops/skills.ops.js";
+import { PlatformModule } from "./platform.module.js";
+/**
+ * The `Platform` tool's operations (ruling P2): one provider per domain, each registering its
+ * operations into `PlatformOperations` from `onModuleInit`. It imports the domain modules, which
+ * `PlatformModule` itself must not.
+ */
+let PlatformOpsModule = class PlatformOpsModule {
+};
+PlatformOpsModule = __decorate([
+    Module({
+        imports: [
+            PlatformModule,
+            SkillsModule,
+            AgentsModule,
+            OrgsModule,
+            CatalogModule,
+            ExtensionsModule,
+            ToolsModule,
+        ],
+        providers: [
+            PlatformOperationsProvider,
+            SkillsOperations,
+            AgentsOperations,
+            AgentTemplatesOperations,
+            PluginsOperations,
+            MarketplacesOperations,
+            RequestsOperations,
+            ConnectorsOperations,
+            ExtensionsOperations,
+        ],
+    })
+], PlatformOpsModule);
+export { PlatformOpsModule };

package/dist/platform/platform.module.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The `Platform` tool's core (Platform tool spec §3, §6, §7): the operation registry, the actor
+ * facts and the agent docs. It imports no domain module (ruling P2), so `ToolsModule` can import it without a
+ * cycle; domain providers register their operations into `PlatformOperations` from
+ * `onModuleInit`.
+ */
+export declare class PlatformModule {
+}

package/dist/platform/platform.module.js

@@ -0,0 +1,25 @@
+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 { PlatformActor } from "./actor.js";
+import { AgentDocs } from "./agent-docs.js";
+import { PlatformOperations } from "./registry.js";
+/**
+ * The `Platform` tool's core (Platform tool spec §3, §6, §7): the operation registry, the actor
+ * facts and the agent docs. It imports no domain module (ruling P2), so `ToolsModule` can import it without a
+ * cycle; domain providers register their operations into `PlatformOperations` from
+ * `onModuleInit`.
+ */
+let PlatformModule = class PlatformModule {
+};
+PlatformModule = __decorate([
+    Module({
+        providers: [PlatformOperations, PlatformActor, AgentDocs],
+        exports: [PlatformOperations, PlatformActor, AgentDocs],
+    })
+], PlatformModule);
+export { PlatformModule };

package/dist/platform/redact-orgs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A super-admin result as it may enter one org's event log (Platform tool spec §6.1): every org
+ * list becomes `{ count }`, org ids and names elsewhere are dropped, and an org owner is given as
+ * `{ kind: "org" }` only. Shared agents, trajectories and eval snapshots expose the log to other
+ * people, so another org is never named or described; the admin console shows which.
+ */
+export declare function redactOrgs(value: unknown): unknown;

package/dist/platform/redact-orgs.js

@@ -0,0 +1,52 @@
+/**
+ * Keys whose value lists orgs in the platform views (`CatalogItemView.scopeOrgs`, the update
+ * preview's `extension.orgs`, `connectorOrgs`, a component's `pinnedOrgs` and `kept`, a scope
+ * preview's `affected`, …): replaced with `{ count }`.
+ */
+const ORG_LISTS = new Set([
+    "orgs",
+    "scopeOrgs",
+    "pinnedOrgs",
+    "connectorOrgs",
+    "kept",
+    "usedBy",
+    "affected",
+]);
+/** Keys naming one org, or orgs by id: dropped. */
+const ORG_KEYS = new Set([
+    "orgId",
+    "orgIds",
+    "orgName",
+    "orgNames",
+    "ownerOrgId",
+]);
+/**
+ * A super-admin result as it may enter one org's event log (Platform tool spec §6.1): every org
+ * list becomes `{ count }`, org ids and names elsewhere are dropped, and an org owner is given as
+ * `{ kind: "org" }` only. Shared agents, trajectories and eval snapshots expose the log to other
+ * people, so another org is never named or described; the admin console shows which.
+ */
+export function redactOrgs(value) {
+    if (Array.isArray(value))
+        return value.map(redactOrgs);
+    if (value === null || typeof value !== "object")
+        return value;
+    if (value instanceof Date)
+        return value;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (ORG_KEYS.has(k))
+            continue;
+        if (ORG_LISTS.has(k) && Array.isArray(v)) {
+            out[k] = { count: v.length };
+            continue;
+        }
+        if (k === "owner" && isOrgOwner(v)) {
+            out[k] = { kind: "org" };
+            continue;
+        }
+        out[k] = redactOrgs(v);
+    }
+    return out;
+}
+const isOrgOwner = (v) => typeof v === "object" && v !== null && v.kind === "org";

package/dist/platform/registry.d.ts

@@ -0,0 +1,30 @@
+import { type PlatformOperation } from "./operation.js";
+/**
+ * The `Platform` tool's operations (spec §7). Domain providers add theirs with {@link register}
+ * from `onModuleInit` (ruling P2: this module imports no domain module); a bad batch throws and
+ * registers nothing, so a mistake fails the kernel's start.
+ */
+export declare class PlatformOperations {
+    private readonly ops;
+    /**
+     * Adds `ops`. Throws on an id not shaped `<domain>.<verb>`, a domain outside
+     * {@link PLATFORM_DOMAINS}, a duplicate id (in the batch or already registered), or a write
+     * (`confirm` other than `read`) without `summary`.
+     */
+    register(ops: readonly PlatformOperation[]): void;
+    domains(): readonly {
+        id: string;
+        description: string;
+    }[];
+    /** The domain's operations, sorted by id. */
+    inDomain(domain: string): PlatformOperation[];
+    get(id: string): PlatformOperation | null;
+    /** Every operation, sorted by id. */
+    all(): PlatformOperation[];
+    /**
+     * Keyword search (deterministic, like ToolSearch's): per distinct query term,
+     * `idf × (ID_WEIGHT if in the id + 1 if in the description)`; a term also matches a word it is a
+     * prefix of. Zero scores are dropped; ties go by id.
+     */
+    search(query: string, limit: number): PlatformOperation[];
+}

package/dist/platform/registry.js

@@ -0,0 +1,111 @@
+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 { Injectable } from "@nestjs/common";
+import { tokenize } from "../tools/builtins/tool-search.js";
+import { OPERATION_ID, operationDomain, PLATFORM_DOMAINS, } from "./operation.js";
+/** A word of an operation id weighs more than a word of its description (like ToolSearch). */
+const ID_WEIGHT = 2;
+/** The shortest query term that also matches as a word's prefix (`skill` → `skills`). */
+const MIN_PREFIX = 3;
+const DOMAIN_IDS = new Set(PLATFORM_DOMAINS.map((d) => d.id));
+const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+/** A query term matches a word when equal, or as its prefix when long enough. */
+const matches = (words, term) => {
+    if (words.has(term))
+        return true;
+    if (term.length < MIN_PREFIX)
+        return false;
+    for (const w of words)
+        if (w.startsWith(term))
+            return true;
+    return false;
+};
+/**
+ * The `Platform` tool's operations (spec §7). Domain providers add theirs with {@link register}
+ * from `onModuleInit` (ruling P2: this module imports no domain module); a bad batch throws and
+ * registers nothing, so a mistake fails the kernel's start.
+ */
+let PlatformOperations = class PlatformOperations {
+    ops = new Map();
+    /**
+     * Adds `ops`. Throws on an id not shaped `<domain>.<verb>`, a domain outside
+     * {@link PLATFORM_DOMAINS}, a duplicate id (in the batch or already registered), or a write
+     * (`confirm` other than `read`) without `summary`.
+     */
+    register(ops) {
+        const seen = new Set();
+        for (const op of ops) {
+            if (!OPERATION_ID.test(op.id)) {
+                throw new Error(`Platform operation id "${op.id}" is not shaped <domain>.<verb>`);
+            }
+            if (!DOMAIN_IDS.has(operationDomain(op.id))) {
+                throw new Error(`Platform operation "${op.id}" names an unknown domain`);
+            }
+            if (seen.has(op.id) || this.ops.has(op.id)) {
+                throw new Error(`duplicate Platform operation "${op.id}"`);
+            }
+            if (op.confirm !== "read" && op.summary === undefined) {
+                throw new Error(`Platform operation "${op.id}" is a write without a summary`);
+            }
+            seen.add(op.id);
+        }
+        for (const op of ops)
+            this.ops.set(op.id, op);
+    }
+    domains() {
+        return PLATFORM_DOMAINS;
+    }
+    /** The domain's operations, sorted by id. */
+    inDomain(domain) {
+        return this.all().filter((op) => operationDomain(op.id) === domain);
+    }
+    get(id) {
+        return this.ops.get(id) ?? null;
+    }
+    /** Every operation, sorted by id. */
+    all() {
+        return [...this.ops.values()].sort(byId);
+    }
+    /**
+     * Keyword search (deterministic, like ToolSearch's): per distinct query term,
+     * `idf × (ID_WEIGHT if in the id + 1 if in the description)`; a term also matches a word it is a
+     * prefix of. Zero scores are dropped; ties go by id.
+     */
+    search(query, limit) {
+        const terms = [...new Set(tokenize(query))];
+        if (terms.length === 0)
+            return [];
+        const docs = this.all().map((op) => ({
+            op,
+            id: new Set(tokenize(op.id)),
+            desc: new Set(tokenize(op.description)),
+        }));
+        const n = docs.length;
+        const idf = new Map();
+        for (const term of terms) {
+            const df = docs.filter((d) => matches(d.id, term) || matches(d.desc, term)).length;
+            idf.set(term, df === 0 ? 0 : Math.log(1 + n / df));
+        }
+        return docs
+            .map((d) => {
+            let score = 0;
+            for (const term of terms) {
+                const w = (matches(d.id, term) ? ID_WEIGHT : 0) + (matches(d.desc, term) ? 1 : 0);
+                score += w * (idf.get(term) ?? 0);
+            }
+            return { op: d.op, score };
+        })
+            .filter((x) => x.score > 0)
+            .sort((a, b) => (b.score !== a.score ? b.score - a.score : byId(a.op, b.op)))
+            .slice(0, limit)
+            .map((x) => x.op);
+    }
+};
+PlatformOperations = __decorate([
+    Injectable()
+], PlatformOperations);
+export { PlatformOperations };

package/dist/roles/worker-role.d.ts

@@ -1,3 +1,4 @@
+import { PluginScopeSyncProcessor } from "../catalog/scope-sync.js";
 import { ChannelsProcessor } from "../channels/channels.module.js";
 import { ChannelOutbound } from "../channels/outbound.js";
 import { TitleQueue } from "../conversations/titles.js";
@@ -14,8 +15,8 @@ import { UsageReporter } from "../runtime/usage-report.js";
 /**
  * The worker role's parts, driven by `KernelLifecycle` at fixed points of its start order and stop
  * phases (so they stay ordered after the extension load and before the extension host closes): the
- * queue consumers (runs, sub-agent runs, evals, maintenance, channel deliveries, `usage.report`,
- * titles) and the schedulers of the `@LockedCron` / `@LockedInterval` jobs. Provided only by
+ * queue consumers (runs, sub-agent runs, evals, maintenance, the plugin scope sync, channel
+ * deliveries, `usage.report`, titles) and the schedulers of the `@LockedCron` / `@LockedInterval` jobs. Provided only by
  * `WorkerModule`, so a process without the worker role has none of them.
  */
 export declare class WorkerRole {
@@ -34,13 +35,14 @@ export declare class WorkerRole {
     private readonly channelsProcessor;
     private readonly evalsProcessor;
     private readonly maintenanceProcessor;
+    private readonly scopeProcessor;
     /** The startup config (the roles). */
     private readonly config;
     /** The run worker was started: the runs phase drains it. */
     private runsStarted;
     /** The eval worker was started: the runs phase drains it. */
     private evalsStarted;
-    constructor(config: KernelConfigService, log: KernelLogger, intervals: LockedIntervalScheduler, scheduledRuns: ScheduledRuns, runWorker: RunWorker, evalWorker: EvalWorker, usageReport: UsageReporter, titles: TitleQueue, channelOutbound: ChannelOutbound, runsProcessor: RunsProcessor, subagentRunsProcessor: SubagentRunsProcessor, usageProcessor: UsageReportProcessor, titleProcessor: TitleProcessor, channelsProcessor: ChannelsProcessor, evalsProcessor: EvalsProcessor, maintenanceProcessor: MaintenanceProcessor);
+    constructor(config: KernelConfigService, log: KernelLogger, intervals: LockedIntervalScheduler, scheduledRuns: ScheduledRuns, runWorker: RunWorker, evalWorker: EvalWorker, usageReport: UsageReporter, titles: TitleQueue, channelOutbound: ChannelOutbound, runsProcessor: RunsProcessor, subagentRunsProcessor: SubagentRunsProcessor, usageProcessor: UsageReportProcessor, titleProcessor: TitleProcessor, channelsProcessor: ChannelsProcessor, evalsProcessor: EvalsProcessor, maintenanceProcessor: MaintenanceProcessor, scopeProcessor: PluginScopeSyncProcessor);
     /**
      * Starts the queue consumers (after the extension load), then opens the schedules' start gate:
      * the cron and interval timers were armed at application bootstrap, but every tick before this
@@ -58,6 +60,6 @@ export declare class WorkerRole {
     drainRuns(budgetMs: number): Promise<void> | undefined;
     /** The eval cases in progress stop (undefined: never started). */
     drainEvals(budgetMs: number): Promise<void> | undefined;
-    /** Closes the maintenance queue's worker. */
+    /** Closes the maintenance queue's worker and the plugin scope sync's (it stops between pairs). */
     closeMaintenance(): Promise<void>;
 }