@pipeline-builder/api-core 4.1.19 → 4.1.21

package/lib/types/ask-proposals.js

@@ -0,0 +1,308 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+// -----------------------------------------------------------------------------
+// Provenance (rule 6)
+// -----------------------------------------------------------------------------
+/** The `proposedBy` value every agent-drafted commit records. */
+export const ASK_AGENT_PROPOSER = 'ask-agent';
+/** The audit `details` key that carries provenance. */
+export const PROPOSED_BY_DETAIL_KEY = 'proposedBy';
+/**
+ * Merge agent provenance into an audit event's free-form `details`.
+ * Provenance is applied LAST so a caller-supplied `proposedBy` cannot overwrite
+ * it — the point of the field is that it is not negotiable.
+ */
+export function askProposalAuditDetails(details) {
+    return { ...details, proposedBy: ASK_AGENT_PROPOSER };
+}
+/**
+ * The request HEADER a proposal commit stamps, and the only channel provenance
+ * travels on.
+ *
+ * A HEADER rather than a body field, for three reasons:
+ *
+ *  - **It cannot collide.** `proposedBy` in a body would be a new key in six
+ *    different domain schemas — `PipelineUpdateSchema`, the plugin/template
+ *    update schemas, three notification/settings schemas — two of which are
+ *    `.strict()` and the rest of which feed `Object.keys(body)` straight into
+ *    the update's column list and the audit's `fields`. A field named after an
+ *    audit key would then be indistinguishable from a real one, and the day a
+ *    domain grows its own `proposedBy` the two meanings merge silently.
+ *  - **It is transport metadata, and stays out of the payload.** Nothing
+ *    downstream of `validateBody` ever sees it, so it cannot be persisted, cannot
+ *    widen a diff, and cannot reach a service that forwards the body onward.
+ *  - **The platform already does this.** `X-Step-Up-Token` is the same shape of
+ *    thing — a per-request assertion about HOW the call was made rather than
+ *    WHAT it changes — and rides a header for the same reasons.
+ *
+ * Lower-case because that is how Node normalises incoming header names; the
+ * browser sends `X-PB-Proposed-By`, which arrives here.
+ */
+export const ASK_PROPOSED_BY_HEADER = 'x-pb-proposed-by';
+/**
+ * Read the provenance claim off a request's header bag.
+ *
+ * Deliberately exact: no trimming, no case folding, no prefix matching. The
+ * only sender is the browser's confirm path, which stamps the shared constant,
+ * so every other value is refused rather than repaired. This is what keeps a
+ * client from writing arbitrary audit `details` — the header's whole vocabulary
+ * is one word, and the word is not the client's to choose.
+ *
+ * Takes the header BAG (`req.headers`) rather than a request, so this module
+ * keeps its zero runtime imports and the browser can still import the constant.
+ */
+export function readProposerClaim(headers) {
+    const bag = headers;
+    const raw = bag && typeof bag === 'object' ? bag[ASK_PROPOSED_BY_HEADER] : undefined;
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    if (value === undefined || value === null || value === '')
+        return 'none';
+    return value === ASK_AGENT_PROPOSER ? 'ask-agent' : 'foreign';
+}
+/**
+ * The audit `details` for a write, with provenance folded in when — and ONLY
+ * when — the request carries the agent marker.
+ *
+ * `details` is what the HANDLER built and stays authoritative. Provenance is
+ * additive: the ONLY key it can ever write is `proposedBy`, so every field the
+ * handler set survives untouched, and {@link askProposalAuditDetails} applies
+ * that one key LAST so a `proposedBy` arriving from anywhere else cannot speak
+ * in its place. A request carrying no marker, or a `foreign` one, gets the
+ * handler's details unchanged — an ordinary edit records no `proposedBy` at
+ * all, which is the distinction the field exists to make.
+ */
+export function withProposalProvenance(headers, details) {
+    return readProposerClaim(headers) === 'ask-agent'
+        ? askProposalAuditDetails(details)
+        : { ...details };
+}
+/**
+ * The `digestMode` vocabulary is MIRRORED, not imported: this module keeps zero
+ * runtime imports so the browser entry stays standalone. The type annotation
+ * makes a REMOVED mode a compile error here, and `ask-proposals.test.ts` asserts
+ * the list against `PLUGIN_SECURITY_DIGEST_MODES` so an ADDED one cannot drift
+ * either.
+ */
+const DIGEST_MODES = ['immediate', 'daily', 'weekly'];
+/**
+ * The allowlist. Adding an entry is a deliberate act: name the route you
+ * checked, confirm it carries no `requireStepUp`, and write the `why`.
+ */
+export const ORG_SETTING_PROPOSAL_ALLOWLIST = [
+    {
+        key: 'reporting.incidentWindowHours',
+        surface: 'reporting',
+        field: 'incidentWindowHours',
+        shape: { kind: 'integer', min: 1, max: 720 },
+        api: { method: 'PUT', path: '/reports/settings/incidents' },
+        permission: 'org:settings',
+        label: 'Incident correlation window (hours)',
+        why: 'Analytics tuning only: it decides how long after a deploy an incident is '
+            + 'attributed to that deploy when DORA metrics are computed. It grants nothing, '
+            + 'reveals nothing and reaches no one — the worst outcome of a wrong value is a '
+            + 'misleading change-failure rate, which the next edit corrects. The route '
+            + 'rejects the sibling retention fields outright (they are billing-owned), so '
+            + 'this is the whole writable surface. Bounded integer, so the diff is one number.',
+    },
+    {
+        key: 'complianceNotifications.notifyOnBlock',
+        surface: 'complianceNotifications',
+        field: 'notifyOnBlock',
+        shape: { kind: 'boolean' },
+        api: { method: 'PUT', path: '/compliance/notification-preferences' },
+        permission: 'compliance:write',
+        label: 'Notify when compliance blocks an action',
+        why: 'A delivery preference, not an enforcement control: the block happens either '
+            + 'way and the policy that caused it is unchanged. Turning it off makes the org '
+            + 'quieter, never more permissive.',
+    },
+    {
+        key: 'complianceNotifications.notifyOnWarning',
+        surface: 'complianceNotifications',
+        field: 'notifyOnWarning',
+        shape: { kind: 'boolean' },
+        api: { method: 'PUT', path: '/compliance/notification-preferences' },
+        permission: 'compliance:write',
+        label: 'Notify on compliance warnings',
+        why: 'As notifyOnBlock — which non-blocking findings are announced, not what is enforced.',
+    },
+    {
+        key: 'complianceNotifications.emailEnabled',
+        surface: 'complianceNotifications',
+        field: 'emailEnabled',
+        shape: { kind: 'boolean' },
+        api: { method: 'PUT', path: '/compliance/notification-preferences' },
+        permission: 'compliance:write',
+        label: 'Send compliance notices by email',
+        why: 'Chooses whether the existing notices go out by email. It does not name a '
+            + 'recipient — the address list is resolved from org membership at send time — '
+            + 'so a flipped boolean can never route mail somewhere new.',
+    },
+    {
+        key: 'complianceNotifications.digestMode',
+        surface: 'complianceNotifications',
+        field: 'digestMode',
+        shape: { kind: 'enum', values: DIGEST_MODES },
+        api: { method: 'PUT', path: '/compliance/notification-preferences' },
+        permission: 'compliance:write',
+        label: 'Compliance notice cadence',
+        why: 'Cadence of an existing notice to existing recipients. Closed enum, so the diff is one word.',
+    },
+    {
+        key: 'pluginSecurityNotifications.notifyRescan',
+        surface: 'pluginSecurityNotifications',
+        field: 'notifyRescan',
+        shape: { kind: 'boolean' },
+        api: { method: 'PUT', path: '/plugins/security-notifications' },
+        permission: 'org:settings',
+        label: 'Notify on nightly rescan findings',
+        why: 'Governs the N31 rescan notice only. The scan GATES are untouched: a build that '
+            + 'trips PLUGIN_VULN_GATE still fails and still sends N30, which this flag cannot '
+            + 'suppress. So it changes how noisy an informational notice is, not whether a '
+            + 'vulnerable version can be published.',
+    },
+    {
+        key: 'pluginSecurityNotifications.digestMode',
+        surface: 'pluginSecurityNotifications',
+        field: 'digestMode',
+        shape: { kind: 'enum', values: DIGEST_MODES },
+        api: { method: 'PUT', path: '/plugins/security-notifications' },
+        permission: 'org:settings',
+        label: 'Plugin security notice cadence',
+        why: 'Cadence of the rescan notice. N30 ("version blocked") is always immediate and '
+            + 'ignores this field, so the urgent channel cannot be slowed down.',
+    },
+];
+/**
+ * Fields DELIBERATELY excluded, with the reason, so a future reader does not
+ * re-litigate them and a reviewer can see they were considered rather than
+ * missed. This is documentation only — {@link pickAllowed} consults the
+ * allowlist alone, and a field absent from BOTH lists is refused identically.
+ */
+export const ORG_SETTING_PROPOSAL_EXCLUSIONS = [
+    { field: 'organization.aiConfig', why: 'Step-up gated (PUT /organization/ai-config) and persists per-org provider secrets.' },
+    { field: 'organization.mfaPolicy', why: 'Security control + step-up. Loosening it removes a control for every member.' },
+    { field: 'organization.passwordPolicy', why: 'Security control + step-up.' },
+    { field: 'organization.authenticatorPolicy', why: 'Security control + step-up.' },
+    { field: 'organization.impersonationPolicy', why: 'Security control + step-up; decides who outside the org may view its data.' },
+    { field: 'organization.idp', why: 'SSO/SAML config: security control on its own capability (org:idp), assurance + strong step-up.' },
+    { field: 'organization.kmsConfig', why: 'Key material. Own capability (org:kms), assurance + strong step-up.' },
+    { field: 'organization.identity', why: 'Org name/slug: no step-up, but renaming an org is an impersonation primitive and the slug is addressable.' },
+    { field: 'organization.domains', why: 'Verified domains drive domain-based join — who may become a member.' },
+    { field: 'organization.joinRequests', why: 'Membership decisions are an authority grant, not a setting.' },
+    { field: 'organization.transferOwner', why: 'Ownership transfer: security control, MFA-grade + step-up.' },
+    { field: 'organization.teams', why: 'Team lifecycle (create/delete/move) is structural and step-up gated.' },
+    { field: 'plugins.installPolicy', why: 'Step-up gated (PUT /plugins/install-policy) and decides what may be installed.' },
+    { field: '*.webhookUrl', why: 'A callback target: proposing one turns the platform into an exfiltration channel.' },
+    { field: '*.webhookSecret', why: 'Bearer-equivalent. The API returns hasWebhookSecret, never the value, so it cannot be diffed.' },
+    { field: 'pluginSecurityNotifications.externalEmail', why: 'An address the platform then mails a confirmation link to. Never model-chosen.' },
+    { field: '*.targetUsers', why: 'A list of opaque user ids is not reviewable in a card, and redirecting recipients can silence a channel.' },
+    { field: 'pluginSecurityNotifications.recipientMode', why: 'Pairs with targetUsers; switching to "users" makes an unreviewable list authoritative.' },
+    { field: 'reporting.eventRetentionDays', why: 'Billing-owned (tier + purchased packs). The route already rejects it; admitting it would be an entitlement bypass.' },
+    { field: 'reporting.doraRetentionDays', why: 'Billing-owned, as above.' },
+];
+// -----------------------------------------------------------------------------
+// Lookup
+// -----------------------------------------------------------------------------
+const BY_KEY = new Map(ORG_SETTING_PROPOSAL_ALLOWLIST.map((spec) => [spec.key, spec]));
+/** Every proposable key — the enum a propose tool's input schema is built from. */
+export const ORG_SETTING_PROPOSAL_KEYS = ORG_SETTING_PROPOSAL_ALLOWLIST.map((spec) => spec.key);
+/** Is `key` on the allowlist? */
+export function isProposableOrgSetting(key) {
+    return BY_KEY.has(key);
+}
+/** The spec for `key`, or undefined when it is not proposable. */
+export function orgSettingSpec(key) {
+    return BY_KEY.get(key);
+}
+/** Does `value` match the shape the field declares? */
+export function isValidOrgSettingValue(spec, value) {
+    const shape = spec.shape;
+    if (shape.kind === 'boolean')
+        return typeof value === 'boolean';
+    if (shape.kind === 'integer') {
+        return typeof value === 'number' && Number.isInteger(value) && value >= shape.min && value <= shape.max;
+    }
+    return typeof value === 'string' && shape.values.includes(value);
+}
+/**
+ * Keep only the allowlisted, shape-valid fields of a candidate proposal, and
+ * report everything dropped.
+ *
+ * The result's `allowed` map IS the commit payload (rule 3): the confirm
+ * handler sends these fields and only these, so anything the model slipped in
+ * is structurally unappliable rather than merely unrendered.
+ *
+ * `candidate` is untrusted model output, so it is read defensively: anything
+ * that is not a plain object yields an empty result.
+ */
+export function pickAllowed(candidate) {
+    const allowed = {};
+    const refused = [];
+    const invalid = [];
+    if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
+        for (const [key, value] of Object.entries(candidate)) {
+            const spec = BY_KEY.get(key);
+            if (!spec) {
+                refused.push(key);
+                continue;
+            }
+            if (!isValidOrgSettingValue(spec, value)) {
+                invalid.push(spec.key);
+                continue;
+            }
+            allowed[spec.key] = value;
+        }
+    }
+    return { allowed, refused, invalid, refusedCount: refused.length };
+}
+/**
+ * The changes a proposal actually makes, given the CURRENT values. A field
+ * whose proposed value already equals the current one is dropped — it is not a
+ * change, and rendering it as one makes a diff the user cannot read.
+ *
+ * The confirm handler re-runs this against a FRESH read immediately before
+ * committing (rule 7): these records carry no version column, so if the list
+ * that comes back differs from the one the user approved, state moved under the
+ * proposal and the commit must be refused rather than applied blind.
+ */
+export function diffOrgSettings(current, proposed) {
+    const changes = [];
+    for (const spec of ORG_SETTING_PROPOSAL_ALLOWLIST) {
+        const to = proposed[spec.key];
+        if (to === undefined)
+            continue;
+        const from = current[spec.key];
+        if (from === to)
+            continue;
+        changes.push({ spec, from, to });
+    }
+    return changes;
+}
+/**
+ * Group approved changes into one request per surface, translating proposal
+ * keys back to the field names each API expects. Order follows the allowlist,
+ * so the same proposal always produces the same call sequence.
+ */
+export function orgSettingRequests(changes) {
+    const bySurface = new Map();
+    for (const spec of ORG_SETTING_PROPOSAL_ALLOWLIST) {
+        const change = changes.find((c) => c.spec.key === spec.key);
+        if (!change)
+            continue;
+        const existing = bySurface.get(spec.surface);
+        if (existing) {
+            existing.body[spec.field] = change.to;
+            continue;
+        }
+        bySurface.set(spec.surface, {
+            surface: spec.surface,
+            method: spec.api.method,
+            path: spec.api.path,
+            permission: spec.permission,
+            body: { [spec.field]: change.to },
+        });
+    }
+    return [...bySurface.values()];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ask-proposals.js","sourceRoot":"","sources":["../../src/types/ask-proposals.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The shared contract between the ask agent's PROPOSE tools and the browser's\n * CONFIRM handlers. Two things live here, and they live here because BOTH sides\n * need them: `api/ask` builds its tool schema from this module, the frontend's\n * confirm handler builds its request from it, and the tests of both assert\n * against it. A second copy would be a second policy.\n *\n * Dependency-free on purpose — no runtime imports at all — so the browser can\n * import it through api-core's `./ask-proposals` entry without dragging in the\n * server graph (express / jwt / ioredis). The only imports are `import type`,\n * which the compiler erases.\n *\n * -----------------------------------------------------------------------------\n * 1. PROVENANCE\n * -----------------------------------------------------------------------------\n * Every commit that started life as an agent draft stamps\n * `details: { proposedBy: 'ask-agent' }` onto its audit event. The audit trail\n * is hash-chained and tamper-evident, but without this field it cannot\n * distinguish \"the admin changed this\" from \"an AI drafted it and the admin\n * clicked Apply\" — the two mean very different things in an incident review.\n * The constant exists so the literal is not retyped in two codebases, where a\n * typo would silently produce an unqueryable trail.\n *\n * -----------------------------------------------------------------------------\n * 2. THE ORG-SETTINGS ALLOWLIST\n * -----------------------------------------------------------------------------\n * This is an ALLOWLIST, not a denylist, and the distinction is the whole point:\n * a setting added to the platform tomorrow is UNAVAILABLE to the agent until\n * someone deliberately adds it here, rather than being exposed by omission.\n * If you are reading this because a proposal was refused, the fix is to add the\n * field below WITH its `why` — not to loosen {@link pickAllowed}.\n *\n * A field earns a place here only if all of the following hold. They were\n * checked against the routes, not assumed:\n *\n *  - **No step-up.** A route carrying `requireStepUp` is out, no exceptions.\n *    Step-up means the platform already decided a live session is not enough\n *    authority; a chat proposal is strictly less. This is what keeps\n *    `PUT /organization/ai-config` out (it persists per-org provider SECRETS),\n *    along with the MFA / password / authenticator policies,\n *    `PUT /plugins/install-policy`, org restore and transfer-owner.\n *  - **Not a security control.** MFA / password / authenticator / impersonation\n *    policy, SSO+SAML and its group mappings, verified domains and domain-based\n *    join, join-request decisions, transfer-owner and team lifecycle are ABSENT\n *    here rather than gated within — \"relax the MFA policy\" is precisely what an\n *    injection payload asks for, and it arrives through text the agent already\n *    reads. Absent cannot be argued with; gated can.\n *  - **Carries no secret and no callback target.** An API that returns\n *    `hasWebhookSecret` instead of the secret is telling you the field cannot be\n *    diffed, so it cannot be reviewed, so it cannot be proposed. Webhook URLs\n *    and email addresses are out for the same reason plus one more: they are\n *    exfiltration targets, and a confirmation mail to an attacker-chosen address\n *    is a send the platform performs on the model's say-so.\n *  - **Reviewable as a diff.** A scalar with a closed shape (boolean, bounded\n *    integer, small enum). A list of opaque user ids renders as ids in a card\n *    nobody can check, so recipient LISTS are out even though cadence is in.\n *\n * Each entry names the API that applies it. The browser applies it through the\n * USER's own session and the user's own permissions — the agent never writes —\n * so a proposal a member may not commit simply 403s at the route, exactly as a\n * hand-made request would.\n *\n * Rule 10 lives in {@link pickAllowed}: a candidate carrying a field outside\n * this list is the injection signal, so the refused names come back to the\n * caller to be counted and logged rather than being quietly dropped.\n */\n\nimport type { Permission } from './permissions.js';\nimport type { PluginSecurityDigestMode } from './wire-vocabulary.js';\n\n// -----------------------------------------------------------------------------\n// Provenance (rule 6)\n// -----------------------------------------------------------------------------\n\n/** The `proposedBy` value every agent-drafted commit records. */\nexport const ASK_AGENT_PROPOSER = 'ask-agent';\n\n/** The audit `details` key that carries provenance. */\nexport const PROPOSED_BY_DETAIL_KEY = 'proposedBy';\n\n/** The provenance fragment merged into a `RemoteAuditEvent.details`. */\nexport interface AskProposalProvenance {\n  readonly proposedBy: typeof ASK_AGENT_PROPOSER;\n}\n\n/**\n * Merge agent provenance into an audit event's free-form `details`.\n * Provenance is applied LAST so a caller-supplied `proposedBy` cannot overwrite\n * it — the point of the field is that it is not negotiable.\n */\nexport function askProposalAuditDetails(\n  details?: Readonly<Record<string, unknown>>,\n): Record<string, unknown> & AskProposalProvenance {\n  return { ...details, proposedBy: ASK_AGENT_PROPOSER };\n}\n\n/**\n * The request HEADER a proposal commit stamps, and the only channel provenance\n * travels on.\n *\n * A HEADER rather than a body field, for three reasons:\n *\n *  - **It cannot collide.** `proposedBy` in a body would be a new key in six\n *    different domain schemas — `PipelineUpdateSchema`, the plugin/template\n *    update schemas, three notification/settings schemas — two of which are\n *    `.strict()` and the rest of which feed `Object.keys(body)` straight into\n *    the update's column list and the audit's `fields`. A field named after an\n *    audit key would then be indistinguishable from a real one, and the day a\n *    domain grows its own `proposedBy` the two meanings merge silently.\n *  - **It is transport metadata, and stays out of the payload.** Nothing\n *    downstream of `validateBody` ever sees it, so it cannot be persisted, cannot\n *    widen a diff, and cannot reach a service that forwards the body onward.\n *  - **The platform already does this.** `X-Step-Up-Token` is the same shape of\n *    thing — a per-request assertion about HOW the call was made rather than\n *    WHAT it changes — and rides a header for the same reasons.\n *\n * Lower-case because that is how Node normalises incoming header names; the\n * browser sends `X-PB-Proposed-By`, which arrives here.\n */\nexport const ASK_PROPOSED_BY_HEADER = 'x-pb-proposed-by';\n\n/**\n * What a request's provenance header claims.\n *\n * `foreign` is any value that is not EXACTLY {@link ASK_AGENT_PROPOSER} — there\n * is one legitimate proposer and no free-form text, so anything else is a bug\n * or a forgery and is named as such rather than folded into `none`.\n */\nexport type ProposerClaim = 'none' | 'ask-agent' | 'foreign';\n\n/**\n * Read the provenance claim off a request's header bag.\n *\n * Deliberately exact: no trimming, no case folding, no prefix matching. The\n * only sender is the browser's confirm path, which stamps the shared constant,\n * so every other value is refused rather than repaired. This is what keeps a\n * client from writing arbitrary audit `details` — the header's whole vocabulary\n * is one word, and the word is not the client's to choose.\n *\n * Takes the header BAG (`req.headers`) rather than a request, so this module\n * keeps its zero runtime imports and the browser can still import the constant.\n */\nexport function readProposerClaim(headers: unknown): ProposerClaim {\n  const bag = headers as Record<string, unknown> | null | undefined;\n  const raw = bag && typeof bag === 'object' ? bag[ASK_PROPOSED_BY_HEADER] : undefined;\n  const value = Array.isArray(raw) ? raw[0] : raw;\n  if (value === undefined || value === null || value === '') return 'none';\n  return value === ASK_AGENT_PROPOSER ? 'ask-agent' : 'foreign';\n}\n\n/**\n * The audit `details` for a write, with provenance folded in when — and ONLY\n * when — the request carries the agent marker.\n *\n * `details` is what the HANDLER built and stays authoritative. Provenance is\n * additive: the ONLY key it can ever write is `proposedBy`, so every field the\n * handler set survives untouched, and {@link askProposalAuditDetails} applies\n * that one key LAST so a `proposedBy` arriving from anywhere else cannot speak\n * in its place. A request carrying no marker, or a `foreign` one, gets the\n * handler's details unchanged — an ordinary edit records no `proposedBy` at\n * all, which is the distinction the field exists to make.\n */\nexport function withProposalProvenance(\n  headers: unknown,\n  details?: Readonly<Record<string, unknown>>,\n): Record<string, unknown> {\n  return readProposerClaim(headers) === 'ask-agent'\n    ? askProposalAuditDetails(details)\n    : { ...details };\n}\n\n// -----------------------------------------------------------------------------\n// The allowlist\n// -----------------------------------------------------------------------------\n\n/** A value an allowlisted org setting can hold. */\nexport type OrgSettingValue = string | number | boolean;\n\n/** Which per-org record (and therefore which API) a field belongs to. */\nexport type OrgSettingSurface =\n  | 'reporting'\n  | 'complianceNotifications'\n  | 'pluginSecurityNotifications';\n\n/**\n * Every proposable setting, as `<surface>.<field>`. Writing the union out by\n * hand (rather than inferring it from the array) is deliberate: the key space\n * is the contract the tool schema and the confirm handler share, so it is\n * stated once, explicitly, and a typo in an entry below is a compile error.\n */\nexport type OrgSettingKey =\n  | 'reporting.incidentWindowHours'\n  | 'complianceNotifications.notifyOnBlock'\n  | 'complianceNotifications.notifyOnWarning'\n  | 'complianceNotifications.emailEnabled'\n  | 'complianceNotifications.digestMode'\n  | 'pluginSecurityNotifications.notifyRescan'\n  | 'pluginSecurityNotifications.digestMode';\n\n/** The closed shape a proposed value must match before it is accepted. */\nexport type OrgSettingShape =\n  | { readonly kind: 'boolean' }\n  | { readonly kind: 'integer'; readonly min: number; readonly max: number }\n  | { readonly kind: 'enum'; readonly values: readonly string[] };\n\n/** One proposable org setting. */\nexport interface OrgSettingSpec {\n  /** Stable proposal key — `<surface>.<field>`. This is what the model names. */\n  readonly key: OrgSettingKey;\n  readonly surface: OrgSettingSurface;\n  /** The request-body field name the API expects. */\n  readonly field: string;\n  readonly shape: OrgSettingShape;\n  /** The route that applies it, called by the BROWSER with the user's session. */\n  readonly api: { readonly method: 'PUT'; readonly path: string };\n  /** The permission that route requires of the caller. */\n  readonly permission: Permission;\n  /** Short human label for the confirm card. */\n  readonly label: string;\n  /** WHY this field is safe to propose. Every entry states its own case. */\n  readonly why: string;\n}\n\n/**\n * The `digestMode` vocabulary is MIRRORED, not imported: this module keeps zero\n * runtime imports so the browser entry stays standalone. The type annotation\n * makes a REMOVED mode a compile error here, and `ask-proposals.test.ts` asserts\n * the list against `PLUGIN_SECURITY_DIGEST_MODES` so an ADDED one cannot drift\n * either.\n */\nconst DIGEST_MODES: readonly PluginSecurityDigestMode[] = ['immediate', 'daily', 'weekly'];\n\n/**\n * The allowlist. Adding an entry is a deliberate act: name the route you\n * checked, confirm it carries no `requireStepUp`, and write the `why`.\n */\nexport const ORG_SETTING_PROPOSAL_ALLOWLIST: readonly OrgSettingSpec[] = [\n  {\n    key: 'reporting.incidentWindowHours',\n    surface: 'reporting',\n    field: 'incidentWindowHours',\n    shape: { kind: 'integer', min: 1, max: 720 },\n    api: { method: 'PUT', path: '/reports/settings/incidents' },\n    permission: 'org:settings',\n    label: 'Incident correlation window (hours)',\n    why:\n      'Analytics tuning only: it decides how long after a deploy an incident is '\n      + 'attributed to that deploy when DORA metrics are computed. It grants nothing, '\n      + 'reveals nothing and reaches no one — the worst outcome of a wrong value is a '\n      + 'misleading change-failure rate, which the next edit corrects. The route '\n      + 'rejects the sibling retention fields outright (they are billing-owned), so '\n      + 'this is the whole writable surface. Bounded integer, so the diff is one number.',\n  },\n  {\n    key: 'complianceNotifications.notifyOnBlock',\n    surface: 'complianceNotifications',\n    field: 'notifyOnBlock',\n    shape: { kind: 'boolean' },\n    api: { method: 'PUT', path: '/compliance/notification-preferences' },\n    permission: 'compliance:write',\n    label: 'Notify when compliance blocks an action',\n    why:\n      'A delivery preference, not an enforcement control: the block happens either '\n      + 'way and the policy that caused it is unchanged. Turning it off makes the org '\n      + 'quieter, never more permissive.',\n  },\n  {\n    key: 'complianceNotifications.notifyOnWarning',\n    surface: 'complianceNotifications',\n    field: 'notifyOnWarning',\n    shape: { kind: 'boolean' },\n    api: { method: 'PUT', path: '/compliance/notification-preferences' },\n    permission: 'compliance:write',\n    label: 'Notify on compliance warnings',\n    why: 'As notifyOnBlock — which non-blocking findings are announced, not what is enforced.',\n  },\n  {\n    key: 'complianceNotifications.emailEnabled',\n    surface: 'complianceNotifications',\n    field: 'emailEnabled',\n    shape: { kind: 'boolean' },\n    api: { method: 'PUT', path: '/compliance/notification-preferences' },\n    permission: 'compliance:write',\n    label: 'Send compliance notices by email',\n    why:\n      'Chooses whether the existing notices go out by email. It does not name a '\n      + 'recipient — the address list is resolved from org membership at send time — '\n      + 'so a flipped boolean can never route mail somewhere new.',\n  },\n  {\n    key: 'complianceNotifications.digestMode',\n    surface: 'complianceNotifications',\n    field: 'digestMode',\n    shape: { kind: 'enum', values: DIGEST_MODES },\n    api: { method: 'PUT', path: '/compliance/notification-preferences' },\n    permission: 'compliance:write',\n    label: 'Compliance notice cadence',\n    why: 'Cadence of an existing notice to existing recipients. Closed enum, so the diff is one word.',\n  },\n  {\n    key: 'pluginSecurityNotifications.notifyRescan',\n    surface: 'pluginSecurityNotifications',\n    field: 'notifyRescan',\n    shape: { kind: 'boolean' },\n    api: { method: 'PUT', path: '/plugins/security-notifications' },\n    permission: 'org:settings',\n    label: 'Notify on nightly rescan findings',\n    why:\n      'Governs the N31 rescan notice only. The scan GATES are untouched: a build that '\n      + 'trips PLUGIN_VULN_GATE still fails and still sends N30, which this flag cannot '\n      + 'suppress. So it changes how noisy an informational notice is, not whether a '\n      + 'vulnerable version can be published.',\n  },\n  {\n    key: 'pluginSecurityNotifications.digestMode',\n    surface: 'pluginSecurityNotifications',\n    field: 'digestMode',\n    shape: { kind: 'enum', values: DIGEST_MODES },\n    api: { method: 'PUT', path: '/plugins/security-notifications' },\n    permission: 'org:settings',\n    label: 'Plugin security notice cadence',\n    why:\n      'Cadence of the rescan notice. N30 (\"version blocked\") is always immediate and '\n      + 'ignores this field, so the urgent channel cannot be slowed down.',\n  },\n];\n\n/**\n * Fields DELIBERATELY excluded, with the reason, so a future reader does not\n * re-litigate them and a reviewer can see they were considered rather than\n * missed. This is documentation only — {@link pickAllowed} consults the\n * allowlist alone, and a field absent from BOTH lists is refused identically.\n */\nexport const ORG_SETTING_PROPOSAL_EXCLUSIONS: ReadonlyArray<{ readonly field: string; readonly why: string }> = [\n  { field: 'organization.aiConfig', why: 'Step-up gated (PUT /organization/ai-config) and persists per-org provider secrets.' },\n  { field: 'organization.mfaPolicy', why: 'Security control + step-up. Loosening it removes a control for every member.' },\n  { field: 'organization.passwordPolicy', why: 'Security control + step-up.' },\n  { field: 'organization.authenticatorPolicy', why: 'Security control + step-up.' },\n  { field: 'organization.impersonationPolicy', why: 'Security control + step-up; decides who outside the org may view its data.' },\n  { field: 'organization.idp', why: 'SSO/SAML config: security control on its own capability (org:idp), assurance + strong step-up.' },\n  { field: 'organization.kmsConfig', why: 'Key material. Own capability (org:kms), assurance + strong step-up.' },\n  { field: 'organization.identity', why: 'Org name/slug: no step-up, but renaming an org is an impersonation primitive and the slug is addressable.' },\n  { field: 'organization.domains', why: 'Verified domains drive domain-based join — who may become a member.' },\n  { field: 'organization.joinRequests', why: 'Membership decisions are an authority grant, not a setting.' },\n  { field: 'organization.transferOwner', why: 'Ownership transfer: security control, MFA-grade + step-up.' },\n  { field: 'organization.teams', why: 'Team lifecycle (create/delete/move) is structural and step-up gated.' },\n  { field: 'plugins.installPolicy', why: 'Step-up gated (PUT /plugins/install-policy) and decides what may be installed.' },\n  { field: '*.webhookUrl', why: 'A callback target: proposing one turns the platform into an exfiltration channel.' },\n  { field: '*.webhookSecret', why: 'Bearer-equivalent. The API returns hasWebhookSecret, never the value, so it cannot be diffed.' },\n  { field: 'pluginSecurityNotifications.externalEmail', why: 'An address the platform then mails a confirmation link to. Never model-chosen.' },\n  { field: '*.targetUsers', why: 'A list of opaque user ids is not reviewable in a card, and redirecting recipients can silence a channel.' },\n  { field: 'pluginSecurityNotifications.recipientMode', why: 'Pairs with targetUsers; switching to \"users\" makes an unreviewable list authoritative.' },\n  { field: 'reporting.eventRetentionDays', why: 'Billing-owned (tier + purchased packs). The route already rejects it; admitting it would be an entitlement bypass.' },\n  { field: 'reporting.doraRetentionDays', why: 'Billing-owned, as above.' },\n];\n\n// -----------------------------------------------------------------------------\n// Lookup\n// -----------------------------------------------------------------------------\n\nconst BY_KEY: ReadonlyMap<string, OrgSettingSpec> =\n  new Map(ORG_SETTING_PROPOSAL_ALLOWLIST.map((spec) => [spec.key, spec]));\n\n/** Every proposable key — the enum a propose tool's input schema is built from. */\nexport const ORG_SETTING_PROPOSAL_KEYS: readonly OrgSettingKey[] =\n  ORG_SETTING_PROPOSAL_ALLOWLIST.map((spec) => spec.key);\n\n/** Is `key` on the allowlist? */\nexport function isProposableOrgSetting(key: string): key is OrgSettingKey {\n  return BY_KEY.has(key);\n}\n\n/** The spec for `key`, or undefined when it is not proposable. */\nexport function orgSettingSpec(key: string): OrgSettingSpec | undefined {\n  return BY_KEY.get(key);\n}\n\n/** Does `value` match the shape the field declares? */\nexport function isValidOrgSettingValue(spec: OrgSettingSpec, value: unknown): value is OrgSettingValue {\n  const shape = spec.shape;\n  if (shape.kind === 'boolean') return typeof value === 'boolean';\n  if (shape.kind === 'integer') {\n    return typeof value === 'number' && Number.isInteger(value) && value >= shape.min && value <= shape.max;\n  }\n  return typeof value === 'string' && shape.values.includes(value);\n}\n\n// -----------------------------------------------------------------------------\n// pickAllowed (rules 1, 3 and 10)\n// -----------------------------------------------------------------------------\n\n/** A proposal's settings, keyed by allowlist key. */\nexport type OrgSettingPatch = Partial<Record<OrgSettingKey, OrgSettingValue>>;\n\n/** What {@link pickAllowed} kept, and what it threw away. */\nexport interface PickAllowedResult {\n  /** The allowlisted, shape-valid settings. */\n  readonly allowed: OrgSettingPatch;\n  /**\n   * Field names the candidate carried that are NOT on the allowlist. THIS is\n   * the injection signal (rule 10): a legitimate draft has none, so a non-empty\n   * list is a counter to increment and a line to log, not a silent drop.\n   */\n  readonly refused: readonly string[];\n  /**\n   * Allowlisted keys whose value did not match the declared shape. Dropped too,\n   * but reported separately — a bad value is a drafting mistake, not an attempt\n   * to reach a field the agent was never given.\n   */\n  readonly invalid: readonly OrgSettingKey[];\n  /** `refused.length`, so a caller can count without re-deriving it. */\n  readonly refusedCount: number;\n}\n\n/**\n * Keep only the allowlisted, shape-valid fields of a candidate proposal, and\n * report everything dropped.\n *\n * The result's `allowed` map IS the commit payload (rule 3): the confirm\n * handler sends these fields and only these, so anything the model slipped in\n * is structurally unappliable rather than merely unrendered.\n *\n * `candidate` is untrusted model output, so it is read defensively: anything\n * that is not a plain object yields an empty result.\n */\nexport function pickAllowed(candidate: unknown): PickAllowedResult {\n  const allowed: OrgSettingPatch = {};\n  const refused: string[] = [];\n  const invalid: OrgSettingKey[] = [];\n\n  if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {\n    for (const [key, value] of Object.entries(candidate as Record<string, unknown>)) {\n      const spec = BY_KEY.get(key);\n      if (!spec) { refused.push(key); continue; }\n      if (!isValidOrgSettingValue(spec, value)) { invalid.push(spec.key); continue; }\n      allowed[spec.key] = value;\n    }\n  }\n\n  return { allowed, refused, invalid, refusedCount: refused.length };\n}\n\n// -----------------------------------------------------------------------------\n// Diff + request planning (rules 3 and 7)\n// -----------------------------------------------------------------------------\n\n/** One reviewed change: what the setting is now, and what it would become. */\nexport interface OrgSettingChange {\n  readonly spec: OrgSettingSpec;\n  readonly from: OrgSettingValue | undefined;\n  readonly to: OrgSettingValue;\n}\n\n/**\n * The changes a proposal actually makes, given the CURRENT values. A field\n * whose proposed value already equals the current one is dropped — it is not a\n * change, and rendering it as one makes a diff the user cannot read.\n *\n * The confirm handler re-runs this against a FRESH read immediately before\n * committing (rule 7): these records carry no version column, so if the list\n * that comes back differs from the one the user approved, state moved under the\n * proposal and the commit must be refused rather than applied blind.\n */\nexport function diffOrgSettings(\n  current: Readonly<OrgSettingPatch>,\n  proposed: Readonly<OrgSettingPatch>,\n): readonly OrgSettingChange[] {\n  const changes: OrgSettingChange[] = [];\n  for (const spec of ORG_SETTING_PROPOSAL_ALLOWLIST) {\n    const to = proposed[spec.key];\n    if (to === undefined) continue;\n    const from = current[spec.key];\n    if (from === to) continue;\n    changes.push({ spec, from, to });\n  }\n  return changes;\n}\n\n/** One API call the confirm handler makes: one surface, one body. */\nexport interface OrgSettingRequest {\n  readonly surface: OrgSettingSurface;\n  readonly method: 'PUT';\n  readonly path: string;\n  readonly permission: Permission;\n  /** Request body: the API's own field names, carrying only reviewed values. */\n  readonly body: Record<string, OrgSettingValue>;\n}\n\n/**\n * Group approved changes into one request per surface, translating proposal\n * keys back to the field names each API expects. Order follows the allowlist,\n * so the same proposal always produces the same call sequence.\n */\nexport function orgSettingRequests(changes: readonly OrgSettingChange[]): readonly OrgSettingRequest[] {\n  const bySurface = new Map<OrgSettingSurface, OrgSettingRequest>();\n  for (const spec of ORG_SETTING_PROPOSAL_ALLOWLIST) {\n    const change = changes.find((c) => c.spec.key === spec.key);\n    if (!change) continue;\n    const existing = bySurface.get(spec.surface);\n    if (existing) {\n      existing.body[spec.field] = change.to;\n      continue;\n    }\n    bySurface.set(spec.surface, {\n      surface: spec.surface,\n      method: spec.api.method,\n      path: spec.api.path,\n      permission: spec.permission,\n      body: { [spec.field]: change.to },\n    });\n  }\n  return [...bySurface.values()];\n}\n"]}

package/lib/types/compliance-exemption.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The `POST /compliance/exemptions` request body.
+ *
+ * It lives here because it crosses a SERVICE boundary: the Ask agent drafts one
+ * (`api/ask` — a proposal the user reviews and commits through their own
+ * session) and the compliance service inserts it (`api/compliance`). Each side
+ * had its own six-field declaration, so a field added on one side was invisible
+ * to the other until a request failed validation at runtime.
+ */
+/** A request to waive one compliance rule for one entity. */
+export interface ComplianceExemptionRequest {
+    /** The rule being waived. */
+    ruleId: string;
+    /** Which kind of entity the waiver covers. */
+    entityType: 'plugin' | 'pipeline';
+    /** The entity the waiver applies to. */
+    entityId: string;
+    /** Display label for the entity, for the review queue and the audit trail. */
+    entityName?: string;
+    /** Why the waiver is being asked for; shown to the approver. */
+    reason: string;
+    /** ISO-8601 expiry. Omitted means the waiver does not self-expire. */
+    expiresAt?: string;
+}

package/lib/types/compliance-exemption.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGxpYW5jZS1leGVtcHRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvY29tcGxpYW5jZS1leGVtcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFRoZSBgUE9TVCAvY29tcGxpYW5jZS9leGVtcHRpb25zYCByZXF1ZXN0IGJvZHkuXG4gKlxuICogSXQgbGl2ZXMgaGVyZSBiZWNhdXNlIGl0IGNyb3NzZXMgYSBTRVJWSUNFIGJvdW5kYXJ5OiB0aGUgQXNrIGFnZW50IGRyYWZ0cyBvbmVcbiAqIChgYXBpL2Fza2Ag4oCUIGEgcHJvcG9zYWwgdGhlIHVzZXIgcmV2aWV3cyBhbmQgY29tbWl0cyB0aHJvdWdoIHRoZWlyIG93blxuICogc2Vzc2lvbikgYW5kIHRoZSBjb21wbGlhbmNlIHNlcnZpY2UgaW5zZXJ0cyBpdCAoYGFwaS9jb21wbGlhbmNlYCkuIEVhY2ggc2lkZVxuICogaGFkIGl0cyBvd24gc2l4LWZpZWxkIGRlY2xhcmF0aW9uLCBzbyBhIGZpZWxkIGFkZGVkIG9uIG9uZSBzaWRlIHdhcyBpbnZpc2libGVcbiAqIHRvIHRoZSBvdGhlciB1bnRpbCBhIHJlcXVlc3QgZmFpbGVkIHZhbGlkYXRpb24gYXQgcnVudGltZS5cbiAqL1xuXG4vKiogQSByZXF1ZXN0IHRvIHdhaXZlIG9uZSBjb21wbGlhbmNlIHJ1bGUgZm9yIG9uZSBlbnRpdHkuICovXG5leHBvcnQgaW50ZXJmYWNlIENvbXBsaWFuY2VFeGVtcHRpb25SZXF1ZXN0IHtcbiAgLyoqIFRoZSBydWxlIGJlaW5nIHdhaXZlZC4gKi9cbiAgcnVsZUlkOiBzdHJpbmc7XG4gIC8qKiBXaGljaCBraW5kIG9mIGVudGl0eSB0aGUgd2FpdmVyIGNvdmVycy4gKi9cbiAgZW50aXR5VHlwZTogJ3BsdWdpbicgfCAncGlwZWxpbmUnO1xuICAvKiogVGhlIGVudGl0eSB0aGUgd2FpdmVyIGFwcGxpZXMgdG8uICovXG4gIGVudGl0eUlkOiBzdHJpbmc7XG4gIC8qKiBEaXNwbGF5IGxhYmVsIGZvciB0aGUgZW50aXR5LCBmb3IgdGhlIHJldmlldyBxdWV1ZSBhbmQgdGhlIGF1ZGl0IHRyYWlsLiAqL1xuICBlbnRpdHlOYW1lPzogc3RyaW5nO1xuICAvKiogV2h5IHRoZSB3YWl2ZXIgaXMgYmVpbmcgYXNrZWQgZm9yOyBzaG93biB0byB0aGUgYXBwcm92ZXIuICovXG4gIHJlYXNvbjogc3RyaW5nO1xuICAvKiogSVNPLTg2MDEgZXhwaXJ5LiBPbWl0dGVkIG1lYW5zIHRoZSB3YWl2ZXIgZG9lcyBub3Qgc2VsZi1leHBpcmUuICovXG4gIGV4cGlyZXNBdD86IHN0cmluZztcbn1cbiJdfQ==

package/lib/types/index.d.ts

@@ -5,6 +5,7 @@ export { type Lifecycle, type Criticality, type OwnerType, type EntityLink, type
 export { type TemplateInput, } from './pipeline-template.js';
 export * from './visibility.js';
 export * from './wire-vocabulary.js';
+export { type ComplianceExemptionRequest } from './compliance-exemption.js';
 export { PLUGIN_SUMMARY_MAX, PLUGIN_README_MAX_BYTES, PLUGIN_CHANGELOG_MAX_BYTES, PLUGIN_CATEGORIES, type PluginCatalogCategory, PLUGIN_CATALOG_FIELDS, type PluginCatalogField, PLUGIN_CATALOG_LINK_FIELDS, METADATA_SOURCES, type MetadataSource, type MetadataSources, } from './plugin-catalog.js';
 export { type HttpRequest, } from './http.js';
 export { tierAllowsTeams, isBillingEnabled, isValidTier, getTierLimits, type QuotaTier, type QuotaTierLimits, QUOTA_TIERS, VALID_TIERS, STANDARD_TIERS, TEAM_CAPABLE_TIERS, DEFAULT_TIER, QUOTA_RESET_DAYS, nextQuotaResetDate, } from './quota-tiers.js';
@@ -12,7 +13,9 @@ export * from './feature-flags.js';
 export { permissionLabel, isValidPermission, isSystemOrgOnlyPermission, isOrgAssignablePermission, normalizePermissionSubset, intersectPermissions, resolveUserPermissions, confinePermissionsToOrg, hasPermission, type Permission, ALL_PERMISSIONS, PERMISSION_GATES, PERMISSION_CATALOG, SUPERADMIN_ONLY_PERMISSIONS, SYSTEM_ORG_ONLY_PERMISSIONS, ORG_ASSIGNABLE_PERMISSIONS, ORG_ASSIGNABLE_CATEGORIES, READ_ONLY_PERMISSIONS, ROLE_PERMISSIONS, ECOSYSTEM_MANAGER_PERMISSIONS, } from './permissions.js';
 export { METADATA_KEY_CATALOG, MetadataKeys, type MetadataKey, type MetadataKeyOption, METADATA_KEY_GROUPS, } from './metadata-keys.js';
 export { type AuditEvent, } from './audit-events.js';
+export { REMOTE_AUDIT_ACTIONS, isRemoteAuditAction, type RemoteAuditAction, } from './remote-audit-actions.js';
+export { ASK_AGENT_PROPOSER, ASK_PROPOSED_BY_HEADER, PROPOSED_BY_DETAIL_KEY, askProposalAuditDetails, readProposerClaim, withProposalProvenance, ORG_SETTING_PROPOSAL_ALLOWLIST, ORG_SETTING_PROPOSAL_EXCLUSIONS, ORG_SETTING_PROPOSAL_KEYS, isProposableOrgSetting, isValidOrgSettingValue, orgSettingSpec, pickAllowed, diffOrgSettings, orgSettingRequests, type AskProposalProvenance, type ProposerClaim, type OrgSettingChange, type OrgSettingKey, type OrgSettingPatch, type OrgSettingRequest, type OrgSettingShape, type OrgSettingSpec, type OrgSettingSurface, type OrgSettingValue, type PickAllowedResult, } from './ask-proposals.js';
 export { isEcosystemNotificationEvent, parseEcosystemNotifyRequest, nextEcosystemDigestTime, renderEcosystemManagerChange, renderEcosystemDigest, type EcosystemNotificationEventId, type EcosystemNotificationChannel, ECOSYSTEM_EMAIL_PREFERENCE_FIELDS, type EcosystemEmailPreferenceField, ECOSYSTEM_EMAIL_PREFERENCE_FIELD_NAMES, ECOSYSTEM_NOTIFICATION_EVENTS, type EcosystemRecipientSpec, type EcosystemNotifyRequest, } from './ecosystem-notifications.js';
 export { publisherTermsVersion, publisherHandleProblem, isOfficialAutoApprovalEnabled, isPluginPublishingEnabled, isAnonymousSubmissionsEnabled, isPluginReviewsEnabled, OFFICIAL_CATALOG_LOADER_ACCOUNT, DEFAULT_PUBLISHER_TERMS_VERSION, BUILTIN_RESERVED_HANDLES, TENANT_REQUEST_KINDS, PUBLISH_PERMISSION_REQUEST_KINDS, VERIFY_REQUEST_KINDS, STEP_UP_REQUEST_KINDS, REQUEST_SLA_HOURS, } from './ecosystem.js';
-export { ageScore, vulnScore, computeHealthScore, publisherHealthScore, publisherSuccessRate, healthBand, HEALTH_COMPONENTS, HEALTH_WEIGHTS, type HealthBreakdown, type HealthResult, type HealthInputs, type HealthBand, } from './plugin-health.js';
-export { asScanFlag, blockOnNewCritical, describeFindings, describeFix, exceedsVulnFloor, pluginVulnMaxCritical, SCAN_FLAG_TOP_FINDINGS, VULN_FLAGGED_WARNING, vulnBlockedMessage, vulnFlaggedMessage, vulnFlaggedWarning, type PluginScanFinding, type PluginScanFlag, type VulnFlaggedWarning, } from './plugin-scan.js';
+export { ageScore, vulnScore, computeHealthScore, publisherHealthScore, publisherSuccessRate, healthBand, HEALTH_COMPONENTS, HEALTH_WEIGHTS, type HealthBreakdown, type HealthComponentScore, type HealthResult, type HealthInputs, type HealthBand, } from './plugin-health.js';
+export { asScanFlag, blockOnNewCritical, describeFindings, describeFix, exceedsVulnFloor, pluginVulnMaxCritical, SCAN_FLAG_TOP_FINDINGS, vulnBlockedMessage, vulnFlaggedMessage, vulnFlaggedWarning, type PluginScanFinding, type PluginScanFlag, type VulnFlaggedWarning, } from './plugin-scan.js';

package/lib/types/index.js

@@ -7,6 +7,7 @@ export {} from './catalog-metadata.js';
 export {} from './pipeline-template.js';
 export * from './visibility.js';
 export * from './wire-vocabulary.js';
+export {} from './compliance-exemption.js';
 export { PLUGIN_SUMMARY_MAX, PLUGIN_README_MAX_BYTES, PLUGIN_CHANGELOG_MAX_BYTES, PLUGIN_CATEGORIES, PLUGIN_CATALOG_FIELDS, PLUGIN_CATALOG_LINK_FIELDS, METADATA_SOURCES, } from './plugin-catalog.js';
 export {} from './http.js';
 export { tierAllowsTeams, isBillingEnabled, isValidTier, getTierLimits, QUOTA_TIERS, VALID_TIERS, STANDARD_TIERS, TEAM_CAPABLE_TIERS, DEFAULT_TIER, QUOTA_RESET_DAYS, nextQuotaResetDate, } from './quota-tiers.js';
@@ -14,8 +15,10 @@ export * from './feature-flags.js';
 export { permissionLabel, isValidPermission, isSystemOrgOnlyPermission, isOrgAssignablePermission, normalizePermissionSubset, intersectPermissions, resolveUserPermissions, confinePermissionsToOrg, hasPermission, ALL_PERMISSIONS, PERMISSION_GATES, PERMISSION_CATALOG, SUPERADMIN_ONLY_PERMISSIONS, SYSTEM_ORG_ONLY_PERMISSIONS, ORG_ASSIGNABLE_PERMISSIONS, ORG_ASSIGNABLE_CATEGORIES, READ_ONLY_PERMISSIONS, ROLE_PERMISSIONS, ECOSYSTEM_MANAGER_PERMISSIONS, } from './permissions.js';
 export { METADATA_KEY_CATALOG, MetadataKeys, METADATA_KEY_GROUPS, } from './metadata-keys.js';
 export {} from './audit-events.js';
+export { REMOTE_AUDIT_ACTIONS, isRemoteAuditAction, } from './remote-audit-actions.js';
+export { ASK_AGENT_PROPOSER, ASK_PROPOSED_BY_HEADER, PROPOSED_BY_DETAIL_KEY, askProposalAuditDetails, readProposerClaim, withProposalProvenance, ORG_SETTING_PROPOSAL_ALLOWLIST, ORG_SETTING_PROPOSAL_EXCLUSIONS, ORG_SETTING_PROPOSAL_KEYS, isProposableOrgSetting, isValidOrgSettingValue, orgSettingSpec, pickAllowed, diffOrgSettings, orgSettingRequests, } from './ask-proposals.js';
 export { isEcosystemNotificationEvent, parseEcosystemNotifyRequest, nextEcosystemDigestTime, renderEcosystemManagerChange, renderEcosystemDigest, ECOSYSTEM_EMAIL_PREFERENCE_FIELDS, ECOSYSTEM_EMAIL_PREFERENCE_FIELD_NAMES, ECOSYSTEM_NOTIFICATION_EVENTS, } from './ecosystem-notifications.js';
 export { publisherTermsVersion, publisherHandleProblem, isOfficialAutoApprovalEnabled, isPluginPublishingEnabled, isAnonymousSubmissionsEnabled, isPluginReviewsEnabled, OFFICIAL_CATALOG_LOADER_ACCOUNT, DEFAULT_PUBLISHER_TERMS_VERSION, BUILTIN_RESERVED_HANDLES, TENANT_REQUEST_KINDS, PUBLISH_PERMISSION_REQUEST_KINDS, VERIFY_REQUEST_KINDS, STEP_UP_REQUEST_KINDS, REQUEST_SLA_HOURS, } from './ecosystem.js';
 export { ageScore, vulnScore, computeHealthScore, publisherHealthScore, publisherSuccessRate, healthBand, HEALTH_COMPONENTS, HEALTH_WEIGHTS, } from './plugin-health.js';
-export { asScanFlag, blockOnNewCritical, describeFindings, describeFix, exceedsVulnFloor, pluginVulnMaxCritical, SCAN_FLAG_TOP_FINDINGS, VULN_FLAGGED_WARNING, vulnBlockedMessage, vulnFlaggedMessage, vulnFlaggedWarning, } from './plugin-scan.js';
-//# sourceMappingURL=data:application/json;base64,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
+export { asScanFlag, blockOnNewCritical, describeFindings, describeFix, exceedsVulnFloor, pluginVulnMaxCritical, SCAN_FLAG_TOP_FINDINGS, vulnBlockedMessage, vulnFlaggedMessage, vulnFlaggedWarning, } from './plugin-scan.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EACL,gBAAgB,EAEhB,YAAY,EAMZ,iBAAiB,GAMlB,MAAM,aAAa,CAAC;AACrB,cAAc,eAAe,CAAC;AAC9B,OAAO,EAMN,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEN,MAAM,wBAAwB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAmC,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,EAC1B,iBAAiB,EAEjB,qBAAqB,EAErB,0BAA0B,EAC1B,gBAAgB,GAGjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEN,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,aAAa,EAGb,WAAW,EACX,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EAEb,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,2BAA2B,EAC3B,2BAA2B,EAC3B,0BAA0B,EAC1B,yBAAyB,EACzB,qBAAqB,EACrB,gBAAgB,EAChB,6BAA6B,GAC9B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,YAAY,EAGZ,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAEN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,oBAAoB,EACpB,mBAAmB,GAEpB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,8BAA8B,EAC9B,+BAA+B,EAC/B,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,cAAc,EACd,WAAW,EACX,eAAe,EACf,kBAAkB,GAYnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,4BAA4B,EAC5B,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,EAC5B,qBAAqB,EAGrB,iCAAiC,EAEjC,sCAAsC,EACtC,6BAA6B,GAG9B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,6BAA6B,EAC7B,yBAAyB,EACzB,6BAA6B,EAC7B,sBAAsB,EACtB,+BAA+B,EAC/B,+BAA+B,EAC/B,wBAAwB,EACxB,oBAAoB,EACpB,gCAAgC,EAChC,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,QAAQ,EACR,SAAS,EACT,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,UAAU,EACV,iBAAiB,EACjB,cAAc,GAMf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,GAInB,MAAM,kBAAkB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport { ErrorCode, getStatusForErrorCode } from './error-codes.js';\nexport {\n  isValidQuotaType,\n  type TokenScope,\n  TOKEN_SCOPES,\n  type PrincipalType,\n  type TokenUse,\n  type AuthMethod,\n  type AssuranceLevel,\n  type QuotaType,\n  VALID_QUOTA_TYPES,\n  type QuotaCheckResult,\n  type QuotaInfo,\n  type ApiResponse,\n  type JwtPayload,\n  type HealthCheckResponse,\n} from './common.js';\nexport * from './pipeline.js';\nexport {\n  type Lifecycle,\n  type Criticality,\n  type OwnerType,\n  type EntityLink,\n  type EntityLabels,\n} from './catalog-metadata.js';\nexport {\n  type TemplateInput,\n} from './pipeline-template.js';\nexport * from './visibility.js';\nexport * from './wire-vocabulary.js';\nexport { type ComplianceExemptionRequest } from './compliance-exemption.js';\nexport {\n  PLUGIN_SUMMARY_MAX,\n  PLUGIN_README_MAX_BYTES,\n  PLUGIN_CHANGELOG_MAX_BYTES,\n  PLUGIN_CATEGORIES,\n  type PluginCatalogCategory,\n  PLUGIN_CATALOG_FIELDS,\n  type PluginCatalogField,\n  PLUGIN_CATALOG_LINK_FIELDS,\n  METADATA_SOURCES,\n  type MetadataSource,\n  type MetadataSources,\n} from './plugin-catalog.js';\nexport {\n  type HttpRequest,\n} from './http.js';\nexport {\n  tierAllowsTeams,\n  isBillingEnabled,\n  isValidTier,\n  getTierLimits,\n  type QuotaTier,\n  type QuotaTierLimits,\n  QUOTA_TIERS,\n  VALID_TIERS,\n  STANDARD_TIERS,\n  TEAM_CAPABLE_TIERS,\n  DEFAULT_TIER,\n  QUOTA_RESET_DAYS,\n  nextQuotaResetDate,\n} from './quota-tiers.js';\nexport * from './feature-flags.js';\nexport {\n  permissionLabel,\n  isValidPermission,\n  isSystemOrgOnlyPermission,\n  isOrgAssignablePermission,\n  normalizePermissionSubset,\n  intersectPermissions,\n  resolveUserPermissions,\n  confinePermissionsToOrg,\n  hasPermission,\n  type Permission,\n  ALL_PERMISSIONS,\n  PERMISSION_GATES,\n  PERMISSION_CATALOG,\n  SUPERADMIN_ONLY_PERMISSIONS,\n  SYSTEM_ORG_ONLY_PERMISSIONS,\n  ORG_ASSIGNABLE_PERMISSIONS,\n  ORG_ASSIGNABLE_CATEGORIES,\n  READ_ONLY_PERMISSIONS,\n  ROLE_PERMISSIONS,\n  ECOSYSTEM_MANAGER_PERMISSIONS,\n} from './permissions.js';\nexport {\n  METADATA_KEY_CATALOG,\n  MetadataKeys,\n  type MetadataKey,\n  type MetadataKeyOption,\n  METADATA_KEY_GROUPS,\n} from './metadata-keys.js';\nexport {\n  type AuditEvent,\n} from './audit-events.js';\nexport {\n  REMOTE_AUDIT_ACTIONS,\n  isRemoteAuditAction,\n  type RemoteAuditAction,\n} from './remote-audit-actions.js';\nexport {\n  ASK_AGENT_PROPOSER,\n  ASK_PROPOSED_BY_HEADER,\n  PROPOSED_BY_DETAIL_KEY,\n  askProposalAuditDetails,\n  readProposerClaim,\n  withProposalProvenance,\n  ORG_SETTING_PROPOSAL_ALLOWLIST,\n  ORG_SETTING_PROPOSAL_EXCLUSIONS,\n  ORG_SETTING_PROPOSAL_KEYS,\n  isProposableOrgSetting,\n  isValidOrgSettingValue,\n  orgSettingSpec,\n  pickAllowed,\n  diffOrgSettings,\n  orgSettingRequests,\n  type AskProposalProvenance,\n  type ProposerClaim,\n  type OrgSettingChange,\n  type OrgSettingKey,\n  type OrgSettingPatch,\n  type OrgSettingRequest,\n  type OrgSettingShape,\n  type OrgSettingSpec,\n  type OrgSettingSurface,\n  type OrgSettingValue,\n  type PickAllowedResult,\n} from './ask-proposals.js';\nexport {\n  isEcosystemNotificationEvent,\n  parseEcosystemNotifyRequest,\n  nextEcosystemDigestTime,\n  renderEcosystemManagerChange,\n  renderEcosystemDigest,\n  type EcosystemNotificationEventId,\n  type EcosystemNotificationChannel,\n  ECOSYSTEM_EMAIL_PREFERENCE_FIELDS,\n  type EcosystemEmailPreferenceField,\n  ECOSYSTEM_EMAIL_PREFERENCE_FIELD_NAMES,\n  ECOSYSTEM_NOTIFICATION_EVENTS,\n  type EcosystemRecipientSpec,\n  type EcosystemNotifyRequest,\n} from './ecosystem-notifications.js';\nexport {\n  publisherTermsVersion,\n  publisherHandleProblem,\n  isOfficialAutoApprovalEnabled,\n  isPluginPublishingEnabled,\n  isAnonymousSubmissionsEnabled,\n  isPluginReviewsEnabled,\n  OFFICIAL_CATALOG_LOADER_ACCOUNT,\n  DEFAULT_PUBLISHER_TERMS_VERSION,\n  BUILTIN_RESERVED_HANDLES,\n  TENANT_REQUEST_KINDS,\n  PUBLISH_PERMISSION_REQUEST_KINDS,\n  VERIFY_REQUEST_KINDS,\n  STEP_UP_REQUEST_KINDS,\n  REQUEST_SLA_HOURS,\n} from './ecosystem.js';\nexport {\n  ageScore,\n  vulnScore,\n  computeHealthScore,\n  publisherHealthScore,\n  publisherSuccessRate,\n  healthBand,\n  HEALTH_COMPONENTS,\n  HEALTH_WEIGHTS,\n  type HealthBreakdown,\n  type HealthComponentScore,\n  type HealthResult,\n  type HealthInputs,\n  type HealthBand,\n} from './plugin-health.js';\nexport {\n  asScanFlag,\n  blockOnNewCritical,\n  describeFindings,\n  describeFix,\n  exceedsVulnFloor,\n  pluginVulnMaxCritical,\n  SCAN_FLAG_TOP_FINDINGS,\n  vulnBlockedMessage,\n  vulnFlaggedMessage,\n  vulnFlaggedWarning,\n  type PluginScanFinding,\n  type PluginScanFlag,\n  type VulnFlaggedWarning,\n} from './plugin-scan.js';\n"]}

package/lib/types/remote-audit-actions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The remote (non-platform) audit ACTION VOCABULARY.
+ *
+ * Kept apart from the client that ships the events (`services/remote-audit-client.ts`)
+ * because it is an allow-list, not machinery: it is the thing a reviewer reads
+ * end to end when deciding whether a service may emit a given action, and it is
+ * what platform's ingest validates against.
+ */
+/**
+ * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to
+ * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`
+ * is derived from it, so the type and the runtime allow-list can never drift.
+ *
+ * SECURITY: platform's ingest validates `action` against this subset (via
+ * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a
+ * `service:*` token must not be able to forge platform-authority events
+ * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep
+ * this list free of any platform-only action.
+ */
+export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.scan.skipped', 'plugin.delete', 'plugin.restore', 'plugin.purge', 'plugin.update', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'plugin.build.retry', 'plugin.dlq.replay', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline.restore', 'pipeline.purge', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline_template.restore', 'pipeline_template.purge', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.rule.restore', 'compliance.rule.purge', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.policy.restore', 'compliance.policy.purge', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.create', 'compliance.scan.cancel', 'compliance.notification-preference.update', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'registry.image.sign', 'message.announcement.create', 'message.delete', 'message.restore', 'message.purge', 'billing.subscription.create', 'billing.subscription.update', 'billing.subscription.reactivate', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'reporting.settings.update', 'reporting.deployment.outcome', 'reporting.retention.sync', 'authz.denied', 'ask.query', 'ask.agent.turn', 'publisher.create', 'publisher.update', 'publisher.terms.accept', 'publisher.verify.request', 'publisher.verify.approve', 'publisher.verify.reject', 'publisher.tier.change', 'publisher.suspend', 'publisher.unsuspend', 'publisher.transfer.request', 'publisher.transfer.accept', 'publisher.transfer.decline', 'publisher.transfer.approve', 'publisher.transfer.reject', 'publisher.profile-change.approve', 'publisher.profile-change.reject', 'plugin.request.submit', 'plugin.request.withdraw', 'plugin.request.approve', 'plugin.request.second-approve', 'plugin.request.reject', 'plugin.request.auto-approve', 'plugin.listing.publish', 'plugin.listing.unlist', 'plugin.listing.update', 'plugin.listing.state.change', 'plugin.listing.pause', 'plugin.listing.unpause', 'plugin.version.pause', 'plugin.version.yank', 'plugin.version.unyank', 'plugin.version.deprecate', 'plugin.collection.update', 'ecosystem.auto-approval-rule.create', 'ecosystem.auto-approval-rule.update', 'ecosystem.auto-approval-rule.delete', 'ecosystem.reserved-name.update', 'ecosystem.sla.update', 'registry.image.publish', 'registry.image.resign', 'registry.image.yank', 'registry.image.gc', 'plugin.install.request', 'plugin.install.approve', 'plugin.install.deny', 'plugin.install.create', 'plugin.install.upgrade', 'plugin.install.change-request', 'plugin.install.change-approve', 'plugin.install.change-reject', 'plugin.install.remove', 'org.plugin-install-policy.update', 'plugin.review.create', 'plugin.review.update', 'plugin.review.delete', 'plugin.review.report', 'plugin.review.hold', 'plugin.review.release', 'plugin.review.remove', 'plugin.review.anonymize', 'plugin.review.reply.create', 'plugin.review.reply.update', 'plugin.review.reply.delete', 'plugin.submission.create', 'plugin.submission.verify', 'plugin.submission.gate-fail', 'plugin.submission.approve', 'plugin.submission.reject', 'plugin.submission.claim', 'plugin.submission.expire', 'plugin.advisory.create', 'plugin.advisory.update', 'plugin.advisory.publish', 'plugin.advisory.withdraw', 'plugin.security_notifications.update', 'plugin.security_notifications.external_email.verify', 'plugin.security_notifications.test'];
+export type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];
+/** Whether `value` is an action a remote service may emit (the ingest allow-list). */
+export declare function isRemoteAuditAction(value: string): value is RemoteAuditAction;