@atlasauth/pca-ciba 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atlas Authorization
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,64 @@
-# Temporary Holding Version
+# @atlasauth/pca-ciba
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A CIBA (OpenID Connect Client-Initiated Backchannel Authentication) on-ramp for Proof-Carrying Authority (PCA) step-up. It turns a risk-gated step-up into a standard asynchronous human-approval flow, interrupting a person only for the actions that actually need it.
+
+In CIBA a backend opens an `auth_req_id`, the human is notified out of band, and the decision comes back by poll or ping/push. The `binding_message` carries the human-readable approval context, so the thing approved on the phone is the thing the agent is about to do ("Approve stripe.refund $480 on charge:ch_1 - because you asked support-bot to 'reconcile October refunds'").
+
+This is a bridge, not a replacement. PCA's cryptographic step-up (a FROST threshold cosign, in `@atlasauth/pca`) stays the enforcement; CIBA is the notification and decision envelope around it.
+
+Gating is risk-adaptive: only a tier-3 step-up (human required, typically irreversible) is routed through CIBA. Tier-2 (guardian auto-cosign) and tier-1 (`auto`) never interrupt a person.
+
+## Install
+
+```sh
+npm i @atlasauth/pca-ciba @atlasauth/pca
+```
+
+## Usage
+
+```ts
+import { agent, generateKeyPair, reviewAction } from '@atlasauth/pca';
+import { requiresCiba, createCibaBroker, cibaDecisionToCosign } from '@atlasauth/pca-ciba';
+
+const a = agent({
+  principal: generateKeyPair(),
+  goal: 'reconcile October refunds',
+  permissions: { stripe: ['payout'] },
+  limits: { payout: '$100' },
+  aud: 'rs_demo',
+  riskPolicy: { theta1: 0.3, theta2: 0.6 },
+});
+
+const review = reviewAction(a, 'stripe.payout', 'acct:1', { amount: 80 }, { goal: 'reconcile October refunds' });
+
+if (review.kind === 'step_up' && requiresCiba(review)) {
+  const broker = createCibaBroker({ onComplete: (session) => console.log(session.status) }); // omit onComplete for POLL
+  const ciba = broker.start(review.request, { actsFor: 'support-bot', loginHint: 'owner@acme' });
+  // ciba.auth_req_id, ciba.binding_message, ciba.requested_expiry, ...
+
+  broker.poll(ciba.auth_req_id).status; // 'pending' | 'approved' | 'denied' | 'expired'
+
+  // The human decides out of band:
+  const session = broker.resolve(ciba.auth_req_id, 'approve', 'owner@acme');
+
+  // Fold the decision back into the trust budget:
+  const { budget, cosigned } = cibaDecisionToCosign(
+    session.status === 'approved' ? 'approve' : 'deny',
+    a.budget,
+    a.policy.riskPolicy,
+    Date.now(),
+  );
+}
+```
+
+`toCibaAuthRequest(stepUp, opts?)` is the pure mapping from a step-up to a CIBA request, if you want to drive your own broker or a real OpenID provider.
+
+## Status
+
+The broker is in-memory and models the CIBA lifecycle without any network; a production deployment would swap in a real OpenID provider. The package computes approval envelopes and the derived trust budget and authorises nothing on its own: `cibaDecisionToCosign` is only the budget-level effect. The cryptographic cosign (FROST) is produced and verified separately, and the resource server's verifier remains the authority. Cryptography in PCA is unaudited.
+
+Source and issues: https://github.com/Atlas-Authorization/pca
+
+## License
+
+MIT - see LICENSE

package/dist/index.d.ts

@@ -0,0 +1,147 @@
+/**
+ * @atlasauth/pca-ciba — a CIBA on-ramp for PCA's FROST step-up.
+ *
+ * CIBA (OpenID Connect Client-Initiated Backchannel Authentication, OpenID CIBA Core) is the
+ * convergent human-in-the-loop (HITL) primitive every modern IdP ships — Auth0 ("CIBA / push
+ * authorization"), Descope, Stytch — for *asynchronous* out-of-band approval: a backend starts an
+ * `auth_req_id`, the human is notified on a separate device, and the backend learns the decision by
+ * polling (POLL) or via a callback (PING/PUSH). Its `binding_message` field carries the short
+ * human-readable context the person sees while approving, so the thing they approve on their phone is
+ * provably the thing the agent is about to do.
+ *
+ * This package is a BRIDGE, not a replacement. PCA's cryptographic step-up (FROST threshold cosign —
+ * see `@atlasauth/pca` `threshold`/`frost`) stays the *enforcement*: a tier-3 action proceeds only once
+ * a real threshold signature recharges the trust budget. CIBA is only the human-notification / decision
+ * *envelope* around that cosign — it standardises how the human is asked and how the answer comes back.
+ * PCA's FROST step-up is cryptographically stronger than a bare CIBA approval (an OP's yes/no is a
+ * trusted single party; a FROST cosign is an unforgeable t-of-n signature); this just gives it the
+ * industry-standard async-approval + binding-message on-ramp.
+ *
+ * Risk-adaptive gating is the point. If every action prompts a human, humans blanket-approve (Anthropic
+ * observed 93% blanket-approval under always-prompt). So only a tier-3 step-up — a human-required,
+ * typically irreversible/high-risk action — is routed through CIBA. Tier-2 (guardian auto-cosign) and
+ * tier-1 (`auto`) never interrupt a person. `requiresCiba()` encodes exactly that gate.
+ *
+ * Everything here is pure or in-memory and authorises nothing on its own: the resource server's verifier
+ * (`requirePCA` / the adjudicator) and the FROST cosigners remain the run-time authority.
+ */
+import { type StepUpRequest, type Review, type TrustBudget, type RiskPolicy } from '@atlasauth/pca';
+/** A CIBA backchannel authentication request derived from a PCA step-up. */
+export interface CibaAuthRequest {
+    /**
+     * The CIBA `auth_req_id` — the opaque handle the backend polls / correlates on. Derived
+     * deterministically from the step-up id, so the same step-up always maps to the same request.
+     */
+    auth_req_id: string;
+    /**
+     * The human-readable approval context shown to the person (OpenID CIBA `binding_message`): what is
+     * being approved and why, traced to the goal the agent was given.
+     */
+    binding_message: string;
+    /** CIBA `scope` (space-delimited), carrying `openid` + a PCA step-up scope for this verb. */
+    scope: string;
+    /** CIBA `requested_expiry` in SECONDS — how long the human has to decide. */
+    requested_expiry: number;
+    /** CIBA `interval` in SECONDS — minimum poll spacing for POLL mode. */
+    interval: number;
+    /** CIBA `login_hint` — who to notify, if the caller supplied one. */
+    login_hint?: string;
+    /** The PCA step-up this request fulfils (back-link for correlation). */
+    stepUpId: string;
+    /** The PCA risk tier that produced the step-up (2 guardian / 3 human). */
+    tier: 2 | 3;
+}
+/** Options shared by `toCibaAuthRequest` and the broker's `start`. */
+export interface CibaRequestOptions {
+    /** Override the `requested_expiry` (seconds). Default 300. */
+    expiresInSec?: number;
+    /** CIBA `login_hint` for the OP: the identifier of the human to notify. */
+    loginHint?: string;
+    /**
+     * The agent's human-facing name used in the binding message ("because you asked <actsFor> to …"),
+     * e.g. `"support-bot"`. Default `"your agent"`.
+     */
+    actsFor?: string;
+}
+/**
+ * Map a PCA {@link StepUpRequest} to a {@link CibaAuthRequest}. Pure: derives a stable `auth_req_id`
+ * from the step-up id, renders the `binding_message`, and carries the scope / expiry / poll interval.
+ * Does not start a flow or notify anyone — that's the broker.
+ */
+export declare function toCibaAuthRequest(stepUp: StepUpRequest, opts?: CibaRequestOptions): CibaAuthRequest;
+/** The settled outcome of a CIBA request, with `pending` while the human hasn't acted and `expired`
+ *  once `requested_expiry` elapses. */
+export type CibaStatus = 'pending' | 'approved' | 'denied' | 'expired';
+/** A broker session: the request plus the (lazily-evaluated) decision state. */
+export interface CibaSession {
+    auth_req_id: string;
+    request: CibaAuthRequest;
+    /** Effective status computed at read time (never a stale stored flag). */
+    status: CibaStatus;
+    /** ms epoch the session was started. */
+    createdAt: number;
+    /** ms epoch the request expires (`createdAt + requested_expiry·1000`). */
+    expiresAt: number;
+    /** Who acted, once resolved. */
+    decidedBy?: string;
+    /** ms epoch the human acted, once resolved. */
+    decidedAt?: number;
+}
+/** Options for {@link createCibaBroker}. */
+export interface CibaBrokerOptions {
+    /** Clock (ms). Default `Date.now`. Inject for deterministic tests / expiry. */
+    now?: () => number;
+    /**
+     * PING/PUSH mode: called once, synchronously, the moment a session is resolved (approved or denied).
+     * Omit it to use pure POLL mode (the caller drives `poll`).
+     */
+    onComplete?: (session: CibaSession) => void;
+}
+/** The in-memory CIBA broker returned by {@link createCibaBroker}. */
+export interface CibaBroker {
+    /** Begin a backchannel flow for a step-up; returns the CIBA auth request (status starts `pending`). */
+    start(stepUp: StepUpRequest, opts?: CibaRequestOptions): CibaAuthRequest;
+    /** POLL: the current effective status (`authorization_pending` semantics while `pending`). */
+    poll(auth_req_id: string): {
+        status: CibaStatus;
+    };
+    /** The human acts out-of-band: approve or deny. Fires `onComplete` (PING/PUSH) if configured. */
+    resolve(auth_req_id: string, decision: 'approve' | 'deny', by: string): CibaSession;
+    /** Read a full session snapshot (status computed at read time), or `undefined` if unknown. */
+    get(auth_req_id: string): CibaSession | undefined;
+}
+/**
+ * An in-memory CIBA broker. Models the backchannel lifecycle without any network: `start` opens a
+ * session, `poll` reports `pending`/`approved`/`denied`/`expired`, and `resolve` records the human's
+ * decision. Supports both delivery modes — POLL (caller drives `poll`) and PING/PUSH (an `onComplete`
+ * callback fires on resolution). A production deployment swaps this for the real OP + FROST cosigners;
+ * the shape stays the same.
+ */
+export declare function createCibaBroker(opts?: CibaBrokerOptions): CibaBroker;
+/**
+ * The gate: does this review need a CIBA human-approval round-trip? Only a tier-3 step-up (human
+ * required — typically irreversible / high blast-radius) does. A tier-2 step-up is handled by the
+ * guardian's auto-cosign, and an `auto`/`deny` review never notifies a human. This is the
+ * risk-adaptive interrupt that avoids blanket-approval fatigue.
+ */
+export declare function requiresCiba(review: Review): boolean;
+/** The budget effect of a settled CIBA decision. */
+export interface CibaCosignResult {
+    /** The trust budget after applying the decision (recharged on approve, unchanged on deny). */
+    budget: TrustBudget;
+    /** Whether a (budget-level) cosign was applied. */
+    cosigned: boolean;
+}
+/**
+ * Fold a settled CIBA decision back into PCA's trust budget. On `approve`, recharge via `applyCosign`
+ * (partial ρ per cosign, or full with `{ full: true }`); on `deny`, the budget is unchanged.
+ *
+ * NOTE: this is the BUDGET-level effect only. The actual cryptographic cosign that authorises a tier-3
+ * action is a FROST threshold signature (`@atlasauth/pca` `threshold`/`frost`), produced out of band and
+ * verified by the resource server — CIBA carries the human *decision*, not the signature. A real
+ * integration gates `applyCosign` on a verified FROST cosign; here we model the budget recharge the
+ * approval authorises.
+ */
+export declare function cibaDecisionToCosign(decision: 'approve' | 'deny', budget: TrustBudget, policy: RiskPolicy, now: number, opts?: {
+    full?: boolean;
+}): CibaCosignResult;

package/dist/index.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * @atlasauth/pca-ciba — a CIBA on-ramp for PCA's FROST step-up.
+ *
+ * CIBA (OpenID Connect Client-Initiated Backchannel Authentication, OpenID CIBA Core) is the
+ * convergent human-in-the-loop (HITL) primitive every modern IdP ships — Auth0 ("CIBA / push
+ * authorization"), Descope, Stytch — for *asynchronous* out-of-band approval: a backend starts an
+ * `auth_req_id`, the human is notified on a separate device, and the backend learns the decision by
+ * polling (POLL) or via a callback (PING/PUSH). Its `binding_message` field carries the short
+ * human-readable context the person sees while approving, so the thing they approve on their phone is
+ * provably the thing the agent is about to do.
+ *
+ * This package is a BRIDGE, not a replacement. PCA's cryptographic step-up (FROST threshold cosign —
+ * see `@atlasauth/pca` `threshold`/`frost`) stays the *enforcement*: a tier-3 action proceeds only once
+ * a real threshold signature recharges the trust budget. CIBA is only the human-notification / decision
+ * *envelope* around that cosign — it standardises how the human is asked and how the answer comes back.
+ * PCA's FROST step-up is cryptographically stronger than a bare CIBA approval (an OP's yes/no is a
+ * trusted single party; a FROST cosign is an unforgeable t-of-n signature); this just gives it the
+ * industry-standard async-approval + binding-message on-ramp.
+ *
+ * Risk-adaptive gating is the point. If every action prompts a human, humans blanket-approve (Anthropic
+ * observed 93% blanket-approval under always-prompt). So only a tier-3 step-up — a human-required,
+ * typically irreversible/high-risk action — is routed through CIBA. Tier-2 (guardian auto-cosign) and
+ * tier-1 (`auto`) never interrupt a person. `requiresCiba()` encodes exactly that gate.
+ *
+ * Everything here is pure or in-memory and authorises nothing on its own: the resource server's verifier
+ * (`requirePCA` / the adjudicator) and the FROST cosigners remain the run-time authority.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCibaAuthRequest = toCibaAuthRequest;
+exports.createCibaBroker = createCibaBroker;
+exports.requiresCiba = requiresCiba;
+exports.cibaDecisionToCosign = cibaDecisionToCosign;
+const pca_1 = require("@atlasauth/pca");
+const DEFAULT_EXPIRY_SEC = 300;
+const DEFAULT_INTERVAL_SEC = 5;
+/** A short "$480" / "480 EUR" fragment from a step-up's params, or "" when there's no amount. */
+function amountFragment(params) {
+    if (!params)
+        return '';
+    const amt = params['amount'];
+    if (typeof amt !== 'number' || !Number.isFinite(amt))
+        return '';
+    const cur = params['currency'];
+    if (typeof cur === 'string' && cur.length > 0 && cur.toLowerCase() !== 'usd') {
+        return ` ${amt} ${cur.toUpperCase()}`;
+    }
+    return ` $${amt}`;
+}
+/**
+ * Build the CIBA `binding_message`: the one-line human-readable approval context. Combines the
+ * verb + optional amount + resource with the goal-lineage ("because you asked <agent> to '<goal>'").
+ * Falls back to the salted goal commitment when the plaintext goal isn't carried on the step-up, so
+ * lineage is always present.
+ */
+function bindingMessage(stepUp, actsFor) {
+    const head = `Approve ${stepUp.verb}${amountFragment(stepUp.params)} on ${stepUp.resource}`;
+    const goalText = stepUp.goal !== undefined && stepUp.goal.length > 0
+        ? stepUp.goal
+        : stepUp.goalCommit.length > 0
+            ? `goal ${stepUp.goalCommit.slice(0, 10)}…`
+            : undefined;
+    return goalText === undefined ? head : `${head} — because you asked ${actsFor} to '${goalText}'`;
+}
+/**
+ * Map a PCA {@link StepUpRequest} to a {@link CibaAuthRequest}. Pure: derives a stable `auth_req_id`
+ * from the step-up id, renders the `binding_message`, and carries the scope / expiry / poll interval.
+ * Does not start a flow or notify anyone — that's the broker.
+ */
+function toCibaAuthRequest(stepUp, opts = {}) {
+    const actsFor = opts.actsFor !== undefined && opts.actsFor.length > 0 ? opts.actsFor : 'your agent';
+    const auth_req_id = (0, pca_1.hashCanonical)({ d: 'atlas-pca/ciba/auth_req_id/v1', stepUp: stepUp.id });
+    return {
+        auth_req_id,
+        binding_message: bindingMessage(stepUp, actsFor),
+        scope: `openid urn:atlas:pca:stepup:${stepUp.verb}`,
+        requested_expiry: opts.expiresInSec !== undefined ? opts.expiresInSec : DEFAULT_EXPIRY_SEC,
+        interval: DEFAULT_INTERVAL_SEC,
+        ...(opts.loginHint !== undefined ? { login_hint: opts.loginHint } : {}),
+        stepUpId: stepUp.id,
+        tier: stepUp.tier,
+    };
+}
+/** Status is computed, never stored — a decision wins, else expiry, else pending (read-time truth). */
+function effectiveStatus(s, now) {
+    if (s.decision === 'approve')
+        return 'approved';
+    if (s.decision === 'deny')
+        return 'denied';
+    if (now >= s.expiresAt)
+        return 'expired';
+    return 'pending';
+}
+function snapshot(s, now) {
+    return {
+        auth_req_id: s.request.auth_req_id,
+        request: s.request,
+        status: effectiveStatus(s, now),
+        createdAt: s.createdAt,
+        expiresAt: s.expiresAt,
+        ...(s.decidedBy !== undefined ? { decidedBy: s.decidedBy } : {}),
+        ...(s.decidedAt !== undefined ? { decidedAt: s.decidedAt } : {}),
+    };
+}
+/**
+ * An in-memory CIBA broker. Models the backchannel lifecycle without any network: `start` opens a
+ * session, `poll` reports `pending`/`approved`/`denied`/`expired`, and `resolve` records the human's
+ * decision. Supports both delivery modes — POLL (caller drives `poll`) and PING/PUSH (an `onComplete`
+ * callback fires on resolution). A production deployment swaps this for the real OP + FROST cosigners;
+ * the shape stays the same.
+ */
+function createCibaBroker(opts = {}) {
+    const clock = opts.now ?? Date.now;
+    const sessions = new Map();
+    return {
+        start(stepUp, reqOpts) {
+            const request = toCibaAuthRequest(stepUp, reqOpts);
+            const createdAt = clock();
+            const stored = {
+                request,
+                createdAt,
+                expiresAt: createdAt + request.requested_expiry * 1000,
+            };
+            sessions.set(request.auth_req_id, stored);
+            return request;
+        },
+        poll(auth_req_id) {
+            const s = sessions.get(auth_req_id);
+            if (!s)
+                throw new Error(`ciba: unknown auth_req_id ${auth_req_id}`);
+            return { status: effectiveStatus(s, clock()) };
+        },
+        resolve(auth_req_id, decision, by) {
+            const s = sessions.get(auth_req_id);
+            if (!s)
+                throw new Error(`ciba: unknown auth_req_id ${auth_req_id}`);
+            const now = clock();
+            const current = effectiveStatus(s, now);
+            if (current !== 'pending') {
+                throw new Error(`ciba: cannot resolve ${auth_req_id} — already ${current}`);
+            }
+            s.decision = decision;
+            s.decidedBy = by;
+            s.decidedAt = now;
+            const snap = snapshot(s, now);
+            if (opts.onComplete)
+                opts.onComplete(snap);
+            return snap;
+        },
+        get(auth_req_id) {
+            const s = sessions.get(auth_req_id);
+            return s ? snapshot(s, clock()) : undefined;
+        },
+    };
+}
+// ---- risk-adaptive gating + the hand-off back to the cryptographic cosign -------------------------
+/**
+ * The gate: does this review need a CIBA human-approval round-trip? Only a tier-3 step-up (human
+ * required — typically irreversible / high blast-radius) does. A tier-2 step-up is handled by the
+ * guardian's auto-cosign, and an `auto`/`deny` review never notifies a human. This is the
+ * risk-adaptive interrupt that avoids blanket-approval fatigue.
+ */
+function requiresCiba(review) {
+    return review.kind === 'step_up' && review.request.tier === 3;
+}
+/**
+ * Fold a settled CIBA decision back into PCA's trust budget. On `approve`, recharge via `applyCosign`
+ * (partial ρ per cosign, or full with `{ full: true }`); on `deny`, the budget is unchanged.
+ *
+ * NOTE: this is the BUDGET-level effect only. The actual cryptographic cosign that authorises a tier-3
+ * action is a FROST threshold signature (`@atlasauth/pca` `threshold`/`frost`), produced out of band and
+ * verified by the resource server — CIBA carries the human *decision*, not the signature. A real
+ * integration gates `applyCosign` on a verified FROST cosign; here we model the budget recharge the
+ * approval authorises.
+ */
+function cibaDecisionToCosign(decision, budget, policy, now, opts = {}) {
+    if (decision === 'approve')
+        return { budget: (0, pca_1.applyCosign)(budget, policy, now, opts), cosigned: true };
+    return { budget, cosigned: false };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@atlasauth/pca-ciba",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "CIBA (Client-Initiated Backchannel Authentication) bridge for PCA FROST step-up: turn a step-up request into a backchannel human-approval flow with risk-adaptive gating.",
+  "keywords": [
+    "ciba",
+    "backchannel",
+    "human approval",
+    "step-up",
+    "agent authorization",
+    "proof-carrying authority",
+    "pca",
+    "ai agents"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/Atlas-Authorization/pca#readme",
+  "bugs": {
+    "url": "https://github.com/Atlas-Authorization/pca/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Atlas-Authorization/pca.git",
+    "directory": "packages/pca-ciba"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@atlasauth/pca": "0.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
 }