@pipeline-builder/api-core 4.1.20 → 4.1.22

package/lib/services/s3-client.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The shared S3-compatible client, and the bucket-ensure backstop that goes
+ * with it.
+ *
+ * Backed by MinIO in every environment (self-hosted, no AWS-account coupling);
+ * because MinIO speaks the S3 API this uses the AWS S3 SDK, so a real-S3 swap is
+ * a pure config change (drop the custom endpoint + path-style, supply IAM creds).
+ *
+ * Config (env) — one set of names, read identically by every service; each
+ * container is pointed at its OWN bucket with bucket-scoped credentials:
+ *   S3_ENDPOINT           MinIO/S3 endpoint URL (e.g. http://minio:9000). Empty
+ *                         ⇒ default AWS S3 (no custom endpoint).
+ *   S3_REGION             region (default 'us-east-1').
+ *   S3_ACCESS_KEY_ID      access key.
+ *   S3_SECRET_ACCESS_KEY  secret key.
+ *   S3_FORCE_PATH_STYLE   'true' for MinIO (path-style addressing); default true.
+ *
+ * `S3_BUCKET` is deliberately NOT read here: the bucket is the caller's, and
+ * each service keeps its own default and its own key convention.
+ *
+ * **Reached through the `@pipeline-builder/api-core/s3` subpath, never the root
+ * barrel** — only two services do blob storage, and the S3 SDK is a large
+ * eager dependency that the other eight must not pay for at boot. Same reason
+ * `@aws-sdk/client-kms` is dynamically imported inside secret-encryption.
+ */
+import { S3Client } from '@aws-sdk/client-s3';
+/**
+ * The process-wide S3 client, built from env on first use.
+ *
+ * Lazy so a service that never touches blob storage — and a test that never
+ * configures S3 — never constructs one.
+ */
+export declare function s3Client(): S3Client;
+/**
+ * Ensure `bucket` exists, once per process per bucket.
+ *
+ * MinIO — unlike an auto-provisioned S3 bucket — won't create a bucket on first
+ * write, so HEAD it and CREATE on 404/NoSuchBucket. Idempotent and
+ * concurrency-safe: concurrent callers share the single in-flight promise.
+ *
+ * The important part is the failure branch. A CreateBucket failure is EITHER a
+ * benign race (another replica created it between our HEAD and our CREATE) or a
+ * real outage (MinIO not up yet, credentials wrong, network down). Re-HEADing
+ * tells them apart:
+ *
+ *  - it now exists  → benign race, continue;
+ *  - it still does not → DROP the memo entry and fail this attempt.
+ *
+ * Dropping the entry is load-bearing. Memoizing a resolved "ready" after a
+ * failed create caches a permanently-broken success for the process lifetime:
+ * every later upload then fails `NoSuchBucket` against a MinIO that came up
+ * seconds after boot, until the pod is restarted.
+ */
+export declare function ensureBucket(bucket: string): Promise<void>;

package/lib/services/s3-client.js

@@ -0,0 +1,106 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The shared S3-compatible client, and the bucket-ensure backstop that goes
+ * with it.
+ *
+ * Backed by MinIO in every environment (self-hosted, no AWS-account coupling);
+ * because MinIO speaks the S3 API this uses the AWS S3 SDK, so a real-S3 swap is
+ * a pure config change (drop the custom endpoint + path-style, supply IAM creds).
+ *
+ * Config (env) — one set of names, read identically by every service; each
+ * container is pointed at its OWN bucket with bucket-scoped credentials:
+ *   S3_ENDPOINT           MinIO/S3 endpoint URL (e.g. http://minio:9000). Empty
+ *                         ⇒ default AWS S3 (no custom endpoint).
+ *   S3_REGION             region (default 'us-east-1').
+ *   S3_ACCESS_KEY_ID      access key.
+ *   S3_SECRET_ACCESS_KEY  secret key.
+ *   S3_FORCE_PATH_STYLE   'true' for MinIO (path-style addressing); default true.
+ *
+ * `S3_BUCKET` is deliberately NOT read here: the bucket is the caller's, and
+ * each service keeps its own default and its own key convention.
+ *
+ * **Reached through the `@pipeline-builder/api-core/s3` subpath, never the root
+ * barrel** — only two services do blob storage, and the S3 SDK is a large
+ * eager dependency that the other eight must not pay for at boot. Same reason
+ * `@aws-sdk/client-kms` is dynamically imported inside secret-encryption.
+ */
+import { S3Client, HeadBucketCommand, CreateBucketCommand } from '@aws-sdk/client-s3';
+import { envBool, envStr } from '../utils/env.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('s3-client');
+let client = null;
+/**
+ * The process-wide S3 client, built from env on first use.
+ *
+ * Lazy so a service that never touches blob storage — and a test that never
+ * configures S3 — never constructs one.
+ */
+export function s3Client() {
+    if (client)
+        return client;
+    const endpoint = envStr('S3_ENDPOINT', '');
+    client = new S3Client({
+        region: envStr('S3_REGION', 'us-east-1'),
+        ...(endpoint ? { endpoint } : {}),
+        // Path-style is required by MinIO (no virtual-host bucket DNS). Harmless
+        // against real S3, but default-on here because MinIO is the default backend.
+        forcePathStyle: envBool('S3_FORCE_PATH_STYLE', true),
+        credentials: {
+            accessKeyId: envStr('S3_ACCESS_KEY_ID', 'minioadmin'),
+            secretAccessKey: envStr('S3_SECRET_ACCESS_KEY', 'minioadmin'),
+        },
+    });
+    return client;
+}
+/** In-flight / settled ensure per bucket. A rejected attempt is never left here. */
+const bucketsReady = new Map();
+/**
+ * Ensure `bucket` exists, once per process per bucket.
+ *
+ * MinIO — unlike an auto-provisioned S3 bucket — won't create a bucket on first
+ * write, so HEAD it and CREATE on 404/NoSuchBucket. Idempotent and
+ * concurrency-safe: concurrent callers share the single in-flight promise.
+ *
+ * The important part is the failure branch. A CreateBucket failure is EITHER a
+ * benign race (another replica created it between our HEAD and our CREATE) or a
+ * real outage (MinIO not up yet, credentials wrong, network down). Re-HEADing
+ * tells them apart:
+ *
+ *  - it now exists  → benign race, continue;
+ *  - it still does not → DROP the memo entry and fail this attempt.
+ *
+ * Dropping the entry is load-bearing. Memoizing a resolved "ready" after a
+ * failed create caches a permanently-broken success for the process lifetime:
+ * every later upload then fails `NoSuchBucket` against a MinIO that came up
+ * seconds after boot, until the pod is restarted.
+ */
+export async function ensureBucket(bucket) {
+    let ready = bucketsReady.get(bucket);
+    if (!ready) {
+        ready = (async () => {
+            try {
+                await s3Client().send(new HeadBucketCommand({ Bucket: bucket }));
+            }
+            catch {
+                try {
+                    await s3Client().send(new CreateBucketCommand({ Bucket: bucket }));
+                    logger.info('Created S3 bucket', { bucket });
+                }
+                catch (err) {
+                    try {
+                        await s3Client().send(new HeadBucketCommand({ Bucket: bucket }));
+                        logger.warn('S3 bucket ensure race (now exists, continuing)', { bucket, error: String(err) });
+                    }
+                    catch {
+                        bucketsReady.delete(bucket);
+                        throw new Error(`S3 bucket "${bucket}" unavailable: ${String(err)}`);
+                    }
+                }
+            }
+        })();
+        bucketsReady.set(bucket, ready);
+    }
+    return ready;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"s3-client.js","sourceRoot":"","sources":["../../src/services/s3-client.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAEtF,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,MAAM,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;AAEzC,IAAI,MAAM,GAAoB,IAAI,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,UAAU,QAAQ;IACtB,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAC1B,MAAM,QAAQ,GAAG,MAAM,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;IAC3C,MAAM,GAAG,IAAI,QAAQ,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC;QACxC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACjC,yEAAyE;QACzE,6EAA6E;QAC7E,cAAc,EAAE,OAAO,CAAC,qBAAqB,EAAE,IAAI,CAAC;QACpD,WAAW,EAAE;YACX,WAAW,EAAE,MAAM,CAAC,kBAAkB,EAAE,YAAY,CAAC;YACrD,eAAe,EAAE,MAAM,CAAC,sBAAsB,EAAE,YAAY,CAAC;SAC9D;KACF,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,oFAAoF;AACpF,MAAM,YAAY,GAAG,IAAI,GAAG,EAAyB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,MAAc;IAC/C,IAAI,KAAK,GAAG,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG,CAAC,KAAK,IAAI,EAAE;YAClB,IAAI,CAAC;gBACH,MAAM,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;YACnE,CAAC;YAAC,MAAM,CAAC;gBACP,IAAI,CAAC;oBACH,MAAM,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,mBAAmB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;oBACnE,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;gBAC/C,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,CAAC;wBACH,MAAM,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;wBACjE,MAAM,CAAC,IAAI,CAAC,gDAAgD,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBAChG,CAAC;oBAAC,MAAM,CAAC;wBACP,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;wBAC5B,MAAM,IAAI,KAAK,CAAC,cAAc,MAAM,kBAAkB,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACvE,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QACL,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The shared S3-compatible client, and the bucket-ensure backstop that goes\n * with it.\n *\n * Backed by MinIO in every environment (self-hosted, no AWS-account coupling);\n * because MinIO speaks the S3 API this uses the AWS S3 SDK, so a real-S3 swap is\n * a pure config change (drop the custom endpoint + path-style, supply IAM creds).\n *\n * Config (env) — one set of names, read identically by every service; each\n * container is pointed at its OWN bucket with bucket-scoped credentials:\n *   S3_ENDPOINT           MinIO/S3 endpoint URL (e.g. http://minio:9000). Empty\n *                         ⇒ default AWS S3 (no custom endpoint).\n *   S3_REGION             region (default 'us-east-1').\n *   S3_ACCESS_KEY_ID      access key.\n *   S3_SECRET_ACCESS_KEY  secret key.\n *   S3_FORCE_PATH_STYLE   'true' for MinIO (path-style addressing); default true.\n *\n * `S3_BUCKET` is deliberately NOT read here: the bucket is the caller's, and\n * each service keeps its own default and its own key convention.\n *\n * **Reached through the `@pipeline-builder/api-core/s3` subpath, never the root\n * barrel** — only two services do blob storage, and the S3 SDK is a large\n * eager dependency that the other eight must not pay for at boot. Same reason\n * `@aws-sdk/client-kms` is dynamically imported inside secret-encryption.\n */\n\nimport { S3Client, HeadBucketCommand, CreateBucketCommand } from '@aws-sdk/client-s3';\n\nimport { envBool, envStr } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('s3-client');\n\nlet client: S3Client | null = null;\n\n/**\n * The process-wide S3 client, built from env on first use.\n *\n * Lazy so a service that never touches blob storage — and a test that never\n * configures S3 — never constructs one.\n */\nexport function s3Client(): S3Client {\n  if (client) return client;\n  const endpoint = envStr('S3_ENDPOINT', '');\n  client = new S3Client({\n    region: envStr('S3_REGION', 'us-east-1'),\n    ...(endpoint ? { endpoint } : {}),\n    // Path-style is required by MinIO (no virtual-host bucket DNS). Harmless\n    // against real S3, but default-on here because MinIO is the default backend.\n    forcePathStyle: envBool('S3_FORCE_PATH_STYLE', true),\n    credentials: {\n      accessKeyId: envStr('S3_ACCESS_KEY_ID', 'minioadmin'),\n      secretAccessKey: envStr('S3_SECRET_ACCESS_KEY', 'minioadmin'),\n    },\n  });\n  return client;\n}\n\n/** In-flight / settled ensure per bucket. A rejected attempt is never left here. */\nconst bucketsReady = new Map<string, Promise<void>>();\n\n/**\n * Ensure `bucket` exists, once per process per bucket.\n *\n * MinIO — unlike an auto-provisioned S3 bucket — won't create a bucket on first\n * write, so HEAD it and CREATE on 404/NoSuchBucket. Idempotent and\n * concurrency-safe: concurrent callers share the single in-flight promise.\n *\n * The important part is the failure branch. A CreateBucket failure is EITHER a\n * benign race (another replica created it between our HEAD and our CREATE) or a\n * real outage (MinIO not up yet, credentials wrong, network down). Re-HEADing\n * tells them apart:\n *\n *  - it now exists  → benign race, continue;\n *  - it still does not → DROP the memo entry and fail this attempt.\n *\n * Dropping the entry is load-bearing. Memoizing a resolved \"ready\" after a\n * failed create caches a permanently-broken success for the process lifetime:\n * every later upload then fails `NoSuchBucket` against a MinIO that came up\n * seconds after boot, until the pod is restarted.\n */\nexport async function ensureBucket(bucket: string): Promise<void> {\n  let ready = bucketsReady.get(bucket);\n  if (!ready) {\n    ready = (async () => {\n      try {\n        await s3Client().send(new HeadBucketCommand({ Bucket: bucket }));\n      } catch {\n        try {\n          await s3Client().send(new CreateBucketCommand({ Bucket: bucket }));\n          logger.info('Created S3 bucket', { bucket });\n        } catch (err) {\n          try {\n            await s3Client().send(new HeadBucketCommand({ Bucket: bucket }));\n            logger.warn('S3 bucket ensure race (now exists, continuing)', { bucket, error: String(err) });\n          } catch {\n            bucketsReady.delete(bucket);\n            throw new Error(`S3 bucket \"${bucket}\" unavailable: ${String(err)}`);\n          }\n        }\n      }\n    })();\n    bucketsReady.set(bucket, ready);\n  }\n  return ready;\n}\n"]}

package/lib/types/ask-proposals.d.ts

@@ -0,0 +1,269 @@
+/**
+ * The shared contract between the ask agent's PROPOSE tools and the browser's
+ * CONFIRM handlers. Two things live here, and they live here because BOTH sides
+ * need them: `api/ask` builds its tool schema from this module, the frontend's
+ * confirm handler builds its request from it, and the tests of both assert
+ * against it. A second copy would be a second policy.
+ *
+ * Dependency-free on purpose — no runtime imports at all — so the browser can
+ * import it through api-core's `./ask-proposals` entry without dragging in the
+ * server graph (express / jwt / ioredis). The only imports are `import type`,
+ * which the compiler erases.
+ *
+ * -----------------------------------------------------------------------------
+ * 1. PROVENANCE
+ * -----------------------------------------------------------------------------
+ * Every commit that started life as an agent draft stamps
+ * `details: { proposedBy: 'ask-agent' }` onto its audit event. The audit trail
+ * is hash-chained and tamper-evident, but without this field it cannot
+ * distinguish "the admin changed this" from "an AI drafted it and the admin
+ * clicked Apply" — the two mean very different things in an incident review.
+ * The constant exists so the literal is not retyped in two codebases, where a
+ * typo would silently produce an unqueryable trail.
+ *
+ * -----------------------------------------------------------------------------
+ * 2. THE ORG-SETTINGS ALLOWLIST
+ * -----------------------------------------------------------------------------
+ * This is an ALLOWLIST, not a denylist, and the distinction is the whole point:
+ * a setting added to the platform tomorrow is UNAVAILABLE to the agent until
+ * someone deliberately adds it here, rather than being exposed by omission.
+ * If you are reading this because a proposal was refused, the fix is to add the
+ * field below WITH its `why` — not to loosen {@link pickAllowed}.
+ *
+ * A field earns a place here only if all of the following hold. They were
+ * checked against the routes, not assumed:
+ *
+ *  - **No step-up.** A route carrying `requireStepUp` is out, no exceptions.
+ *    Step-up means the platform already decided a live session is not enough
+ *    authority; a chat proposal is strictly less. This is what keeps
+ *    `PUT /organization/ai-config` out (it persists per-org provider SECRETS),
+ *    along with the MFA / password / authenticator policies,
+ *    `PUT /plugins/install-policy`, org restore and transfer-owner.
+ *  - **Not a security control.** MFA / password / authenticator / impersonation
+ *    policy, SSO+SAML and its group mappings, verified domains and domain-based
+ *    join, join-request decisions, transfer-owner and team lifecycle are ABSENT
+ *    here rather than gated within — "relax the MFA policy" is precisely what an
+ *    injection payload asks for, and it arrives through text the agent already
+ *    reads. Absent cannot be argued with; gated can.
+ *  - **Carries no secret and no callback target.** An API that returns
+ *    `hasWebhookSecret` instead of the secret is telling you the field cannot be
+ *    diffed, so it cannot be reviewed, so it cannot be proposed. Webhook URLs
+ *    and email addresses are out for the same reason plus one more: they are
+ *    exfiltration targets, and a confirmation mail to an attacker-chosen address
+ *    is a send the platform performs on the model's say-so.
+ *  - **Reviewable as a diff.** A scalar with a closed shape (boolean, bounded
+ *    integer, small enum). A list of opaque user ids renders as ids in a card
+ *    nobody can check, so recipient LISTS are out even though cadence is in.
+ *
+ * Each entry names the API that applies it. The browser applies it through the
+ * USER's own session and the user's own permissions — the agent never writes —
+ * so a proposal a member may not commit simply 403s at the route, exactly as a
+ * hand-made request would.
+ *
+ * Rule 10 lives in {@link pickAllowed}: a candidate carrying a field outside
+ * this list is the injection signal, so the refused names come back to the
+ * caller to be counted and logged rather than being quietly dropped.
+ */
+import type { Permission } from './permissions.js';
+/** The `proposedBy` value every agent-drafted commit records. */
+export declare const ASK_AGENT_PROPOSER = "ask-agent";
+/** The audit `details` key that carries provenance. */
+export declare const PROPOSED_BY_DETAIL_KEY = "proposedBy";
+/** The provenance fragment merged into a `RemoteAuditEvent.details`. */
+export interface AskProposalProvenance {
+    readonly proposedBy: typeof ASK_AGENT_PROPOSER;
+}
+/**
+ * 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 declare function askProposalAuditDetails(details?: Readonly<Record<string, unknown>>): Record<string, unknown> & AskProposalProvenance;
+/**
+ * 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 declare const ASK_PROPOSED_BY_HEADER = "x-pb-proposed-by";
+/**
+ * What a request's provenance header claims.
+ *
+ * `foreign` is any value that is not EXACTLY {@link ASK_AGENT_PROPOSER} — there
+ * is one legitimate proposer and no free-form text, so anything else is a bug
+ * or a forgery and is named as such rather than folded into `none`.
+ */
+export type ProposerClaim = 'none' | 'ask-agent' | 'foreign';
+/**
+ * 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 declare function readProposerClaim(headers: unknown): ProposerClaim;
+/**
+ * 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 declare function withProposalProvenance(headers: unknown, details?: Readonly<Record<string, unknown>>): Record<string, unknown>;
+/** A value an allowlisted org setting can hold. */
+export type OrgSettingValue = string | number | boolean;
+/** Which per-org record (and therefore which API) a field belongs to. */
+export type OrgSettingSurface = 'reporting' | 'complianceNotifications' | 'pluginSecurityNotifications';
+/**
+ * Every proposable setting, as `<surface>.<field>`. Writing the union out by
+ * hand (rather than inferring it from the array) is deliberate: the key space
+ * is the contract the tool schema and the confirm handler share, so it is
+ * stated once, explicitly, and a typo in an entry below is a compile error.
+ */
+export type OrgSettingKey = 'reporting.incidentWindowHours' | 'complianceNotifications.notifyOnBlock' | 'complianceNotifications.notifyOnWarning' | 'complianceNotifications.emailEnabled' | 'complianceNotifications.digestMode' | 'pluginSecurityNotifications.notifyRescan' | 'pluginSecurityNotifications.digestMode';
+/** The closed shape a proposed value must match before it is accepted. */
+export type OrgSettingShape = {
+    readonly kind: 'boolean';
+} | {
+    readonly kind: 'integer';
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly kind: 'enum';
+    readonly values: readonly string[];
+};
+/** One proposable org setting. */
+export interface OrgSettingSpec {
+    /** Stable proposal key — `<surface>.<field>`. This is what the model names. */
+    readonly key: OrgSettingKey;
+    readonly surface: OrgSettingSurface;
+    /** The request-body field name the API expects. */
+    readonly field: string;
+    readonly shape: OrgSettingShape;
+    /** The route that applies it, called by the BROWSER with the user's session. */
+    readonly api: {
+        readonly method: 'PUT';
+        readonly path: string;
+    };
+    /** The permission that route requires of the caller. */
+    readonly permission: Permission;
+    /** Short human label for the confirm card. */
+    readonly label: string;
+    /** WHY this field is safe to propose. Every entry states its own case. */
+    readonly why: string;
+}
+/**
+ * The allowlist. Adding an entry is a deliberate act: name the route you
+ * checked, confirm it carries no `requireStepUp`, and write the `why`.
+ */
+export declare const ORG_SETTING_PROPOSAL_ALLOWLIST: readonly OrgSettingSpec[];
+/**
+ * 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 declare const ORG_SETTING_PROPOSAL_EXCLUSIONS: ReadonlyArray<{
+    readonly field: string;
+    readonly why: string;
+}>;
+/** Every proposable key — the enum a propose tool's input schema is built from. */
+export declare const ORG_SETTING_PROPOSAL_KEYS: readonly OrgSettingKey[];
+/** Is `key` on the allowlist? */
+export declare function isProposableOrgSetting(key: string): key is OrgSettingKey;
+/** The spec for `key`, or undefined when it is not proposable. */
+export declare function orgSettingSpec(key: string): OrgSettingSpec | undefined;
+/** Does `value` match the shape the field declares? */
+export declare function isValidOrgSettingValue(spec: OrgSettingSpec, value: unknown): value is OrgSettingValue;
+/** A proposal's settings, keyed by allowlist key. */
+export type OrgSettingPatch = Partial<Record<OrgSettingKey, OrgSettingValue>>;
+/** What {@link pickAllowed} kept, and what it threw away. */
+export interface PickAllowedResult {
+    /** The allowlisted, shape-valid settings. */
+    readonly allowed: OrgSettingPatch;
+    /**
+     * Field names the candidate carried that are NOT on the allowlist. THIS is
+     * the injection signal (rule 10): a legitimate draft has none, so a non-empty
+     * list is a counter to increment and a line to log, not a silent drop.
+     */
+    readonly refused: readonly string[];
+    /**
+     * Allowlisted keys whose value did not match the declared shape. Dropped too,
+     * but reported separately — a bad value is a drafting mistake, not an attempt
+     * to reach a field the agent was never given.
+     */
+    readonly invalid: readonly OrgSettingKey[];
+    /** `refused.length`, so a caller can count without re-deriving it. */
+    readonly refusedCount: number;
+}
+/**
+ * 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 declare function pickAllowed(candidate: unknown): PickAllowedResult;
+/** One reviewed change: what the setting is now, and what it would become. */
+export interface OrgSettingChange {
+    readonly spec: OrgSettingSpec;
+    readonly from: OrgSettingValue | undefined;
+    readonly to: OrgSettingValue;
+}
+/**
+ * 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 declare function diffOrgSettings(current: Readonly<OrgSettingPatch>, proposed: Readonly<OrgSettingPatch>): readonly OrgSettingChange[];
+/** One API call the confirm handler makes: one surface, one body. */
+export interface OrgSettingRequest {
+    readonly surface: OrgSettingSurface;
+    readonly method: 'PUT';
+    readonly path: string;
+    readonly permission: Permission;
+    /** Request body: the API's own field names, carrying only reviewed values. */
+    readonly body: Record<string, OrgSettingValue>;
+}
+/**
+ * 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 declare function orgSettingRequests(changes: readonly OrgSettingChange[]): readonly OrgSettingRequest[];