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

package/dist/identity/me.controller.js

@@ -20,6 +20,7 @@ import { ApiTokenService, FutureIsoDate } from "./api-tokens.js";
 import { MAX_PASSWORD_LENGTH } from "./login.js";
 import { CurrentPrincipal, requireUser, SessionOnly } from "./principal.js";
 import { SessionService } from "./sessions.js";
+import { SettingsService } from "./settings.js";
 /** The credential throttlers of a password change (per account, per client IP). */
 const CHANGE_PASSWORD_THROTTLERS = ["change-password", "change-password-ip"];
 const ChangePasswordSchema = z.object({
@@ -45,13 +46,15 @@ let MeController = class MeController {
     tokens;
     throttler;
     log;
-    constructor(accounts, sessions, orgs, tokens, throttler, log) {
+    settings;
+    constructor(accounts, sessions, orgs, tokens, throttler, log, settings) {
         this.accounts = accounts;
         this.sessions = sessions;
         this.orgs = orgs;
         this.tokens = tokens;
         this.throttler = throttler;
         this.log = log;
+        this.settings = settings;
     }
     async me(principal) {
         const p = requireUser(principal);
@@ -62,7 +65,12 @@ let MeController = class MeController {
             name: o.name,
             role: o.role,
         }));
-        return { account: p.account, via: p.via, currentOrgId, memberships };
+        // a session's org the account has since left reads as none (removal clears it, but a session
+        // created at that moment may still name it)
+        const current = memberships.some((m) => m.orgId === currentOrgId) ? currentOrgId : null;
+        const { orgCreation } = await this.settings.get();
+        const canCreateOrg = orgCreation === "anyone" || p.account.isSuperAdmin;
+        return { account: p.account, via: p.via, currentOrgId: current, memberships, canCreateOrg };
     }
     /** 切换当前组织（仅 Web 会话）；`null` 清空。非成员或已软删除的组织 → `org.not_found`。 */
     async setCurrentOrg(principal, body) {
@@ -160,6 +168,7 @@ MeController = __decorate([
     __param(2, Inject(OrgsService)),
     __param(3, Inject(ApiTokenService)),
     __param(4, Inject(CredentialThrottler)),
-    __param(5, Inject(KERNEL_LOGGER))
+    __param(5, Inject(KERNEL_LOGGER)),
+    __param(6, Inject(SettingsService))
 ], MeController);
 export { MeController };

package/dist/identity/principal.d.ts

@@ -28,7 +28,7 @@ declare module "fastify" {
 }
 export declare const PUBLIC_KEY = "capybara:auth:public";
 export declare const SESSION_ONLY_KEY = "capybara:auth:session-only";
-export declare const ENTERPRISE_ADMIN_KEY = "capybara:auth:enterprise-admin";
+export declare const SUPER_ADMIN_KEY = "capybara:auth:super-admin";
 export declare const ALLOW_SERVICE_KEY = "capybara:auth:allow-service";
 /**
  * 不要求凭据：无凭据时放行（principal 为 undefined）；带了有效凭据仍解析，无效凭据按无凭据处理。
@@ -37,8 +37,8 @@ export declare const ALLOW_SERVICE_KEY = "capybara:auth:allow-service";
 export declare const Public: () => MethodDecorator & ClassDecorator;
 /** 仅接受 Web 会话（`via: "session"`）；个人令牌 → `auth.session_required`。 */
 export declare const SessionOnly: () => MethodDecorator;
-/** 仅企业管理员（user principal 且 `isEnterpriseAdmin`）；否则 `forbidden`。 */
-export declare const EnterpriseAdmin: () => MethodDecorator & ClassDecorator;
+/** 仅超级管理员（user principal 且 `isSuperAdmin`）；否则 `forbidden`。 */
+export declare const SuperAdmin: () => MethodDecorator & ClassDecorator;
 /**
  * 允许服务令牌（service principal）访问。默认拒绝：未标注的路由只接受 user principal，service → `forbidden`。
  * 组织级路由由 OrgGuard 再核对令牌所属组织与角色。

package/dist/identity/principal.js

@@ -2,7 +2,7 @@ import { createParamDecorator, SetMetadata } from "@nestjs/common";
 import { ApiError } from "../errors.js";
 export const PUBLIC_KEY = "capybara:auth:public";
 export const SESSION_ONLY_KEY = "capybara:auth:session-only";
-export const ENTERPRISE_ADMIN_KEY = "capybara:auth:enterprise-admin";
+export const SUPER_ADMIN_KEY = "capybara:auth:super-admin";
 export const ALLOW_SERVICE_KEY = "capybara:auth:allow-service";
 /**
  * 不要求凭据：无凭据时放行（principal 为 undefined）；带了有效凭据仍解析，无效凭据按无凭据处理。
@@ -11,8 +11,8 @@ export const ALLOW_SERVICE_KEY = "capybara:auth:allow-service";
 export const Public = () => SetMetadata(PUBLIC_KEY, true);
 /** 仅接受 Web 会话（`via: "session"`）；个人令牌 → `auth.session_required`。 */
 export const SessionOnly = () => SetMetadata(SESSION_ONLY_KEY, true);
-/** 仅企业管理员（user principal 且 `isEnterpriseAdmin`）；否则 `forbidden`。 */
-export const EnterpriseAdmin = () => SetMetadata(ENTERPRISE_ADMIN_KEY, true);
+/** 仅超级管理员（user principal 且 `isSuperAdmin`）；否则 `forbidden`。 */
+export const SuperAdmin = () => SetMetadata(SUPER_ADMIN_KEY, true);
 /**
  * 允许服务令牌（service principal）访问。默认拒绝：未标注的路由只接受 user principal，service → `forbidden`。
  * 组织级路由由 OrgGuard 再核对令牌所属组织与角色。

package/dist/identity/sessions.d.ts

@@ -36,6 +36,18 @@ export declare class SessionService {
         userAgent?: string;
         ip?: string;
     }): Promise<IssuedSession>;
+    /**
+     * The org a new session starts in: the account's last chosen one while it is still a member of it
+     * (and the org is not deleted), else its only org when it has exactly one, else none (the web
+     * app then asks to choose or create one).
+     */
+    private startingOrg;
+    /**
+     * Read-only: of several refresh tokens (a cookie header carrying the legacy and the `Path=/`
+     * cookie), the first that is the current token of a live session, if any. Choosing before
+     * rotating keeps a stale token from tripping replay detection on a still valid session.
+     */
+    pickCurrentRefresh(candidates: readonly string[]): Promise<string | undefined>;
     refresh(refreshToken: string, meta: {
         userAgent?: string;
         ip?: string;

package/dist/identity/sessions.js

@@ -72,11 +72,49 @@ let SessionService = class SessionService {
             user_agent: meta.userAgent ?? null,
             ip: meta.ip ?? null,
             expires_at: sql `now() + make_interval(days => ${refreshTtlDays})`,
+            current_org_id: await this.startingOrg(accountId),
         })
             .returning(["expires_at"])
             .executeTakeFirstOrThrow();
         return this.issue(id, accountId, refreshToken, row.expires_at);
     }
+    /**
+     * The org a new session starts in: the account's last chosen one while it is still a member of it
+     * (and the org is not deleted), else its only org when it has exactly one, else none (the web
+     * app then asks to choose or create one).
+     */
+    async startingOrg(accountId) {
+        const orgs = await this.db
+            .selectFrom("memberships as m")
+            .innerJoin("orgs as o", "o.id", "m.org_id")
+            .innerJoin("accounts as a", "a.id", "m.account_id")
+            .select(["m.org_id as orgId", "a.last_org_id as lastOrgId"])
+            .where("m.account_id", "=", accountId)
+            .where("o.deleted_at", "is", null)
+            .execute();
+        const last = orgs.find((o) => o.orgId === o.lastOrgId);
+        if (last)
+            return last.orgId;
+        return orgs.length === 1 ? (orgs[0]?.orgId ?? null) : null;
+    }
+    /**
+     * Read-only: of several refresh tokens (a cookie header carrying the legacy and the `Path=/`
+     * cookie), the first that is the current token of a live session, if any. Choosing before
+     * rotating keeps a stale token from tripping replay detection on a still valid session.
+     */
+    async pickCurrentRefresh(candidates) {
+        if (candidates.length === 0)
+            return undefined;
+        const rows = await this.db
+            .selectFrom("sessions")
+            .select("refresh_hash")
+            .where("refresh_hash", "in", candidates.map((c) => sha256Hex(c)))
+            .where("revoked_at", "is", null)
+            .where("expires_at", ">", sql `now()`)
+            .execute();
+        const live = new Set(rows.map((r) => r.refresh_hash));
+        return candidates.find((c) => live.has(sha256Hex(c)));
+    }
     async refresh(refreshToken, meta) {
         const oldHash = sha256Hex(refreshToken);
         const next = newRefreshToken();
@@ -277,6 +315,13 @@ let SessionService = class SessionService {
                 .executeTakeFirst());
         if (!m)
             throw new ApiError("org.not_found", "Organization not found");
+        // remembered for the next sign-in; the account row before the session row, the order a
+        // password change takes (account, then its sessions)
+        await this.db
+            .updateTable("accounts")
+            .set({ last_org_id: orgId })
+            .where("id", "=", accountId)
+            .execute();
         const r = await this.db
             .updateTable("sessions")
             .set({ current_org_id: orgId })

package/dist/identity/settings.d.ts

@@ -3,7 +3,7 @@ import type { KernelSchemaDb } from "../db/kernel-schema.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import type { KernelLogger } from "../log.js";
-import { EnterpriseAdminLock } from "./enterprise-admin.js";
+import { SuperAdminLock } from "./super-admin.js";
 /** 沙箱 cpu（核）与内存（MB）覆盖的范围（C19）。 */
 export declare const SANDBOX_CPU_RANGE: {
     readonly min: 0.25;
@@ -20,11 +20,13 @@ export declare const SANDBOX_LIMIT_OVERRIDE: z.ZodObject<{
 }, z.core.$strict>;
 export type SandboxLimitOverride = z.infer<typeof SANDBOX_LIMIT_OVERRIDE>;
 /**
- * One organization's sub-agent limits (sub-agents spec §8.2): any of the three `subagents.*`
- * values, within the same bounds; the ones not given use the deployment's config.
+ * One organization's sub-agent limits (sub-agents spec §8.2, agent map spec §6): any of the
+ * `subagents.*` values, within the same bounds (0 for dispatches or tokens: no limit); the ones not
+ * given use the deployment's config.
  */
 export declare const SUBAGENT_LIMIT_OVERRIDE: z.ZodObject<{
-    maxConcurrentPerRun: z.ZodOptional<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    maxConcurrentPerConversation: z.ZodOptional<z.ZodNumber>;
     maxDispatchesPerRun: z.ZodOptional<z.ZodNumber>;
     maxTokensPerRun: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
@@ -32,7 +34,7 @@ export type SubagentLimitOverride = z.infer<typeof SUBAGENT_LIMIT_OVERRIDE>;
 export declare const DEPLOYMENT_SETTINGS: z.ZodObject<{
     orgCreation: z.ZodDefault<z.ZodEnum<{
         anyone: "anyone";
-        enterprise_admin: "enterprise_admin";
+        super_admin: "super_admin";
     }>>;
     runConcurrencyOverrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     priceCurrency: z.ZodDefault<z.ZodString>;
@@ -41,7 +43,8 @@ export declare const DEPLOYMENT_SETTINGS: z.ZodObject<{
         memoryMb: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
     subagentLimitOverrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        maxConcurrentPerRun: z.ZodOptional<z.ZodNumber>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxConcurrentPerConversation: z.ZodOptional<z.ZodNumber>;
         maxDispatchesPerRun: z.ZodOptional<z.ZodNumber>;
         maxTokensPerRun: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
@@ -53,6 +56,7 @@ export declare const DEPLOYMENT_SETTINGS: z.ZodObject<{
         allow: "allow";
         deny: "deny";
     }>>;
+    orgMarketplaceBrowse: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type DeploymentSettings = z.infer<typeof DEPLOYMENT_SETTINGS>;
 /**
@@ -66,7 +70,7 @@ export type DeploymentSettings = z.infer<typeof DEPLOYMENT_SETTINGS>;
 export declare const DEPLOYMENT_SETTINGS_PATCH: z.ZodObject<{
     orgCreation: z.ZodOptional<z.ZodEnum<{
         anyone: "anyone";
-        enterprise_admin: "enterprise_admin";
+        super_admin: "super_admin";
     }>>;
     runConcurrencyOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodNumber>>>;
     priceCurrency: z.ZodOptional<z.ZodString>;
@@ -75,7 +79,8 @@ export declare const DEPLOYMENT_SETTINGS_PATCH: z.ZodObject<{
         memoryMb: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>>;
     subagentLimitOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
-        maxConcurrentPerRun: z.ZodOptional<z.ZodNumber>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxConcurrentPerConversation: z.ZodOptional<z.ZodNumber>;
         maxDispatchesPerRun: z.ZodOptional<z.ZodNumber>;
         maxTokensPerRun: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>>;
@@ -87,6 +92,7 @@ export declare const DEPLOYMENT_SETTINGS_PATCH: z.ZodObject<{
         allow: "allow";
         deny: "deny";
     }>>;
+    orgMarketplaceBrowse: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export type DeploymentSettingsPatch = z.infer<typeof DEPLOYMENT_SETTINGS_PATCH>;
 /**
@@ -102,18 +108,23 @@ export declare function readSandboxLimitOverride(db: KernelSchemaDb, orgId: stri
 export declare function readSubagentLimitOverride(db: KernelSchemaDb, orgId: string): Promise<SubagentLimitOverride | undefined>;
 /**
  * When orgs may not create their own connectors / skills (deployment setting `customConnectors` /
- * `customSkills` is `deny`, C22) throws `catalog.custom_disabled`: install from the enterprise
+ * `customSkills` is `deny`, C22) throws `catalog.custom_disabled`: install from the platform
  * catalog only. Reads PG live every time (can read in the caller's transaction); an invalid stored
  * value counts as allow.
  */
 export declare function assertCustomAllowed(db: KernelSchemaDb, key: "customConnectors" | "customSkills"): Promise<void>;
+/**
+ * The deployment setting `orgMarketplaceBrowse`, read live from PG (in the caller's transaction
+ * when there is one); missing or invalid -> the default, true.
+ */
+export declare function readOrgMarketplaceBrowse(db: KernelSchemaDb): Promise<boolean>;
 /** Deployment settings: one row per key, defaults for missing keys. */
 export declare class SettingsService {
     private readonly db;
     readonly txHost: TransactionHost;
     private readonly adminLock;
     private readonly log;
-    constructor(db: KernelDb, txHost: TransactionHost, adminLock: EnterpriseAdminLock, log: Pick<KernelLogger, "warn">);
+    constructor(db: KernelDb, txHost: TransactionHost, adminLock: SuperAdminLock, log: Pick<KernelLogger, "warn">);
     /**
      * Reads every setting, in the context's transaction when there is one (a caller holding a
      * transaction connection does not take a second one from the pool). Each key is validated on
@@ -121,7 +132,7 @@ export declare class SettingsService {
      * valid keys apply; unknown keys (written by a newer version) are ignored.
      */
     get(): Promise<DeploymentSettings>;
-    /** Updates settings under the enterprise admin lock, re-checking the actor (else `forbidden`). */
+    /** Updates settings under the super admin lock, re-checking the actor (else `forbidden`). */
     update(patch: DeploymentSettingsPatch, actorAccountId: string, actorTokenId?: string): Promise<DeploymentSettings>;
     private write;
 }

package/dist/identity/settings.js

@@ -15,7 +15,7 @@ import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { audit } from "./audit.js";
-import { EnterpriseAdminLock } from "./enterprise-admin.js";
+import { SuperAdminLock } from "./super-admin.js";
 /** 币种代码：ISO 4217 的三位大写字母（如 USD、CNY）。 */
 const CurrencyCode = z.string().regex(/^[A-Z]{3}$/, "must be a 3-letter ISO 4217 currency code");
 /** 沙箱 cpu（核）与内存（MB）覆盖的范围（C19）。 */
@@ -37,23 +37,34 @@ export const SANDBOX_LIMIT_OVERRIDE = z
     message: "give cpu, memoryMb or both",
 });
 /**
- * One organization's sub-agent limits (sub-agents spec §8.2): any of the three `subagents.*`
- * values, within the same bounds; the ones not given use the deployment's config.
+ * One organization's sub-agent limits (sub-agents spec §8.2, agent map spec §6): any of the
+ * `subagents.*` values, within the same bounds (0 for dispatches or tokens: no limit); the ones not
+ * given use the deployment's config.
  */
 export const SUBAGENT_LIMIT_OVERRIDE = z
     .object({
-    maxConcurrentPerRun: z.number().int().min(1).max(20).optional(),
-    maxDispatchesPerRun: z.number().int().min(1).max(500).optional(),
-    maxTokensPerRun: z.number().int().min(10_000).optional(),
+    maxDepth: z.number().int().min(1).max(5).optional(),
+    maxConcurrentPerConversation: z.number().int().min(1).max(20).optional(),
+    maxDispatchesPerRun: z
+        .number()
+        .int()
+        .max(500)
+        .refine((n) => n === 0 || n >= 1, "0 (no limit) or 1 to 500")
+        .optional(),
+    maxTokensPerRun: z
+        .number()
+        .int()
+        .refine((n) => n === 0 || n >= 10_000, "0 (no limit) or at least 10,000")
+        .optional(),
 })
     .strict()
     .refine((o) => Object.values(o).some((v) => v !== undefined), {
-    message: "give maxConcurrentPerRun, maxDispatchesPerRun or maxTokensPerRun",
+    message: "give maxDepth, maxConcurrentPerConversation, maxDispatchesPerRun or maxTokensPerRun",
 });
-/** 组织能否自建连接器 / 技能（C22）：`deny` 时只能从企业目录安装（T26 执行）。 */
+/** 组织能否自建连接器 / 技能（C22）：`deny` 时只能从平台目录安装（T26 执行）。 */
 const CustomPolicy = z.enum(["allow", "deny"]);
 export const DEPLOYMENT_SETTINGS = z.object({
-    orgCreation: z.enum(["anyone", "enterprise_admin"]).default("anyone"),
+    orgCreation: z.enum(["anyone", "super_admin"]).default("anyone"),
     /** 按组织覆盖运行并发上限（orgId → 上限）；未列出的组织用 `runtime.orgConcurrency`。 */
     runConcurrencyOverrides: z.record(z.string().min(1), z.number().int().positive()).default({}),
     /** 模型价格表（`model_prices`）的币种；只用于显示估算成本，不做换算。 */
@@ -65,13 +76,18 @@ export const DEPLOYMENT_SETTINGS = z.object({
      * not given, use `subagents.*`. Read live on every dispatch and tool resolution.
      */
     subagentLimitOverrides: z.record(z.string().min(1), SUBAGENT_LIMIT_OVERRIDE).default({}),
-    /** 组织能否自建连接器（不经企业目录）。 */
+    /** 组织能否自建连接器（不经平台目录）。 */
     customConnectors: CustomPolicy.default("allow"),
     /**
-     * 组织能否自建技能（不经企业目录）：deny 时组织管理员不能上传技能包。agent 自写技能（`SkillWrite`，私有 agent 的
+     * 组织能否自建技能（不经平台目录）：deny 时组织管理员不能上传技能包。agent 自写技能（`SkillWrite`，私有 agent 的
      * agent 级技能与共享 agent 经负责人审批的变更）不受此开关约束——那是 agent 定义的一部分，由 R3 / R4 把关。
      */
     customSkills: CustomPolicy.default("allow"),
+    /**
+     * Org admins may browse the marketplaces read-only and ask for an entry to be imported (plugin
+     * scope spec §5.1 rule 3). false hides the browse route and refuses those requests.
+     */
+    orgMarketplaceBrowse: z.boolean().default(true),
 });
 const DEFAULTS = DEPLOYMENT_SETTINGS.parse({});
 /**
@@ -84,7 +100,7 @@ const DEFAULTS = DEPLOYMENT_SETTINGS.parse({});
  */
 export const DEPLOYMENT_SETTINGS_PATCH = z
     .object({
-    orgCreation: z.enum(["anyone", "enterprise_admin"]).optional(),
+    orgCreation: z.enum(["anyone", "super_admin"]).optional(),
     runConcurrencyOverrides: z
         .record(z.string().min(1), z.number().int().positive().nullable())
         .optional(),
@@ -97,6 +113,7 @@ export const DEPLOYMENT_SETTINGS_PATCH = z
         .optional(),
     customConnectors: CustomPolicy.optional(),
     customSkills: CustomPolicy.optional(),
+    orgMarketplaceBrowse: z.boolean().optional(),
 })
     .strict();
 /**
@@ -140,7 +157,7 @@ export async function readSubagentLimitOverride(db, orgId) {
 }
 /**
  * When orgs may not create their own connectors / skills (deployment setting `customConnectors` /
- * `customSkills` is `deny`, C22) throws `catalog.custom_disabled`: install from the enterprise
+ * `customSkills` is `deny`, C22) throws `catalog.custom_disabled`: install from the platform
  * catalog only. Reads PG live every time (can read in the caller's transaction); an invalid stored
  * value counts as allow.
  */
@@ -155,10 +172,25 @@ export async function assertCustomAllowed(db, key) {
     const parsed = CustomPolicy.safeParse(row.value);
     if (parsed.success && parsed.data === "deny") {
         throw new ApiError("catalog.custom_disabled", key === "customConnectors"
-            ? "Custom connectors are disabled in this deployment; install connectors from the enterprise catalog"
-            : "Custom skills are disabled in this deployment; install skills from the enterprise catalog");
+            ? "Custom connectors are disabled in this deployment; install connectors from the platform catalog"
+            : "Custom skills are disabled in this deployment; install skills from the platform catalog");
     }
 }
+/**
+ * The deployment setting `orgMarketplaceBrowse`, read live from PG (in the caller's transaction
+ * when there is one); missing or invalid -> the default, true.
+ */
+export async function readOrgMarketplaceBrowse(db) {
+    const row = await db
+        .selectFrom("deployment_settings")
+        .select("value")
+        .where("key", "=", "orgMarketplaceBrowse")
+        .executeTakeFirst();
+    if (!row)
+        return true;
+    const parsed = z.boolean().safeParse(row.value);
+    return parsed.success ? parsed.data : true;
+}
 /** 按组织合并覆盖：值为 null 删除该组织，其余整项替换；未列出的组织不变。 */
 function mergeByOrg(current, patch) {
     const merged = { ...current };
@@ -208,7 +240,7 @@ let SettingsService = class SettingsService {
         }
         return out;
     }
-    /** Updates settings under the enterprise admin lock, re-checking the actor (else `forbidden`). */
+    /** Updates settings under the super admin lock, re-checking the actor (else `forbidden`). */
     async update(patch, actorAccountId, actorTokenId) {
         const check = DEPLOYMENT_SETTINGS_PATCH.safeParse(patch);
         if (!check.success) {
@@ -219,7 +251,7 @@ let SettingsService = class SettingsService {
     }
     async write(patch, actorAccountId, actorTokenId) {
         await this.adminLock.lockAndAuthorize(actorAccountId);
-        // The enterprise admin lock serializes every settings write: the current overrides are read
+        // The super admin lock serializes every settings write: the current overrides are read
         // and merged under it, so no concurrent change is lost
         const next = {};
         if (patch.orgCreation !== undefined)
@@ -230,6 +262,9 @@ let SettingsService = class SettingsService {
             next.customConnectors = patch.customConnectors;
         if (patch.customSkills !== undefined)
             next.customSkills = patch.customSkills;
+        if (patch.orgMarketplaceBrowse !== undefined) {
+            next.orgMarketplaceBrowse = patch.orgMarketplaceBrowse;
+        }
         const { runConcurrencyOverrides: runPatch, sandboxLimitOverrides: sandboxPatch, subagentLimitOverrides: subagentPatch, } = patch;
         if (runPatch !== undefined || sandboxPatch !== undefined || subagentPatch !== undefined) {
             const current = await this.get();
@@ -270,7 +305,7 @@ SettingsService = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
     __param(1, Inject(TransactionHost)),
-    __param(2, Inject(EnterpriseAdminLock)),
+    __param(2, Inject(SuperAdminLock)),
     __param(3, Inject(KERNEL_LOGGER))
 ], SettingsService);
 export { SettingsService };

package/dist/identity/{enterprise-admin.d.ts → super-admin.d.ts}

@@ -2,19 +2,19 @@ import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { XactLock } from "../infra/database/xact-lock.js";
 /**
- * The enterprise admin lock, the one implementation of "lock, then re-check the actor":
+ * The super admin lock, the one implementation of "lock, then re-check the actor":
  * both methods join the caller's transaction (`mandatory`), which holds the lock until it ends.
  */
-export declare class EnterpriseAdminLock {
+export declare class SuperAdminLock {
     private readonly db;
     private readonly xactLock;
     readonly txHost: TransactionHost;
     constructor(db: KernelDb, xactLock: XactLock, txHost: TransactionHost);
     /** Only the lock (callers without an actor: the CLI, bootstrap). */
     lock(): Promise<void>;
-    /** The lock, then {@link assertActiveEnterpriseAdmin} under it. */
+    /** The lock, then {@link assertActiveSuperAdmin} under it. */
     lockAndAuthorize(actorAccountId: string): Promise<void>;
 }
-/** The one {@link EnterpriseAdminLock}: identity, models, the extensions and the catalog import it. */
-export declare class EnterpriseAdminLockModule {
+/** The one {@link SuperAdminLock}: identity, models, the extensions and the catalog import it. */
+export declare class SuperAdminLockModule {
 }

package/dist/identity/{enterprise-admin.js → super-admin.js}

@@ -15,32 +15,32 @@ import { Transactional } from "../infra/database/transactional.decorator.js";
 import { XactLock } from "../infra/database/xact-lock.js";
 /**
  * The transaction-scoped lock (`XactLock`, `pg_advisory_xact_lock`) that serializes every
- * enterprise admin write: revoke / disable / create an admin, deployment settings, prices,
+ * super admin write: revoke / disable / create an admin, deployment settings, prices,
  * purposes, the catalog and extension admin writes, the CLI's `capybara admin grant|revoke`.
  */
-const ENTERPRISE_ADMINS_LOCK = "capybara.enterprise_admins";
+const SUPER_ADMINS_LOCK = "capybara.super_admins";
 /**
- * The run-time re-check of an enterprise admin write (spec 3.6 R5), under
- * {@link ENTERPRISE_ADMINS_LOCK}: the actor must still be an active enterprise admin, else
+ * The run-time re-check of a super admin write (spec 3.6 R5), under
+ * {@link SUPER_ADMINS_LOCK}: the actor must still be an active super admin, else
  * `forbidden`. The identity the auth guard read at the start of the request may be stale (another
  * admin just revoked it), so it is re-read under the lock.
  */
-async function assertActiveEnterpriseAdmin(db, actorAccountId) {
+async function assertActiveSuperAdmin(db, actorAccountId) {
     const actor = await db
         .selectFrom("accounts")
         .select("id")
         .where("id", "=", actorAccountId)
-        .where("is_enterprise_admin", "=", true)
+        .where("is_super_admin", "=", true)
         .where("status", "=", "active")
         .executeTakeFirst();
     if (!actor)
-        throw new ApiError("forbidden", "Enterprise admin required");
+        throw new ApiError("forbidden", "Super admin required");
 }
 /**
- * The enterprise admin lock, the one implementation of "lock, then re-check the actor":
+ * The super admin lock, the one implementation of "lock, then re-check the actor":
  * both methods join the caller's transaction (`mandatory`), which holds the lock until it ends.
  */
-let EnterpriseAdminLock = class EnterpriseAdminLock {
+let SuperAdminLock = class SuperAdminLock {
     db;
     xactLock;
     txHost;
@@ -51,31 +51,31 @@ let EnterpriseAdminLock = class EnterpriseAdminLock {
     }
     /** Only the lock (callers without an actor: the CLI, bootstrap). */
     async lock() {
-        await this.xactLock.lock(ENTERPRISE_ADMINS_LOCK);
+        await this.xactLock.lock(SUPER_ADMINS_LOCK);
     }
-    /** The lock, then {@link assertActiveEnterpriseAdmin} under it. */
+    /** The lock, then {@link assertActiveSuperAdmin} under it. */
     async lockAndAuthorize(actorAccountId) {
-        await this.xactLock.lock(ENTERPRISE_ADMINS_LOCK);
-        await assertActiveEnterpriseAdmin(this.db.db, actorAccountId);
+        await this.xactLock.lock(SUPER_ADMINS_LOCK);
+        await assertActiveSuperAdmin(this.db.db, actorAccountId);
     }
 };
 __decorate([
     Transactional({ propagation: "mandatory" })
-], EnterpriseAdminLock.prototype, "lock", null);
+], SuperAdminLock.prototype, "lock", null);
 __decorate([
     Transactional({ propagation: "mandatory" })
-], EnterpriseAdminLock.prototype, "lockAndAuthorize", null);
-EnterpriseAdminLock = __decorate([
+], SuperAdminLock.prototype, "lockAndAuthorize", null);
+SuperAdminLock = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
     __param(1, Inject(XactLock)),
     __param(2, Inject(TransactionHost))
-], EnterpriseAdminLock);
-export { EnterpriseAdminLock };
-/** The one {@link EnterpriseAdminLock}: identity, models, the extensions and the catalog import it. */
-let EnterpriseAdminLockModule = class EnterpriseAdminLockModule {
+], SuperAdminLock);
+export { SuperAdminLock };
+/** The one {@link SuperAdminLock}: identity, models, the extensions and the catalog import it. */
+let SuperAdminLockModule = class SuperAdminLockModule {
 };
-EnterpriseAdminLockModule = __decorate([
-    Module({ providers: [EnterpriseAdminLock], exports: [EnterpriseAdminLock] })
-], EnterpriseAdminLockModule);
-export { EnterpriseAdminLockModule };
+SuperAdminLockModule = __decorate([
+    Module({ providers: [SuperAdminLock], exports: [SuperAdminLock] })
+], SuperAdminLockModule);
+export { SuperAdminLockModule };

package/dist/inbox/inbox.module.d.ts

@@ -1,3 +1,6 @@
-/** The inbox: pending tool approvals, skill changes and catalog requests, read live from PG. */
+/**
+ * The inboxes, read live from PG: an org member's (pending tool approvals, skill changes, catalog
+ * requests, org notices) and the super admin's (`PlatformInboxService`).
+ */
 export declare class InboxModule {
 }

package/dist/inbox/inbox.module.js

@@ -9,14 +9,18 @@ import { CatalogModule } from "../catalog/catalog.module.js";
 import { SkillsModule } from "../skills/skills.module.js";
 import { ToolsModule } from "../tools/tools.module.js";
 import { InboxService } from "./inbox.service.js";
-/** The inbox: pending tool approvals, skill changes and catalog requests, read live from PG. */
+import { PlatformInboxService } from "./platform-inbox.service.js";
+/**
+ * The inboxes, read live from PG: an org member's (pending tool approvals, skill changes, catalog
+ * requests, org notices) and the super admin's (`PlatformInboxService`).
+ */
 let InboxModule = class InboxModule {
 };
 InboxModule = __decorate([
     Module({
         imports: [ToolsModule, SkillsModule, CatalogModule],
-        providers: [InboxService],
-        exports: [InboxService],
+        providers: [InboxService, PlatformInboxService],
+        exports: [InboxService, PlatformInboxService],
     })
 ], InboxModule);
 export { InboxModule };