@atlasauth/pca-policy-ci 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,62 @@
-# Temporary Holding Version
+# @atlasauth/pca-policy-ci
 
-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 CI gate for Proof-Carrying Authority (PCA) policies. It statically analyzes an envelope, a minted grant, or a delegation chain and reports findings so an unsafe policy fails the build before it ships. It is driven by the `@atlasauth/pca-analyzer` decision procedure.
+
+Rules (each can be toggled):
+
+- `over-broad-grant`: wildcard verb or resource, a provable always-allow, or a dangerous verb with no narrowing condition
+- `privilege-escalation`: a delegation hop whose authority is not a subset of its parent
+- `redundant-caveat`: a duplicate, subsumed, unsatisfiable, or non-binding caveat or condition
+- `dangerous-reachability`: a dangerous action provably reachable with no budget, rate, or step-up gate
+- `missing-safety-floor`: no expiry, or no blast-radius, rate, or budget gate on a non-trivial grant
+
+A hard `error` is only emitted from a proven analyzer verdict; undecidable features (regex resources, cross-field refs, over-large grids) degrade to a `warn` or `info` that says so.
+
+## Install
+
+```sh
+npm i -D @atlasauth/pca-policy-ci
+```
+
+## Usage
+
+CLI:
+
+```sh
+npx pca-policy-ci policies/*.json [--max-severity error|warn|info] [--format text|github] [--quiet]
+```
+
+Each file is a JSON envelope, grant, compiled policy, `{ predicates, caveats }`, or an array (treated as a delegation chain). The exit code is non-zero when any finding reaches `--max-severity` (default `error`). `--format github` emits GitHub Actions annotations.
+
+Library:
+
+```ts
+import { lint, lintPolicies } from '@atlasauth/pca-policy-ci';
+
+const findings = lint({
+  predicates: [{ verb: '*', resource: '*' }],
+  caveats: [],
+});
+// [{ rule: 'over-broad-grant', severity: 'error', message: '...', where: 'predicates[0]' }, ...]
+
+const summary = lintPolicies(
+  [{ label: 'refund-agent', policy: envelope }],
+  { maxSeverity: 'warn' },
+);
+process.exit(summary.exitCode);
+```
+
+## API
+
+- `lint(input, opts?)`: dispatches to `lintPolicy` (single policy) or `lintChain` (array)
+- `lintPolicies(items, opts?)`: labeled batch, returns a `LintSummary` with `counts`, `ok`, `exitCode`
+- `summarize(results, opts?)`, `normalizePolicyInput`, `DEFAULT_DANGEROUS_VERBS`
+- Options: `rules` to enable/disable or tune each check (dangerous verbs, targets, safety floor)
+
+## Status
+
+Part of [Proof-Carrying Authority](https://github.com/Atlas-Authorization/pca). A clean run means no rule fired, not that a policy is correct; it complements review, not replaces it.
+
+## License
+
+MIT - see LICENSE

package/dist/cli.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * pca-policy-ci — CLI for the PCA policy-safety gate.
+ *
+ * Usage:
+ *   pca-policy-ci <files...> [--max-severity error|warn|info] [--format text|github] [--quiet]
+ *
+ * Each file is a JSON policy document: an `Envelope`, a minted grant (`Capability`), a compiled
+ * policy, a bare `{ predicates, caveats }`, or a JSON ARRAY (treated as a delegation chain). Findings
+ * are printed and the process exits non-zero when any finding is at or above `--max-severity`
+ * (default `error`). `--format github` emits GitHub-Actions workflow annotations.
+ */
+import { type Severity } from './index';
+interface CliArgs {
+    files: string[];
+    maxSeverity: Severity;
+    format: 'text' | 'github';
+    quiet: boolean;
+    help: boolean;
+}
+export declare function parseArgs(argv: readonly string[]): {
+    args: CliArgs;
+} | {
+    error: string;
+};
+export declare function run(argv: readonly string[], write?: (s: string) => void): number;
+export {};

package/dist/cli.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * pca-policy-ci — CLI for the PCA policy-safety gate.
+ *
+ * Usage:
+ *   pca-policy-ci <files...> [--max-severity error|warn|info] [--format text|github] [--quiet]
+ *
+ * Each file is a JSON policy document: an `Envelope`, a minted grant (`Capability`), a compiled
+ * policy, a bare `{ predicates, caveats }`, or a JSON ARRAY (treated as a delegation chain). Findings
+ * are printed and the process exits non-zero when any finding is at or above `--max-severity`
+ * (default `error`). `--format github` emits GitHub-Actions workflow annotations.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.run = run;
+const node_fs_1 = require("node:fs");
+const node_process_1 = __importDefault(require("node:process"));
+const index_1 = require("./index");
+const SEVERITIES = ['error', 'warn', 'info'];
+function isSeverity(x) {
+    return x === 'error' || x === 'warn' || x === 'info';
+}
+function parseArgs(argv) {
+    const files = [];
+    let maxSeverity = 'error';
+    let format = 'text';
+    let quiet = false;
+    let help = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === undefined)
+            continue;
+        if (a === '--help' || a === '-h') {
+            help = true;
+        }
+        else if (a === '--quiet' || a === '-q') {
+            quiet = true;
+        }
+        else if (a === '--max-severity') {
+            const v = argv[++i];
+            if (v === undefined || !isSeverity(v))
+                return { error: `--max-severity expects one of ${SEVERITIES.join('|')}` };
+            maxSeverity = v;
+        }
+        else if (a.startsWith('--max-severity=')) {
+            const v = a.slice('--max-severity='.length);
+            if (!isSeverity(v))
+                return { error: `--max-severity expects one of ${SEVERITIES.join('|')}` };
+            maxSeverity = v;
+        }
+        else if (a === '--format') {
+            const v = argv[++i];
+            if (v !== 'text' && v !== 'github')
+                return { error: `--format expects 'text' or 'github'` };
+            format = v;
+        }
+        else if (a.startsWith('--format=')) {
+            const v = a.slice('--format='.length);
+            if (v !== 'text' && v !== 'github')
+                return { error: `--format expects 'text' or 'github'` };
+            format = v;
+        }
+        else if (a.startsWith('-')) {
+            return { error: `unknown option '${a}'` };
+        }
+        else {
+            files.push(a);
+        }
+    }
+    return { args: { files, maxSeverity, format, quiet, help } };
+}
+const HELP = `pca-policy-ci — statically catch unsafe PCA policies before they ship.
+
+Usage:
+  pca-policy-ci <files...> [options]
+
+Options:
+  --max-severity <error|warn|info>  Lowest severity that fails the gate (default: error)
+  --format <text|github>            Output format (default: text; 'github' = workflow annotations)
+  --quiet, -q                       Only print findings and the summary line
+  --help, -h                        Show this help
+
+Each file is a JSON policy (Envelope / grant / compiled / { predicates, caveats }) or a JSON array
+treated as a delegation chain. Exits non-zero when any finding is at or above --max-severity.`;
+function lintFile(file) {
+    let text;
+    try {
+        text = (0, node_fs_1.readFileSync)(file, 'utf8');
+    }
+    catch (e) {
+        return [{ rule: 'malformed-policy', severity: 'error', message: `cannot read file: ${e instanceof Error ? e.message : String(e)}` }];
+    }
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch (e) {
+        return [{ rule: 'malformed-policy', severity: 'error', message: `invalid JSON: ${e instanceof Error ? e.message : String(e)}` }];
+    }
+    return (0, index_1.lint)(doc);
+}
+const GH_LEVEL = { error: 'error', warn: 'warning', info: 'notice' };
+const TEXT_TAG = { error: 'ERROR', warn: 'WARN', info: 'INFO' };
+function printText(results, quiet, write) {
+    for (const r of results) {
+        if (!quiet)
+            write(`\n${r.label}:`);
+        if (r.findings.length === 0) {
+            if (!quiet)
+                write('  (clean)');
+            continue;
+        }
+        for (const f of r.findings) {
+            const loc = f.where !== undefined ? ` [${f.where}]` : '';
+            write(`  ${TEXT_TAG[f.severity].padEnd(5)} ${f.rule}${loc}: ${f.message}`);
+        }
+    }
+}
+function escapeGh(s) {
+    return s.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+}
+function printGithub(results, write) {
+    for (const r of results) {
+        for (const f of r.findings) {
+            const props = [`file=${escapeGh(r.label)}`, `title=${escapeGh(f.rule)}`].join(',');
+            const loc = f.where !== undefined ? `${f.where}: ` : '';
+            write(`::${GH_LEVEL[f.severity]} ${props}::${escapeGh(`${loc}${f.message}`)}`);
+        }
+    }
+}
+function run(argv, write = (s) => node_process_1.default.stdout.write(s + '\n')) {
+    const parsed = parseArgs(argv);
+    if ('error' in parsed) {
+        write(parsed.error);
+        write(HELP);
+        return 2;
+    }
+    const { args } = parsed;
+    if (args.help) {
+        write(HELP);
+        return 0;
+    }
+    if (args.files.length === 0) {
+        write('error: no policy files given');
+        write(HELP);
+        return 2;
+    }
+    const results = args.files.map((file) => ({ label: file, findings: lintFile(file) }));
+    const summary = (0, index_1.summarize)(results, { maxSeverity: args.maxSeverity });
+    if (args.format === 'github')
+        printGithub(results, write);
+    else
+        printText(results, args.quiet, write);
+    write(`\n${summary.ok ? 'PASS' : 'FAIL'} — ${summary.counts.error} error(s), ${summary.counts.warn} warning(s), ${summary.counts.info} info across ${results.length} policy/policies (fail threshold: ${summary.maxSeverity})`);
+    return summary.exitCode;
+}
+// Entry point (skipped when imported by tests). Guarded so it is inert under a test runner that may
+// not provide the CommonJS `require`/`module` globals.
+if (typeof require !== 'undefined' && typeof module !== 'undefined' && require.main === module) {
+    node_process_1.default.exit(run(node_process_1.default.argv.slice(2)));
+}
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

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

package/dist/deps.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Centralized re-exports of the two upstream packages this gate is built on. The CI gate does NOT
+ * re-implement any static analysis — it drives the real `@atlasauth/pca-analyzer` decision procedure
+ * and reads the real `@atlasauth/pca` policy shapes.
+ */
+export { alwaysAllows, alwaysDenies, disjoint, equivalent, reachable, subsumes, predicateNumericSatisfiable, tightenInterval, intervalEmpty, FULL_INTERVAL, } from '@atlasauth/pca-analyzer';
+export type { AnalyzerAction, AnalyzerOptions, PolicyInput, NumInterval, ReachableResult, AlwaysAllowsResult, AlwaysDeniesResult, SubsumesResult, } from '@atlasauth/pca-analyzer';
+export { ENVELOPE_CAVEAT, isLeafCondition } from '@atlasauth/pca';
+export type { Capability, Caveat, Condition, Envelope, LeafCondition, Predicate, RiskPolicy } from '@atlasauth/pca';

package/dist/deps.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Centralized re-exports of the two upstream packages this gate is built on. The CI gate does NOT
+ * re-implement any static analysis — it drives the real `@atlasauth/pca-analyzer` decision procedure
+ * and reads the real `@atlasauth/pca` policy shapes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLeafCondition = exports.ENVELOPE_CAVEAT = exports.FULL_INTERVAL = exports.intervalEmpty = exports.tightenInterval = exports.predicateNumericSatisfiable = exports.subsumes = exports.reachable = exports.equivalent = exports.disjoint = exports.alwaysDenies = exports.alwaysAllows = void 0;
+var pca_analyzer_1 = require("@atlasauth/pca-analyzer");
+Object.defineProperty(exports, "alwaysAllows", { enumerable: true, get: function () { return pca_analyzer_1.alwaysAllows; } });
+Object.defineProperty(exports, "alwaysDenies", { enumerable: true, get: function () { return pca_analyzer_1.alwaysDenies; } });
+Object.defineProperty(exports, "disjoint", { enumerable: true, get: function () { return pca_analyzer_1.disjoint; } });
+Object.defineProperty(exports, "equivalent", { enumerable: true, get: function () { return pca_analyzer_1.equivalent; } });
+Object.defineProperty(exports, "reachable", { enumerable: true, get: function () { return pca_analyzer_1.reachable; } });
+Object.defineProperty(exports, "subsumes", { enumerable: true, get: function () { return pca_analyzer_1.subsumes; } });
+Object.defineProperty(exports, "predicateNumericSatisfiable", { enumerable: true, get: function () { return pca_analyzer_1.predicateNumericSatisfiable; } });
+Object.defineProperty(exports, "tightenInterval", { enumerable: true, get: function () { return pca_analyzer_1.tightenInterval; } });
+Object.defineProperty(exports, "intervalEmpty", { enumerable: true, get: function () { return pca_analyzer_1.intervalEmpty; } });
+Object.defineProperty(exports, "FULL_INTERVAL", { enumerable: true, get: function () { return pca_analyzer_1.FULL_INTERVAL; } });
+var pca_1 = require("@atlasauth/pca");
+Object.defineProperty(exports, "ENVELOPE_CAVEAT", { enumerable: true, get: function () { return pca_1.ENVELOPE_CAVEAT; } });
+Object.defineProperty(exports, "isLeafCondition", { enumerable: true, get: function () { return pca_1.isLeafCondition; } });
+//# sourceMappingURL=deps.js.map

package/dist/deps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.js","sourceRoot":"","sources":["../src/deps.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,wDAWiC;AAV/B,4GAAA,YAAY,OAAA;AACZ,4GAAA,YAAY,OAAA;AACZ,wGAAA,QAAQ,OAAA;AACR,0GAAA,UAAU,OAAA;AACV,yGAAA,SAAS,OAAA;AACT,wGAAA,QAAQ,OAAA;AACR,2HAAA,2BAA2B,OAAA;AAC3B,+GAAA,eAAe,OAAA;AACf,6GAAA,aAAa,OAAA;AACb,6GAAA,aAAa,OAAA;AAcf,sCAAkE;AAAzD,sGAAA,eAAe,OAAA;AAAE,sGAAA,eAAe,OAAA"}

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @atlasauth/pca-policy-ci — a CI gate that STATICALLY catches unsafe PCA policies before they ship.
+ *
+ * This is the "shift-left policy safety" boundary. It drives the real `@atlasauth/pca-analyzer`
+ * decision procedure (reachability, totality/always-allow, delegation-safety subsumption, numeric
+ * satisfiability) over a PCA `Envelope` / `grant` / chain and reports a list of {@link Finding}s. Five
+ * rules, each toggleable:
+ *
+ *  - **over-broad-grant** — a wildcard verb/resource, a semantically-proven always-allow, or a
+ *    dangerous verb granted with no narrowing `where` or scope-narrowing caveat.
+ *  - **privilege-escalation** — a delegation hop whose effective authority is NOT a subset of its
+ *    parent (a hard error if the analyzer proves it; attenuation should make this impossible).
+ *  - **redundant-caveat** — a caveat (or `where` condition) that can never bite: a duplicate, one
+ *    subsumed by a stricter one of the same type, an unsatisfiable predicate, a non-binding bound.
+ *  - **dangerous-reachability** — a dangerous (verb, resource) the analyzer PROVES reachable with no
+ *    budget / rate / step-up gate.
+ *  - **missing-safety-floor** — no expiry, or no blast/rate/budget gate on a non-trivial grant.
+ *
+ * SOUNDNESS: a hard `error` is only ever emitted from a PROVEN analyzer verdict. Any undecidable
+ * feature (a `re:` regex resource, a cross-field `ref`, an over-large grid) fails safe to a
+ * `warn`/`info` that says it is undecidable — the gate never fails a build on a false positive, and
+ * never silently passes a provably-unsafe policy.
+ */
+import type { AnalyzerOptions } from './deps';
+import { type Finding, type LabeledFindings, type LintRules, type LintSummary, type SummaryOptions } from './types';
+export * from './types';
+export { normalizePolicyInput, normalizeChain, isCapability, isEnvelope, type NormalizedPolicy } from './normalize';
+export interface LintOptions extends AnalyzerOptions {
+    rules?: LintRules;
+}
+/**
+ * Lint a single PCA policy: an `Envelope`, a minted `grant` (`Capability`), a `compilePolicy` result,
+ * or a bare `{ predicates, caveats? }`. Returns all findings (empty = clean).
+ */
+export declare function lintPolicy(input: unknown, opts?: LintOptions): Finding[];
+/**
+ * Lint a delegation chain (root -> leaf): a `Capability[]` (a real minted chain) or an array of
+ * already-effective `{ predicates, caveats }` hops. Runs the privilege-escalation check across every
+ * consecutive pair, then runs the single-policy rules on the acting LEAF's effective authority.
+ */
+export declare function lintChain(chain: readonly unknown[], opts?: LintOptions): Finding[];
+/** Dispatch: an array input is a delegation chain ({@link lintChain}); anything else is a single policy. */
+export declare function lint(input: unknown, opts?: LintOptions): Finding[];
+export interface LintItem {
+    label?: string;
+    policy: unknown;
+}
+/** Lint a list of labeled policies (or chains) and roll the findings into a {@link LintSummary}. */
+export declare function lintPolicies(items: readonly LintItem[], opts?: LintOptions & SummaryOptions): LintSummary;
+/** Roll a set of labeled findings into counts + an exit-code mapping (`error` -> non-zero). */
+export declare function summarize(results: LabeledFindings[], opts?: SummaryOptions): LintSummary;

package/dist/index.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * @atlasauth/pca-policy-ci — a CI gate that STATICALLY catches unsafe PCA policies before they ship.
+ *
+ * This is the "shift-left policy safety" boundary. It drives the real `@atlasauth/pca-analyzer`
+ * decision procedure (reachability, totality/always-allow, delegation-safety subsumption, numeric
+ * satisfiability) over a PCA `Envelope` / `grant` / chain and reports a list of {@link Finding}s. Five
+ * rules, each toggleable:
+ *
+ *  - **over-broad-grant** — a wildcard verb/resource, a semantically-proven always-allow, or a
+ *    dangerous verb granted with no narrowing `where` or scope-narrowing caveat.
+ *  - **privilege-escalation** — a delegation hop whose effective authority is NOT a subset of its
+ *    parent (a hard error if the analyzer proves it; attenuation should make this impossible).
+ *  - **redundant-caveat** — a caveat (or `where` condition) that can never bite: a duplicate, one
+ *    subsumed by a stricter one of the same type, an unsatisfiable predicate, a non-binding bound.
+ *  - **dangerous-reachability** — a dangerous (verb, resource) the analyzer PROVES reachable with no
+ *    budget / rate / step-up gate.
+ *  - **missing-safety-floor** — no expiry, or no blast/rate/budget gate on a non-trivial grant.
+ *
+ * SOUNDNESS: a hard `error` is only ever emitted from a PROVEN analyzer verdict. Any undecidable
+ * feature (a `re:` regex resource, a cross-field `ref`, an over-large grid) fails safe to a
+ * `warn`/`info` that says it is undecidable — the gate never fails a build on a false positive, and
+ * never silently passes a provably-unsafe policy.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnvelope = exports.isCapability = exports.normalizeChain = exports.normalizePolicyInput = void 0;
+exports.lintPolicy = lintPolicy;
+exports.lintChain = lintChain;
+exports.lint = lint;
+exports.lintPolicies = lintPolicies;
+exports.summarize = summarize;
+const normalize_1 = require("./normalize");
+const rules_1 = require("./rules");
+const types_1 = require("./types");
+__exportStar(require("./types"), exports);
+var normalize_2 = require("./normalize");
+Object.defineProperty(exports, "normalizePolicyInput", { enumerable: true, get: function () { return normalize_2.normalizePolicyInput; } });
+Object.defineProperty(exports, "normalizeChain", { enumerable: true, get: function () { return normalize_2.normalizeChain; } });
+Object.defineProperty(exports, "isCapability", { enumerable: true, get: function () { return normalize_2.isCapability; } });
+Object.defineProperty(exports, "isEnvelope", { enumerable: true, get: function () { return normalize_2.isEnvelope; } });
+function resolveRules(rules) {
+    const r = rules ?? {};
+    const ob = r.overBroadGrant;
+    const dr = r.dangerousReachability;
+    const sf = r.missingSafetyFloor;
+    return {
+        overBroadGrant: {
+            enabled: ob !== false,
+            dangerousVerbs: typeof ob === 'object' && ob.dangerousVerbs ? ob.dangerousVerbs : types_1.DEFAULT_DANGEROUS_VERBS,
+        },
+        privilegeEscalation: r.privilegeEscalation !== false,
+        redundantCaveat: r.redundantCaveat !== false,
+        dangerousReachability: {
+            enabled: dr !== false,
+            dangerousVerbs: typeof dr === 'object' && dr.dangerousVerbs ? dr.dangerousVerbs : types_1.DEFAULT_DANGEROUS_VERBS,
+            targets: typeof dr === 'object' && dr.targets ? dr.targets : [],
+        },
+        missingSafetyFloor: {
+            enabled: sf !== false,
+            requireExpiry: typeof sf === 'object' ? sf.requireExpiry !== false : true,
+            requireScopeGate: typeof sf === 'object' ? sf.requireScopeGate !== false : true,
+        },
+    };
+}
+function analyzerOpts(opts) {
+    return opts?.maxCombinations !== undefined ? { maxCombinations: opts.maxCombinations } : {};
+}
+// ---- lintPolicy / lintChain / lint ----------------------------------------------------------------
+/**
+ * Lint a single PCA policy: an `Envelope`, a minted `grant` (`Capability`), a `compilePolicy` result,
+ * or a bare `{ predicates, caveats? }`. Returns all findings (empty = clean).
+ */
+function lintPolicy(input, opts = {}) {
+    const norm = (0, normalize_1.normalizePolicyInput)(input);
+    if (!norm.ok)
+        return [{ rule: 'malformed-policy', severity: 'error', message: norm.reason }];
+    const cfg = resolveRules(opts.rules);
+    const ao = analyzerOpts(opts);
+    const policy = norm.policy;
+    const out = [];
+    if (cfg.overBroadGrant.enabled)
+        out.push(...(0, rules_1.ruleOverBroadGrant)(policy, cfg.overBroadGrant.dangerousVerbs, ao));
+    if (cfg.redundantCaveat)
+        out.push(...(0, rules_1.ruleRedundantCaveat)(policy));
+    if (cfg.dangerousReachability.enabled) {
+        out.push(...(0, rules_1.ruleDangerousReachability)(policy, cfg.dangerousReachability.dangerousVerbs, cfg.dangerousReachability.targets, ao));
+    }
+    if (cfg.missingSafetyFloor.enabled) {
+        out.push(...(0, rules_1.ruleMissingSafetyFloor)(policy, cfg.missingSafetyFloor, cfg.overBroadGrant.dangerousVerbs));
+    }
+    return out;
+}
+/**
+ * Lint a delegation chain (root -> leaf): a `Capability[]` (a real minted chain) or an array of
+ * already-effective `{ predicates, caveats }` hops. Runs the privilege-escalation check across every
+ * consecutive pair, then runs the single-policy rules on the acting LEAF's effective authority.
+ */
+function lintChain(chain, opts = {}) {
+    const norm = (0, normalize_1.normalizeChain)(chain);
+    if (!norm.ok)
+        return [{ rule: 'malformed-policy', severity: 'error', message: norm.reason }];
+    const cfg = resolveRules(opts.rules);
+    const ao = analyzerOpts(opts);
+    const hops = norm.hops;
+    const out = [];
+    if (cfg.privilegeEscalation)
+        out.push(...(0, rules_1.rulePrivilegeEscalation)(hops, ao));
+    const leaf = hops[hops.length - 1];
+    if (leaf !== undefined) {
+        if (cfg.overBroadGrant.enabled)
+            out.push(...(0, rules_1.ruleOverBroadGrant)(leaf, cfg.overBroadGrant.dangerousVerbs, ao));
+        if (cfg.redundantCaveat)
+            out.push(...(0, rules_1.ruleRedundantCaveat)(leaf));
+        if (cfg.dangerousReachability.enabled) {
+            out.push(...(0, rules_1.ruleDangerousReachability)(leaf, cfg.dangerousReachability.dangerousVerbs, cfg.dangerousReachability.targets, ao));
+        }
+        if (cfg.missingSafetyFloor.enabled) {
+            out.push(...(0, rules_1.ruleMissingSafetyFloor)(leaf, cfg.missingSafetyFloor, cfg.overBroadGrant.dangerousVerbs));
+        }
+    }
+    return out;
+}
+/** Dispatch: an array input is a delegation chain ({@link lintChain}); anything else is a single policy. */
+function lint(input, opts = {}) {
+    return Array.isArray(input) ? lintChain(input, opts) : lintPolicy(input, opts);
+}
+/** Lint a list of labeled policies (or chains) and roll the findings into a {@link LintSummary}. */
+function lintPolicies(items, opts = {}) {
+    const results = items.map((item, i) => ({
+        label: item.label ?? `policy[${i}]`,
+        findings: lint(item.policy, opts),
+    }));
+    return summarize(results, opts);
+}
+/** Roll a set of labeled findings into counts + an exit-code mapping (`error` -> non-zero). */
+function summarize(results, opts = {}) {
+    const maxSeverity = opts.maxSeverity ?? 'error';
+    const counts = { error: 0, warn: 0, info: 0 };
+    let failing = 0;
+    const threshold = types_1.SEVERITY_RANK[maxSeverity];
+    for (const r of results) {
+        for (const f of r.findings) {
+            counts[f.severity] += 1;
+            if (types_1.SEVERITY_RANK[f.severity] >= threshold)
+                failing += 1;
+        }
+    }
+    const ok = failing === 0;
+    return { results, counts, maxSeverity, ok, exitCode: ok ? 0 : 1 };
+}
+//# 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/dist/normalize.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Input detection + normalization.
+ *
+ * `lintPolicy` accepts anything a principal might hand a CI gate: a bare predicate/caveat set, a
+ * compiled policy, a signed `Envelope`, or a minted `grant` (`Capability`). They all reduce to the
+ * same effective authority — a predicate set plus the runtime caveat (gate) set, and (when known) the
+ * risk policy. The grant/chain reduction is the subtle part and is documented on {@link fromGrant}.
+ */
+import { type Capability, type Caveat, type Envelope, type Predicate, type RiskPolicy } from '@atlasauth/pca';
+export type PolicyKind = 'bare' | 'compiled' | 'envelope' | 'grant' | 'chain-hop';
+/** The effective authority of one policy (or one chain hop), ready for the static analyzer. */
+export interface NormalizedPolicy {
+    predicates: Predicate[];
+    /** Runtime gate caveats (expires / rate / max_blast_radius / reversibility_max / ...). */
+    caveats: Caveat[];
+    /** The risk policy, when the input carried one (envelope / grant / compiled). */
+    riskPolicy?: RiskPolicy;
+    kind: PolicyKind;
+}
+export type NormalizeResult = {
+    ok: true;
+    policy: NormalizedPolicy;
+} | {
+    ok: false;
+    reason: string;
+};
+/** A minted grant / delegation hop: has the content-addressed, signed shape of a `Capability`. */
+export declare function isCapability(x: unknown): x is Capability;
+/** A signed policy envelope (the Root Intent Grant payload). */
+export declare function isEnvelope(x: unknown): x is Envelope;
+/**
+ * Reduce a grant to its effective authority. The grant's predicates and baseline gate caveats live
+ * INSIDE its first `envelope` caveat (signed into the grant). Delegation then APPENDS further gate
+ * caveats to the grant's top-level `caveats` array. So the effective gates are the envelope's own
+ * caveats PLUS the appended (non-envelope) top-level caveats, and the predicates come from the
+ * envelope. A malformed / unreadable envelope is a hard failure the caller surfaces as a finding.
+ */
+export declare function fromGrant(grant: Capability): NormalizeResult;
+/** Normalize any single-policy input to its effective authority. */
+export declare function normalizePolicyInput(input: unknown): NormalizeResult;
+export type ChainNormalizeResult = {
+    ok: true;
+    hops: NormalizedPolicy[];
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Normalize a delegation chain to one {@link NormalizedPolicy} per hop (root -> leaf). A chain of
+ * `Capability`s uses the grant reduction: the predicates are shared (from the root envelope) and each
+ * hop's effective gate caveats are the envelope's caveats plus that hop's appended caveats, so a
+ * well-formed (append-only) chain yields a monotonically narrowing authority. A chain of already
+ * effective `{ predicates, caveats }` hops is taken as-is (useful for testing an escalation directly).
+ */
+export declare function normalizeChain(chain: readonly unknown[]): ChainNormalizeResult;