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

package/dist/extensions/admin-view.d.ts

@@ -1,11 +1,13 @@
-import { EnterpriseAdminLock } from "../identity/enterprise-admin.js";
+import { SuperAdminLock } from "../identity/super-admin.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import type { KernelLogger } from "../log.js";
 import { ExtensionApprovals } from "./approvals.js";
 import { ExtensionBlobs } from "./blobs.js";
+import { ExtensionDeploymentConfigService } from "./deployment-config.js";
 import { ExtensionDisplayNames } from "./display-name.js";
+import { EffectiveConfigs } from "./effective-config.js";
 import { ExtensionHost } from "./host.js";
 import { ExtensionInstalls } from "./installs.js";
 import { ExtensionLifecycle, PLUGINS_CHANGED_TOPIC } from "./lifecycle.js";
@@ -23,13 +25,13 @@ export interface PublishBus {
     publish(topic: string, payload: unknown): Promise<void>;
 }
 /**
- * 部署级插件后台（企业管理员）：列表 / 详情与网页批准权限（D8）。无状态，多副本共用；
+ * 部署级插件后台（超级管理员）：列表 / 详情与网页批准权限（D8）。无状态，多副本共用；
  * 状态由 PG（安装记录、快照、各副本状态行）与本副本宿主（配置声明插件的清单）推出。
  */
 export declare class ExtensionAdmin {
     private readonly kdb;
     readonly txHost: TransactionHost;
-    /** The enterprise admin lock (identity/enterprise-admin.ts): joins the transaction. */
+    /** The super admin lock (identity/super-admin.ts): joins the transaction. */
     private readonly adminLock;
     private readonly approveLock;
     private readonly blobs;
@@ -43,17 +45,29 @@ export declare class ExtensionAdmin {
     private readonly bus;
     private readonly log;
     private readonly displayNames;
+    /** Which required overridable fields the platform left empty (spec A §5.4a). */
+    private readonly deploymentConfig;
+    /** How many orgs still need their own config for such an extension. */
+    private readonly effectiveConfigs;
     private readonly packageSets;
     constructor(kdb: KernelDb, txHost: TransactionHost, 
-    /** The enterprise admin lock (identity/enterprise-admin.ts): joins the transaction. */
-    adminLock: EnterpriseAdminLock, approveLock: PluginApproveLock, blobs: ExtensionBlobs, installs: ExtensionInstalls, approvals: ExtensionApprovals, 
+    /** The super admin lock (identity/super-admin.ts): joins the transaction. */
+    adminLock: SuperAdminLock, approveLock: PluginApproveLock, blobs: ExtensionBlobs, installs: ExtensionInstalls, approvals: ExtensionApprovals, 
     /** The config-declared extensions (this replica's host; the CLI fills it from its inspection). */
     host: ExtensionHost, 
     /** This replica's reconcile after an approval (a no-op where the lifecycle never started: the CLI). */
-    lifecycle: ExtensionLifecycle, config: KernelConfigService, bus: PublishBus, log: KernelLogger, displayNames: ExtensionDisplayNames);
+    lifecycle: ExtensionLifecycle, config: KernelConfigService, bus: PublishBus, log: KernelLogger, displayNames: ExtensionDisplayNames, 
+    /** Which required overridable fields the platform left empty (spec A §5.4a). */
+    deploymentConfig: ExtensionDeploymentConfigService, 
+    /** How many orgs still need their own config for such an extension. */
+    effectiveConfigs: EffectiveConfigs);
     private get db();
-    /** 全部插件（配置声明 → 安装记录，各自按名字）。 */
-    list(): Promise<AdminExtensionView[]>;
+    /**
+     * Every extension (config-declared, then install records, each by name). With `names`, only
+     * those: no other package is read, so a caller that needs a few items (the catalog's pending
+     * check) neither pays for nor logs about the packages of unrelated extensions.
+     */
+    list(names?: ReadonlySet<string>): Promise<AdminExtensionView[]>;
     /**
      * A single extension; unknown -> `extension.not_found`; package unreadable ->
      * `extension.package_unavailable`. With `allowUnreadable` an unreadable package returns the same
@@ -66,7 +80,12 @@ export declare class ExtensionAdmin {
         allowUnreadable?: boolean;
     }): Promise<AdminExtensionView>;
     /**
-     * Web approval: re-checks the enterprise admin under the lock, compares the reviewed package
+     * The review digest of a stored package (the `reviewHash` its extension would show once
+     * installed); null when the package cannot be read.
+     */
+    packageReviewHash(sha256: string): Promise<string | null>;
+    /**
+     * Web approval: re-checks the super admin under the lock, compares the reviewed package
      * (`sha256`) and permission digest (`reviewHash`), writes the snapshot (source web) and the
      * `extension.permissions_approved` audit; after the commit publishes `kernel.plugins.changed` (a
      * failure only warns) and waits for one reconcile on this replica (other replicas converge through
@@ -76,10 +95,12 @@ export declare class ExtensionAdmin {
      *   recomputed now -> `extension.approval_stale`; a config-declared extension's `sha256` must be
      *   null (otherwise `validation_failed`);
      * - the snapshot already covers the current permission set (nothing to approve, F-N) ->
-     *   `extension.not_pending`.
+     *   `extension.not_pending`, except with `confirmBootstrap` when the snapshot is the bootstrap
+     *   step's (the catalog's confirm re-writes it with source web).
      */
     approve(actor: string, name: string, body: ApproveBody, opts?: {
         actorTokenId?: string;
+        confirmBootstrap?: boolean;
     }): Promise<AdminExtensionView>;
     private writeApproval;
     /** 配置声明 → 安装记录（与配置声明重名的安装记录不生效，不单列）。`only` 给出时只取这一个。 */
@@ -88,5 +109,11 @@ export declare class ExtensionAdmin {
      * 包的权限集合（静态清单 + 迁移 SQL，与上传时的审阅相同）、迁移审阅警告与是否有部署级配置字段；按 sha256 缓存。
      */
     private packageInfo;
+    /**
+     * For each configurable, readable extension whose platform config leaves required overridable
+     * fields empty (spec A §5.4a): the number of orgs still needing their own config. Extensions
+     * without overridable fields cost no read.
+     */
+    private orgsNeedingConfig;
     private views;
 }

package/dist/extensions/admin-view.js

@@ -11,7 +11,7 @@ import { SDK_VERSION } from "@capybara-hq/plugin-sdk";
 import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { ApiError } from "../errors.js";
-import { EnterpriseAdminLock } from "../identity/enterprise-admin.js";
+import { SuperAdminLock } from "../identity/super-admin.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
@@ -19,7 +19,10 @@ import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { ExtensionApprovals, snapshotCovers, writeSnapshot, } from "./approvals.js";
 import { ExtensionBlobs } from "./blobs.js";
+import { ExtensionDeploymentConfigService } from "./deployment-config.js";
 import { ExtensionDisplayNames } from "./display-name.js";
+import { EffectiveConfigs } from "./effective-config.js";
+import { enabledExtensionsByOrg } from "./enabled.js";
 import { ExtensionHost } from "./host.js";
 import { ExtensionInstalls } from "./installs.js";
 import { ExtensionLifecycle, PLUGINS_CHANGED_TOPIC, STALE_RECONCILE_PERIODS } from "./lifecycle.js";
@@ -27,6 +30,7 @@ import { PluginApproveLock } from "./locks.js";
 import { ExtensionPackageError, permissionSetOfPackage, readExtensionPackage } from "./package.js";
 import { buildPermissionSet, diffPermissions } from "./permission-set.js";
 import { deriveExtensionStatus, migrationWarnings, permissionGroups, permissionKeyItems, reviewHash, } from "./permission-view.js";
+import { pluginItemsOf } from "./plugin-items.js";
 export { PLUGINS_CHANGED_TOPIC };
 /** 内容寻址的包 → 权限集合（包不可变，缓存安全；只作缓存，不是跨副本状态）。 */
 const PACKAGE_SET_CACHE_MAX = 256;
@@ -48,7 +52,7 @@ function assertReadable(s) {
     }
 }
 /**
- * 部署级插件后台（企业管理员）：列表 / 详情与网页批准权限（D8）。无状态，多副本共用；
+ * 部署级插件后台（超级管理员）：列表 / 详情与网页批准权限（D8）。无状态，多副本共用；
  * 状态由 PG（安装记录、快照、各副本状态行）与本副本宿主（配置声明插件的清单）推出。
  */
 let ExtensionAdmin = class ExtensionAdmin {
@@ -65,14 +69,20 @@ let ExtensionAdmin = class ExtensionAdmin {
     bus;
     log;
     displayNames;
+    deploymentConfig;
+    effectiveConfigs;
     packageSets = new Map();
     constructor(kdb, txHost, 
-    /** The enterprise admin lock (identity/enterprise-admin.ts): joins the transaction. */
+    /** The super admin lock (identity/super-admin.ts): joins the transaction. */
     adminLock, approveLock, blobs, installs, approvals, 
     /** The config-declared extensions (this replica's host; the CLI fills it from its inspection). */
     host, 
     /** This replica's reconcile after an approval (a no-op where the lifecycle never started: the CLI). */
-    lifecycle, config, bus, log, displayNames) {
+    lifecycle, config, bus, log, displayNames, 
+    /** Which required overridable fields the platform left empty (spec A §5.4a). */
+    deploymentConfig, 
+    /** How many orgs still need their own config for such an extension. */
+    effectiveConfigs) {
         this.kdb = kdb;
         this.txHost = txHost;
         this.adminLock = adminLock;
@@ -86,13 +96,19 @@ let ExtensionAdmin = class ExtensionAdmin {
         this.bus = bus;
         this.log = log;
         this.displayNames = displayNames;
+        this.deploymentConfig = deploymentConfig;
+        this.effectiveConfigs = effectiveConfigs;
     }
     get db() {
         return this.kdb.db;
     }
-    /** 全部插件（配置声明 → 安装记录，各自按名字）。 */
-    async list() {
-        const subjects = await this.subjects();
+    /**
+     * Every extension (config-declared, then install records, each by name). With `names`, only
+     * those: no other package is read, so a caller that needs a few items (the catalog's pending
+     * check) neither pays for nor logs about the packages of unrelated extensions.
+     */
+    async list(names) {
+        const subjects = await this.subjects(undefined, names);
         return this.views(subjects);
     }
     /**
@@ -112,7 +128,20 @@ let ExtensionAdmin = class ExtensionAdmin {
         return (await this.views([s]))[0];
     }
     /**
-     * Web approval: re-checks the enterprise admin under the lock, compares the reviewed package
+     * The review digest of a stored package (the `reviewHash` its extension would show once
+     * installed); null when the package cannot be read.
+     */
+    async packageReviewHash(sha256) {
+        try {
+            const { set, warnings } = await this.packageInfo(sha256);
+            return reviewHash(set, warnings);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Web approval: re-checks the super admin under the lock, compares the reviewed package
      * (`sha256`) and permission digest (`reviewHash`), writes the snapshot (source web) and the
      * `extension.permissions_approved` audit; after the commit publishes `kernel.plugins.changed` (a
      * failure only warns) and waits for one reconcile on this replica (other replicas converge through
@@ -122,7 +151,8 @@ let ExtensionAdmin = class ExtensionAdmin {
      *   recomputed now -> `extension.approval_stale`; a config-declared extension's `sha256` must be
      *   null (otherwise `validation_failed`);
      * - the snapshot already covers the current permission set (nothing to approve, F-N) ->
-     *   `extension.not_pending`.
+     *   `extension.not_pending`, except with `confirmBootstrap` when the snapshot is the bootstrap
+     *   step's (the catalog's confirm re-writes it with source web).
      */
     async approve(actor, name, body, opts = {}) {
         const s = (await this.subjects(name))[0];
@@ -137,7 +167,7 @@ let ExtensionAdmin = class ExtensionAdmin {
             throw stale();
         if (body.reviewHash !== reviewHash(s.set, s.warnings))
             throw stale();
-        await this.writeApproval(actor, name, s, opts.actorTokenId, stale);
+        await this.writeApproval(actor, name, s, opts.actorTokenId, stale, opts.confirmBootstrap === true);
         try {
             await this.bus.publish(PLUGINS_CHANGED_TOPIC, { plugin: name });
         }
@@ -153,7 +183,7 @@ let ExtensionAdmin = class ExtensionAdmin {
         }
         return this.get(name);
     }
-    async writeApproval(actor, name, s, actorTokenId, stale) {
+    async writeApproval(actor, name, s, actorTokenId, stale, confirmBootstrap) {
         const db = this.db;
         await this.adminLock.lockAndAuthorize(actor);
         await this.approveLock.lock(name);
@@ -170,7 +200,7 @@ let ExtensionAdmin = class ExtensionAdmin {
         }
         const snapRow = await db
             .selectFrom("extension_permission_snapshots")
-            .select(["version", "permissions"])
+            .select(["version", "permissions", "source"])
             .where("plugin", "=", name)
             .forUpdate()
             .executeTakeFirst();
@@ -178,7 +208,9 @@ let ExtensionAdmin = class ExtensionAdmin {
             version: snapRow.version,
             permissions: snapRow.permissions,
         };
-        if (snapshotCovers(snap, s.set)) {
+        // `confirmBootstrap` (the catalog's confirm): a snapshot the bootstrap step wrote was never
+        // confirmed by a person, so a covered one is still taken over
+        if (snapshotCovers(snap, s.set) && !(confirmBootstrap && snapRow?.source === "bootstrap")) {
             throw new ApiError("extension.not_pending", `Extension ${name} ${s.version} has no new permissions awaiting approval`);
         }
         const { added, removed } = diffPermissions(snap?.permissions, s.set);
@@ -190,10 +222,9 @@ let ExtensionAdmin = class ExtensionAdmin {
         });
     }
     /** 配置声明 → 安装记录（与配置声明重名的安装记录不生效，不单列）。`only` 给出时只取这一个。 */
-    async subjects(only) {
-        const declared = this.host
-            .declaredPlugins()
-            .filter((p) => only === undefined || p.name === only);
+    async subjects(only, names) {
+        const wanted = (name) => (only === undefined || name === only) && (names === undefined || names.has(name));
+        const declared = this.host.declaredPlugins().filter((p) => wanted(p.name));
         const taken = new Set(this.host.declaredPlugins().map((p) => p.name));
         const out = [...declared]
             .sort((a, b) => a.name.localeCompare(b.name))
@@ -209,7 +240,7 @@ let ExtensionAdmin = class ExtensionAdmin {
         }));
         if (only !== undefined && out.length > 0)
             return out;
-        const rows = (await this.installs.list()).filter((r) => !taken.has(r.name) && (only === undefined || r.name === only));
+        const rows = (await this.installs.list()).filter((r) => !taken.has(r.name) && wanted(r.name));
         for (const r of rows) {
             let info;
             try {
@@ -276,6 +307,32 @@ let ExtensionAdmin = class ExtensionAdmin {
         }
         return { ...cached, configurable: cached.set.config.deployment.length > 0 };
     }
+    /**
+     * For each configurable, readable extension whose platform config leaves required overridable
+     * fields empty (spec A §5.4a): the number of orgs still needing their own config. Extensions
+     * without overridable fields cost no read.
+     */
+    async orgsNeedingConfig(subjects) {
+        const out = new Map();
+        for (const s of subjects) {
+            if (!s.configurable || s.broken !== undefined)
+                continue;
+            try {
+                const missing = await this.deploymentConfig.orgMustConfigure(s.name);
+                if (missing.length > 0) {
+                    out.set(s.name, await this.effectiveConfigs.countNeedingConfig(s.name));
+                }
+            }
+            catch (err) {
+                // the list never fails for one extension's config; the field is then left out
+                this.log.warn("cannot tell whether orgs must configure the extension", {
+                    plugin: s.name,
+                    err,
+                });
+            }
+        }
+        return out;
+    }
     async views(subjects) {
         if (subjects.length === 0)
             return [];
@@ -290,7 +347,28 @@ let ExtensionAdmin = class ExtensionAdmin {
             .where("heartbeat_at", ">", sql `now() - make_interval(secs => ${staleSeconds})`)
             .orderBy("replica_id")
             .execute();
+        const items = await pluginItemsOf(this.db, names);
+        const needing = await this.orgsNeedingConfig(subjects);
+        const counts = new Map((await this.db
+            .selectFrom(enabledExtensionsByOrg(this.db).as("en"))
+            .innerJoin("orgs", "orgs.id", "en.org_id")
+            .select(["en.plugin", (eb) => eb.fn.countAll().as("n")])
+            .where("orgs.deleted_at", "is", null)
+            .where("en.plugin", "in", names)
+            .groupBy("en.plugin")
+            .execute()).map((r) => [r.plugin, Number(r.n)]));
         return subjects.map((s) => {
+            const of = items.get(s.name);
+            const builtin = of?.some((i) => i.builtin) === true || s.install?.required === true;
+            const scopeInfo = {
+                scope: of?.[0]
+                    ? builtin || of.some((i) => i.scope === "all")
+                        ? "all"
+                        : of[0].scope
+                    : null,
+                enabledOrgs: counts.get(s.name) ?? 0,
+                builtin,
+            };
             const replicas = rows.filter((r) => r.plugin === s.name);
             const snap = snapshots.get(s.name);
             const { added, removed } = diffPermissions(snap?.permissions, s.set);
@@ -325,6 +403,7 @@ let ExtensionAdmin = class ExtensionAdmin {
                     configValid,
                     removable: install?.required !== true,
                     required: install?.required === true,
+                    ...scopeInfo,
                     installSource: install?.source ?? null,
                     error: s.broken,
                 };
@@ -360,8 +439,10 @@ let ExtensionAdmin = class ExtensionAdmin {
                 snapshot: snapshotView(snap),
                 configurable: s.configurable,
                 configValid,
+                ...(needing.has(s.name) && { orgsNeedingConfig: needing.get(s.name) }),
                 removable: s.source === "install" && install?.required !== true,
                 required: install?.required === true,
+                ...scopeInfo,
                 installSource: install?.source ?? null,
             };
         });
@@ -374,7 +455,7 @@ ExtensionAdmin = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
     __param(1, Inject(TransactionHost)),
-    __param(2, Inject(EnterpriseAdminLock)),
+    __param(2, Inject(SuperAdminLock)),
     __param(3, Inject(PluginApproveLock)),
     __param(4, Inject(ExtensionBlobs)),
     __param(5, Inject(ExtensionInstalls)),
@@ -384,7 +465,9 @@ ExtensionAdmin = __decorate([
     __param(9, Inject(KernelConfigService)),
     __param(10, Inject(KERNEL_BUS)),
     __param(11, Inject(KERNEL_LOGGER)),
-    __param(12, Inject(ExtensionDisplayNames))
+    __param(12, Inject(ExtensionDisplayNames)),
+    __param(13, Inject(ExtensionDeploymentConfigService)),
+    __param(14, Inject(EffectiveConfigs))
 ], ExtensionAdmin);
 export { ExtensionAdmin };
 const replicaView = (r) => ({

package/dist/extensions/bootstrap.d.ts

@@ -35,7 +35,7 @@ import { ExtensionRegistry } from "./registry.js";
  *   manifest's sha256 (written with the audit `bootstrap.completed` only when every entry
  *   succeeded; otherwise the next start runs it again, which is idempotent).
  * - Only entries new to the manifest are installed (Ruling 5): an optional entry that the last
- *   completed run already handled and that is not installed now (an enterprise admin uninstalled
+ *   completed run already handled and that is not installed now (a super admin uninstalled
  *   it) stays uninstalled -> `kept`. A required entry is always installed.
  * - Per entry, by the installed state of its extension:
  *   - not installed (and new, or required): imported into the catalog (source `bootstrap`, ref
@@ -44,8 +44,8 @@ import { ExtensionRegistry } from "./registry.js";
  *     and enabled -> `installed`;
  *   - installed from `bootstrap` at a lower version: upgraded the same way (core's release vouched
  *     for the version, so new permissions are pre-approved and audited), keeping the desired state
- *     an enterprise admin chose (a disabled optional plugin stays disabled) -> `upgraded`;
- *   - installed at a higher version, or from another source (an enterprise admin upgraded it), or
+ *     a super admin chose (a disabled optional plugin stays disabled) -> `upgraded`;
+ *   - installed at a higher version, or from another source (a super admin upgraded it), or
  *     the name is config-declared (`declared`: config wins, no install record is created):
  *     untouched, never downgraded -> `kept`;
  *   - a declarative plugin (no extension): imported into the catalog only -> `imported` (`kept`
@@ -175,6 +175,12 @@ export declare class BootstrapService {
         /** The plugin import a declarative entry (or an entry's catalog version) goes through. */
         imports: BootstrapImports;
     }): Promise<BootstrapResult>;
+    /**
+     * A pin whose plugin name an org holds (a live org-owned catalog item): the bootstrap takes no
+     * name over (ruling P3-28), so the entry fails; this warning tells the super admin why and
+     * which org holds it (final review M4).
+     */
+    private warnIfHeld;
     /** The `bootstrap_runs` row and the `bootstrap.completed` audit, in one transaction. */
     private recordDone;
     /**
@@ -186,10 +192,17 @@ export declare class BootstrapService {
     /** The entry names the last completed run handled (undefined before any run completed). */
     private lastRunNames;
     private entry;
+    /**
+     * The catalog item of a bootstrap entry follows `required`: a required entry is builtin, offered
+     * to every org (scope `all`) and not disabled (migration 0075 could leave a required plugin
+     * disabled); an entry that stops being required is no longer builtin and keeps scope `all` (the
+     * admin may change it from then on).
+     */
+    private markBuiltin;
     /** A declarative plugin: catalog only. Returns false when that version is already imported. */
     private importOnly;
     /**
-     * Imports, approves, installs and enables (one review, confirmed with `deployExtension`). When
+     * Imports, approves, installs and enables (one review; its confirm deploys the extension). When
      * the catalog already has this version (an earlier run stopped after importing, or the same
      * package came from a marketplace), the extension is deployed from the package store instead.
      */

package/dist/extensions/bootstrap.js

@@ -15,6 +15,7 @@ import { parseBootstrapManifest, SDK_VERSION, } from "@capybara-hq/plugin-sdk";
 import { Inject, Injectable, Optional } from "@nestjs/common";
 import { sql } from "kysely";
 import semver from "semver";
+import { otherNameOwner } from "../catalog/ownership.js";
 import { catalogPackageError } from "../catalog/plugin-import.js";
 import { PluginPackageError, readPluginPackage } from "../catalog/plugin-package.js";
 import { ApiError } from "../errors.js";
@@ -57,7 +58,7 @@ import { ExtensionRegistry } from "./registry.js";
  *   manifest's sha256 (written with the audit `bootstrap.completed` only when every entry
  *   succeeded; otherwise the next start runs it again, which is idempotent).
  * - Only entries new to the manifest are installed (Ruling 5): an optional entry that the last
- *   completed run already handled and that is not installed now (an enterprise admin uninstalled
+ *   completed run already handled and that is not installed now (a super admin uninstalled
  *   it) stays uninstalled -> `kept`. A required entry is always installed.
  * - Per entry, by the installed state of its extension:
  *   - not installed (and new, or required): imported into the catalog (source `bootstrap`, ref
@@ -66,8 +67,8 @@ import { ExtensionRegistry } from "./registry.js";
  *     and enabled -> `installed`;
  *   - installed from `bootstrap` at a lower version: upgraded the same way (core's release vouched
  *     for the version, so new permissions are pre-approved and audited), keeping the desired state
- *     an enterprise admin chose (a disabled optional plugin stays disabled) -> `upgraded`;
- *   - installed at a higher version, or from another source (an enterprise admin upgraded it), or
+ *     a super admin chose (a disabled optional plugin stays disabled) -> `upgraded`;
+ *   - installed at a higher version, or from another source (a super admin upgraded it), or
  *     the name is config-declared (`declared`: config wins, no install record is created):
  *     untouched, never downgraded -> `kept`;
  *   - a declarative plugin (no extension): imported into the catalog only -> `imported` (`kept`
@@ -306,6 +307,7 @@ let BootstrapService = class BootstrapService {
             const failures = [];
             for (const e of o.manifest.plugins) {
                 signal.throwIfAborted();
+                await this.warnIfHeld(e);
                 try {
                     const r = await this.entry(e, files.get(e.name), handled, o.imports);
                     results.push(carried(r, o.carry));
@@ -334,6 +336,23 @@ let BootstrapService = class BootstrapService {
             return { manifestSha256, results };
         });
     }
+    /**
+     * A pin whose plugin name an org holds (a live org-owned catalog item): the bootstrap takes no
+     * name over (ruling P3-28), so the entry fails; this warning tells the super admin why and
+     * which org holds it (final review M4).
+     */
+    async warnIfHeld(e) {
+        const holder = await otherNameOwner(this.db, e.name, null);
+        if (holder?.kind !== "org")
+            return;
+        this.log.warn("bootstrap: the plugin name is held by an organization; the entry cannot take it over until the organization renames or deletes its plugin", {
+            plugin: e.name,
+            version: e.version,
+            required: e.required,
+            ownerOrgId: holder.orgId,
+            ownerOrg: holder.name,
+        });
+    }
     /** The `bootstrap_runs` row and the `bootstrap.completed` audit, in one transaction. */
     async recordDone(manifestSha256, results) {
         await this.db
@@ -400,9 +419,11 @@ let BootstrapService = class BootstrapService {
         // Not new to the manifest: an optional entry left out on purpose stays out (Ruling 5)
         const isNew = handled === undefined || !handled.has(e.name);
         if (!pkg.manifest.extension) {
+            await this.markBuiltin(e.name, e.required);
             if (!isNew)
                 return { name: e.name, action: "kept", version: e.version };
             const imported = await this.importOnly(e, bytes, ref, imports);
+            await this.markBuiltin(e.name, e.required);
             return { name: e.name, action: imported ? "imported" : "kept", version: e.version };
         }
         if (this.registry.declared().has(e.name)) {
@@ -451,8 +472,41 @@ let BootstrapService = class BootstrapService {
         if (e.required && row?.desired_state === "disabled") {
             await this.ops.enable(e.name, null);
         }
+        await this.markBuiltin(e.name, e.required);
         return result;
     }
+    /**
+     * The catalog item of a bootstrap entry follows `required`: a required entry is builtin, offered
+     * to every org (scope `all`) and not disabled (migration 0075 could leave a required plugin
+     * disabled); an entry that stops being required is no longer builtin and keeps scope `all` (the
+     * admin may change it from then on).
+     */
+    async markBuiltin(name, required) {
+        const touch = { updated_at: sql `now()` };
+        if (required) {
+            await this.db
+                .updateTable("catalog_items")
+                .set({
+                builtin: true,
+                scope: "all",
+                disabled: false,
+                scope_version: sql `scope_version + 1`,
+                ...touch,
+            })
+                .where("name", "=", name)
+                .where("deleted_at", "is", null)
+                .where((eb) => eb.or([eb("builtin", "=", false), eb("scope", "<>", "all"), eb("disabled", "=", true)]))
+                .execute();
+            return;
+        }
+        await this.db
+            .updateTable("catalog_items")
+            .set({ builtin: false, ...touch })
+            .where("name", "=", name)
+            .where("deleted_at", "is", null)
+            .where("builtin", "=", true)
+            .execute();
+    }
     /** A declarative plugin: catalog only. Returns false when that version is already imported. */
     async importOnly(e, bytes, ref, imports) {
         try {
@@ -461,10 +515,7 @@ let BootstrapService = class BootstrapService {
                 ref,
                 integrity: e.integrity,
             });
-            await imports.confirm(null, stagingId, {
-                reviewHash: review.reviewHash,
-                deployExtension: false,
-            });
+            await imports.confirm(null, stagingId, { reviewHash: review.reviewHash });
             return true;
         }
         catch (err) {
@@ -474,7 +525,7 @@ let BootstrapService = class BootstrapService {
         }
     }
     /**
-     * Imports, approves, installs and enables (one review, confirmed with `deployExtension`). When
+     * Imports, approves, installs and enables (one review; its confirm deploys the extension). When
      * the catalog already has this version (an earlier run stopped after importing, or the same
      * package came from a marketplace), the extension is deployed from the package store instead.
      */
@@ -496,7 +547,6 @@ let BootstrapService = class BootstrapService {
         }
         const r = await imports.confirm(null, staged.stagingId, {
             reviewHash: staged.review.reviewHash,
-            deployExtension: true,
             enable,
         });
         if (r.deploy?.result === "failed") {
@@ -552,6 +602,17 @@ let BootstrapService = class BootstrapService {
         if (names.length > 0)
             q = q.where("name", "not in", names);
         const rows = await q.returning(["name", "version"]).execute();
+        for (const r of rows)
+            await this.markBuiltin(r.name, false);
+        // A declarative plugin has no install record: clear builtin by catalog name
+        let items = this.db
+            .updateTable("catalog_items")
+            .set({ builtin: false, updated_at: sql `now()` })
+            .where("builtin", "=", true)
+            .where("deleted_at", "is", null);
+        if (names.length > 0)
+            items = items.where("name", "not in", names);
+        await items.execute();
         return rows.map((r) => ({ name: r.name, action: "required_cleared", version: r.version }));
     }
 };

package/dist/extensions/cli.d.ts

@@ -54,6 +54,18 @@ export interface ExtensionCli {
     publishChanged(plugin: string): Promise<boolean>;
     close(): Promise<void>;
 }
+/**
+ * The effective deployment config (the startup config `fileValue` completed by the `stored` PG
+ * fields) parsed as the host's load gate does: overridable fields may stay empty (spec A §5.4a),
+ * hidden and read-only ones must be complete.
+ */
+export declare function parseDeploymentConfig(schema: z.ZodTypeAny, stored: Record<string, unknown>, fileValue: unknown): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    issues: ConfigIssue[];
+};
 /**
  * The CLI's extension management context (C18, F-Q): a Nest application context with
  * the extensions module over the database and a lazy Redis connection used only for publishing

package/dist/extensions/cli.js

@@ -13,7 +13,17 @@ import { ExtensionsModule } from "./extensions.module.js";
 import { ExtensionHost } from "./host.js";
 import { ExtensionInstalls } from "./installs.js";
 import { PLUGINS_CHANGED_TOPIC } from "./lifecycle-topics.js";
+import { parseLoadGate } from "./org-levels.js";
 import { ExtensionPackageError, extensionPackageApiError, permissionSetOfPackage, readExtensionPackage, } from "./package.js";
+/**
+ * The effective deployment config (the startup config `fileValue` completed by the `stored` PG
+ * fields) parsed as the host's load gate does: overridable fields may stay empty (spec A §5.4a),
+ * hidden and read-only ones must be complete.
+ */
+export function parseDeploymentConfig(schema, stored, fileValue) {
+    const r = parseLoadGate(schema, mergeDeploymentConfig(stored, fileValue, schemaFields(schema).map((f) => f.path)));
+    return r.success ? { ok: true, value: r.data } : { ok: false, issues: toIssues(r.error) };
+}
 /**
  * The CLI's extension management context (C18, F-Q): a Nest application context with
  * the extensions module over the database and a lazy Redis connection used only for publishing
@@ -44,8 +54,7 @@ export async function openExtensionCli(config, log, opts = {}) {
         const stored = await readStoredDeploymentConfig(db.db, keyring, name, {
             secretPaths: secretPathsOf(schemaFields(schema)),
         });
-        const r = schema.safeParse(mergeDeploymentConfig(stored, config.extensionConfig[name], schemaFields(schema).map((f) => f.path)));
-        return r.success ? { ok: true, value: r.data } : { ok: false, issues: toIssues(r.error) };
+        return parseDeploymentConfig(schema, stored, config.extensionConfig[name]);
     };
     const configIssues = new Map();
     const deploymentConfigs = new Map();