@capybara-hq/kernel 0.1.0-rc.0 → 0.1.0-rc.10

package/dist/catalog/claude/agents.js

@@ -13,16 +13,21 @@ import { item } from "./report.js";
 export const GENERATED_AGENTS_DIR = ".capybara-generated/agents";
 /** Claude Code tool names -> Capybara tool keys (spec §16.4; anything else is dropped). */
 const TOOL_MAP = {
-    Bash: "sandbox_bash",
-    Read: "sandbox_read",
-    Write: "sandbox_write",
-    Edit: "sandbox_edit",
-    MultiEdit: "sandbox_edit",
-    Glob: "sandbox_glob",
-    Grep: "sandbox_grep",
-    Skill: "skill_load",
-    TodoWrite: "todo__write",
-    ToolSearch: "tool_search",
+    Bash: "Bash",
+    Read: "Read",
+    Write: "Write",
+    Edit: "Edit",
+    MultiEdit: "Edit",
+    Glob: "Glob",
+    Grep: "Grep",
+    Skill: "Skill",
+    AskUserQuestion: "AskUserQuestion",
+    ToolSearch: "ToolSearch",
+    Agent: "Agent",
+    Task: "Agent",
+    TodoWrite: "plugin__todo__write",
+    WebFetch: "WebFetch",
+    WebSearch: "WebSearch",
 };
 /** Claude ignores these for plugin agents: `not_applicable`. */
 const NOT_APPLICABLE = new Set(["permissionMode", "hooks", "mcpServers"]);

package/dist/catalog/cli.d.ts

@@ -4,11 +4,21 @@ import { type ExtensionCli } from "../extensions/cli.js";
 import type { KernelLogger } from "../log.js";
 import { CatalogService } from "./catalog.service.js";
 import { PluginImport } from "./plugin-import.js";
+import type { PluginScope } from "./scope.js";
 /** {@link openCatalogCli}'s result: the extension CLI context plus the catalog services. */
 export interface CatalogCli extends ExtensionCli {
     catalog: CatalogService;
     /** Plugin import (prepare / confirm). The CLI acts without an account (actor `null`). */
     imports: PluginImport;
+    /**
+     * After an import's confirm: enqueues the item's plugin scope sync, as the admin console's
+     * confirm does, when its scope turns it on by itself (`all` or `named`). A failure only warns
+     * (the next worker start enqueues every item); returns whether it was enqueued.
+     */
+    enqueueScopeSync(item: {
+        id: string;
+        scope: PluginScope;
+    }): Promise<boolean>;
 }
 /** What the CLI can do with the deployment's object store, and why not when it cannot. */
 export type CliObjectStore = {
@@ -32,9 +42,10 @@ export type CliObjectStore = {
  */
 export declare function loadCliObjectStore(cli: Pick<ExtensionCli, "inspected" | "deploymentConfigs" | "deploymentConfigOf" | "approvals" | "config" | "configIssues" | "installs" | "packageSet" | "readPackage">, log: Pick<KernelLogger, "warn">, syncDir: string): Promise<CliObjectStore>;
 /**
- * The CLI's plugin catalog context (`capybara plugins *`): {@link openExtensionCli} plus
- * {@link PluginImport} and {@link CatalogService}. Imports run with actor `null` (the operator of the
- * deployment, like `capybara extensions install`: no enterprise-admin re-check, audits without an
+ * The CLI's plugin catalog context (`capybara plugins *`): {@link openExtensionCli} with the
+ * catalog's {@link CatalogImportModule}, so {@link PluginImport} and {@link CatalogService} are the
+ * kernel's providers. Imports run with actor `null` (the operator of the
+ * deployment, like `capybara extensions install`: no super-admin re-check, audits without an
  * actor, permission snapshots written with source `cli`). Files of the plugin (skills, connector
  * templates, icons) go to the deployment's object store, set up in-process from the declared or
  * installed object-store extension (see {@link loadCliObjectStore}; an installed package is synced

package/dist/catalog/cli.js

@@ -8,10 +8,15 @@ import { openExtensionCli } from "../extensions/cli.js";
 import { assertSecretsReachable } from "../extensions/host.js";
 import { importExtensionModule, matchesSection } from "../extensions/instance.js";
 import { packageRootOf, syncPackage } from "../extensions/sync.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { addJobOnce } from "../infra/queue/add-job-once.js";
+import { REDIS } from "../infra/tokens.js";
 import { packagePath } from "../packages/tgz.js";
-import { StorageService } from "../storage/storage.service.js";
+import { PrefixedStorage } from "../storage/storage.service.js";
+import { CatalogImportModule } from "./catalog.module.js";
 import { CatalogService } from "./catalog.service.js";
 import { PluginImport } from "./plugin-import.js";
+import { PLUGIN_SCOPE_QUEUE, scopeItemJob } from "./scope-sync.js";
 /**
  * Sets up the deployment's object-store extension inside the CLI process. The CLI hosts no
  * extensions, so this runs only the provider's `setup` with a context that offers `config` and
@@ -131,7 +136,7 @@ export async function loadCliObjectStore(cli, log, syncDir) {
     return { store: undefined, reason: reasons.join("; ") };
 }
 /** `storage.unavailable` with the CLI's constraint spelled out (the generic text points to a plugin install). */
-class CliStorage extends StorageService {
+class CliStorage extends PrefixedStorage {
     reason;
     constructor(deps, reason) {
         super(deps);
@@ -144,9 +149,10 @@ class CliStorage extends StorageService {
     }
 }
 /**
- * The CLI's plugin catalog context (`capybara plugins *`): {@link openExtensionCli} plus
- * {@link PluginImport} and {@link CatalogService}. Imports run with actor `null` (the operator of the
- * deployment, like `capybara extensions install`: no enterprise-admin re-check, audits without an
+ * The CLI's plugin catalog context (`capybara plugins *`): {@link openExtensionCli} with the
+ * catalog's {@link CatalogImportModule}, so {@link PluginImport} and {@link CatalogService} are the
+ * kernel's providers. Imports run with actor `null` (the operator of the
+ * deployment, like `capybara extensions install`: no super-admin re-check, audits without an
  * actor, permission snapshots written with source `cli`). Files of the plugin (skills, connector
  * templates, icons) go to the deployment's object store, set up in-process from the declared or
  * installed object-store extension (see {@link loadCliObjectStore}; an installed package is synced
@@ -154,7 +160,7 @@ class CliStorage extends StorageService {
  * plugin does not bring are checked statically only (the CLI loads no connector).
  */
 export async function openCatalogCli(config, log, opts = {}) {
-    const cli = await openExtensionCli(config, log, opts);
+    const cli = await openExtensionCli(config, log, { ...opts, modules: [CatalogImportModule] });
     let syncDir;
     const removeSyncDir = async () => {
         if (syncDir !== undefined)
@@ -167,36 +173,37 @@ export async function openCatalogCli(config, log, opts = {}) {
             provider: () => store,
             plugins: async () => cli.inspected.map((p) => p.manifest.name),
         }, "reason" in rest ? rest.reason : undefined);
-        const declared = new Map(cli.inspected.map((p) => [p.manifest.name, p.source]));
-        const imports = new PluginImport({
-            db: cli.db,
-            config: () => config,
-            storage,
-            installs: cli.installs,
-            ops: cli.ops,
-            blobs: { get: (sha256) => cli.readPackage(sha256) },
-            declared: () => declared,
-            // The CLI loads no connectors: templates get static checks only (the org install re-checks)
-            findConnector: () => undefined,
-            connectorsLoaded: false,
-            log,
-        });
-        const catalog = new CatalogService({
-            db: cli.db,
-            config: () => config,
-            installs: cli.installs,
-            ops: cli.ops,
-            pluginImport: imports,
-            // Unreachable from the CLI: only marketplace imports (CatalogService.importFromMarketplace)
-            // download archives, and the CLI offers file, npm and direct git imports only.
-            fetchArchive: () => Promise.reject(new ApiError("internal", "marketplace imports are not available in the CLI")),
-            // Only marketplace imports send a marketplace token; a direct git import has none
-            marketplaceToken: async () => undefined,
-        });
+        // Plugin files go to that store; connector templates get static checks only (the CLI loads
+        // no connector; the org install re-checks them). Config-declared names come from the
+        // inspection (the registry), marketplace imports are not offered by the CLI.
+        const imports = cli.app.get(PluginImport);
+        imports.useCliStorage(storage);
+        const catalog = cli.app.get(CatalogService);
+        const db = cli.app.get(KernelDb);
+        const redis = cli.app.get(REDIS);
         return {
             ...cli,
             catalog,
             imports,
+            async enqueueScopeSync(item) {
+                if (item.scope === "optional")
+                    return false;
+                try {
+                    const row = await db.db
+                        .selectFrom("catalog_items")
+                        .select("scope_version")
+                        .where("id", "=", item.id)
+                        .executeTakeFirst();
+                    if (!row)
+                        return false;
+                    await addJobOnce(redis, PLUGIN_SCOPE_QUEUE, scopeItemJob(item.id, row.scope_version));
+                    return true;
+                }
+                catch (err) {
+                    log.warn("cannot enqueue the plugin scope sync; the next worker start converges the orgs", { itemId: item.id, err });
+                    return false;
+                }
+            },
             async close() {
                 await cli.close();
                 await removeSyncDir();

package/dist/catalog/component-promotion.d.ts

@@ -0,0 +1,96 @@
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import { ApiError } from "../errors.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { StorageService } from "../storage/storage.service.js";
+/** The kinds an org owns as rows of its own (connector templates have none). */
+export type PromotableKind = "skill" | "agent_template";
+/**
+ * An org's own skill (org scope) or agent template, as the admin component routes see it: not
+ * linked (`link` null), or linked to a platform row the same org owns (`link`: that row, already
+ * promoted). A copy linked to a platform row of another owner is never an `OrgRow`.
+ */
+export interface OrgRow {
+    kind: PromotableKind;
+    id: string;
+    orgId: string;
+    name: string;
+    /** The roster plugin of an agent template (null: a bare `<name>`); null for skills. */
+    plugin: string | null;
+    version: number;
+    shareable: boolean;
+    /** The platform row the org promoted it to, or null while it is an org row only. */
+    link: string | null;
+    /**
+     * Content the org created itself (ruling P3-46): a skill without plugin provenance
+     * (`catalog_item_id` null); an agent template without a plugin and a catalog item (an org
+     * template saved from an agent, ruling P4-13). Anything else is refused with 409
+     * `catalog.not_owned`.
+     */
+    ownable: boolean;
+}
+/** A promotion whose files are copied ({@link ComponentPromotion.prepare}), waiting for its rows. */
+export interface PreparedPromotion {
+    readonly kind: PromotableKind;
+    readonly orgRowId: string;
+    readonly orgId: string;
+    /** The platform id it gets (the existing one when the row is promoted already). */
+    readonly platformId: string;
+    /** The org row's version the files were copied from. */
+    readonly version: number;
+    readonly already: boolean;
+    /** Where the files were copied (a fresh prefix, ruling P3-45); null: nothing copied. */
+    readonly prefix: string | null;
+}
+/** The org row changed between {@link ComponentPromotion.prepare} and its transaction: prepare again. */
+export declare class PromotionStale extends Error {
+}
+/** How many times a caller prepares again after {@link PromotionStale}. */
+export declare const PROMOTION_ATTEMPTS = 3;
+/** 409 `catalog.not_owned`: only the org's own rows can be shared (P3-6). */
+export declare function notOwnedError(what: string): ApiError;
+/** 409 `component.version_stale`: the org row kept changing while it was being promoted. */
+export declare const promotionStaleError: () => ApiError;
+/**
+ * Promotes an org's own skill or agent template to a platform row when it is first shared
+ * (ruling P3-3). Stateless, shared by every replica.
+ */
+export declare class ComponentPromotion {
+    private readonly kdb;
+    /** Where files are read and written (the kernel's object storage). */
+    private readonly files;
+    readonly txHost: TransactionHost;
+    constructor(kdb: KernelDb, 
+    /** Where files are read and written (the kernel's object storage). */
+    files: StorageService, txHost: TransactionHost);
+    private get db();
+    /**
+     * The live org row `id` of `kind` (an org-scope skill, an agent template) of a live org, when it
+     * is the org's own (see {@link OrgRow}); undefined otherwise.
+     */
+    orgRow(kind: PromotableKind, id: string, forUpdate?: boolean): Promise<OrgRow | undefined>;
+    /**
+     * The first phase, outside any transaction: reads the org row and (a skill) copies its current
+     * version's files to `deployment/platform/skills/<platformId>/<version>/`, checking each file
+     * against the manifest. A row promoted already needs nothing. A failed copy throws and nothing is
+     * linked (the copied files stay unreferenced). Missing or not the org's own -> 404.
+     */
+    prepare(kind: PromotableKind, orgRowId: string): Promise<PreparedPromotion>;
+    /** Deletes a prepared promotion's files after its transaction failed (best effort, P3-45). */
+    discard(p: PreparedPromotion): Promise<void>;
+    /**
+     * The second phase, in the caller's transaction: re-reads the org row under its lock (after the
+     * org row, so an org deletion is serialized), checks the share gate on it (409
+     * `catalog.not_shareable`) and writes the platform row (`current_version` = the org row's, one
+     * version row at that number), its list `[owner]`, and the link (no pin). Idempotent: a row the
+     * org promoted already returns its platform id. A version written since {@link prepare} ->
+     * {@link PromotionStale}; a live platform row of the same name created in this org already (a
+     * shared item whose owner deleted it and then made a new one) -> 409 `plugin.skill_conflict`.
+     * Audits `component.promoted`. Returns the platform id.
+     */
+    promote(p: PreparedPromotion, actor: string | null): Promise<string>;
+    /** Copies the skill's current version files to its platform prefix (outside any transaction). */
+    private copySkillFiles;
+}
+/** {@link ComponentPromotion.orgRow} through `db` (readers outside the provider). */
+export declare function readOrgRow(db: KernelSchemaDb, kind: PromotableKind, id: string, forUpdate?: boolean): Promise<OrgRow | undefined>;

package/dist/catalog/component-promotion.js

@@ -0,0 +1,395 @@
+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); }
+};
+// Promote on share (plugin scope phase 3, spec §14, rulings P3-3 to P3-6, P3-23): an org's own
+// skill or agent template stays an org row (`skills` / `agent_templates`) until the super admin
+// first shows it to other orgs or associates it with one. That action promotes it, in its own
+// transaction: a platform row owned by the org (`owner_org_id` = `origin_org_id` = the org,
+// `scope_mode own`, `named: [owner]`, `shown_to_others false`) at the org row's version number,
+// and the org row linked to it without a pin (ruling B2). The owner's agents keep referencing the
+// org row's id; `skills/usable.ts` and `agents/templates.ts` serve that row its own stored version
+// while it is the platform row's current one, so nothing the owner's agents see changes (no
+// "Updated skills" line, same `subagent_started` reference). Other orgs reference the platform id.
+import { createHash, randomUUID } from "node:crypto";
+import { Inject, Injectable } from "@nestjs/common";
+import { sql } from "kysely";
+import { ApiError } from "../errors.js";
+import { audit } from "../identity/audit.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { StorageService } from "../storage/storage.service.js";
+import { putCatalogFiles } from "./catalog-items.js";
+import { platformSkillPrefix, uniqueVersionPrefix } from "./platform-components.js";
+/** The org row changed between {@link ComponentPromotion.prepare} and its transaction: prepare again. */
+export class PromotionStale extends Error {
+}
+/** How many times a caller prepares again after {@link PromotionStale}. */
+export const PROMOTION_ATTEMPTS = 3;
+const notFound = () => new ApiError("component.not_found", "Component not found");
+/** 409 `catalog.not_owned`: only the org's own rows can be shared (P3-6). */
+export function notOwnedError(what) {
+    return new ApiError("catalog.not_owned", `${what} is not this organization's own: only its own org skills and agent templates can be shared`);
+}
+/** 409 `component.version_stale`: the org row kept changing while it was being promoted. */
+export const promotionStaleError = () => new ApiError("component.version_stale", "The skill or agent template changed while it was being shared; try again");
+/** The platform table of a kind. */
+const PLATFORM_TABLE = {
+    skill: "platform_skills",
+    agent_template: "platform_agent_templates",
+};
+/**
+ * Promotes an org's own skill or agent template to a platform row when it is first shared
+ * (ruling P3-3). Stateless, shared by every replica.
+ */
+let ComponentPromotion = class ComponentPromotion {
+    kdb;
+    files;
+    txHost;
+    constructor(kdb, 
+    /** Where files are read and written (the kernel's object storage). */
+    files, txHost) {
+        this.kdb = kdb;
+        this.files = files;
+        this.txHost = txHost;
+    }
+    get db() {
+        return this.kdb.db;
+    }
+    /**
+     * The live org row `id` of `kind` (an org-scope skill, an agent template) of a live org, when it
+     * is the org's own (see {@link OrgRow}); undefined otherwise.
+     */
+    async orgRow(kind, id, forUpdate = false) {
+        return readOrgRow(this.db, kind, id, forUpdate);
+    }
+    /**
+     * The first phase, outside any transaction: reads the org row and (a skill) copies its current
+     * version's files to `deployment/platform/skills/<platformId>/<version>/`, checking each file
+     * against the manifest. A row promoted already needs nothing. A failed copy throws and nothing is
+     * linked (the copied files stay unreferenced). Missing or not the org's own -> 404.
+     */
+    async prepare(kind, orgRowId) {
+        const row = await this.orgRow(kind, orgRowId);
+        if (!row)
+            throw notFound();
+        if (row.link !== null) {
+            return {
+                kind,
+                orgRowId,
+                orgId: row.orgId,
+                platformId: row.link,
+                version: row.version,
+                already: true,
+                prefix: null,
+            };
+        }
+        if (!row.ownable)
+            throw notOwnedError(row.name);
+        const platformId = randomUUID();
+        const prefix = kind === "skill" ? uniqueVersionPrefix(platformSkillPrefix(platformId, row.version)) : null;
+        if (prefix !== null)
+            await this.copySkillFiles(row, prefix);
+        return {
+            kind,
+            orgRowId,
+            orgId: row.orgId,
+            platformId,
+            version: row.version,
+            already: false,
+            prefix,
+        };
+    }
+    /** Deletes a prepared promotion's files after its transaction failed (best effort, P3-45). */
+    async discard(p) {
+        if (p.prefix === null)
+            return;
+        try {
+            await this.files.deployment().deletePrefix(p.prefix);
+        }
+        catch {
+            // unreferenced objects only: nothing reads them
+        }
+    }
+    /**
+     * The second phase, in the caller's transaction: re-reads the org row under its lock (after the
+     * org row, so an org deletion is serialized), checks the share gate on it (409
+     * `catalog.not_shareable`) and writes the platform row (`current_version` = the org row's, one
+     * version row at that number), its list `[owner]`, and the link (no pin). Idempotent: a row the
+     * org promoted already returns its platform id. A version written since {@link prepare} ->
+     * {@link PromotionStale}; a live platform row of the same name created in this org already (a
+     * shared item whose owner deleted it and then made a new one) -> 409 `plugin.skill_conflict`.
+     * Audits `component.promoted`. Returns the platform id.
+     */
+    async promote(p, actor) {
+        const org = await this.db
+            .selectFrom("orgs")
+            .select("id")
+            .where("id", "=", p.orgId)
+            .where("deleted_at", "is", null)
+            .forShare()
+            .executeTakeFirst();
+        if (!org)
+            throw notFound();
+        const row = await this.orgRow(p.kind, p.orgRowId, true);
+        if (!row)
+            throw notFound();
+        if (row.link !== null)
+            return row.link;
+        if (!row.ownable)
+            throw notOwnedError(row.name);
+        if (!row.shareable) {
+            throw new ApiError("catalog.not_shareable", `${row.name} is owned by an organization that has not made it shareable`);
+        }
+        if (p.already || p.version !== row.version)
+            throw new PromotionStale();
+        const table = PLATFORM_TABLE[p.kind];
+        const taken = await this.db
+            .selectFrom(table)
+            .select("id")
+            .where("name", "=", row.name)
+            .where("origin_org_id", "=", row.orgId)
+            .where(sql `coalesce(plugin_name, '')`, "=", row.plugin ?? "")
+            .where("deleted_at", "is", null)
+            .executeTakeFirst();
+        if (taken) {
+            throw new ApiError("plugin.skill_conflict", `A shared ${p.kind === "skill" ? "skill" : "agent template"} named "${row.name}" from this organization already exists on the platform`, [{ skill: row.name, orgId: row.orgId, skills: [taken.id], source: { kind: "org" } }]);
+        }
+        const owned = {
+            owner_org_id: row.orgId,
+            origin_org_id: row.orgId,
+            shareable: row.shareable,
+            shown_to_others: false,
+            scope_mode: "own",
+            scope: "named",
+        };
+        if (p.kind === "skill") {
+            const v = await this.db
+                .selectFrom("skill_versions")
+                .select(["manifest", "source_format", "suggest_pinned", "created_by"])
+                .where("skill_id", "=", row.id)
+                .where("version", "=", row.version)
+                .executeTakeFirstOrThrow();
+            await this.db
+                .insertInto("platform_skills")
+                .values({
+                id: p.platformId,
+                catalog_item_id: null,
+                plugin_name: null,
+                name: row.name,
+                description: v.manifest.description,
+                description_zh: null,
+                current_version: row.version,
+                ...owned,
+            })
+                .execute();
+            await this.db
+                .insertInto("platform_skill_versions")
+                .values({
+                skill_id: p.platformId,
+                version: row.version,
+                manifest: JSON.stringify(v.manifest),
+                object_prefix: p.prefix,
+                catalog_version: null,
+                source_format: v.source_format,
+                suggest_pinned: v.suggest_pinned,
+                created_by: v.created_by,
+            })
+                .execute();
+            await this.db
+                .updateTable("skills")
+                .set({ platform_skill_id: p.platformId, updated_at: sql `now()` })
+                .where("id", "=", row.id)
+                .execute();
+        }
+        else {
+            const v = await this.db
+                .selectFrom("agent_template_versions")
+                .select(["definition", "source_format", "catalog_version"])
+                .where("template_id", "=", row.id)
+                .where("version", "=", row.version)
+                .executeTakeFirstOrThrow();
+            const description = v.definition?.description;
+            await this.db
+                .insertInto("platform_agent_templates")
+                .values({
+                id: p.platformId,
+                catalog_item_id: null,
+                // the roster type `<plugin>:<name>` is model-visible: other orgs see the same type
+                plugin_name: row.plugin,
+                name: row.name,
+                description: typeof description === "string" ? description : null,
+                current_version: row.version,
+                ...owned,
+            })
+                .execute();
+            await this.db
+                .insertInto("platform_agent_template_versions")
+                .values({
+                template_id: p.platformId,
+                version: row.version,
+                // the stored definition as it is (its tool keys are normalized when read)
+                definition: JSON.stringify(v.definition),
+                // an org template has no file: only its parsed definition is stored
+                object_prefix: null,
+                catalog_version: v.catalog_version,
+                source_format: v.source_format,
+            })
+                .execute();
+            await this.db
+                .updateTable("agent_templates")
+                .set({ platform_template_id: p.platformId, updated_at: new Date() })
+                .where("id", "=", row.id)
+                .execute();
+        }
+        await this.db
+            .insertInto("component_scope_orgs")
+            .values({ kind: p.kind, component_id: p.platformId, org_id: row.orgId })
+            .execute();
+        await audit(this.db, {
+            actorAccountId: actor,
+            orgId: row.orgId,
+            action: "component.promoted",
+            target: p.platformId,
+            detail: { kind: p.kind, name: row.name, from: row.id, version: row.version },
+        });
+        return p.platformId;
+    }
+    /** Copies the skill's current version files to its platform prefix (outside any transaction). */
+    async copySkillFiles(row, prefix) {
+        const v = await this.db
+            .selectFrom("skill_versions")
+            .select(["manifest", "object_prefix"])
+            .where("skill_id", "=", row.id)
+            .where("version", "=", row.version)
+            .executeTakeFirst();
+        if (!v)
+            throw notFound();
+        this.files.assertAvailable();
+        const store = this.files.kernel(row.orgId);
+        const out = [];
+        for (const f of v.manifest.files) {
+            const got = await store.get(`${v.object_prefix}${f.path}`);
+            if (!got)
+                throw new ApiError("internal", `Stored skill file ${f.path} is missing`);
+            const data = new Uint8Array(await new Response(got.body).arrayBuffer());
+            if (createHash("sha256").update(data).digest("hex") !== f.sha256) {
+                throw new ApiError("internal", `Stored skill file ${f.path} does not match its manifest`);
+            }
+            out.push({ path: f.path, size: data.byteLength, data });
+        }
+        await putCatalogFiles(this.files, prefix, out);
+    }
+};
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], ComponentPromotion.prototype, "promote", null);
+ComponentPromotion = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(StorageService)),
+    __param(2, Inject(TransactionHost))
+], ComponentPromotion);
+export { ComponentPromotion };
+/** {@link ComponentPromotion.orgRow} through `db` (readers outside the provider). */
+export async function readOrgRow(db, kind, id, forUpdate = false) {
+    if (kind === "skill") {
+        let q = db
+            .selectFrom("skills as s")
+            .innerJoin("orgs as o", "o.id", "s.org_id")
+            .leftJoin("platform_skills as p", "p.id", "s.platform_skill_id")
+            .select([
+            "s.id",
+            "s.org_id",
+            "s.name",
+            "s.current_version",
+            "s.shareable",
+            "s.platform_skill_id",
+            "s.pinned_version",
+            "s.catalog_item_id",
+            "p.owner_org_id",
+            "p.deleted_at as p_deleted_at",
+        ])
+            .where("s.id", "=", id)
+            .where("s.scope", "=", "org")
+            .where("s.deleted_at", "is", null)
+            .where("o.deleted_at", "is", null);
+        if (forUpdate)
+            q = q.forUpdate("s");
+        const r = await q.executeTakeFirst();
+        if (!r)
+            return undefined;
+        const link = ownedLink(r);
+        if (link === false)
+            return undefined;
+        return {
+            kind,
+            id: r.id,
+            orgId: r.org_id,
+            name: r.name,
+            plugin: null,
+            version: r.current_version,
+            shareable: r.shareable,
+            link,
+            ownable: r.catalog_item_id === null,
+        };
+    }
+    let q = db
+        .selectFrom("agent_templates as t")
+        .innerJoin("orgs as o", "o.id", "t.org_id")
+        .leftJoin("platform_agent_templates as p", "p.id", "t.platform_template_id")
+        .select([
+        "t.id",
+        "t.org_id",
+        "t.name",
+        "t.plugin_name",
+        "t.current_version",
+        "t.shareable",
+        "t.platform_template_id as platform_skill_id",
+        "t.pinned_version",
+        "t.catalog_item_id",
+        "p.owner_org_id",
+        "p.deleted_at as p_deleted_at",
+    ])
+        .where("t.id", "=", id)
+        .where("t.deleted_at", "is", null)
+        .where("o.deleted_at", "is", null);
+    if (forUpdate)
+        q = q.forUpdate("t");
+    const r = await q.executeTakeFirst();
+    if (!r)
+        return undefined;
+    const link = ownedLink(r);
+    if (link === false)
+        return undefined;
+    return {
+        kind,
+        id: r.id,
+        orgId: r.org_id,
+        name: r.name,
+        plugin: r.plugin_name,
+        version: r.current_version,
+        shareable: r.shareable,
+        link,
+        // an org template (ruling P4-13); a plugin's template keeps its roster type and is not
+        ownable: r.catalog_item_id === null && r.plugin_name === null,
+    };
+}
+/**
+ * The platform row an org row is promoted to (null: not linked), or false when the row is a copy
+ * of a platform row the org does not own (P3-6: not the org's own).
+ */
+function ownedLink(r) {
+    if (r.platform_skill_id === null)
+        return null;
+    if (r.pinned_version === null && r.owner_org_id === r.org_id && r.p_deleted_at === null) {
+        return r.platform_skill_id;
+    }
+    return false;
+}