@pipeline-builder/api-core 5.2.3 → 5.2.4

package/lib/types/permissions.js

@@ -1,24 +1,58 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+/**
+ * The CLOSED set of actions a permission id may end in — the second half of the
+ * `resource:action` strategy the docs describe.
+ *
+ * It is closed for one concrete reason: `isMutationPermission` (frontend
+ * `lib/auth-helpers.ts`) classifies read vs write BY SUFFIX, and that is what
+ * disables every write affordance during a read-only impersonation session. A
+ * noun-shaped action (the former `org:settings` and `consoles:datastore`) cannot be classified
+ * by name, so each one had to be hand-listed — and a permission added without
+ * remembering that list renders an enabled control that dead-ends on a 403.
+ *
+ * Reads are `:read` and `:rollup` (a read-VISIBILITY scope). Everything else is
+ * a write. The five domain verbs are kept because each names an action with no
+ * synonym in this vocabulary — `:export` is egress rather than mutation,
+ * `:install` is consumption rather than authoring, `:moderate` and `:verify` are
+ * ecosystem decisions, and `:operate` moves another tenant's money.
+ *
+ * `PERMISSION_ID_SHAPE` and this list are asserted over the whole catalog in
+ * api-core's `test/permissions.test.ts`, so adding an off-strategy id fails
+ * there rather than at a 403.
+ */
+export const PERMISSION_ACTIONS = [
+    'read', 'rollup',
+    'write', 'manage', 'publish', 'open',
+    'export', 'install', 'moderate', 'verify', 'operate', 'purge', 'approve',
+];
+/** `resource:action`, where resource is `snake_case` and action is in {@link PERMISSION_ACTIONS}. */
+export const PERMISSION_ID_SHAPE = /^[a-z][a-z0-9_]*:[a-z]+$/;
 /** All valid permissions (order determines display order in the picker). */
 export const ALL_PERMISSIONS = [
-    'pipelines:read', 'pipelines:write', 'pipelines:publish',
+    'pipelines:read', 'pipelines:write', 'pipelines:publish', 'pipeline_registry:write',
     'templates:read', 'templates:write', 'templates:publish',
     'plugins:read', 'plugins:write', 'plugins:publish',
     'plugins:install', 'plugin_installs:manage', 'publishers:manage',
     'plugins:moderate', 'publishers:verify',
+    'platform:read', 'orgs:read', 'billing:operate',
+    'observability_console:open', 'database_console:open', 'objectstore_console:open',
     'oncall:manage',
+    'support_cases:write', 'support_content:write',
+    'subscriptions:read', 'subscriptions:manage',
+    'orgs:manage', 'quotas:manage', 'plugin_queue:manage',
     'compliance:read', 'compliance:write',
     'members:manage', 'roles:manage', 'invitations:manage', 'service_accounts:manage',
     'dashboards:read', 'dashboards:write',
     'observability:read', 'observability:write',
-    'logs:export',
-    'reports:read', 'reports:rollup', 'reports:author', 'reports:share',
+    'logs:export', 'audit:read',
+    'reports:read', 'reports:rollup', 'reports:write', 'reports:publish',
     'messages:read', 'messages:write',
     'billing:read', 'billing:manage',
     'quotas:read',
-    'registry:read', 'registry:write',
-    'org:settings', 'org:idp', 'org:kms', 'org:impersonation',
+    'registry:read', 'registry:write', 'registry:purge',
+    'impersonation:open', 'impersonation:approve', 'team_access:open',
+    'org_settings:write', 'org_idp:write', 'org_kms:write', 'org_impersonation:write',
 ];
 /**
  * The CLOSED set of functions that take a {@link Permission} and decide access.
@@ -44,7 +78,7 @@ export const PERMISSION_GATES = [
     'requireAllPermissions',
     'requirePermissionOrService',
     // The plugin-ecosystem governance chain (system org + permission + aal2).
-    'requireEcosystemPermission',
+    'requireSystemOrgPermission',
     // The single runtime primitive every gate above delegates to; also called
     // directly where a controller branches on a capability rather than rejecting.
     'userHasPermission',
@@ -53,6 +87,11 @@ export const PERMISSION_GATES = [
     'requireVisibilityWriteAccess',
     'checkVisibilityWriteAccess',
     'resolveVisibility',
+    // quota's own wrapper. It delegates to `requirePermission`, but it takes the
+    // id as an OPTION (`authorizeOrg({ permission: 'quotas:manage' })`) because it
+    // also canonicalizes the `:orgId` param, which the route cannot drop. Without
+    // this entry the coverage scan reported `quotas:manage` as enforced nowhere.
+    'authorizeOrg',
 ];
 /**
  * The permission catalog with display metadata, in picker order.
@@ -67,6 +106,7 @@ export const PERMISSION_CATALOG = [
     { id: 'pipelines:read', label: 'View pipelines', description: 'View pipelines and their executions', category: 'Pipelines' },
     { id: 'pipelines:write', label: 'Manage pipelines', description: 'Create, edit, and delete pipelines', category: 'Pipelines' },
     { id: 'pipelines:publish', label: 'Publish pipelines', description: 'Make pipelines public (org-wide/catalog visibility)', category: 'Pipelines' },
+    { id: 'pipeline_registry:write', label: 'Register deployments', description: 'Record and remove the deployed stack and step manifest behind a pipeline (the pipeline registry)', category: 'Pipelines' },
     { id: 'templates:read', label: 'View templates', description: 'View the golden-path template catalog', category: 'Templates' },
     { id: 'templates:write', label: 'Manage templates', description: 'Author, edit, and delete pipeline templates', category: 'Templates' },
     { id: 'templates:publish', label: 'Publish templates', description: 'Share a template beyond your org (public visibility)', category: 'Templates' },
@@ -78,7 +118,20 @@ export const PERMISSION_CATALOG = [
     { id: 'publishers:manage', label: 'Manage publisher profile', description: "Manage your org's publisher profile and submit publish, verification, transfer, and advisory requests", category: 'Plugin Ecosystem' },
     { id: 'plugins:moderate', label: 'Moderate the plugin ecosystem', description: 'Decide publish requests, moderate submissions and reviews, yank versions, and publish advisories (system org only)', category: 'Plugin Ecosystem' },
     { id: 'publishers:verify', label: 'Verify publishers', description: 'Approve Verified applications, publisher tier and profile changes, and ownership transfers (system org only)', category: 'Plugin Ecosystem' },
+    { id: 'platform:read', label: 'View platform operations', description: 'Read the platform settings and the cross-tenant organization list (system org only)', category: 'Platform operations' },
+    { id: 'orgs:read', label: 'View all organizations', description: 'List and open every organization on the deployment \u2014 the roster the operator surfaces work from (system org only)', category: 'Platform operations' },
+    { id: 'billing:operate', label: 'Operate discounts and promotions', description: 'Create, apply and revoke discount tokens and promotion campaigns across tenants (system org only)', category: 'Platform operations' },
+    { id: 'observability_console:open', label: 'Open the observability consoles', description: 'Open Grafana and Kiali — dashboards, traffic and mesh health across every tenant (system org only)', category: 'Platform operations' },
+    { id: 'database_console:open', label: 'Open the database consoles', description: 'Open pgAdmin and mongo-express — a direct read/write shell over every tenant\u2019s rows (system org only)', category: 'Platform operations' },
+    { id: 'objectstore_console:open', label: 'Open the object-store console', description: 'Open the RustFS (S3) console — list and delete objects in every bucket, including the audit chain (system org only)', category: 'Platform operations' },
     { id: 'oncall:manage', label: 'Manage on-call paging', description: 'Read the paging posture and send a test page (system org only; the rota lives with the provider)', category: 'On-call' },
+    { id: 'support_cases:write', label: 'Work the support desk', description: 'Triage the support queue, assign and re-prioritise cases, write internal notes, and record incidents against a support contract (system org only)', category: 'Support desk' },
+    { id: 'support_content:write', label: 'Author canned replies', description: 'Write and retire the reusable support replies offered to every customer (system org only)', category: 'Support desk' },
+    { id: 'subscriptions:read', label: 'View all subscriptions', description: 'View every organization\u2019s subscription, plan mix and billing events (system org only)', category: 'Platform operations' },
+    { id: 'subscriptions:manage', label: 'Change any subscription', description: 'Change a plan, set a support floor, and cancel an organization\u2019s subscription (system org only)', category: 'Platform operations' },
+    { id: 'orgs:manage', label: 'Administer any organization', description: 'Rename, re-tier, move and delete any organization (system org only)', category: 'Platform operations' },
+    { id: 'quotas:manage', label: 'Change any quota', description: 'Raise, reset and clear another organization\u2019s quotas (system org only; viewing them rides platform:read)', category: 'Platform operations' },
+    { id: 'plugin_queue:manage', label: 'Run the plugin build queue', description: 'Read build-queue depth and purge the dead-letter queue (system org only)', category: 'Platform operations' },
     { id: 'compliance:read', label: 'View compliance', description: 'View compliance rules, policies, and scans', category: 'Compliance' },
     { id: 'compliance:write', label: 'Manage compliance', description: 'Create and edit rules, policies, and exemptions', category: 'Compliance' },
     { id: 'members:manage', label: 'Manage members', description: 'Add, remove, and change roles of org members', category: 'Members & Access' },
@@ -90,21 +143,26 @@ export const PERMISSION_CATALOG = [
     { id: 'observability:read', label: 'View alerting', description: 'View alert rules and destinations', category: 'Observability' },
     { id: 'observability:write', label: 'Manage alerting', description: 'Create and edit alert rules and destinations', category: 'Observability' },
     { id: 'logs:export', label: 'Download logs', description: "Download your organization's log entries as a file (viewing logs only needs 'View alerting')", category: 'Observability' },
+    { id: 'audit:read', label: 'View the audit log', description: "Read the organization's own tamper-evident audit trail", category: 'Observability' },
     { id: 'reports:read', label: 'View reports', description: 'View analytics and reports', category: 'Insights' },
     { id: 'reports:rollup', label: 'Roll up team reports', description: 'Include descendant teams when viewing reports', category: 'Insights' },
-    { id: 'reports:author', label: 'Author stakeholder reports', description: 'Create, schedule and draft scheduled reports for managers', category: 'Insights' },
-    { id: 'reports:share', label: 'Publish reports externally', description: 'Publish a report and mint expiring share links for people outside the platform', category: 'Insights' },
+    { id: 'reports:write', label: 'Author stakeholder reports', description: 'Create, schedule and draft scheduled reports for managers', category: 'Insights' },
+    { id: 'reports:publish', label: 'Publish reports externally', description: 'Publish a report and mint expiring share links for people outside the platform', category: 'Insights' },
     { id: 'messages:read', label: 'View messages', description: 'View messages and announcements', category: 'Messaging' },
     { id: 'messages:write', label: 'Send messages', description: 'Send messages and announcements', category: 'Messaging' },
     { id: 'billing:read', label: 'View billing', description: 'View subscriptions and usage', category: 'Billing & Quotas' },
     { id: 'billing:manage', label: 'Manage billing', description: 'Manage subscriptions, add-ons, and the billing portal', category: 'Billing & Quotas' },
     { id: 'quotas:read', label: 'View quotas', description: 'View organization quotas and usage', category: 'Billing & Quotas' },
     { id: 'registry:read', label: 'View registry', description: 'View the container image registry', category: 'Registry' },
-    { id: 'registry:write', label: 'Manage registry', description: 'Delete and copy container images', category: 'Registry' },
-    { id: 'org:settings', label: 'Organization settings', description: 'Manage general org settings and AI config', category: 'Organization' },
-    { id: 'org:idp', label: 'Manage SSO/IdP', description: 'Configure single sign-on and identity providers', category: 'Organization' },
-    { id: 'org:kms', label: 'Manage encryption keys', description: 'Configure customer-managed KMS encryption keys', category: 'Organization' },
-    { id: 'org:impersonation', label: 'Manage impersonation policy', description: 'Control whether platform operators may view the organization as one of its members', category: 'Organization' },
+    { id: 'registry:write', label: 'Copy container images', description: 'Copy and promote a container image into another repository', category: 'Registry' },
+    { id: 'registry:purge', label: 'Delete container images', description: 'Delete images and repositories, and run registry garbage collection', category: 'Registry' },
+    { id: 'impersonation:open', label: 'Open an impersonation session', description: "View a customer's account as one of its users, with that organization's consent", category: 'Impersonation' },
+    { id: 'impersonation:approve', label: 'Answer impersonation requests', description: 'Approve or deny a request to view a member of this organization as that member', category: 'Impersonation' },
+    { id: 'team_access:open', label: "View a team member's account", description: "View a member of one of this organization's teams as that member (read-only)", category: 'Impersonation' },
+    { id: 'org_settings:write', label: 'Organization settings', description: 'Manage general org settings and AI config', category: 'Organization' },
+    { id: 'org_idp:write', label: 'Manage SSO/IdP', description: 'Configure single sign-on and identity providers', category: 'Organization' },
+    { id: 'org_kms:write', label: 'Manage encryption keys', description: 'Configure customer-managed KMS encryption keys', category: 'Organization' },
+    { id: 'org_impersonation:write', label: 'Manage impersonation policy', description: 'Control whether platform operators may view the organization as one of its members', category: 'Organization' },
 ];
 const PERMISSION_LABELS = new Map(PERMISSION_CATALOG.map((p) => [p.id, p.label]));
 /** Human label for a permission id (falls back to the raw id for an unknown one). */
@@ -139,8 +197,13 @@ export function isValidPermission(value) {
  * them (see platform `sanitizePermissions`).
  */
 export const SUPERADMIN_ONLY_PERMISSIONS = [
-    'registry:read',
-    'registry:write',
+    // `registry:read` and `registry:write` were both here. What stays is the
+    // destructive rung alone: deleting a manifest or a whole repository, and the
+    // GC prune, each of which can remove an image a tenant's pipeline still
+    // resolves — including the digest-pinned plugin images the supply chain
+    // verifies against. That is the one registry action with no undo, so it keeps
+    // the narrowest possible audience: the flag, and never a Role.
+    'registry:purge',
 ];
 /**
  * Permissions that govern the PLUGIN ECOSYSTEM and may be held only inside the
@@ -162,11 +225,63 @@ export const SUPERADMIN_ONLY_PERMISSIONS = [
 export const SYSTEM_ORG_ONLY_PERMISSIONS = [
     'plugins:moderate',
     'publishers:verify',
+    // The cross-tenant operator surfaces, system-org-only for the same reason the
+    // consoles are: they read and move things belonging to organisations the
+    // holder is not a member of, so they must never be grantable inside a tenant.
+    'platform:read',
+    'orgs:read',
+    // Reading the image registry: repository names, tags, manifests, blobs and the
+    // storage rollup. Promoted out of SUPERADMIN_ONLY because the registry browser
+    // was invisible to every Role, so a Platform Operator debugging a failed
+    // plugin build could see the build queue and its dead letters but not the
+    // images the build produced — and the only way to look was the superadmin
+    // flag. It stays system-org-only (no tenant Role may carry it) and is paired
+    // with a per-repo org-ownership filter that runs AFTER it, so widening the
+    // permission does not widen which repositories a holder can reach: a
+    // system-org member who is not a superadmin sees `system/*`, `library/*` and
+    // `public/*` — this deployment's own base and plugin images — and no tenant's
+    // `org-*` repositories at all (`canReadRepo` in the image-registry service).
+    'registry:read',
+    // Copying/promoting an image. System-org-only rather than superadmin-only
+    // because it is ADDITIVE: it writes a new tag and makes nothing stop
+    // resolving, and `canWriteRepo` confines a non-superadmin system-org caller
+    // to `system/*` regardless. Deliberately carried by NO built-in bundle today
+    // — promoting an image is a job, not a side effect of running the deployment,
+    // so it waits for a Role of its own rather than riding along with
+    // `platform:read`.
+    'registry:write',
+    'billing:operate',
+    'observability_console:open',
+    'database_console:open',
+    'objectstore_console:open',
+    // Opening a cross-tenant impersonation session. System-org-only for the
+    // obvious reason — it views an organisation the holder is not a member of —
+    // and it is the ONE permission in this list that also has to clear a gate the
+    // permission system does not own: the target organisation's consent (its
+    // `org_impersonation:write` policy), plus aal2 and a strong step-up. The
+    // permission says who may ASK; the tenant still answers.
+    //
+    // It does NOT cover emergency access. `POST /:userId/breakglass` bypasses
+    // tenant consent and so stays on the superadmin flag alone, approved by a
+    // SECOND superadmin (four-eyes). A permission that could be delegated must not
+    // be able to walk past consent.
+    'impersonation:open',
     // Paging is the vendor's own operational concern and grants NO tenant access
     // — `isSystemOrgId` is a content-owner check, not a privilege gate — so a
     // tenant role must never be able to carry it, and a tenant must never be able
     // to make this deployment send a page.
     'oncall:manage',
+    // The vendor's own operational tasks. Each one replaced a `requireSystemAdmin`
+    // gate, so the point of listing them here is the same as the point of adding
+    // them at all: a Role composed in the system org can carry exactly one job,
+    // and no Role in any tenant can carry it at all.
+    'support_cases:write',
+    'support_content:write',
+    'subscriptions:read',
+    'subscriptions:manage',
+    'orgs:manage',
+    'quotas:manage',
+    'plugin_queue:manage',
 ];
 /** Whether `permission` may be held only inside the system org. */
 export function isSystemOrgOnlyPermission(permission) {
@@ -252,7 +367,7 @@ export function intersectPermissions(effective, subset) {
  *   separately, not via a permission).
  */
 const MEMBER_PERMISSIONS = [
-    'pipelines:read', 'pipelines:write',
+    'pipelines:read', 'pipelines:write', 'pipeline_registry:write',
     'templates:read', 'templates:write',
     'plugins:read', 'plugins:write',
     'plugins:install',
@@ -284,6 +399,339 @@ export const ROLE_PERMISSIONS = {
  * tenant-facing: no `registry:*`, no `members:manage`. The Role grants the
  * coarse `member` label and never sets `isSuperAdmin`.
  */
+/**
+ * The PLATFORM OPERATOR bundle — the third rung of the system org's ladder.
+ *
+ * Before it the ladder had two rungs and a gap: Ecosystem Manager (plugin
+ * moderation) and Super Admin (implicit-all, which also carries impersonation,
+ * pgAdmin and mongo-express). Anything in between — read the platform settings,
+ * run a promotion campaign, check whether the pager is configured — had to be
+ * done by making somebody a full superadmin.
+ *
+ * It is a BUNDLE rather than a grantable list because `SYSTEM_ORG_ONLY_PERMISSIONS`
+ * can never be carried by a custom Role in any org: without a seeded bundle
+ * these permissions had no grant path at all and were superadmin-only in
+ * practice, which is exactly the thing they were added to avoid.
+ *
+ * Deliberately NOT carrying `plugins:moderate` / `publishers:verify`: ecosystem
+ * moderation is a different job with its own Role, and a reviewer of plugins
+ * should not acquire the ability to move another tenant's money by being handed
+ * the operator Role.
+ */
+export const PLATFORM_OPERATOR_PERMISSIONS = [
+    // BOTH halves of the old `platform:read`: this is the one job that genuinely
+    // wants the deploy's own configuration AND the customer roster.
+    'platform:read',
+    'orgs:read',
+    'oncall:manage',
+    'observability_console:open',
+    // RUNNING the deployment: raise a quota during an incident, watch the build
+    // queue and purge its dead-letter queue.
+    'quotas:manage',
+    'plugin_queue:manage',
+    // Reads that make the operator views usable: the dashboards the posture panels
+    // live on, the cross-tenant log view, and the customer's plan when a limit is
+    // the thing being debugged.
+    'observability:read',
+    'dashboards:read',
+    'subscriptions:read',
+    // The registry browser: repository names, tags and manifests for the images
+    // this deployment's builds produce. It was withheld while `registry:read` was
+    // superadmin-only — a seeded bundle carrying a superadmin-only permission
+    // would make that list a lie, since bundles bypass `sanitizePermissions`. The
+    // permission was promoted to system-org-only deliberately rather than smuggled
+    // in here, which is the order those two changes have to happen in.
+    'registry:read',
+];
+/**
+ * ACCOUNT MANAGER — the commercial relationship with a customer, as opposed to
+ * running the deployment.
+ *
+ * Split from {@link PLATFORM_OPERATOR_PERMISSIONS} rather than piled onto it,
+ * because the two jobs diverge at exactly the permissions added alongside this
+ * bundle. `billing:operate` MOVED here from the operator bundle for that reason:
+ * minting a discount token is a commercial act, not an operational one, and the
+ * person who restarts a stuck build queue has no reason to hold it.
+ *
+ * The destructive half of the catalogue lives here — `orgs:manage` can DELETE
+ * an organisation and `subscriptions:manage` can cancel its subscription — so
+ * this is deliberately the smaller, more rarely-assigned of the two.
+ */
+export const ACCOUNT_MANAGER_PERMISSIONS = [
+    'subscriptions:read',
+    'subscriptions:manage',
+    'orgs:manage',
+    'billing:operate',
+    // A quota bump is as often a commercial concession as an operational one, so
+    // both bundles carry it.
+    'quotas:manage',
+    // The all-organizations list, which is the surface this job works from — and
+    // only that. It used to take `platform:read`, which also handed over the
+    // deploy's RLS mode, KMS posture and rendered alert rules: internals a
+    // commercial role has no use for.
+    'orgs:read',
+];
+/**
+ * CONSOLE ADMINISTRATOR — the operator consoles, as a Role.
+ *
+ * WHY THIS EXISTS even though each console permission is grantable by hand: with
+ * no seeded Role, the only path to pgAdmin was a superadmin composing a custom
+ * Role for it, and the observed outcome of asking people to do that is that they
+ * reach for the superadmin FLAG instead — the exact failure these permissions
+ * were added to remove. A named Role also makes "who can open a data shell?" one
+ * query instead of an audit of every custom Role.
+ *
+ * It carries all three consoles, which is the whole job for the person who holds
+ * it. ONE CONSEQUENCE WORTH KNOWING: `database_console:open` and
+ * `objectstore_console:open` are the two halves of the audit tamper-evidence
+ * design — a Mongo shell can truncate a hash chain's tail, and the object store
+ * holds the signed heads that would expose the truncation — so a holder of this
+ * Role can do both. The permissions stay SEPARATE for exactly that reason: a
+ * deployment that wants them held by different people composes a narrower Role
+ * by hand (a superadmin may include any system-org-only permission in a Role
+ * authored in the system org) and assigns this one to nobody.
+ */
+/**
+ * PLATFORM OBSERVER — look, don't touch. The ladder's missing bottom rung.
+ *
+ * Every other system-org bundle grants a write. The one that does not —
+ * Console Administrator — grants a read that IS a database shell. So somebody
+ * who should see the deployment and change nothing (a new operator shadowing, an
+ * auditor, an on-call engineer during a handover) had two options: Super Admin,
+ * or nothing. The usual outcome of a choice like that is the flag.
+ *
+ * Strictly read-only by construction: every permission here ends `:read`, which
+ * `isMutationPermission` classifies as a read, so the dashboard disables every
+ * write affordance for a holder rather than offering controls that 403.
+ *
+ * NOT `audit:read`. It would be the obvious addition and it is the wrong one:
+ * `listAuditEvents` pins every non-superadmin to their OWN org, so a system-org
+ * observer holding it would see the system org's audit trail and nothing else —
+ * an affordance that looks like fleet-wide audit access and is not. Reading
+ * another tenant's trail is deliberately the flag's alone.
+ */
+export const PLATFORM_OBSERVER_PERMISSIONS = [
+    'platform:read',
+    'orgs:read',
+    'subscriptions:read',
+    'observability:read',
+    'dashboards:read',
+    // A read, and this Role is reads — the registry browser with neither of the
+    // two write rungs (`registry:write` copies, `registry:purge` deletes).
+    'registry:read',
+];
+export const CONSOLE_ADMIN_PERMISSIONS = [
+    'observability_console:open',
+    'database_console:open',
+    'objectstore_console:open',
+    // The all-organizations list, so a holder can find the org they were asked
+    // about without a second Role — and nothing more. This was `platform:read`,
+    // which meant opening a database console also granted the deploy's own
+    // configuration, for no reason beyond the two sharing a gate.
+    'orgs:read',
+];
+/**
+ * REGISTRY OPERATOR — moves container images around, and nothing else.
+ *
+ * THE GAP IT FILLS. Promoting an image — copying a built tag from one repository
+ * to the one a release resolves — is a job somebody does, and until now the only
+ * identity that could do it was a superadmin. `registry:write` has no other
+ * carrier, and a system-org-only permission with no seeded carrier is
+ * superadmin-only in practice (the `platform:read` failure, pinned by the
+ * "at least one seeded carrier" assertion in api-core's `test/permissions.test.ts`).
+ * So splitting `registry:purge` out of `registry:write` is only half the change:
+ * the additive half needs a Role or the split buys nothing.
+ *
+ * WHY IT IS NOT PART OF PLATFORM OPERATOR. That Role runs the deployment and
+ * already reads the registry. Promoting an image is a release decision, not an
+ * operational side effect, and rolling it into the Role everyone on call holds
+ * would mean the pager rotation can retag a release at 3am. The two Roles
+ * compose instead — a member may hold any number, and permissions are the union.
+ *
+ * WHY IT IS ONLY TWO PERMISSIONS. Deliberately nothing else: no `platform:read`,
+ * no console, no `orgs:read`. `canReadRepo`/`canWriteRepo` confine a
+ * non-superadmin system-org holder to `system/*`, `library/*` and `public/*` —
+ * this deployment's own base and plugin images — so the Role cannot reach a
+ * tenant's repositories at all, and a holder who also needs the operator views
+ * gets the operator Role too. It does NOT carry `registry:purge`, which is in
+ * {@link SUPERADMIN_ONLY_PERMISSIONS} and in no bundle by design: an image
+ * promoter has no business deleting the image a tenant's pipeline resolves.
+ */
+export const REGISTRY_OPERATOR_PERMISSIONS = [
+    'registry:read',
+    'registry:write',
+];
+/**
+ * SUPPORT AGENT — the support desk, and nothing else.
+ *
+ * Deliberately carries no `platform:read`, no console and no billing write: an
+ * agent answers cases and writes the canned replies. `subscriptions:read` is
+ * here because the first question on any case is what the customer is entitled
+ * to, and without it an agent would have to ask someone else to look.
+ */
+export const SUPPORT_AGENT_PERMISSIONS = [
+    'support_cases:write',
+    'support_content:write',
+    'subscriptions:read',
+    // NEW, and the gap the split exposed: an agent triaging a case needs to find
+    // the customer's organization. The only permission that listed orgs was
+    // `platform:read`, which would also have handed a support agent the deploy's
+    // internals — so they had neither, and had to ask someone else to look.
+    'orgs:read',
+    // Reading and answering the case itself rides the ordinary messaging
+    // permissions — a support case IS a message thread.
+    'messages:read',
+    'messages:write',
+];
+/**
+ * SUPPORT LEAD — the support desk, plus the authority to look.
+ *
+ * THE GAP IT FILLS. `impersonation:open` is system-org-only, and a system-org-only
+ * permission with no seeded carrier is superadmin-only in practice — the
+ * invariant api-core's `test/permissions.test.ts` asserts, and the reason
+ * `platform:read` shipped unusable. Without this Role, splitting impersonation
+ * out of the flag would change nothing: the only way to let somebody view a
+ * customer's account would still be to make them a full Super Admin, handing
+ * over `/admin/users/:id/grants`, the single-person MFA reset, the database
+ * console and `registry:purge` at the same time.
+ *
+ * WHY IT IS THE SUPPORT DESK AND NOT THE OPERATOR. The question impersonation
+ * answers is "what is this customer actually seeing?", which is a support
+ * question. Platform Operator runs the deployment and is held by whoever is on
+ * call; adding this to it would hand every rota member the ability to become any
+ * customer's user at 3am. Support Agent's bundle plus the one permission is the
+ * narrower, more honest shape — and a lead who also runs the deployment holds
+ * both Roles.
+ *
+ * WHAT IT STILL CANNOT DO. Emergency access: `breakglass` bypasses tenant
+ * consent and stays on the flag, approved by a second Super Admin. And the
+ * tenant can refuse — `impersonation:open` is permission to ASK.
+ */
+export const SUPPORT_LEAD_PERMISSIONS = [
+    ...SUPPORT_AGENT_PERMISSIONS,
+    'impersonation:open',
+];
+export const ROLE_TEMPLATES = [
+    {
+        // Was a SEEDED Role in every org until it became a template. It is the only
+        // built-in that was a job description rather than a structural requirement:
+        // Super Admin is where `isSuperAdmin` is derived from, Admin and Member are
+        // the floor an org is unusable without, and the system-org Roles carry
+        // permissions no custom Role may hold. Team Lead was none of those — it is
+        // `member` plus two report permissions, and an org that does not delegate
+        // report authoring had an undeletable row for it anyway.
+        //
+        // CONSEQUENCE, stated rather than discovered: a new org no longer has a Role
+        // that grants `reports:write` to a non-admin. An admin holds both permissions
+        // (they are in the admin bundle) and instantiates this template to delegate
+        // them — the same shape as the four below. Orgs that already have the seeded
+        // Role keep it, and the backfill keeps its bundle current.
+        id: 'team-lead',
+        name: 'Team Lead',
+        description: 'Authors and shares stakeholder reports for a team, without org-admin access.',
+        permissions: [...MEMBER_PERMISSIONS, 'reports:write', 'reports:publish'],
+    },
+    {
+        /**
+         * MEMBER ALREADY IS THE DEVELOPER ROLE — this template exists for what it
+         * does NOT cover.
+         *
+         * Everything in a developer's loop is `pipelines:read` + `pipelines:write`,
+         * both in the member bundle: create, edit, validate, run, stop, the bulk
+         * ops, AI generation (`/pipelines/generate`, incl. from-url and streaming),
+         * the pipeline registry, plus `templates:read` to instantiate and
+         * `plugins:install` to add a plugin. A template restating that would buy
+         * nothing.
+         *
+         * What a developer hits the cliff on is the SELF-SERVICE operate pair: they
+         * can read their service's dashboards and metrics and cannot change either,
+         * because both writes sit in the admin bundle. So the person who owns a
+         * pipeline files a ticket to get an alert on it.
+         *
+         * DELIBERATELY NOT HERE. `logs:export` — viewing logs rides
+         * `observability:read`, but downloading them is bulk egress an org may
+         * withhold from members (docs/permissions.md), and a template aimed at every
+         * engineer would reverse that. `pipelines:publish` — sharing beyond the
+         * author is a release decision, which is Release Manager's below; somebody
+         * who does both holds both Roles.
+         */
+        id: 'developer',
+        name: 'Developer',
+        description: 'Builds and runs pipelines, and owns the dashboards and alerts for what they build.',
+        permissions: [...MEMBER_PERMISSIONS, 'dashboards:write', 'observability:write'],
+    },
+    {
+        id: 'release-manager',
+        name: 'Release Manager',
+        description: 'Decides what becomes shared beyond its author, and approves plugin installs.',
+        permissions: [
+            'pipelines:read', 'pipelines:publish',
+            'templates:read', 'templates:publish',
+            'plugins:read', 'plugins:publish',
+            'plugin_installs:manage',
+        ],
+    },
+    {
+        id: 'security-officer',
+        name: 'Security Officer',
+        description: 'Identity, encryption keys and the evidence trail — the surface an auditor asks about.',
+        permissions: [
+            'audit:read', 'logs:export',
+            'compliance:read', 'compliance:write',
+            'org_idp:write', 'org_kms:write', 'org_impersonation:write',
+            // Owning the impersonation POLICY (`org_impersonation:write`) without
+            // being able to answer a REQUEST was the asymmetry the consent flow left
+            // behind: the lesser act had a permission of its own and the greater one
+            // had none. Whoever decides whether consent is required should be able to
+            // give or withhold it.
+            'impersonation:approve',
+        ],
+    },
+    {
+        id: 'people-manager',
+        name: 'People Manager',
+        description: 'The roster and its machine credentials, across the account\u2019s teams — without the org\u2019s settings or its money.',
+        permissions: [
+            'members:manage', 'invitations:manage', 'service_accounts:manage',
+            // The same job, one level down: entering a descendant team to work on its
+            // roster, and viewing one of its members as that member. Without it a
+            // people manager in a parent org can administer the account's teams on
+            // paper and not reach them.
+            'team_access:open',
+        ],
+    },
+    {
+        id: 'billing-manager',
+        name: 'Billing Manager',
+        description: 'The subscription, seats and invoices for this organization.',
+        permissions: [
+            'billing:read', 'billing:manage', 'quotas:read',
+        ],
+    },
+    {
+        /**
+         * The job the impersonation consent flow created INSIDE the tenant: the
+         * named person who answers "may a support engineer view this account?" and
+         * can afterwards read what happened.
+         *
+         * It exists as a template because `impersonation:approve` is in the admin
+         * and owner bundles — so by default every admin may consent — and the whole
+         * point of splitting it out was to let an org say "this decision is one
+         * person's". Doing that means authoring a Role that holds it and taking it
+         * off the others, and hand-composing was the only route.
+         *
+         * Two permissions and no more: approving is not administering. `audit:read`
+         * is here because consenting without being able to check what the session
+         * then did is consent in name only.
+         */
+        id: 'access-approver',
+        name: 'Access Approver',
+        description: 'Answers requests to view this organization\u2019s accounts, and reads the trail of what happened.',
+        permissions: [
+            'impersonation:approve', 'audit:read',
+        ],
+    },
+];
 export const ECOSYSTEM_MANAGER_PERMISSIONS = [
     'plugins:read',
     'plugins:moderate',
@@ -295,9 +743,9 @@ export const ECOSYSTEM_MANAGER_PERMISSIONS = [
  * Seed bundle for the built-in "Team Lead" Role — the person who reports UPWARD.
  *
  * Exists because the target user for stakeholder reports is a lead, not an admin,
- * and granting `reports:author` only through the admin bundle would have forced
+ * and granting `reports:write` only through the admin bundle would have forced
  * every reporting lead to be an org admin (members:manage, roles:manage,
- * org:settings, billing) to send their manager a weekly summary.
+ * org_settings:write, billing) to send their manager a weekly summary.
  *
  * Deliberately NOT included: `reports:rollup`. Rolling a report up over descendant
  * teams is downward visibility across the org tree, which is a granted capability
@@ -307,8 +755,43 @@ export const ECOSYSTEM_MANAGER_PERMISSIONS = [
  */
 export const TEAM_LEAD_PERMISSIONS = [
     ...MEMBER_PERMISSIONS,
-    'reports:author',
-    'reports:share',
+    'reports:write',
+    'reports:publish',
+];
+/**
+ * Seed bundle for the built-in "Pipeline Automation" Role — what the org's
+ * unscoped stored credential (the `platform-automation` service account that
+ * `pipeline-manager infra store-token` provisions) needs, and nothing more.
+ *
+ * Derived by tracing every call made with that key, not by guessing:
+ *  - `pipelines:read` — the CodeBuild synth (and `pipeline deploy --store-tokens`)
+ *    fetching the pipeline it builds (`GET /pipelines/:id`);
+ *  - `plugins:read`   — plugin resolution at synth/deploy and in the plugin-lookup
+ *    Lambda (`POST /plugins/lookup`), and the run-time vulnerability check step
+ *    (`POST /plugins/runtime-check`).
+ *
+ * What it deliberately does NOT carry, and where that work went:
+ *  - registry writes (`pipeline_registry:write`) — the synth registers its step
+ *    manifest with the separate `pipeline-register` key (Pipeline Registration);
+ *  - image pushes and pulls — CodeBuild authenticates to the image registry with
+ *    the `registry-push` scoped key, never this one;
+ *  - reporting writes — the events Lambda and step report uploads use the
+ *    `reporting:ingest` scoped key.
+ *
+ * It used to be the org ADMIN Role, so a leaked synth credential could rewrite
+ * every pipeline, Role and member of the org.
+ */
+export const PIPELINE_AUTOMATION_PERMISSIONS = [
+    'pipelines:read',
+    'plugins:read',
+];
+/**
+ * Seed bundle for the built-in "Pipeline Registration" Role, held by the
+ * `pipeline-register` service account: `POST`/`DELETE /pipelines/registry` for
+ * its own org and nothing else — not even a read.
+ */
+export const PIPELINE_REGISTRATION_PERMISSIONS = [
+    'pipeline_registry:write',
 ];
 // =============================================================================
 // Resolution
@@ -365,4 +848,96 @@ export function hasPermission(granted, permission, isSuperAdmin) {
         return true;
     return !!granted && granted.includes(permission);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../src/types/permissions.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { OrgRole } from './common.js';\n\n// =============================================================================\n// Permission identifiers\n// =============================================================================\n\n/**\n * Canonical fine-grained permission identifiers, in `resource:action` form.\n *\n * These are the ORG-SCOPED capabilities a Role can grant (RBAC). Coarse by\n * design — `:write` covers create/update/delete for a resource — so the catalog\n * and permission-picker UI stay small; split a `:write` into `:create`/`:delete`\n * later if a resource needs it.\n *\n * NOT modeled here (intentionally): platform-operator actions (org delete, tier/\n * quota override, user admin, impersonation, platform settings) stay behind the\n * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`\n * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.\n */\nexport type Permission =\n  // Pipelines\n  | 'pipelines:read'\n  | 'pipelines:write'\n  | 'pipelines:publish'\n  // Golden-path pipeline templates. Split out of `pipelines:*` so a platform\n  // team can curate the starter catalog WITHOUT write access to every pipeline\n  // (and vice versa). `:publish` maps to the\n  // template ladder's `public` rung; `org` and `private` need only `:write`.\n  | 'templates:read'\n  | 'templates:write'\n  | 'templates:publish'\n  // Plugins\n  | 'plugins:read'\n  | 'plugins:write'\n  | 'plugins:publish'\n  // Plugin ecosystem (docs/plugin-publishing.md). Org-assignable:\n  //  - `plugins:install`        — install/upgrade/uninstall listings (or REQUEST\n  //                               an install when the org's policy needs approval).\n  //  - `plugin_installs:manage` — the org's consumption policy + deciding install\n  //                               requests WITHIN the org (org-local only).\n  //  - `publishers:manage`      — the org's publisher profile + submitting\n  //                               ecosystem requests (every decision is system-org).\n  // System-org-only (see SYSTEM_ORG_ONLY_PERMISSIONS):\n  //  - `plugins:moderate`       — decide publish requests, moderate, yank, advisories.\n  //  - `publishers:verify`      — publisher tiers, profile changes, transfers.\n  | 'plugins:install'\n  | 'plugin_installs:manage'\n  | 'publishers:manage'\n  | 'plugins:moderate'\n  | 'publishers:verify'\n  // On-call (system-org only). Reads the paging POSTURE and sends a test page.\n  // Not a schedule editor — the provider owns the rota — and deliberately not a\n  // settings surface either, because every knob is operator-side env. What it\n  // grants is the one thing a product surface can give that a shell cannot:\n  // \"will we actually be paged\", answerable without cluster access.\n  | 'oncall:manage'\n  // Compliance\n  | 'compliance:read'\n  | 'compliance:write'\n  // Members & access\n  | 'members:manage'\n  | 'roles:manage'\n  | 'invitations:manage'\n  // Org-scoped service accounts (non-human principals) and their access keys.\n  // Split out of `members:manage` because a service account is a CREDENTIAL\n  // holder, not a person: granting someone the ability to mint long-lived\n  // machine keys is a different decision from letting them manage the roster.\n  | 'service_accounts:manage'\n  // Observability\n  | 'dashboards:read'\n  | 'dashboards:write'\n  | 'observability:read'\n  | 'observability:write'\n  // `logs:export` is split OUT of `observability:read` deliberately. Reading\n  // logs in the UI is paged and ephemeral; EXPORTING them is bulk egress that\n  // leaves the building and outlives a revoked session, so an org admin must be\n  // able to grant log viewing without granting downloads.\n  | 'logs:export'\n  // Insights\n  | 'reports:read'\n  | 'reports:rollup'\n  // Stakeholder reports. `reports:read` stays the FREE on-demand dashboard read;\n  // these two are the add-on's write surface — `author` saves/schedules/drafts a\n  // report, `share` publishes it beyond the platform (PDF, email, share links).\n  // Split because publishing externally is a different risk from composing:\n  // a lead can be allowed to build reports without being allowed to email them out.\n  | 'reports:author'\n  | 'reports:share'\n  // Messaging\n  | 'messages:read'\n  | 'messages:write'\n  // Billing & quotas\n  | 'billing:read'\n  | 'billing:manage'\n  | 'quotas:read'\n  // Registry\n  | 'registry:read'\n  | 'registry:write'\n  // Organization settings.\n  //  - `org:settings` — general org settings + AI config.\n  //  - `org:idp`      — SSO / IdP configuration (sensitive: controls login).\n  //  - `org:kms`      — customer-managed KMS key configuration (sensitive:\n  //                     controls encryption of org data).\n  //  - `org:impersonation` — the impersonation policy (sensitive: controls who\n  //                     may VIEW the org's data as one of its members).\n  // `org:idp`/`org:kms`/`org:impersonation` were split OUT of `org:settings` so a\n  // custom role can grant general settings WITHOUT the sensitive surfaces — a\n  // \"settings manager\" role for org name or AI provider must not also be able to\n  // switch the org to `open`. All remain org-assignable and are seeded into the\n  // admin/owner bundles (via ORG_ASSIGNABLE_PERMISSIONS) so existing admins keep\n  // full access.\n  | 'org:settings'\n  | 'org:idp'\n  | 'org:kms'\n  | 'org:impersonation';\n\n/** All valid permissions (order determines display order in the picker). */\nexport const ALL_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write', 'pipelines:publish',\n  'templates:read', 'templates:write', 'templates:publish',\n  'plugins:read', 'plugins:write', 'plugins:publish',\n  'plugins:install', 'plugin_installs:manage', 'publishers:manage',\n  'plugins:moderate', 'publishers:verify',\n  'oncall:manage',\n  'compliance:read', 'compliance:write',\n  'members:manage', 'roles:manage', 'invitations:manage', 'service_accounts:manage',\n  'dashboards:read', 'dashboards:write',\n  'observability:read', 'observability:write',\n  'logs:export',\n  'reports:read', 'reports:rollup', 'reports:author', 'reports:share',\n  'messages:read', 'messages:write',\n  'billing:read', 'billing:manage',\n  'quotas:read',\n  'registry:read', 'registry:write',\n  'org:settings', 'org:idp', 'org:kms', 'org:impersonation',\n];\n\n/**\n * The CLOSED set of functions that take a {@link Permission} and decide access.\n *\n * \"Is permission X enforced anywhere?\" has to be answerable statically, which\n * a grep can't do: four different call shapes consume a permission id\n * (`requirePermission('x')` at a route, `userHasPermission(req, 'x')` inside a\n * controller, and `resolveVisibility(req, v, 'x')` /\n * `requireVisibilityWriteAccess(…, 'x')` in the visibility helpers), so a naive\n * grep for a route-level gate reports `templates:publish` as UNENFORCED when it\n * is in fact enforced on every template publish.\n *\n * They all bottom out in `userHasPermission`, so the RUNTIME primitive was\n * already one. This constant makes the STATIC surface one as well: it names\n * every entry point, so `permission-coverage.test.ts` can enumerate the catalog\n * and report each permission's enforcement sites without guessing. A new gate\n * that takes a `Permission` must be listed here, or the coverage report starts\n * lying about the permissions only that gate enforces.\n */\nexport const PERMISSION_GATES: readonly string[] = [\n  // Middleware gates (route level) — all any-of except requireAllPermissions.\n  'requirePermission',\n  'requireAllPermissions',\n  'requirePermissionOrService',\n  // The plugin-ecosystem governance chain (system org + permission + aal2).\n  'requireEcosystemPermission',\n  // The single runtime primitive every gate above delegates to; also called\n  // directly where a controller branches on a capability rather than rejecting.\n  'userHasPermission',\n  'hasPermission',\n  // Visibility helpers — they take the entity's PUBLISH permission.\n  'requireVisibilityWriteAccess',\n  'checkVisibilityWriteAccess',\n  'resolveVisibility',\n];\n\n/**\n * Display metadata for one permission: the label + description the\n * permission-picker UI shows, and the category it groups under.\n */\nexport interface PermissionMeta {\n  id: Permission;\n  label: string;\n  description: string;\n  category: string;\n}\n\n/**\n * The permission catalog with display metadata, in picker order.\n *\n * This module is the SINGLE catalog for backend and browser alike: it has no\n * runtime dependencies (the only import is a type), so the frontend imports it\n * through the `@pipeline-builder/api-core/permissions` subpath instead of keeping\n * a hand-maintained mirror. Every id in {@link ALL_PERMISSIONS} must appear here\n * exactly once (asserted by `permissions.test.ts`).\n */\nexport const PERMISSION_CATALOG: readonly PermissionMeta[] = [\n  { id: 'pipelines:read', label: 'View pipelines', description: 'View pipelines and their executions', category: 'Pipelines' },\n  { id: 'pipelines:write', label: 'Manage pipelines', description: 'Create, edit, and delete pipelines', category: 'Pipelines' },\n  { id: 'pipelines:publish', label: 'Publish pipelines', description: 'Make pipelines public (org-wide/catalog visibility)', category: 'Pipelines' },\n  { id: 'templates:read', label: 'View templates', description: 'View the golden-path template catalog', category: 'Templates' },\n  { id: 'templates:write', label: 'Manage templates', description: 'Author, edit, and delete pipeline templates', category: 'Templates' },\n  { id: 'templates:publish', label: 'Publish templates', description: 'Share a template beyond your org (public visibility)', category: 'Templates' },\n  { id: 'plugins:read', label: 'View plugins', description: 'View plugins and builds', category: 'Plugins' },\n  { id: 'plugins:write', label: 'Manage plugins', description: 'Create, upload, edit, and delete plugins', category: 'Plugins' },\n  { id: 'plugins:publish', label: 'Publish plugins', description: 'Make plugins public (org-wide/catalog visibility)', category: 'Plugins' },\n  { id: 'plugins:install', label: 'Install plugins', description: 'Install, upgrade, and uninstall ecosystem plugins (or request an install when your org requires approval)', category: 'Plugin Ecosystem' },\n  { id: 'plugin_installs:manage', label: 'Manage plugin installs', description: \"Set your org's plugin consumption policy and approve or deny install requests within the org\", category: 'Plugin Ecosystem' },\n  { id: 'publishers:manage', label: 'Manage publisher profile', description: \"Manage your org's publisher profile and submit publish, verification, transfer, and advisory requests\", category: 'Plugin Ecosystem' },\n  { id: 'plugins:moderate', label: 'Moderate the plugin ecosystem', description: 'Decide publish requests, moderate submissions and reviews, yank versions, and publish advisories (system org only)', category: 'Plugin Ecosystem' },\n  { id: 'publishers:verify', label: 'Verify publishers', description: 'Approve Verified applications, publisher tier and profile changes, and ownership transfers (system org only)', category: 'Plugin Ecosystem' },\n  { id: 'oncall:manage', label: 'Manage on-call paging', description: 'Read the paging posture and send a test page (system org only; the rota lives with the provider)', category: 'On-call' },\n  { id: 'compliance:read', label: 'View compliance', description: 'View compliance rules, policies, and scans', category: 'Compliance' },\n  { id: 'compliance:write', label: 'Manage compliance', description: 'Create and edit rules, policies, and exemptions', category: 'Compliance' },\n  { id: 'members:manage', label: 'Manage members', description: 'Add, remove, and change roles of org members', category: 'Members & Access' },\n  { id: 'roles:manage', label: 'Manage roles', description: 'Create, edit, and delete roles', category: 'Members & Access' },\n  { id: 'invitations:manage', label: 'Manage invitations', description: 'Send, resend, and revoke invitations', category: 'Members & Access' },\n  { id: 'service_accounts:manage', label: 'Manage service accounts', description: 'Create org service accounts, assign their roles, and issue or revoke their keys', category: 'Members & Access' },\n  { id: 'dashboards:read', label: 'View dashboards', description: 'View custom dashboards', category: 'Observability' },\n  { id: 'dashboards:write', label: 'Manage dashboards', description: 'Create and edit custom dashboards', category: 'Observability' },\n  { id: 'observability:read', label: 'View alerting', description: 'View alert rules and destinations', category: 'Observability' },\n  { id: 'observability:write', label: 'Manage alerting', description: 'Create and edit alert rules and destinations', category: 'Observability' },\n  { id: 'logs:export', label: 'Download logs', description: \"Download your organization's log entries as a file (viewing logs only needs 'View alerting')\", category: 'Observability' },\n  { id: 'reports:read', label: 'View reports', description: 'View analytics and reports', category: 'Insights' },\n  { id: 'reports:rollup', label: 'Roll up team reports', description: 'Include descendant teams when viewing reports', category: 'Insights' },\n  { id: 'reports:author', label: 'Author stakeholder reports', description: 'Create, schedule and draft scheduled reports for managers', category: 'Insights' },\n  { id: 'reports:share', label: 'Publish reports externally', description: 'Publish a report and mint expiring share links for people outside the platform', category: 'Insights' },\n  { id: 'messages:read', label: 'View messages', description: 'View messages and announcements', category: 'Messaging' },\n  { id: 'messages:write', label: 'Send messages', description: 'Send messages and announcements', category: 'Messaging' },\n  { id: 'billing:read', label: 'View billing', description: 'View subscriptions and usage', category: 'Billing & Quotas' },\n  { id: 'billing:manage', label: 'Manage billing', description: 'Manage subscriptions, add-ons, and the billing portal', category: 'Billing & Quotas' },\n  { id: 'quotas:read', label: 'View quotas', description: 'View organization quotas and usage', category: 'Billing & Quotas' },\n  { id: 'registry:read', label: 'View registry', description: 'View the container image registry', category: 'Registry' },\n  { id: 'registry:write', label: 'Manage registry', description: 'Delete and copy container images', category: 'Registry' },\n  { id: 'org:settings', label: 'Organization settings', description: 'Manage general org settings and AI config', category: 'Organization' },\n  { id: 'org:idp', label: 'Manage SSO/IdP', description: 'Configure single sign-on and identity providers', category: 'Organization' },\n  { id: 'org:kms', label: 'Manage encryption keys', description: 'Configure customer-managed KMS encryption keys', category: 'Organization' },\n  { id: 'org:impersonation', label: 'Manage impersonation policy', description: 'Control whether platform operators may view the organization as one of its members', category: 'Organization' },\n];\n\nconst PERMISSION_LABELS = new Map<string, string>(PERMISSION_CATALOG.map((p) => [p.id, p.label]));\n\n/** Human label for a permission id (falls back to the raw id for an unknown one). */\nexport function permissionLabel(id: string): string {\n  return PERMISSION_LABELS.get(id) ?? id;\n}\n\n/** One picker section: a category and the permissions it contains, in catalog order. */\nexport interface PermissionCategory {\n  category: string;\n  permissions: PermissionMeta[];\n}\n\n/** Group a permission list into categories, preserving catalog order. */\nfunction groupByCategory(perms: readonly PermissionMeta[]): PermissionCategory[] {\n  const order: string[] = [];\n  const byCategory = new Map<string, PermissionMeta[]>();\n  for (const p of perms) {\n    if (!byCategory.has(p.category)) { byCategory.set(p.category, []); order.push(p.category); }\n    byCategory.get(p.category)!.push(p);\n  }\n  return order.map((category) => ({ category, permissions: byCategory.get(category)! }));\n}\n\n/** Check whether a string is a valid Permission. */\nexport function isValidPermission(value: string): value is Permission {\n  return (ALL_PERMISSIONS as readonly string[]).includes(value);\n}\n\n/**\n * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —\n * they gate platform-operator surfaces (the shared image registry), so allowing\n * an org admin to mint a Role carrying them would be a latent privilege\n * escalation. They are NOT seeded into ANY built-in Role bundle (neither\n * `member` nor `admin`), so the only holder is a superadmin (implicit-all) —\n * which is what makes the image-registry gates that require them effectively\n * superadmin-only. This list ALSO blocks custom-Role authoring from requesting\n * them (see platform `sanitizePermissions`).\n */\nexport const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[] = [\n  'registry:read',\n  'registry:write',\n];\n\n/**\n * Permissions that govern the PLUGIN ECOSYSTEM and may be held only inside the\n * system org (docs/plugin-publishing.md). Like\n * {@link SUPERADMIN_ONLY_PERMISSIONS} they are in no member/admin/owner bundle\n * and are never grantable through a custom Role in ANY org (platform\n * `sanitizePermissions` refuses them). The only holders are superadmins\n * (implicit-all) and members of the built-in \"Ecosystem Manager\" Role, which is\n * seeded in the system org alone from {@link ECOSYSTEM_MANAGER_PERMISSIONS} and\n * assignable only by a superadmin.\n *\n * `oncall:manage` is in NEITHER named role, which makes it superadmin-only in\n * practice. That is deliberate rather than an oversight: paging is the vendor's\n * own operational concern and has nothing to do with ecosystem moderation, so\n * widening the Ecosystem Manager role to carry it would hand the pager to\n * people hired to review plugins. It is not a placeholder — it gates two live\n * routes (the paging posture read and the test page), unlike `registry:*`.\n */\nexport const SYSTEM_ORG_ONLY_PERMISSIONS: readonly Permission[] = [\n  'plugins:moderate',\n  'publishers:verify',\n  // Paging is the vendor's own operational concern and grants NO tenant access\n  // — `isSystemOrgId` is a content-owner check, not a privilege gate — so a\n  // tenant role must never be able to carry it, and a tenant must never be able\n  // to make this deployment send a page.\n  'oncall:manage',\n];\n\n/** Whether `permission` may be held only inside the system org. */\nexport function isSystemOrgOnlyPermission(permission: string): boolean {\n  return (SYSTEM_ORG_ONLY_PERMISSIONS as readonly string[]).includes(permission);\n}\n\n/**\n * Permissions an org may assign via a CUSTOM Role — every permission except the\n * {@link SUPERADMIN_ONLY_PERMISSIONS} and {@link SYSTEM_ORG_ONLY_PERMISSIONS}.\n * Custom-Role create/update validates the requested permission set against this\n * (see platform roles-service).\n */\nexport const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[] =\n  ALL_PERMISSIONS.filter((p) => isOrgAssignablePermission(p));\n\n/** Whether `permission` may be granted through a user-authored custom Role. */\nexport function isOrgAssignablePermission(permission: Permission): boolean {\n  return !SUPERADMIN_ONLY_PERMISSIONS.includes(permission) && !isSystemOrgOnlyPermission(permission);\n}\n\n/**\n * Category → permissions for the custom-Role AUTHORING picker: the catalog minus\n * the non-assignable permissions, with any now-empty category dropped\n * (so \"Registry\" disappears). The grouped view of\n * {@link ORG_ASSIGNABLE_PERMISSIONS}.\n */\nexport const ORG_ASSIGNABLE_CATEGORIES: readonly PermissionCategory[] =\n  groupByCategory(PERMISSION_CATALOG.filter((p) => isOrgAssignablePermission(p.id)));\n\n// =============================================================================\n// Permission-scoped credentials (personal access keys / machine tokens)\n// =============================================================================\n\n/**\n * Every `:read` permission — the \"read-only\" preset a new personal access key\n * starts from. Derived from the catalog so a new resource's read permission\n * joins the preset without a second edit.\n */\nexport const READ_ONLY_PERMISSIONS: readonly Permission[] =\n  ALL_PERMISSIONS.filter((p) => p.endsWith(':read'));\n\n/**\n * Normalize a requested permission subset: every entry must be a catalog id\n * (anything else → `null`, the caller's 400), duplicates collapse, and the\n * result is in canonical catalog order so a stored subset compares stably.\n * An EMPTY array is valid — a key that can authenticate but do nothing — and\n * is distinct from \"no subset\" (`undefined`), which means full access.\n */\nexport function normalizePermissionSubset(requested: readonly unknown[]): Permission[] | null {\n  const wanted = new Set<string>();\n  for (const p of requested) {\n    if (typeof p !== 'string' || !isValidPermission(p)) return null;\n    wanted.add(p);\n  }\n  return ALL_PERMISSIONS.filter((p) => wanted.has(p));\n}\n\n/**\n * The permissions a permission-scoped credential actually carries: the\n * INTERSECTION of the subset it was created with and the holder's CURRENT\n * effective permissions, in catalog order. Re-evaluated at every issue, so\n * losing a Role shrinks the credential and nothing can ever grow it past the\n * subset it was created with.\n */\nexport function intersectPermissions(\n  effective: readonly string[],\n  subset: readonly string[],\n): Permission[] {\n  const allowed = new Set(subset);\n  const held = new Set(effective);\n  return ALL_PERMISSIONS.filter((p) => allowed.has(p) && held.has(p));\n}\n\n// =============================================================================\n// Built-in Role seed bundles\n// =============================================================================\n\n/**\n * Permission bundles used to SEED the built-in Roles (\"Admin\", \"Member\").\n *\n * This is the single definition of what those built-in Roles grant — it is used\n * when a Role record is created (and by the startup backfill) to populate that\n * Role's own `permissions[]`. It is NOT a runtime permission source: a user's\n * effective permissions come ONLY from the Roles assigned to them (see\n * {@link resolveUserPermissions}). The coarse `role` label (owner/admin/member)\n * survives only for `isAdmin`/ownership/display, never to grant permissions.\n *\n * - `member`  — day-to-day builder: read + write on pipelines/templates/plugins,\n *   read elsewhere. No member/role/billing management, no compliance/alert\n *   authoring, and no `:publish` on any catalog.\n * - `admin`   — full org administration: every ORG-ASSIGNABLE permission (i.e.\n *   ALL_PERMISSIONS minus the {@link SUPERADMIN_ONLY_PERMISSIONS} and the\n *   {@link SYSTEM_ORG_ONLY_PERMISSIONS}, so `registry:*` stay\n *   superadmin-implicit-only and ecosystem moderation stays with the system\n *   org's Ecosystem Managers — neither is granted to org admins).\n * - `owner`   — same as admin (ownership itself — transfer/delete — is gated\n *   separately, not via a permission).\n */\nconst MEMBER_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write',\n  'templates:read', 'templates:write',\n  'plugins:read', 'plugins:write',\n  'plugins:install',\n  'compliance:read',\n  'dashboards:read',\n  'observability:read',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read',\n  'quotas:read',\n];\n\nconst ADMIN_PERMISSIONS: readonly Permission[] = [...ORG_ASSIGNABLE_PERMISSIONS];\n\n/**\n * Seed bundle for each built-in Role, keyed by the coarse role it grants.\n * Consumed by the Role seeder + the startup backfill to populate a built-in\n * Role's `permissions[]`. NOT consulted at request time — see\n * {@link resolveUserPermissions}.\n */\nexport const ROLE_PERMISSIONS: Record<OrgRole, readonly Permission[]> = {\n  member: MEMBER_PERMISSIONS,\n  admin: ADMIN_PERMISSIONS,\n  owner: ADMIN_PERMISSIONS,\n};\n\n/**\n * Seed bundle for the built-in \"Ecosystem Manager\" Role — seeded ONLY in the\n * system org (docs/plugin-publishing.md). It carries the\n * {@link SYSTEM_ORG_ONLY_PERMISSIONS} plus the reads a moderator needs (the\n * in-app catalog, in-app notices, the moderation-SLA dashboard) and nothing\n * tenant-facing: no `registry:*`, no `members:manage`. The Role grants the\n * coarse `member` label and never sets `isSuperAdmin`.\n */\nexport const ECOSYSTEM_MANAGER_PERMISSIONS: readonly Permission[] = [\n  'plugins:read',\n  'plugins:moderate',\n  'publishers:verify',\n  'messages:read',\n  'observability:read',\n];\n\n/**\n * Seed bundle for the built-in \"Team Lead\" Role — the person who reports UPWARD.\n *\n * Exists because the target user for stakeholder reports is a lead, not an admin,\n * and granting `reports:author` only through the admin bundle would have forced\n * every reporting lead to be an org admin (members:manage, roles:manage,\n * org:settings, billing) to send their manager a weekly summary.\n *\n * Deliberately NOT included: `reports:rollup`. Rolling a report up over descendant\n * teams is downward visibility across the org tree, which is a granted capability\n * in this model, not something a team's own lead gets by default — a lead of a\n * PARENT org is granted it explicitly. The Role grants the coarse `member` label\n * and never sets `isSuperAdmin`.\n */\nexport const TEAM_LEAD_PERMISSIONS: readonly Permission[] = [\n  ...MEMBER_PERMISSIONS,\n  'reports:author',\n  'reports:share',\n];\n\n// =============================================================================\n// Resolution\n// =============================================================================\n\n/**\n * Resolve a user's effective org permissions from the Roles assigned to them.\n *\n * Single-source model: a user's abilities are EXACTLY the union of the\n * permissions carried by the Roles they hold (a Role = a named permission set;\n * built-in Roles carry their bundle explicitly, seeded from\n * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the\n * coarse `role` label grants nothing on its own.\n *\n * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.\n * 2. Otherwise, union every permission granted by the user's assigned Roles.\n * 3. Invalid/unknown permission strings are silently ignored.\n *\n * @param assignedPermissions - Flattened permissions from every Role the user holds\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @returns Effective permissions in canonical order\n */\nexport function resolveUserPermissions(\n  assignedPermissions?: readonly string[] | null,\n  isSuperAdmin?: boolean,\n): Permission[] {\n  if (isSuperAdmin) return [...ALL_PERMISSIONS];\n\n  const perms = new Set<Permission>();\n  if (assignedPermissions) {\n    for (const p of assignedPermissions) {\n      if (isValidPermission(p)) perms.add(p);\n    }\n  }\n  return ALL_PERMISSIONS.filter(p => perms.has(p));\n}\n\n/**\n * Confine a resolved permission list to what may be held in the token's ACTIVE\n * org: outside the system org every {@link SYSTEM_ORG_ONLY_PERMISSIONS} entry is\n * dropped (docs/plugin-publishing.md). Applied at token issue on\n * top of {@link resolveUserPermissions} — including a superadmin's implicit-all —\n * so a token minted in a tenant org never CLAIMS `plugins:moderate` /\n * `publishers:verify`, even if a hand-written Role document somehow carried\n * them there. (Superadmins still pass `hasPermission` via the flag; the\n * ecosystem route gate additionally requires the system org, so that bypass\n * never reaches a governance route from a tenant org either.)\n *\n * Takes a boolean rather than an org id so this module stays dependency-free\n * (the frontend imports it); callers decide with api-core `isSystemOrgId`.\n */\nexport function confinePermissionsToOrg<P extends string>(\n  permissions: readonly P[],\n  activeOrgIsSystemOrg: boolean,\n): P[] {\n  return activeOrgIsSystemOrg ? [...permissions] : permissions.filter((p) => !isSystemOrgOnlyPermission(p));\n}\n\n/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */\nexport function hasPermission(\n  granted: readonly string[] | null | undefined,\n  permission: Permission,\n  isSuperAdmin?: boolean,\n): boolean {\n  if (isSuperAdmin) return true;\n  return !!granted && granted.includes(permission);\n}\n"]}
+// =============================================================================
+// Built-in Role seed bundles, as a TABLE
+// =============================================================================
+/**
+ * The named permission bundles a built-in Role may carry, and the Role NAME each
+ * one is seeded under. One table, because the three facts about a job Role —
+ * its id, its permissions and its display name — were previously three
+ * independent lists in three places, and nothing held them together.
+ *
+ * WHAT WENT WRONG WITHOUT IT. The platform resolved a bundle through a
+ * nine-branch `if` chain with a fall-through to the coarse `grantsRole` bundle.
+ * Every job Role grants `member`, so a bundle added to the id list WITHOUT its
+ * branch did not fail — it silently seeded the plain Member bundle, and the
+ * startup backfill then re-synced it to that wrong value on every boot. The
+ * Role existed, was assignable from the staffing panel, and granted fifteen
+ * tenant permissions instead of its job. Nothing anywhere exercised the
+ * resolver per bundle.
+ *
+ * Keyed access plus `satisfies` makes a missing entry a COMPILE error, and an
+ * extra one too — in both directions, with no runtime check to forget.
+ *
+ * The NAME lives here for the same reason. The platform seeded names from its
+ * own constants while the frontend's staffing roster hard-coded its own copy,
+ * each pinned by a test against itself — so renaming a Role passed both suites
+ * and the roster silently rendered "Role not found", which is the grant path for
+ * that Role's permissions disappearing. Both sides read this now.
+ */
+export const SEED_BUNDLES = {
+    ecosystem_manager: { name: 'Ecosystem Manager', permissions: ECOSYSTEM_MANAGER_PERMISSIONS },
+    team_lead: { name: 'Team Lead', permissions: TEAM_LEAD_PERMISSIONS },
+    platform_observer: { name: 'Platform Observer', permissions: PLATFORM_OBSERVER_PERMISSIONS },
+    platform_operator: { name: 'Platform Operator', permissions: PLATFORM_OPERATOR_PERMISSIONS },
+    account_manager: { name: 'Account Manager', permissions: ACCOUNT_MANAGER_PERMISSIONS },
+    console_admin: { name: 'Console Administrator', permissions: CONSOLE_ADMIN_PERMISSIONS },
+    support_agent: { name: 'Support Agent', permissions: SUPPORT_AGENT_PERMISSIONS },
+    support_lead: { name: 'Support Lead', permissions: SUPPORT_LEAD_PERMISSIONS },
+    registry_operator: { name: 'Registry Operator', permissions: REGISTRY_OPERATOR_PERMISSIONS },
+    pipeline_automation: { name: 'Pipeline Automation', permissions: PIPELINE_AUTOMATION_PERMISSIONS },
+    pipeline_registration: { name: 'Pipeline Registration', permissions: PIPELINE_REGISTRATION_PERMISSIONS },
+};
+/** Every seed-bundle id. The platform's `Role.seedBundle` enum is this list. */
+export const SEED_BUNDLE_IDS = Object.keys(SEED_BUNDLES);
+/**
+ * The SYSTEM ORG's job Roles, in staffing order — the subset of
+ * {@link SEED_BUNDLES} seeded there, which is every bundle except `team_lead`
+ * (a tenant job, and a template rather than a seeded Role since it stopped
+ * being structural).
+ *
+ * `ecosystem_manager` IS one of them; it is listed here even though its roster
+ * lives on the Ecosystem console rather than the staffing panel, because what
+ * this list answers is "which Roles does the system org seed", not "which panel
+ * renders them".
+ */
+export const SYSTEM_ORG_JOB_BUNDLES = [
+    'ecosystem_manager',
+    'platform_observer',
+    'platform_operator',
+    'account_manager',
+    'console_admin',
+    'support_agent',
+    'support_lead',
+    'registry_operator',
+];
+/**
+ * The MACHINE Roles every org seeds — the subset of {@link SEED_BUNDLES} held by
+ * the service accounts `pipeline-manager infra store-token` provisions.
+ *
+ * Seeded rather than offered as a {@link ROLE_TEMPLATES} entry, unlike the
+ * tenant job presets, because they are structural: the CLI grants one to the
+ * account it creates and the startup backfill moves existing accounts onto it,
+ * and both have to find it in EVERY org by a stable identity. A template leaves
+ * nothing to find until somebody instantiates it.
+ */
+export const ORG_AUTOMATION_BUNDLES = [
+    'pipeline_automation',
+    'pipeline_registration',
+];
+/**
+ * The service accounts `pipeline-manager infra store-token` provisions, keyed by
+ * account name, and the built-in Role each holds — `null` for an account whose
+ * key carries a capability SCOPE (a `TokenScope`) and so needs no Role at all.
+ *
+ * One table for the CLI (which Role to grant a NEW account) and the platform's
+ * startup backfill (which Role to move an EXISTING account onto, off the org
+ * admin Role these accounts were once given). A rename here moves both.
+ */
+export const AUTOMATION_ACCOUNT_BUNDLES = {
+    'platform-automation': 'pipeline_automation',
+    'pipeline-register': 'pipeline_registration',
+    'reporting-ingest': null,
+    'registry-push': null,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../src/types/permissions.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { OrgRole } from './common.js';\n\n// =============================================================================\n// Permission identifiers\n// =============================================================================\n\n/**\n * Canonical fine-grained permission identifiers, in `resource:action` form.\n *\n * These are the ORG-SCOPED capabilities a Role can grant (RBAC). Coarse by\n * design — `:write` covers create/update/delete for a resource — so the catalog\n * and permission-picker UI stay small; split a `:write` into `:create`/`:delete`\n * later if a resource needs it.\n *\n * NOT modeled here (intentionally): platform-operator actions (org delete, tier/\n * quota override, user admin, impersonation, platform settings) stay behind the\n * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`\n * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.\n */\nexport type Permission =\n  // Pipelines\n  | 'pipelines:read'\n  | 'pipelines:write'\n  | 'pipelines:publish'\n  // The pipeline REGISTRY (`POST`/`DELETE /pipelines/registry`): which deployed\n  // stack backs a pipeline, and the step manifest of plugin digests it runs.\n  // Split out of `pipelines:write` so the CodeBuild synth can keep that record\n  // current with a credential that can do nothing else — a key holding\n  // `pipelines:write` could rewrite every pipeline the org owns. People get it\n  // beside `pipelines:write` (the Member bundle); the `pipeline-register`\n  // service account holds it alone.\n  | 'pipeline_registry:write'\n  // Golden-path pipeline templates. Split out of `pipelines:*` so a platform\n  // team can curate the starter catalog WITHOUT write access to every pipeline\n  // (and vice versa). `:publish` maps to the\n  // template ladder's `public` rung; `org` and `private` need only `:write`.\n  | 'templates:read'\n  | 'templates:write'\n  | 'templates:publish'\n  // Plugins\n  | 'plugins:read'\n  | 'plugins:write'\n  | 'plugins:publish'\n  // Plugin ecosystem (docs/plugin-publishing.md). Org-assignable:\n  //  - `plugins:install`        — install/upgrade/uninstall listings (or REQUEST\n  //                               an install when the org's policy needs approval).\n  //  - `plugin_installs:manage` — the org's consumption policy + deciding install\n  //                               requests WITHIN the org (org-local only).\n  //  - `publishers:manage`      — the org's publisher profile + submitting\n  //                               ecosystem requests (every decision is system-org).\n  // System-org-only (see SYSTEM_ORG_ONLY_PERMISSIONS):\n  //  - `plugins:moderate`       — decide publish requests, moderate, yank, advisories.\n  //  - `publishers:verify`      — publisher tiers, profile changes, transfers.\n  | 'plugins:install'\n  | 'plugin_installs:manage'\n  | 'publishers:manage'\n  | 'plugins:moderate'\n  | 'publishers:verify'\n  // Platform operations (system-org only). The cross-tenant operator surfaces\n  // that used to require the superadmin FLAG, so a deployment can staff them\n  // with a Role instead of handing out implicit-all. Split because the two carry\n  // different risk: reading what a deploy configured is not the same as moving\n  // another organisation's money.\n  | 'platform:read'\n  // The cross-tenant ORG LIST, split out of `platform:read` because that one\n  // permission was doing two jobs with different blast radii: reading what a\n  // DEPLOY was configured to do (RLS mode, KMS posture, the rendered alert\n  // rules) and reading the roster of every CUSTOMER. Three of the four job\n  // bundles carried it, and only one of them wanted the deploy internals —\n  // Console Administrator and Support Agent got them purely because they needed\n  // to find an org by name.\n  //\n  // Same mistake, and same fix, as `consoles:datastore` before it was split by\n  // what a mistaken grant costs.\n  | 'orgs:read'\n  | 'billing:operate'\n  // The operator consoles, split by BLAST RADIUS rather than by product. Three\n  // permissions for five consoles, because what a mistaken grant costs differs\n  // by an order of magnitude at each step:\n  //\n  //  - `observability_console:open` — Grafana and Kiali. Read-only views; the worst\n  //    outcome of a mistaken grant is seeing telemetry.\n  //  - `database_console:open`     — pgAdmin and mongo-express. A database shell\n  //    over every tenant's rows: it can read and rewrite tenant data, but the\n  //    audit chain lives elsewhere, so the damage is recorded.\n  //  - `objectstore_console:open`   — the RustFS (S3) console. It can LIST and\n  //    DELETE objects in the registry, Loki, Thanos, plugin-build and\n  //    audit-chain buckets. Split from the pair above because the two are the\n  //    two HALVES of the audit tamper-evidence design: the chain's HMAC key\n  //    lives outside the DB, so a Mongo shell can tamper but cannot forge a\n  //    consistent chain — except by truncating the tail, which a chain cannot\n  //    see from the inside, and the defence against THAT is the signed\n  //    chain-head export to object storage. One shell can truncate; the other\n  //    can delete the heads that would expose the truncation.\n  //\n  // All three are system-org-only, so none can be held inside a tenant, and only\n  // the first is in the Platform Operator bundle: staffing an operator must never\n  // hand over a data shell as a side effect. Granting either of the other two is\n  // a separate, explicit act by a superadmin composing a Role for exactly that\n  // purpose.\n  //\n  // WHAT THE SPLIT DOES NOT DO, so nobody builds on it: it is not a containment\n  // boundary. Roles live in Mongo (`collection: 'roles'`), so a\n  // `database_console:open` holder can write that collection and grant themselves\n  // `objectstore_console:open` — datastore contains objectstore by escalation. The\n  // split expresses intent, keeps the default grant small and gives each class\n  // its own refusal signal. What actually protects the audit heads from whoever\n  // opens that console is S3 Object Lock with a retain-until-date\n  // (`platform/src/services/audit-head-export.ts`), which holds regardless of\n  // any permission here.\n  | 'observability_console:open'\n  | 'database_console:open'\n  | 'objectstore_console:open'\n  // On-call (system-org only). Reads the paging POSTURE and sends a test page.\n  // Not a schedule editor — the provider owns the rota — and deliberately not a\n  // settings surface either, because every knob is operator-side env. What it\n  // grants is the one thing a product surface can give that a shell cannot:\n  // \"will we actually be paged\", answerable without cluster access.\n  | 'oncall:manage'\n  // The vendor's other operational TASKS (system org only). Each exists so a\n  // superadmin can staff one job with a Role instead of the superadmin flag —\n  // before these, 34 routes were reachable only by someone who also held\n  // impersonation, a database shell and the ability to mint another superadmin.\n  //\n  // Support desk, split in two because the content is reused across every\n  // customer while a case belongs to one: `support_cases:write` is the desk's\n  // own work (triage, assignment, severity, internal notes, recording an\n  // incident against a support contract), `support_content:write` is authoring\n  // the canned replies. Each gates its task's READS as well as its writes,\n  // against the usual convention, because these tables carry no `org_id` — there\n  // is no tenancy boundary underneath to fall back on.\n  | 'support_cases:write'\n  | 'support_content:write'\n  // Cross-tenant subscriptions. Read is split from write because a read-only\n  // holder is a real job here: someone who reports on revenue and plan mix\n  // without being able to change a plan or cancel one.\n  | 'subscriptions:read'\n  | 'subscriptions:manage'\n  // The org lifecycle ACROSS tenants: rename, delete, change tier, move under a\n  // new parent. Distinct from `org_settings:write`, which is an org acting on\n  // itself.\n  | 'orgs:manage'\n  // Cross-tenant quota writes. The matching reads (`/quotas/all`, `/at-risk`)\n  // ride `platform:read` with the rest of the operator dashboard, so someone\n  // watching for exhaustion does not need the ability to raise a limit.\n  | 'quotas:manage'\n  // The plugin BUILD queue — depth, stalls, and purging the dead-letter queue.\n  // Distinct from `plugins:moderate`, which is ecosystem governance: this is\n  // infrastructure, and the people who run it are not the people who review\n  // submissions.\n  | 'plugin_queue:manage'\n  // Compliance\n  | 'compliance:read'\n  | 'compliance:write'\n  // Members & access\n  | 'members:manage'\n  | 'roles:manage'\n  | 'invitations:manage'\n  // Org-scoped service accounts (non-human principals) and their access keys.\n  // Split out of `members:manage` because a service account is a CREDENTIAL\n  // holder, not a person: granting someone the ability to mint long-lived\n  // machine keys is a different decision from letting them manage the roster.\n  | 'service_accounts:manage'\n  // Observability\n  | 'dashboards:read'\n  | 'dashboards:write'\n  | 'observability:read'\n  | 'observability:write'\n  // `logs:export` is split OUT of `observability:read` deliberately. Reading\n  // logs in the UI is paged and ephemeral; EXPORTING them is bulk egress that\n  // leaves the building and outlives a revoked session, so an org admin must be\n  // able to grant log viewing without granting downloads.\n  | 'logs:export'\n  // The org's own hash-chained audit trail. ORG-ASSIGNABLE, unlike the platform\n  // operations pair: the rows an org reads are its own (the query predicate is\n  // `orgId` OR `affectedOrgId`), so delegating it is an org's decision — a\n  // compliance reviewer can be given the trail without being made an admin of\n  // everything that produced it. Read-only by construction; there is no write.\n  | 'audit:read'\n  // Insights\n  | 'reports:read'\n  | 'reports:rollup'\n  // Stakeholder reports. `reports:read` stays the FREE on-demand dashboard read;\n  // these two are the add-on's write surface — `author` saves/schedules/drafts a\n  // report, `share` publishes it beyond the platform (PDF, email, share links).\n  // Split because publishing externally is a different risk from composing:\n  // a lead can be allowed to build reports without being allowed to email them out.\n  | 'reports:write'\n  | 'reports:publish'\n  // Messaging\n  | 'messages:read'\n  | 'messages:write'\n  // Billing & quotas\n  | 'billing:read'\n  | 'billing:manage'\n  | 'quotas:read'\n  // Impersonation — viewing the platform as somebody else. Three ids, because\n  // three different parties are involved and each decision belongs to a\n  // different one of them (docs/permissions.md#impersonation):\n  //  - `impersonation:open`   the VENDOR opening a cross-tenant session, which\n  //                           is system-org-only and still consent-gated;\n  //  - `team_access:open`     a PARENT org's admin viewing one of its own teams'\n  //                           members, which never leaves the tenant;\n  //  - `impersonation:approve` the TENANT answering a consent request.\n  // `org_impersonation:write` below is a fourth thing again: the POLICY that\n  // decides whether consent is needed at all.\n  | 'impersonation:open'\n  | 'impersonation:approve'\n  | 'team_access:open'\n  // Registry. Three rungs, because the write half has two very different\n  // blast radii: `write` COPIES a manifest (additive — it creates a tag,\n  // nothing stops resolving), `purge` DELETES one (a tenant's pipeline or a\n  // digest-pinned plugin image can stop resolving, with no undo).\n  | 'registry:read'\n  | 'registry:write'\n  | 'registry:purge'\n  // Organization settings. Four RESOURCES, each with the `:write` action, rather\n  // than one `org` resource with four noun-shaped actions — these are the org's\n  // own configuration state, which is what `:write` means here (`:manage` is\n  // reserved for administering a collection of other entities: members, roles,\n  // invitations, service accounts, billing).\n  //\n  //  - `org_settings:write`      — general org settings + AI config.\n  //  - `org_idp:write`           — SSO / IdP configuration (sensitive: controls login).\n  //  - `org_kms:write`           — customer-managed KMS key configuration\n  //                                (sensitive: controls encryption of org data).\n  //  - `org_impersonation:write` — the impersonation policy (sensitive: controls\n  //                                who may VIEW the org's data as a member).\n  //\n  // The last three were split OUT of `org_settings:write` so a custom role can\n  // grant general settings WITHOUT the sensitive surfaces — a \"settings manager\"\n  // role for org name or AI provider must not also be able to switch the org to\n  // `open`. All remain org-assignable and are seeded into the admin/owner\n  // bundles (via ORG_ASSIGNABLE_PERMISSIONS) so existing admins keep full\n  // access.\n  | 'org_settings:write'\n  | 'org_idp:write'\n  | 'org_kms:write'\n  | 'org_impersonation:write';\n\n/**\n * The CLOSED set of actions a permission id may end in — the second half of the\n * `resource:action` strategy the docs describe.\n *\n * It is closed for one concrete reason: `isMutationPermission` (frontend\n * `lib/auth-helpers.ts`) classifies read vs write BY SUFFIX, and that is what\n * disables every write affordance during a read-only impersonation session. A\n * noun-shaped action (the former `org:settings` and `consoles:datastore`) cannot be classified\n * by name, so each one had to be hand-listed — and a permission added without\n * remembering that list renders an enabled control that dead-ends on a 403.\n *\n * Reads are `:read` and `:rollup` (a read-VISIBILITY scope). Everything else is\n * a write. The five domain verbs are kept because each names an action with no\n * synonym in this vocabulary — `:export` is egress rather than mutation,\n * `:install` is consumption rather than authoring, `:moderate` and `:verify` are\n * ecosystem decisions, and `:operate` moves another tenant's money.\n *\n * `PERMISSION_ID_SHAPE` and this list are asserted over the whole catalog in\n * api-core's `test/permissions.test.ts`, so adding an off-strategy id fails\n * there rather than at a 403.\n */\nexport const PERMISSION_ACTIONS: readonly string[] = [\n  'read', 'rollup',\n  'write', 'manage', 'publish', 'open',\n  'export', 'install', 'moderate', 'verify', 'operate', 'purge', 'approve',\n];\n\n/** `resource:action`, where resource is `snake_case` and action is in {@link PERMISSION_ACTIONS}. */\nexport const PERMISSION_ID_SHAPE = /^[a-z][a-z0-9_]*:[a-z]+$/;\n\n/** All valid permissions (order determines display order in the picker). */\nexport const ALL_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write', 'pipelines:publish', 'pipeline_registry:write',\n  'templates:read', 'templates:write', 'templates:publish',\n  'plugins:read', 'plugins:write', 'plugins:publish',\n  'plugins:install', 'plugin_installs:manage', 'publishers:manage',\n  'plugins:moderate', 'publishers:verify',\n  'platform:read', 'orgs:read', 'billing:operate',\n  'observability_console:open', 'database_console:open', 'objectstore_console:open',\n  'oncall:manage',\n  'support_cases:write', 'support_content:write',\n  'subscriptions:read', 'subscriptions:manage',\n  'orgs:manage', 'quotas:manage', 'plugin_queue:manage',\n  'compliance:read', 'compliance:write',\n  'members:manage', 'roles:manage', 'invitations:manage', 'service_accounts:manage',\n  'dashboards:read', 'dashboards:write',\n  'observability:read', 'observability:write',\n  'logs:export', 'audit:read',\n  'reports:read', 'reports:rollup', 'reports:write', 'reports:publish',\n  'messages:read', 'messages:write',\n  'billing:read', 'billing:manage',\n  'quotas:read',\n  'registry:read', 'registry:write', 'registry:purge',\n  'impersonation:open', 'impersonation:approve', 'team_access:open',\n  'org_settings:write', 'org_idp:write', 'org_kms:write', 'org_impersonation:write',\n];\n\n/**\n * The CLOSED set of functions that take a {@link Permission} and decide access.\n *\n * \"Is permission X enforced anywhere?\" has to be answerable statically, which\n * a grep can't do: four different call shapes consume a permission id\n * (`requirePermission('x')` at a route, `userHasPermission(req, 'x')` inside a\n * controller, and `resolveVisibility(req, v, 'x')` /\n * `requireVisibilityWriteAccess(…, 'x')` in the visibility helpers), so a naive\n * grep for a route-level gate reports `templates:publish` as UNENFORCED when it\n * is in fact enforced on every template publish.\n *\n * They all bottom out in `userHasPermission`, so the RUNTIME primitive was\n * already one. This constant makes the STATIC surface one as well: it names\n * every entry point, so `permission-coverage.test.ts` can enumerate the catalog\n * and report each permission's enforcement sites without guessing. A new gate\n * that takes a `Permission` must be listed here, or the coverage report starts\n * lying about the permissions only that gate enforces.\n */\nexport const PERMISSION_GATES: readonly string[] = [\n  // Middleware gates (route level) — all any-of except requireAllPermissions.\n  'requirePermission',\n  'requireAllPermissions',\n  'requirePermissionOrService',\n  // The plugin-ecosystem governance chain (system org + permission + aal2).\n  'requireSystemOrgPermission',\n  // The single runtime primitive every gate above delegates to; also called\n  // directly where a controller branches on a capability rather than rejecting.\n  'userHasPermission',\n  'hasPermission',\n  // Visibility helpers — they take the entity's PUBLISH permission.\n  'requireVisibilityWriteAccess',\n  'checkVisibilityWriteAccess',\n  'resolveVisibility',\n  // quota's own wrapper. It delegates to `requirePermission`, but it takes the\n  // id as an OPTION (`authorizeOrg({ permission: 'quotas:manage' })`) because it\n  // also canonicalizes the `:orgId` param, which the route cannot drop. Without\n  // this entry the coverage scan reported `quotas:manage` as enforced nowhere.\n  'authorizeOrg',\n];\n\n/**\n * Display metadata for one permission: the label + description the\n * permission-picker UI shows, and the category it groups under.\n */\nexport interface PermissionMeta {\n  id: Permission;\n  label: string;\n  description: string;\n  category: string;\n}\n\n/**\n * The permission catalog with display metadata, in picker order.\n *\n * This module is the SINGLE catalog for backend and browser alike: it has no\n * runtime dependencies (the only import is a type), so the frontend imports it\n * through the `@pipeline-builder/api-core/permissions` subpath instead of keeping\n * a hand-maintained mirror. Every id in {@link ALL_PERMISSIONS} must appear here\n * exactly once (asserted by `permissions.test.ts`).\n */\nexport const PERMISSION_CATALOG: readonly PermissionMeta[] = [\n  { id: 'pipelines:read', label: 'View pipelines', description: 'View pipelines and their executions', category: 'Pipelines' },\n  { id: 'pipelines:write', label: 'Manage pipelines', description: 'Create, edit, and delete pipelines', category: 'Pipelines' },\n  { id: 'pipelines:publish', label: 'Publish pipelines', description: 'Make pipelines public (org-wide/catalog visibility)', category: 'Pipelines' },\n  { id: 'pipeline_registry:write', label: 'Register deployments', description: 'Record and remove the deployed stack and step manifest behind a pipeline (the pipeline registry)', category: 'Pipelines' },\n  { id: 'templates:read', label: 'View templates', description: 'View the golden-path template catalog', category: 'Templates' },\n  { id: 'templates:write', label: 'Manage templates', description: 'Author, edit, and delete pipeline templates', category: 'Templates' },\n  { id: 'templates:publish', label: 'Publish templates', description: 'Share a template beyond your org (public visibility)', category: 'Templates' },\n  { id: 'plugins:read', label: 'View plugins', description: 'View plugins and builds', category: 'Plugins' },\n  { id: 'plugins:write', label: 'Manage plugins', description: 'Create, upload, edit, and delete plugins', category: 'Plugins' },\n  { id: 'plugins:publish', label: 'Publish plugins', description: 'Make plugins public (org-wide/catalog visibility)', category: 'Plugins' },\n  { id: 'plugins:install', label: 'Install plugins', description: 'Install, upgrade, and uninstall ecosystem plugins (or request an install when your org requires approval)', category: 'Plugin Ecosystem' },\n  { id: 'plugin_installs:manage', label: 'Manage plugin installs', description: \"Set your org's plugin consumption policy and approve or deny install requests within the org\", category: 'Plugin Ecosystem' },\n  { id: 'publishers:manage', label: 'Manage publisher profile', description: \"Manage your org's publisher profile and submit publish, verification, transfer, and advisory requests\", category: 'Plugin Ecosystem' },\n  { id: 'plugins:moderate', label: 'Moderate the plugin ecosystem', description: 'Decide publish requests, moderate submissions and reviews, yank versions, and publish advisories (system org only)', category: 'Plugin Ecosystem' },\n  { id: 'publishers:verify', label: 'Verify publishers', description: 'Approve Verified applications, publisher tier and profile changes, and ownership transfers (system org only)', category: 'Plugin Ecosystem' },\n  { id: 'platform:read', label: 'View platform operations', description: 'Read the platform settings and the cross-tenant organization list (system org only)', category: 'Platform operations' },\n  { id: 'orgs:read', label: 'View all organizations', description: 'List and open every organization on the deployment \\u2014 the roster the operator surfaces work from (system org only)', category: 'Platform operations' },\n  { id: 'billing:operate', label: 'Operate discounts and promotions', description: 'Create, apply and revoke discount tokens and promotion campaigns across tenants (system org only)', category: 'Platform operations' },\n  { id: 'observability_console:open', label: 'Open the observability consoles', description: 'Open Grafana and Kiali — dashboards, traffic and mesh health across every tenant (system org only)', category: 'Platform operations' },\n  { id: 'database_console:open', label: 'Open the database consoles', description: 'Open pgAdmin and mongo-express — a direct read/write shell over every tenant\\u2019s rows (system org only)', category: 'Platform operations' },\n  { id: 'objectstore_console:open', label: 'Open the object-store console', description: 'Open the RustFS (S3) console — list and delete objects in every bucket, including the audit chain (system org only)', category: 'Platform operations' },\n  { id: 'oncall:manage', label: 'Manage on-call paging', description: 'Read the paging posture and send a test page (system org only; the rota lives with the provider)', category: 'On-call' },\n  { id: 'support_cases:write', label: 'Work the support desk', description: 'Triage the support queue, assign and re-prioritise cases, write internal notes, and record incidents against a support contract (system org only)', category: 'Support desk' },\n  { id: 'support_content:write', label: 'Author canned replies', description: 'Write and retire the reusable support replies offered to every customer (system org only)', category: 'Support desk' },\n  { id: 'subscriptions:read', label: 'View all subscriptions', description: 'View every organization\\u2019s subscription, plan mix and billing events (system org only)', category: 'Platform operations' },\n  { id: 'subscriptions:manage', label: 'Change any subscription', description: 'Change a plan, set a support floor, and cancel an organization\\u2019s subscription (system org only)', category: 'Platform operations' },\n  { id: 'orgs:manage', label: 'Administer any organization', description: 'Rename, re-tier, move and delete any organization (system org only)', category: 'Platform operations' },\n  { id: 'quotas:manage', label: 'Change any quota', description: 'Raise, reset and clear another organization\\u2019s quotas (system org only; viewing them rides platform:read)', category: 'Platform operations' },\n  { id: 'plugin_queue:manage', label: 'Run the plugin build queue', description: 'Read build-queue depth and purge the dead-letter queue (system org only)', category: 'Platform operations' },\n  { id: 'compliance:read', label: 'View compliance', description: 'View compliance rules, policies, and scans', category: 'Compliance' },\n  { id: 'compliance:write', label: 'Manage compliance', description: 'Create and edit rules, policies, and exemptions', category: 'Compliance' },\n  { id: 'members:manage', label: 'Manage members', description: 'Add, remove, and change roles of org members', category: 'Members & Access' },\n  { id: 'roles:manage', label: 'Manage roles', description: 'Create, edit, and delete roles', category: 'Members & Access' },\n  { id: 'invitations:manage', label: 'Manage invitations', description: 'Send, resend, and revoke invitations', category: 'Members & Access' },\n  { id: 'service_accounts:manage', label: 'Manage service accounts', description: 'Create org service accounts, assign their roles, and issue or revoke their keys', category: 'Members & Access' },\n  { id: 'dashboards:read', label: 'View dashboards', description: 'View custom dashboards', category: 'Observability' },\n  { id: 'dashboards:write', label: 'Manage dashboards', description: 'Create and edit custom dashboards', category: 'Observability' },\n  { id: 'observability:read', label: 'View alerting', description: 'View alert rules and destinations', category: 'Observability' },\n  { id: 'observability:write', label: 'Manage alerting', description: 'Create and edit alert rules and destinations', category: 'Observability' },\n  { id: 'logs:export', label: 'Download logs', description: \"Download your organization's log entries as a file (viewing logs only needs 'View alerting')\", category: 'Observability' },\n  { id: 'audit:read', label: 'View the audit log', description: \"Read the organization's own tamper-evident audit trail\", category: 'Observability' },\n  { id: 'reports:read', label: 'View reports', description: 'View analytics and reports', category: 'Insights' },\n  { id: 'reports:rollup', label: 'Roll up team reports', description: 'Include descendant teams when viewing reports', category: 'Insights' },\n  { id: 'reports:write', label: 'Author stakeholder reports', description: 'Create, schedule and draft scheduled reports for managers', category: 'Insights' },\n  { id: 'reports:publish', label: 'Publish reports externally', description: 'Publish a report and mint expiring share links for people outside the platform', category: 'Insights' },\n  { id: 'messages:read', label: 'View messages', description: 'View messages and announcements', category: 'Messaging' },\n  { id: 'messages:write', label: 'Send messages', description: 'Send messages and announcements', category: 'Messaging' },\n  { id: 'billing:read', label: 'View billing', description: 'View subscriptions and usage', category: 'Billing & Quotas' },\n  { id: 'billing:manage', label: 'Manage billing', description: 'Manage subscriptions, add-ons, and the billing portal', category: 'Billing & Quotas' },\n  { id: 'quotas:read', label: 'View quotas', description: 'View organization quotas and usage', category: 'Billing & Quotas' },\n  { id: 'registry:read', label: 'View registry', description: 'View the container image registry', category: 'Registry' },\n  { id: 'registry:write', label: 'Copy container images', description: 'Copy and promote a container image into another repository', category: 'Registry' },\n  { id: 'registry:purge', label: 'Delete container images', description: 'Delete images and repositories, and run registry garbage collection', category: 'Registry' },\n  { id: 'impersonation:open', label: 'Open an impersonation session', description: \"View a customer's account as one of its users, with that organization's consent\", category: 'Impersonation' },\n  { id: 'impersonation:approve', label: 'Answer impersonation requests', description: 'Approve or deny a request to view a member of this organization as that member', category: 'Impersonation' },\n  { id: 'team_access:open', label: \"View a team member's account\", description: \"View a member of one of this organization's teams as that member (read-only)\", category: 'Impersonation' },\n  { id: 'org_settings:write', label: 'Organization settings', description: 'Manage general org settings and AI config', category: 'Organization' },\n  { id: 'org_idp:write', label: 'Manage SSO/IdP', description: 'Configure single sign-on and identity providers', category: 'Organization' },\n  { id: 'org_kms:write', label: 'Manage encryption keys', description: 'Configure customer-managed KMS encryption keys', category: 'Organization' },\n  { id: 'org_impersonation:write', label: 'Manage impersonation policy', description: 'Control whether platform operators may view the organization as one of its members', category: 'Organization' },\n];\n\nconst PERMISSION_LABELS = new Map<string, string>(PERMISSION_CATALOG.map((p) => [p.id, p.label]));\n\n/** Human label for a permission id (falls back to the raw id for an unknown one). */\nexport function permissionLabel(id: string): string {\n  return PERMISSION_LABELS.get(id) ?? id;\n}\n\n/** One picker section: a category and the permissions it contains, in catalog order. */\nexport interface PermissionCategory {\n  category: string;\n  permissions: PermissionMeta[];\n}\n\n/** Group a permission list into categories, preserving catalog order. */\nfunction groupByCategory(perms: readonly PermissionMeta[]): PermissionCategory[] {\n  const order: string[] = [];\n  const byCategory = new Map<string, PermissionMeta[]>();\n  for (const p of perms) {\n    if (!byCategory.has(p.category)) { byCategory.set(p.category, []); order.push(p.category); }\n    byCategory.get(p.category)!.push(p);\n  }\n  return order.map((category) => ({ category, permissions: byCategory.get(category)! }));\n}\n\n/** Check whether a string is a valid Permission. */\nexport function isValidPermission(value: string): value is Permission {\n  return (ALL_PERMISSIONS as readonly string[]).includes(value);\n}\n\n/**\n * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —\n * they gate platform-operator surfaces (the shared image registry), so allowing\n * an org admin to mint a Role carrying them would be a latent privilege\n * escalation. They are NOT seeded into ANY built-in Role bundle (neither\n * `member` nor `admin`), so the only holder is a superadmin (implicit-all) —\n * which is what makes the image-registry gates that require them effectively\n * superadmin-only. This list ALSO blocks custom-Role authoring from requesting\n * them (see platform `sanitizePermissions`).\n */\nexport const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[] = [\n  // `registry:read` and `registry:write` were both here. What stays is the\n  // destructive rung alone: deleting a manifest or a whole repository, and the\n  // GC prune, each of which can remove an image a tenant's pipeline still\n  // resolves — including the digest-pinned plugin images the supply chain\n  // verifies against. That is the one registry action with no undo, so it keeps\n  // the narrowest possible audience: the flag, and never a Role.\n  'registry:purge',\n];\n\n/**\n * Permissions that govern the PLUGIN ECOSYSTEM and may be held only inside the\n * system org (docs/plugin-publishing.md). Like\n * {@link SUPERADMIN_ONLY_PERMISSIONS} they are in no member/admin/owner bundle\n * and are never grantable through a custom Role in ANY org (platform\n * `sanitizePermissions` refuses them). The only holders are superadmins\n * (implicit-all) and members of the built-in \"Ecosystem Manager\" Role, which is\n * seeded in the system org alone from {@link ECOSYSTEM_MANAGER_PERMISSIONS} and\n * assignable only by a superadmin.\n *\n * `oncall:manage` is in NEITHER named role, which makes it superadmin-only in\n * practice. That is deliberate rather than an oversight: paging is the vendor's\n * own operational concern and has nothing to do with ecosystem moderation, so\n * widening the Ecosystem Manager role to carry it would hand the pager to\n * people hired to review plugins. It is not a placeholder — it gates two live\n * routes (the paging posture read and the test page), unlike `registry:*`.\n */\nexport const SYSTEM_ORG_ONLY_PERMISSIONS: readonly Permission[] = [\n  'plugins:moderate',\n  'publishers:verify',\n  // The cross-tenant operator surfaces, system-org-only for the same reason the\n  // consoles are: they read and move things belonging to organisations the\n  // holder is not a member of, so they must never be grantable inside a tenant.\n  'platform:read',\n  'orgs:read',\n  // Reading the image registry: repository names, tags, manifests, blobs and the\n  // storage rollup. Promoted out of SUPERADMIN_ONLY because the registry browser\n  // was invisible to every Role, so a Platform Operator debugging a failed\n  // plugin build could see the build queue and its dead letters but not the\n  // images the build produced — and the only way to look was the superadmin\n  // flag. It stays system-org-only (no tenant Role may carry it) and is paired\n  // with a per-repo org-ownership filter that runs AFTER it, so widening the\n  // permission does not widen which repositories a holder can reach: a\n  // system-org member who is not a superadmin sees `system/*`, `library/*` and\n  // `public/*` — this deployment's own base and plugin images — and no tenant's\n  // `org-*` repositories at all (`canReadRepo` in the image-registry service).\n  'registry:read',\n  // Copying/promoting an image. System-org-only rather than superadmin-only\n  // because it is ADDITIVE: it writes a new tag and makes nothing stop\n  // resolving, and `canWriteRepo` confines a non-superadmin system-org caller\n  // to `system/*` regardless. Deliberately carried by NO built-in bundle today\n  // — promoting an image is a job, not a side effect of running the deployment,\n  // so it waits for a Role of its own rather than riding along with\n  // `platform:read`.\n  'registry:write',\n  'billing:operate',\n  'observability_console:open',\n  'database_console:open',\n  'objectstore_console:open',\n  // Opening a cross-tenant impersonation session. System-org-only for the\n  // obvious reason — it views an organisation the holder is not a member of —\n  // and it is the ONE permission in this list that also has to clear a gate the\n  // permission system does not own: the target organisation's consent (its\n  // `org_impersonation:write` policy), plus aal2 and a strong step-up. The\n  // permission says who may ASK; the tenant still answers.\n  //\n  // It does NOT cover emergency access. `POST /:userId/breakglass` bypasses\n  // tenant consent and so stays on the superadmin flag alone, approved by a\n  // SECOND superadmin (four-eyes). A permission that could be delegated must not\n  // be able to walk past consent.\n  'impersonation:open',\n  // Paging is the vendor's own operational concern and grants NO tenant access\n  // — `isSystemOrgId` is a content-owner check, not a privilege gate — so a\n  // tenant role must never be able to carry it, and a tenant must never be able\n  // to make this deployment send a page.\n  'oncall:manage',\n  // The vendor's own operational tasks. Each one replaced a `requireSystemAdmin`\n  // gate, so the point of listing them here is the same as the point of adding\n  // them at all: a Role composed in the system org can carry exactly one job,\n  // and no Role in any tenant can carry it at all.\n  'support_cases:write',\n  'support_content:write',\n  'subscriptions:read',\n  'subscriptions:manage',\n  'orgs:manage',\n  'quotas:manage',\n  'plugin_queue:manage',\n];\n\n/** Whether `permission` may be held only inside the system org. */\nexport function isSystemOrgOnlyPermission(permission: string): boolean {\n  return (SYSTEM_ORG_ONLY_PERMISSIONS as readonly string[]).includes(permission);\n}\n\n/**\n * Permissions an org may assign via a CUSTOM Role — every permission except the\n * {@link SUPERADMIN_ONLY_PERMISSIONS} and {@link SYSTEM_ORG_ONLY_PERMISSIONS}.\n * Custom-Role create/update validates the requested permission set against this\n * (see platform roles-service).\n */\nexport const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[] =\n  ALL_PERMISSIONS.filter((p) => isOrgAssignablePermission(p));\n\n/** Whether `permission` may be granted through a user-authored custom Role. */\nexport function isOrgAssignablePermission(permission: Permission): boolean {\n  return !SUPERADMIN_ONLY_PERMISSIONS.includes(permission) && !isSystemOrgOnlyPermission(permission);\n}\n\n/**\n * Category → permissions for the custom-Role AUTHORING picker: the catalog minus\n * the non-assignable permissions, with any now-empty category dropped\n * (so \"Registry\" disappears). The grouped view of\n * {@link ORG_ASSIGNABLE_PERMISSIONS}.\n */\nexport const ORG_ASSIGNABLE_CATEGORIES: readonly PermissionCategory[] =\n  groupByCategory(PERMISSION_CATALOG.filter((p) => isOrgAssignablePermission(p.id)));\n\n// =============================================================================\n// Permission-scoped credentials (personal access keys / machine tokens)\n// =============================================================================\n\n/**\n * Every `:read` permission — the \"read-only\" preset a new personal access key\n * starts from. Derived from the catalog so a new resource's read permission\n * joins the preset without a second edit.\n */\nexport const READ_ONLY_PERMISSIONS: readonly Permission[] =\n  ALL_PERMISSIONS.filter((p) => p.endsWith(':read'));\n\n/**\n * Normalize a requested permission subset: every entry must be a catalog id\n * (anything else → `null`, the caller's 400), duplicates collapse, and the\n * result is in canonical catalog order so a stored subset compares stably.\n * An EMPTY array is valid — a key that can authenticate but do nothing — and\n * is distinct from \"no subset\" (`undefined`), which means full access.\n */\nexport function normalizePermissionSubset(requested: readonly unknown[]): Permission[] | null {\n  const wanted = new Set<string>();\n  for (const p of requested) {\n    if (typeof p !== 'string' || !isValidPermission(p)) return null;\n    wanted.add(p);\n  }\n  return ALL_PERMISSIONS.filter((p) => wanted.has(p));\n}\n\n/**\n * The permissions a permission-scoped credential actually carries: the\n * INTERSECTION of the subset it was created with and the holder's CURRENT\n * effective permissions, in catalog order. Re-evaluated at every issue, so\n * losing a Role shrinks the credential and nothing can ever grow it past the\n * subset it was created with.\n */\nexport function intersectPermissions(\n  effective: readonly string[],\n  subset: readonly string[],\n): Permission[] {\n  const allowed = new Set(subset);\n  const held = new Set(effective);\n  return ALL_PERMISSIONS.filter((p) => allowed.has(p) && held.has(p));\n}\n\n// =============================================================================\n// Built-in Role seed bundles\n// =============================================================================\n\n/**\n * Permission bundles used to SEED the built-in Roles (\"Admin\", \"Member\").\n *\n * This is the single definition of what those built-in Roles grant — it is used\n * when a Role record is created (and by the startup backfill) to populate that\n * Role's own `permissions[]`. It is NOT a runtime permission source: a user's\n * effective permissions come ONLY from the Roles assigned to them (see\n * {@link resolveUserPermissions}). The coarse `role` label (owner/admin/member)\n * survives only for `isAdmin`/ownership/display, never to grant permissions.\n *\n * - `member`  — day-to-day builder: read + write on pipelines/templates/plugins,\n *   read elsewhere. No member/role/billing management, no compliance/alert\n *   authoring, and no `:publish` on any catalog.\n * - `admin`   — full org administration: every ORG-ASSIGNABLE permission (i.e.\n *   ALL_PERMISSIONS minus the {@link SUPERADMIN_ONLY_PERMISSIONS} and the\n *   {@link SYSTEM_ORG_ONLY_PERMISSIONS}, so `registry:*` stay\n *   superadmin-implicit-only and ecosystem moderation stays with the system\n *   org's Ecosystem Managers — neither is granted to org admins).\n * - `owner`   — same as admin (ownership itself — transfer/delete — is gated\n *   separately, not via a permission).\n */\nconst MEMBER_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write', 'pipeline_registry:write',\n  'templates:read', 'templates:write',\n  'plugins:read', 'plugins:write',\n  'plugins:install',\n  'compliance:read',\n  'dashboards:read',\n  'observability:read',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read',\n  'quotas:read',\n];\n\nconst ADMIN_PERMISSIONS: readonly Permission[] = [...ORG_ASSIGNABLE_PERMISSIONS];\n\n/**\n * Seed bundle for each built-in Role, keyed by the coarse role it grants.\n * Consumed by the Role seeder + the startup backfill to populate a built-in\n * Role's `permissions[]`. NOT consulted at request time — see\n * {@link resolveUserPermissions}.\n */\nexport const ROLE_PERMISSIONS: Record<OrgRole, readonly Permission[]> = {\n  member: MEMBER_PERMISSIONS,\n  admin: ADMIN_PERMISSIONS,\n  owner: ADMIN_PERMISSIONS,\n};\n\n/**\n * Seed bundle for the built-in \"Ecosystem Manager\" Role — seeded ONLY in the\n * system org (docs/plugin-publishing.md). It carries the\n * {@link SYSTEM_ORG_ONLY_PERMISSIONS} plus the reads a moderator needs (the\n * in-app catalog, in-app notices, the moderation-SLA dashboard) and nothing\n * tenant-facing: no `registry:*`, no `members:manage`. The Role grants the\n * coarse `member` label and never sets `isSuperAdmin`.\n */\n/**\n * The PLATFORM OPERATOR bundle — the third rung of the system org's ladder.\n *\n * Before it the ladder had two rungs and a gap: Ecosystem Manager (plugin\n * moderation) and Super Admin (implicit-all, which also carries impersonation,\n * pgAdmin and mongo-express). Anything in between — read the platform settings,\n * run a promotion campaign, check whether the pager is configured — had to be\n * done by making somebody a full superadmin.\n *\n * It is a BUNDLE rather than a grantable list because `SYSTEM_ORG_ONLY_PERMISSIONS`\n * can never be carried by a custom Role in any org: without a seeded bundle\n * these permissions had no grant path at all and were superadmin-only in\n * practice, which is exactly the thing they were added to avoid.\n *\n * Deliberately NOT carrying `plugins:moderate` / `publishers:verify`: ecosystem\n * moderation is a different job with its own Role, and a reviewer of plugins\n * should not acquire the ability to move another tenant's money by being handed\n * the operator Role.\n */\nexport const PLATFORM_OPERATOR_PERMISSIONS: readonly Permission[] = [\n  // BOTH halves of the old `platform:read`: this is the one job that genuinely\n  // wants the deploy's own configuration AND the customer roster.\n  'platform:read',\n  'orgs:read',\n  'oncall:manage',\n  'observability_console:open',\n  // RUNNING the deployment: raise a quota during an incident, watch the build\n  // queue and purge its dead-letter queue.\n  'quotas:manage',\n  'plugin_queue:manage',\n  // Reads that make the operator views usable: the dashboards the posture panels\n  // live on, the cross-tenant log view, and the customer's plan when a limit is\n  // the thing being debugged.\n  'observability:read',\n  'dashboards:read',\n  'subscriptions:read',\n  // The registry browser: repository names, tags and manifests for the images\n  // this deployment's builds produce. It was withheld while `registry:read` was\n  // superadmin-only — a seeded bundle carrying a superadmin-only permission\n  // would make that list a lie, since bundles bypass `sanitizePermissions`. The\n  // permission was promoted to system-org-only deliberately rather than smuggled\n  // in here, which is the order those two changes have to happen in.\n  'registry:read',\n];\n\n/**\n * ACCOUNT MANAGER — the commercial relationship with a customer, as opposed to\n * running the deployment.\n *\n * Split from {@link PLATFORM_OPERATOR_PERMISSIONS} rather than piled onto it,\n * because the two jobs diverge at exactly the permissions added alongside this\n * bundle. `billing:operate` MOVED here from the operator bundle for that reason:\n * minting a discount token is a commercial act, not an operational one, and the\n * person who restarts a stuck build queue has no reason to hold it.\n *\n * The destructive half of the catalogue lives here — `orgs:manage` can DELETE\n * an organisation and `subscriptions:manage` can cancel its subscription — so\n * this is deliberately the smaller, more rarely-assigned of the two.\n */\nexport const ACCOUNT_MANAGER_PERMISSIONS: readonly Permission[] = [\n  'subscriptions:read',\n  'subscriptions:manage',\n  'orgs:manage',\n  'billing:operate',\n  // A quota bump is as often a commercial concession as an operational one, so\n  // both bundles carry it.\n  'quotas:manage',\n  // The all-organizations list, which is the surface this job works from — and\n  // only that. It used to take `platform:read`, which also handed over the\n  // deploy's RLS mode, KMS posture and rendered alert rules: internals a\n  // commercial role has no use for.\n  'orgs:read',\n];\n\n/**\n * CONSOLE ADMINISTRATOR — the operator consoles, as a Role.\n *\n * WHY THIS EXISTS even though each console permission is grantable by hand: with\n * no seeded Role, the only path to pgAdmin was a superadmin composing a custom\n * Role for it, and the observed outcome of asking people to do that is that they\n * reach for the superadmin FLAG instead — the exact failure these permissions\n * were added to remove. A named Role also makes \"who can open a data shell?\" one\n * query instead of an audit of every custom Role.\n *\n * It carries all three consoles, which is the whole job for the person who holds\n * it. ONE CONSEQUENCE WORTH KNOWING: `database_console:open` and\n * `objectstore_console:open` are the two halves of the audit tamper-evidence\n * design — a Mongo shell can truncate a hash chain's tail, and the object store\n * holds the signed heads that would expose the truncation — so a holder of this\n * Role can do both. The permissions stay SEPARATE for exactly that reason: a\n * deployment that wants them held by different people composes a narrower Role\n * by hand (a superadmin may include any system-org-only permission in a Role\n * authored in the system org) and assigns this one to nobody.\n */\n/**\n * PLATFORM OBSERVER — look, don't touch. The ladder's missing bottom rung.\n *\n * Every other system-org bundle grants a write. The one that does not —\n * Console Administrator — grants a read that IS a database shell. So somebody\n * who should see the deployment and change nothing (a new operator shadowing, an\n * auditor, an on-call engineer during a handover) had two options: Super Admin,\n * or nothing. The usual outcome of a choice like that is the flag.\n *\n * Strictly read-only by construction: every permission here ends `:read`, which\n * `isMutationPermission` classifies as a read, so the dashboard disables every\n * write affordance for a holder rather than offering controls that 403.\n *\n * NOT `audit:read`. It would be the obvious addition and it is the wrong one:\n * `listAuditEvents` pins every non-superadmin to their OWN org, so a system-org\n * observer holding it would see the system org's audit trail and nothing else —\n * an affordance that looks like fleet-wide audit access and is not. Reading\n * another tenant's trail is deliberately the flag's alone.\n */\nexport const PLATFORM_OBSERVER_PERMISSIONS: readonly Permission[] = [\n  'platform:read',\n  'orgs:read',\n  'subscriptions:read',\n  'observability:read',\n  'dashboards:read',\n  // A read, and this Role is reads — the registry browser with neither of the\n  // two write rungs (`registry:write` copies, `registry:purge` deletes).\n  'registry:read',\n];\n\nexport const CONSOLE_ADMIN_PERMISSIONS: readonly Permission[] = [\n  'observability_console:open',\n  'database_console:open',\n  'objectstore_console:open',\n  // The all-organizations list, so a holder can find the org they were asked\n  // about without a second Role — and nothing more. This was `platform:read`,\n  // which meant opening a database console also granted the deploy's own\n  // configuration, for no reason beyond the two sharing a gate.\n  'orgs:read',\n];\n\n/**\n * REGISTRY OPERATOR — moves container images around, and nothing else.\n *\n * THE GAP IT FILLS. Promoting an image — copying a built tag from one repository\n * to the one a release resolves — is a job somebody does, and until now the only\n * identity that could do it was a superadmin. `registry:write` has no other\n * carrier, and a system-org-only permission with no seeded carrier is\n * superadmin-only in practice (the `platform:read` failure, pinned by the\n * \"at least one seeded carrier\" assertion in api-core's `test/permissions.test.ts`).\n * So splitting `registry:purge` out of `registry:write` is only half the change:\n * the additive half needs a Role or the split buys nothing.\n *\n * WHY IT IS NOT PART OF PLATFORM OPERATOR. That Role runs the deployment and\n * already reads the registry. Promoting an image is a release decision, not an\n * operational side effect, and rolling it into the Role everyone on call holds\n * would mean the pager rotation can retag a release at 3am. The two Roles\n * compose instead — a member may hold any number, and permissions are the union.\n *\n * WHY IT IS ONLY TWO PERMISSIONS. Deliberately nothing else: no `platform:read`,\n * no console, no `orgs:read`. `canReadRepo`/`canWriteRepo` confine a\n * non-superadmin system-org holder to `system/*`, `library/*` and `public/*` —\n * this deployment's own base and plugin images — so the Role cannot reach a\n * tenant's repositories at all, and a holder who also needs the operator views\n * gets the operator Role too. It does NOT carry `registry:purge`, which is in\n * {@link SUPERADMIN_ONLY_PERMISSIONS} and in no bundle by design: an image\n * promoter has no business deleting the image a tenant's pipeline resolves.\n */\nexport const REGISTRY_OPERATOR_PERMISSIONS: readonly Permission[] = [\n  'registry:read',\n  'registry:write',\n];\n\n/**\n * SUPPORT AGENT — the support desk, and nothing else.\n *\n * Deliberately carries no `platform:read`, no console and no billing write: an\n * agent answers cases and writes the canned replies. `subscriptions:read` is\n * here because the first question on any case is what the customer is entitled\n * to, and without it an agent would have to ask someone else to look.\n */\nexport const SUPPORT_AGENT_PERMISSIONS: readonly Permission[] = [\n  'support_cases:write',\n  'support_content:write',\n  'subscriptions:read',\n  // NEW, and the gap the split exposed: an agent triaging a case needs to find\n  // the customer's organization. The only permission that listed orgs was\n  // `platform:read`, which would also have handed a support agent the deploy's\n  // internals — so they had neither, and had to ask someone else to look.\n  'orgs:read',\n  // Reading and answering the case itself rides the ordinary messaging\n  // permissions — a support case IS a message thread.\n  'messages:read',\n  'messages:write',\n];\n\n/**\n * SUPPORT LEAD — the support desk, plus the authority to look.\n *\n * THE GAP IT FILLS. `impersonation:open` is system-org-only, and a system-org-only\n * permission with no seeded carrier is superadmin-only in practice — the\n * invariant api-core's `test/permissions.test.ts` asserts, and the reason\n * `platform:read` shipped unusable. Without this Role, splitting impersonation\n * out of the flag would change nothing: the only way to let somebody view a\n * customer's account would still be to make them a full Super Admin, handing\n * over `/admin/users/:id/grants`, the single-person MFA reset, the database\n * console and `registry:purge` at the same time.\n *\n * WHY IT IS THE SUPPORT DESK AND NOT THE OPERATOR. The question impersonation\n * answers is \"what is this customer actually seeing?\", which is a support\n * question. Platform Operator runs the deployment and is held by whoever is on\n * call; adding this to it would hand every rota member the ability to become any\n * customer's user at 3am. Support Agent's bundle plus the one permission is the\n * narrower, more honest shape — and a lead who also runs the deployment holds\n * both Roles.\n *\n * WHAT IT STILL CANNOT DO. Emergency access: `breakglass` bypasses tenant\n * consent and stays on the flag, approved by a second Super Admin. And the\n * tenant can refuse — `impersonation:open` is permission to ASK.\n */\nexport const SUPPORT_LEAD_PERMISSIONS: readonly Permission[] = [\n  ...SUPPORT_AGENT_PERMISSIONS,\n  'impersonation:open',\n];\n\n/**\n * STARTING POINTS for a custom Role in a tenant org — templates, not Roles.\n *\n * THE GAP THEY FILL. An org seeds exactly TWO Roles — Member and Admin — and\n * Admin is every org-assignable permission. So promoting anyone past \"author and\n * read\" hands over the whole remainder at once: `org_kms:write`,\n * `org_idp:write`, `org_impersonation:write`, `billing:manage`, `roles:manage`\n * and `audit:read` among them. The product's answer is \"author a custom Role\",\n * and the safety is already right (`sanitizePermissions` bounds a custom Role by\n * its author's own ceiling). What was missing is the starting point.\n *\n * The exact sizes of that cliff are asserted in `test/permissions.test.ts`\n * rather than written here. This paragraph used to carry them inline — \"three\n * Roles: Member (15), Team Lead (17) and Admin (37)\" — and every one of those\n * numbers went stale: `Team Lead` stopped being seeded when it became the first\n * template below, and the two bundles have grown since. A count nothing checks\n * is a claim that decays, and this one was the stated rationale for the feature.\n *\n * WHY TEMPLATES AND NOT SEEDED ROLES. A seeded built-in is `system: true` and\n * therefore immutable, so seeding these would put four undeletable rows in every\n * org whether it wants them. A template leaves no trace until someone uses it,\n * and what it produces is an ordinary custom Role the org fully owns — editable,\n * deletable, and bounded by the author's ceiling like any other.\n *\n * WHAT THEY DELIBERATELY EXCLUDE. `roles:manage` is in none of them. It is the\n * one permission that compounds — the holder can mint further Roles, up to their\n * own ceiling — so acquiring it should stay a conscious act rather than a side\n * effect of picking a preset. Every permission here is org-assignable, so a\n * template is valid in any org and `sanitizePermissions` accepts it.\n */\nexport interface RoleTemplate {\n  id: string;\n  name: string;\n  /** What the job is — shown next to the template, and a sensible Role description. */\n  description: string;\n  permissions: readonly Permission[];\n}\n\nexport const ROLE_TEMPLATES: readonly RoleTemplate[] = [\n  {\n    // Was a SEEDED Role in every org until it became a template. It is the only\n    // built-in that was a job description rather than a structural requirement:\n    // Super Admin is where `isSuperAdmin` is derived from, Admin and Member are\n    // the floor an org is unusable without, and the system-org Roles carry\n    // permissions no custom Role may hold. Team Lead was none of those — it is\n    // `member` plus two report permissions, and an org that does not delegate\n    // report authoring had an undeletable row for it anyway.\n    //\n    // CONSEQUENCE, stated rather than discovered: a new org no longer has a Role\n    // that grants `reports:write` to a non-admin. An admin holds both permissions\n    // (they are in the admin bundle) and instantiates this template to delegate\n    // them — the same shape as the four below. Orgs that already have the seeded\n    // Role keep it, and the backfill keeps its bundle current.\n    id: 'team-lead',\n    name: 'Team Lead',\n    description: 'Authors and shares stakeholder reports for a team, without org-admin access.',\n    permissions: [...MEMBER_PERMISSIONS, 'reports:write', 'reports:publish'],\n  },\n  {\n    /**\n     * MEMBER ALREADY IS THE DEVELOPER ROLE — this template exists for what it\n     * does NOT cover.\n     *\n     * Everything in a developer's loop is `pipelines:read` + `pipelines:write`,\n     * both in the member bundle: create, edit, validate, run, stop, the bulk\n     * ops, AI generation (`/pipelines/generate`, incl. from-url and streaming),\n     * the pipeline registry, plus `templates:read` to instantiate and\n     * `plugins:install` to add a plugin. A template restating that would buy\n     * nothing.\n     *\n     * What a developer hits the cliff on is the SELF-SERVICE operate pair: they\n     * can read their service's dashboards and metrics and cannot change either,\n     * because both writes sit in the admin bundle. So the person who owns a\n     * pipeline files a ticket to get an alert on it.\n     *\n     * DELIBERATELY NOT HERE. `logs:export` — viewing logs rides\n     * `observability:read`, but downloading them is bulk egress an org may\n     * withhold from members (docs/permissions.md), and a template aimed at every\n     * engineer would reverse that. `pipelines:publish` — sharing beyond the\n     * author is a release decision, which is Release Manager's below; somebody\n     * who does both holds both Roles.\n     */\n    id: 'developer',\n    name: 'Developer',\n    description: 'Builds and runs pipelines, and owns the dashboards and alerts for what they build.',\n    permissions: [...MEMBER_PERMISSIONS, 'dashboards:write', 'observability:write'],\n  },\n  {\n    id: 'release-manager',\n    name: 'Release Manager',\n    description: 'Decides what becomes shared beyond its author, and approves plugin installs.',\n    permissions: [\n      'pipelines:read', 'pipelines:publish',\n      'templates:read', 'templates:publish',\n      'plugins:read', 'plugins:publish',\n      'plugin_installs:manage',\n    ],\n  },\n  {\n    id: 'security-officer',\n    name: 'Security Officer',\n    description: 'Identity, encryption keys and the evidence trail — the surface an auditor asks about.',\n    permissions: [\n      'audit:read', 'logs:export',\n      'compliance:read', 'compliance:write',\n      'org_idp:write', 'org_kms:write', 'org_impersonation:write',\n      // Owning the impersonation POLICY (`org_impersonation:write`) without\n      // being able to answer a REQUEST was the asymmetry the consent flow left\n      // behind: the lesser act had a permission of its own and the greater one\n      // had none. Whoever decides whether consent is required should be able to\n      // give or withhold it.\n      'impersonation:approve',\n    ],\n  },\n  {\n    id: 'people-manager',\n    name: 'People Manager',\n    description: 'The roster and its machine credentials, across the account\\u2019s teams — without the org\\u2019s settings or its money.',\n    permissions: [\n      'members:manage', 'invitations:manage', 'service_accounts:manage',\n      // The same job, one level down: entering a descendant team to work on its\n      // roster, and viewing one of its members as that member. Without it a\n      // people manager in a parent org can administer the account's teams on\n      // paper and not reach them.\n      'team_access:open',\n    ],\n  },\n  {\n    id: 'billing-manager',\n    name: 'Billing Manager',\n    description: 'The subscription, seats and invoices for this organization.',\n    permissions: [\n      'billing:read', 'billing:manage', 'quotas:read',\n    ],\n  },\n  {\n    /**\n     * The job the impersonation consent flow created INSIDE the tenant: the\n     * named person who answers \"may a support engineer view this account?\" and\n     * can afterwards read what happened.\n     *\n     * It exists as a template because `impersonation:approve` is in the admin\n     * and owner bundles — so by default every admin may consent — and the whole\n     * point of splitting it out was to let an org say \"this decision is one\n     * person's\". Doing that means authoring a Role that holds it and taking it\n     * off the others, and hand-composing was the only route.\n     *\n     * Two permissions and no more: approving is not administering. `audit:read`\n     * is here because consenting without being able to check what the session\n     * then did is consent in name only.\n     */\n    id: 'access-approver',\n    name: 'Access Approver',\n    description: 'Answers requests to view this organization\\u2019s accounts, and reads the trail of what happened.',\n    permissions: [\n      'impersonation:approve', 'audit:read',\n    ],\n  },\n];\n\nexport const ECOSYSTEM_MANAGER_PERMISSIONS: readonly Permission[] = [\n  'plugins:read',\n  'plugins:moderate',\n  'publishers:verify',\n  'messages:read',\n  'observability:read',\n];\n\n/**\n * Seed bundle for the built-in \"Team Lead\" Role — the person who reports UPWARD.\n *\n * Exists because the target user for stakeholder reports is a lead, not an admin,\n * and granting `reports:write` only through the admin bundle would have forced\n * every reporting lead to be an org admin (members:manage, roles:manage,\n * org_settings:write, billing) to send their manager a weekly summary.\n *\n * Deliberately NOT included: `reports:rollup`. Rolling a report up over descendant\n * teams is downward visibility across the org tree, which is a granted capability\n * in this model, not something a team's own lead gets by default — a lead of a\n * PARENT org is granted it explicitly. The Role grants the coarse `member` label\n * and never sets `isSuperAdmin`.\n */\nexport const TEAM_LEAD_PERMISSIONS: readonly Permission[] = [\n  ...MEMBER_PERMISSIONS,\n  'reports:write',\n  'reports:publish',\n];\n\n/**\n * Seed bundle for the built-in \"Pipeline Automation\" Role — what the org's\n * unscoped stored credential (the `platform-automation` service account that\n * `pipeline-manager infra store-token` provisions) needs, and nothing more.\n *\n * Derived by tracing every call made with that key, not by guessing:\n *  - `pipelines:read` — the CodeBuild synth (and `pipeline deploy --store-tokens`)\n *    fetching the pipeline it builds (`GET /pipelines/:id`);\n *  - `plugins:read`   — plugin resolution at synth/deploy and in the plugin-lookup\n *    Lambda (`POST /plugins/lookup`), and the run-time vulnerability check step\n *    (`POST /plugins/runtime-check`).\n *\n * What it deliberately does NOT carry, and where that work went:\n *  - registry writes (`pipeline_registry:write`) — the synth registers its step\n *    manifest with the separate `pipeline-register` key (Pipeline Registration);\n *  - image pushes and pulls — CodeBuild authenticates to the image registry with\n *    the `registry-push` scoped key, never this one;\n *  - reporting writes — the events Lambda and step report uploads use the\n *    `reporting:ingest` scoped key.\n *\n * It used to be the org ADMIN Role, so a leaked synth credential could rewrite\n * every pipeline, Role and member of the org.\n */\nexport const PIPELINE_AUTOMATION_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read',\n  'plugins:read',\n];\n\n/**\n * Seed bundle for the built-in \"Pipeline Registration\" Role, held by the\n * `pipeline-register` service account: `POST`/`DELETE /pipelines/registry` for\n * its own org and nothing else — not even a read.\n */\nexport const PIPELINE_REGISTRATION_PERMISSIONS: readonly Permission[] = [\n  'pipeline_registry:write',\n];\n\n// =============================================================================\n// Resolution\n// =============================================================================\n\n/**\n * Resolve a user's effective org permissions from the Roles assigned to them.\n *\n * Single-source model: a user's abilities are EXACTLY the union of the\n * permissions carried by the Roles they hold (a Role = a named permission set;\n * built-in Roles carry their bundle explicitly, seeded from\n * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the\n * coarse `role` label grants nothing on its own.\n *\n * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.\n * 2. Otherwise, union every permission granted by the user's assigned Roles.\n * 3. Invalid/unknown permission strings are silently ignored.\n *\n * @param assignedPermissions - Flattened permissions from every Role the user holds\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @returns Effective permissions in canonical order\n */\nexport function resolveUserPermissions(\n  assignedPermissions?: readonly string[] | null,\n  isSuperAdmin?: boolean,\n): Permission[] {\n  if (isSuperAdmin) return [...ALL_PERMISSIONS];\n\n  const perms = new Set<Permission>();\n  if (assignedPermissions) {\n    for (const p of assignedPermissions) {\n      if (isValidPermission(p)) perms.add(p);\n    }\n  }\n  return ALL_PERMISSIONS.filter(p => perms.has(p));\n}\n\n/**\n * Confine a resolved permission list to what may be held in the token's ACTIVE\n * org: outside the system org every {@link SYSTEM_ORG_ONLY_PERMISSIONS} entry is\n * dropped (docs/plugin-publishing.md). Applied at token issue on\n * top of {@link resolveUserPermissions} — including a superadmin's implicit-all —\n * so a token minted in a tenant org never CLAIMS `plugins:moderate` /\n * `publishers:verify`, even if a hand-written Role document somehow carried\n * them there. (Superadmins still pass `hasPermission` via the flag; the\n * ecosystem route gate additionally requires the system org, so that bypass\n * never reaches a governance route from a tenant org either.)\n *\n * Takes a boolean rather than an org id so this module stays dependency-free\n * (the frontend imports it); callers decide with api-core `isSystemOrgId`.\n */\nexport function confinePermissionsToOrg<P extends string>(\n  permissions: readonly P[],\n  activeOrgIsSystemOrg: boolean,\n): P[] {\n  return activeOrgIsSystemOrg ? [...permissions] : permissions.filter((p) => !isSystemOrgOnlyPermission(p));\n}\n\n/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */\nexport function hasPermission(\n  granted: readonly string[] | null | undefined,\n  permission: Permission,\n  isSuperAdmin?: boolean,\n): boolean {\n  if (isSuperAdmin) return true;\n  return !!granted && granted.includes(permission);\n}\n\n// =============================================================================\n// Built-in Role seed bundles, as a TABLE\n// =============================================================================\n\n/**\n * The named permission bundles a built-in Role may carry, and the Role NAME each\n * one is seeded under. One table, because the three facts about a job Role —\n * its id, its permissions and its display name — were previously three\n * independent lists in three places, and nothing held them together.\n *\n * WHAT WENT WRONG WITHOUT IT. The platform resolved a bundle through a\n * nine-branch `if` chain with a fall-through to the coarse `grantsRole` bundle.\n * Every job Role grants `member`, so a bundle added to the id list WITHOUT its\n * branch did not fail — it silently seeded the plain Member bundle, and the\n * startup backfill then re-synced it to that wrong value on every boot. The\n * Role existed, was assignable from the staffing panel, and granted fifteen\n * tenant permissions instead of its job. Nothing anywhere exercised the\n * resolver per bundle.\n *\n * Keyed access plus `satisfies` makes a missing entry a COMPILE error, and an\n * extra one too — in both directions, with no runtime check to forget.\n *\n * The NAME lives here for the same reason. The platform seeded names from its\n * own constants while the frontend's staffing roster hard-coded its own copy,\n * each pinned by a test against itself — so renaming a Role passed both suites\n * and the roster silently rendered \"Role not found\", which is the grant path for\n * that Role's permissions disappearing. Both sides read this now.\n */\nexport const SEED_BUNDLES = {\n  ecosystem_manager: { name: 'Ecosystem Manager', permissions: ECOSYSTEM_MANAGER_PERMISSIONS },\n  team_lead: { name: 'Team Lead', permissions: TEAM_LEAD_PERMISSIONS },\n  platform_observer: { name: 'Platform Observer', permissions: PLATFORM_OBSERVER_PERMISSIONS },\n  platform_operator: { name: 'Platform Operator', permissions: PLATFORM_OPERATOR_PERMISSIONS },\n  account_manager: { name: 'Account Manager', permissions: ACCOUNT_MANAGER_PERMISSIONS },\n  console_admin: { name: 'Console Administrator', permissions: CONSOLE_ADMIN_PERMISSIONS },\n  support_agent: { name: 'Support Agent', permissions: SUPPORT_AGENT_PERMISSIONS },\n  support_lead: { name: 'Support Lead', permissions: SUPPORT_LEAD_PERMISSIONS },\n  registry_operator: { name: 'Registry Operator', permissions: REGISTRY_OPERATOR_PERMISSIONS },\n  pipeline_automation: { name: 'Pipeline Automation', permissions: PIPELINE_AUTOMATION_PERMISSIONS },\n  pipeline_registration: { name: 'Pipeline Registration', permissions: PIPELINE_REGISTRATION_PERMISSIONS },\n} as const;\n\n/** Every seed-bundle id. The platform's `Role.seedBundle` enum is this list. */\nexport const SEED_BUNDLE_IDS = Object.keys(SEED_BUNDLES) as Array<keyof typeof SEED_BUNDLES>;\nexport type SeedBundleId = keyof typeof SEED_BUNDLES;\n\n/**\n * The SYSTEM ORG's job Roles, in staffing order — the subset of\n * {@link SEED_BUNDLES} seeded there, which is every bundle except `team_lead`\n * (a tenant job, and a template rather than a seeded Role since it stopped\n * being structural).\n *\n * `ecosystem_manager` IS one of them; it is listed here even though its roster\n * lives on the Ecosystem console rather than the staffing panel, because what\n * this list answers is \"which Roles does the system org seed\", not \"which panel\n * renders them\".\n */\nexport const SYSTEM_ORG_JOB_BUNDLES: readonly SeedBundleId[] = [\n  'ecosystem_manager',\n  'platform_observer',\n  'platform_operator',\n  'account_manager',\n  'console_admin',\n  'support_agent',\n  'support_lead',\n  'registry_operator',\n];\n\n/**\n * The MACHINE Roles every org seeds — the subset of {@link SEED_BUNDLES} held by\n * the service accounts `pipeline-manager infra store-token` provisions.\n *\n * Seeded rather than offered as a {@link ROLE_TEMPLATES} entry, unlike the\n * tenant job presets, because they are structural: the CLI grants one to the\n * account it creates and the startup backfill moves existing accounts onto it,\n * and both have to find it in EVERY org by a stable identity. A template leaves\n * nothing to find until somebody instantiates it.\n */\nexport const ORG_AUTOMATION_BUNDLES: readonly SeedBundleId[] = [\n  'pipeline_automation',\n  'pipeline_registration',\n];\n\n/**\n * The service accounts `pipeline-manager infra store-token` provisions, keyed by\n * account name, and the built-in Role each holds — `null` for an account whose\n * key carries a capability SCOPE (a `TokenScope`) and so needs no Role at all.\n *\n * One table for the CLI (which Role to grant a NEW account) and the platform's\n * startup backfill (which Role to move an EXISTING account onto, off the org\n * admin Role these accounts were once given). A rename here moves both.\n */\nexport const AUTOMATION_ACCOUNT_BUNDLES = {\n  'platform-automation': 'pipeline_automation',\n  'pipeline-register': 'pipeline_registration',\n  'reporting-ingest': null,\n  'registry-push': null,\n} as const satisfies Record<string, SeedBundleId | null>;\n"]}