@atlasauth/pca-policy-ci 0.0.0-stage → 0.1.0

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;

package/dist/normalize.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * 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}.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCapability = isCapability;
+exports.isEnvelope = isEnvelope;
+exports.fromGrant = fromGrant;
+exports.normalizePolicyInput = normalizePolicyInput;
+exports.normalizeChain = normalizeChain;
+const pca_1 = require("@atlasauth/pca");
+const util_1 = require("./util");
+function isRecord(x) {
+    return x !== null && typeof x === 'object' && !Array.isArray(x);
+}
+/** A minted grant / delegation hop: has the content-addressed, signed shape of a `Capability`. */
+function isCapability(x) {
+    if (!isRecord(x))
+        return false;
+    return (typeof x.id === 'string' &&
+        typeof x.issuer === 'string' &&
+        typeof x.holder === 'string' &&
+        typeof x.body_digest === 'string' &&
+        typeof x.sig === 'string' &&
+        Array.isArray(x.caveats));
+}
+/** A signed policy envelope (the Root Intent Grant payload). */
+function isEnvelope(x) {
+    if (!isRecord(x))
+        return false;
+    return (typeof x.goal_commit === 'string' &&
+        Array.isArray(x.predicates) &&
+        Array.isArray(x.caveats) &&
+        isRecord(x.agent_binding) &&
+        isRecord(x.risk_policy));
+}
+/** A `compilePolicy` result. */
+function isCompiledPolicy(x) {
+    if (!isRecord(x))
+        return false;
+    return Array.isArray(x.predicates) && Array.isArray(x.caveats) && isRecord(x.riskPolicy) && Array.isArray(x.actions);
+}
+/** A bare `{ predicates, caveats? }` policy. */
+function isBarePolicy(x) {
+    return isRecord(x) && Array.isArray(x.predicates);
+}
+/** Drop the envelope-carrying caveat; keep the runtime gate caveats (and any appended attenuation). */
+function runtimeCaveats(caveats) {
+    return caveats.filter((c) => c !== null && typeof c === 'object' && c.type !== util_1.ENVELOPE_CAVEAT_TYPE);
+}
+/**
+ * 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.
+ */
+function fromGrant(grant) {
+    const env = (0, pca_1.readEnvelope)(grant);
+    if (env === null) {
+        return { ok: false, reason: 'grant has no readable `envelope` caveat (malformed or unsigned payload)' };
+    }
+    const appended = runtimeCaveats(Array.isArray(grant.caveats) ? grant.caveats : []);
+    return {
+        ok: true,
+        policy: {
+            predicates: env.predicates,
+            caveats: [...env.caveats, ...appended],
+            riskPolicy: env.risk_policy,
+            kind: 'grant',
+        },
+    };
+}
+/** Normalize any single-policy input to its effective authority. */
+function normalizePolicyInput(input) {
+    if (isCapability(input))
+        return fromGrant(input);
+    if (isEnvelope(input)) {
+        return { ok: true, policy: { predicates: input.predicates, caveats: input.caveats, riskPolicy: input.risk_policy, kind: 'envelope' } };
+    }
+    if (isCompiledPolicy(input)) {
+        return { ok: true, policy: { predicates: input.predicates, caveats: input.caveats, riskPolicy: input.riskPolicy, kind: 'compiled' } };
+    }
+    if (isBarePolicy(input)) {
+        const caveats = Array.isArray(input.caveats) ? input.caveats : [];
+        return { ok: true, policy: { predicates: input.predicates, caveats, kind: 'bare' } };
+    }
+    return { ok: false, reason: 'unrecognized policy shape (expected an envelope, grant, compiled policy, or { predicates, caveats })' };
+}
+/**
+ * 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).
+ */
+function normalizeChain(chain) {
+    if (chain.length === 0)
+        return { ok: false, reason: 'empty chain' };
+    if (chain.every((c) => isCapability(c))) {
+        const caps = chain;
+        const root = caps[0];
+        if (root === undefined)
+            return { ok: false, reason: 'empty chain' };
+        const env = (0, pca_1.readEnvelope)(root);
+        if (env === null)
+            return { ok: false, reason: 'root grant has no readable `envelope` caveat' };
+        const hops = caps.map((cap) => ({
+            predicates: env.predicates,
+            caveats: [...env.caveats, ...runtimeCaveats(Array.isArray(cap.caveats) ? cap.caveats : [])],
+            riskPolicy: env.risk_policy,
+            kind: 'chain-hop',
+        }));
+        return { ok: true, hops };
+    }
+    const hops = [];
+    for (let i = 0; i < chain.length; i++) {
+        const r = normalizePolicyInput(chain[i]);
+        if (!r.ok)
+            return { ok: false, reason: `hop ${i}: ${r.reason}` };
+        hops.push({ ...r.policy, kind: 'chain-hop' });
+    }
+    return { ok: true, hops };
+}
+//# sourceMappingURL=normalize.js.map

package/dist/normalize.js.map

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

package/dist/rules.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The five policy-safety rules, each driving the real static analyzer. Every rule is SOUND: a verdict
+ * is only ever reported as a hard `error` when the analyzer PROVES it (its result is not
+ * `approximate`); an undecidable policy feature downgrades to a `warn`/`info` that says so, so the
+ * gate never fails the build on a false positive.
+ */
+import { type AnalyzerOptions } from './deps';
+import type { NormalizedPolicy } from './normalize';
+import { type DangerousTarget, type Finding } from './types';
+export declare function ruleOverBroadGrant(policy: NormalizedPolicy, dangerous: readonly string[], opts: AnalyzerOptions): Finding[];
+export declare function rulePrivilegeEscalation(hops: readonly NormalizedPolicy[], opts: AnalyzerOptions): Finding[];
+export declare function ruleRedundantCaveat(policy: NormalizedPolicy): Finding[];
+export declare function ruleDangerousReachability(policy: NormalizedPolicy, dangerous: readonly string[], extraTargets: readonly DangerousTarget[], opts: AnalyzerOptions): Finding[];
+export declare function ruleMissingSafetyFloor(policy: NormalizedPolicy, cfg: {
+    requireExpiry: boolean;
+    requireScopeGate: boolean;
+}, dangerous: readonly string[]): Finding[];

package/dist/rules.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * The five policy-safety rules, each driving the real static analyzer. Every rule is SOUND: a verdict
+ * is only ever reported as a hard `error` when the analyzer PROVES it (its result is not
+ * `approximate`); an undecidable policy feature downgrades to a `warn`/`info` that says so, so the
+ * gate never fails the build on a false positive.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleOverBroadGrant = ruleOverBroadGrant;
+exports.rulePrivilegeEscalation = rulePrivilegeEscalation;
+exports.ruleRedundantCaveat = ruleRedundantCaveat;
+exports.ruleDangerousReachability = ruleDangerousReachability;
+exports.ruleMissingSafetyFloor = ruleMissingSafetyFloor;
+const deps_1 = require("./deps");
+const pca_1 = require("@atlasauth/pca");
+const util_1 = require("./util");
+function analyzerInput(p) {
+    return { predicates: p.predicates, caveats: p.caveats };
+}
+function find(rule, severity, message, where) {
+    return where === undefined ? { rule, severity, message } : { rule, severity, message, where };
+}
+/** Every concrete verb named across the predicate set, plus whether any predicate grants `'*'`. */
+function declaredVerbs(predicates) {
+    const concrete = [];
+    let hasWildcard = false;
+    for (const p of predicates) {
+        if (p === null || typeof p !== 'object')
+            continue;
+        for (const v of (0, util_1.verbsOf)(p.verb)) {
+            if (v === '*')
+                hasWildcard = true;
+            else
+                concrete.push(v);
+        }
+    }
+    return { concrete: (0, util_1.uniq)(concrete), hasWildcard };
+}
+/** Does the policy carry a budget / step-up gate that bounds a dangerous action? */
+function gateDescription(policy) {
+    const gates = [];
+    if ((0, util_1.hasCaveatOfType)(policy.caveats, util_1.BUDGET_GATE_CAVEATS)) {
+        gates.push(policy.caveats.filter((c) => util_1.BUDGET_GATE_CAVEATS.includes(c.type)).map((c) => c.type).join('/'));
+    }
+    const rp = policy.riskPolicy;
+    if (rp !== undefined && Number.isFinite(rp.theta2) && rp.theta2 < 1)
+        gates.push('risk step-up (theta2 < 1)');
+    return gates.length > 0 ? gates.join(', ') : undefined;
+}
+// ---- 1. over-broad grant --------------------------------------------------------------------------
+function ruleOverBroadGrant(policy, dangerous, opts) {
+    const out = [];
+    const input = analyzerInput(policy);
+    const hasScopeNarrowing = (0, util_1.hasCaveatOfType)(policy.caveats, util_1.SCOPE_NARROWING_CAVEATS);
+    policy.predicates.forEach((p, i) => {
+        if (p === null || typeof p !== 'object')
+            return;
+        const verbs = (0, util_1.verbsOf)(p.verb);
+        const where = `predicates[${i}]`;
+        const hasWhere = Array.isArray(p.where) && p.where.length > 0;
+        if (verbs.includes('*')) {
+            out.push(find('over-broad-grant', 'error', `predicate grants a WILDCARD verb '*' — authority over any action`, where));
+        }
+        if ((0, util_1.isWildcardResource)(p.resource)) {
+            const dangerousVerbs = verbs.filter((v) => (0, util_1.isDangerousVerb)(v, dangerous));
+            if (dangerousVerbs.length > 0) {
+                out.push(find('over-broad-grant', 'error', `dangerous verb(s) ${JSON.stringify(dangerousVerbs)} granted on a WILDCARD resource ('*')`, where));
+            }
+            else if (!verbs.includes('*')) {
+                out.push(find('over-broad-grant', 'warn', `predicate matches ANY resource ('*') — consider a resource prefix`, where));
+            }
+        }
+        for (const v of verbs) {
+            if (v !== '*' && (0, util_1.isDangerousVerb)(v, dangerous) && !hasWhere && !hasScopeNarrowing) {
+                out.push(find('over-broad-grant', 'error', `dangerous verb '${v}' is granted with NO narrowing \`where\` and no scope-narrowing caveat (${util_1.SCOPE_NARROWING_CAVEATS.join('/')})`, where));
+            }
+        }
+    });
+    // Semantic always-allow: a verb the analyzer PROVES is total (admits every action of that verb).
+    const { concrete } = declaredVerbs(policy.predicates);
+    for (const v of concrete) {
+        const aa = (0, deps_1.alwaysAllows)(input, v, opts);
+        if (aa.alwaysAllows && aa.approximate !== true) {
+            out.push(find('over-broad-grant', 'error', `grants EVERY action of '${v}' — the authority has no effective constraint (always-allow)`));
+        }
+    }
+    return out;
+}
+// ---- 2. privilege escalation in a chain -----------------------------------------------------------
+function rulePrivilegeEscalation(hops, opts) {
+    const out = [];
+    for (let i = 1; i < hops.length; i++) {
+        const parent = hops[i - 1];
+        const child = hops[i];
+        if (parent === undefined || child === undefined)
+            continue;
+        // A well-attenuated child admits a SUBSET of its parent, i.e. the parent subsumes the child.
+        const s = (0, deps_1.subsumes)(analyzerInput(parent), analyzerInput(child), opts);
+        const where = `hop[${i}]`;
+        if (s.subsumes)
+            continue;
+        if (s.approximate === true) {
+            out.push(find('privilege-escalation', 'warn', `could not prove hop ${i} attenuation (undecidable${s.reason ? `: ${s.reason}` : ''}) — attenuation not verified`, where));
+        }
+        else {
+            const ex = s.counterexample !== undefined ? ` — child admits '${(0, util_1.describeAction)(s.counterexample)}' which its parent denies` : '';
+            out.push(find('privilege-escalation', 'error', `delegation hop ${i} ESCALATES authority: its effective authority is not a subset of its parent (attenuation violated)${ex}`, where));
+        }
+    }
+    return out;
+}
+// For each type: which numeric field carries its bound, and whether the STRICTEST (binding) one is the
+// min or the max. Any non-binding caveat of the same type can never bite — it is dead policy.
+const ORDERED_CAVEATS = {
+    expires: { field: 'at', keep: 'min' }, // earliest expiry dominates
+    not_before: { field: 'at', keep: 'max' }, // latest not-before dominates
+    max_blast_radius: { field: 'max', keep: 'min' }, // smallest radius dominates
+    delegation_depth: { field: 'max', keep: 'min' }, // smallest depth dominates
+    budget_alloc: { field: 'limit', keep: 'min' }, // smallest allocation dominates
+};
+function caveatKey(cv) {
+    try {
+        return JSON.stringify(cv);
+    }
+    catch {
+        return `${cv.type}:<unserializable>`;
+    }
+}
+function ruleRedundantCaveat(policy) {
+    const out = [];
+    // (a) exact-duplicate caveats.
+    const seen = new Map();
+    policy.caveats.forEach((cv, i) => {
+        if (cv === null || typeof cv !== 'object')
+            return;
+        const k = caveatKey(cv);
+        const first = seen.get(k);
+        if (first !== undefined) {
+            out.push(find('redundant-caveat', 'warn', `caveat ${i} ('${cv.type}') is an exact duplicate of caveat ${first} — dead policy`, `caveats[${i}]`));
+        }
+        else {
+            seen.set(k, i);
+        }
+    });
+    // (b) same-type domination: a looser caveat that a stricter one of the same type always subsumes.
+    for (const [type, spec] of Object.entries(ORDERED_CAVEATS)) {
+        const entries = policy.caveats
+            .map((cv, i) => ({ cv, i }))
+            .filter((e) => e.cv !== null && typeof e.cv === 'object' && e.cv.type === type);
+        const vals = entries.map((e) => ({ ...e, v: (0, util_1.num)(e.cv[spec.field]) })).filter((e) => e.v !== undefined);
+        if (vals.length < 2)
+            continue;
+        const binding = spec.keep === 'min' ? Math.min(...vals.map((e) => e.v)) : Math.max(...vals.map((e) => e.v));
+        for (const e of vals) {
+            if (e.v !== binding) {
+                out.push(find('redundant-caveat', 'warn', `caveat ${e.i} ('${type}' ${spec.field}=${e.v}) is subsumed by a stricter '${type}' (${spec.field}=${binding}) — it can never bite`, `caveats[${e.i}]`));
+            }
+        }
+    }
+    // (c) a predicate whose numeric `where` conjunction is UNSATISFIABLE never matches — dead policy.
+    policy.predicates.forEach((p, i) => {
+        if (p === null || typeof p !== 'object' || !Array.isArray(p.where))
+            return;
+        if (!(0, deps_1.predicateNumericSatisfiable)(p.where)) {
+            out.push(find('redundant-caveat', 'warn', `predicate ${i} can never match — its numeric \`where\` constraints are unsatisfiable (dead policy)`, `predicates[${i}]`));
+        }
+        else {
+            out.push(...nonBindingConditions(p.where, i));
+        }
+    });
+    return out;
+}
+const NUMERIC_OPS = new Set(['lt', 'lte', 'gt', 'gte', 'eq']);
+function intervalEq(a, b) {
+    return a.lo === b.lo && a.loInclusive === b.loInclusive && a.hi === b.hi && a.hiInclusive === b.hiInclusive;
+}
+/** A numeric leaf condition that does not tighten its field's interval is redundant (never binds). */
+function nonBindingConditions(where, predIndex) {
+    const byField = new Map();
+    where.forEach((c, i) => {
+        if (!(0, pca_1.isLeafCondition)(c))
+            return;
+        if (c.ref !== undefined)
+            return;
+        if (typeof c.op !== 'string' || !NUMERIC_OPS.has(c.op))
+            return;
+        if ((0, util_1.num)(c.value) === undefined)
+            return;
+        const arr = byField.get(c.field) ?? [];
+        arr.push({ c, i });
+        byField.set(c.field, arr);
+    });
+    const out = [];
+    for (const [field, conds] of byField) {
+        if (conds.length < 2)
+            continue;
+        const full = conds.reduce((iv, e) => (0, deps_1.tightenInterval)(iv, e.c.op, e.c.value), deps_1.FULL_INTERVAL);
+        if ((0, deps_1.intervalEmpty)(full))
+            continue; // the whole-predicate unsat case is reported in (c)
+        for (const e of conds) {
+            const without = conds.filter((x) => x !== e).reduce((iv, x) => (0, deps_1.tightenInterval)(iv, x.c.op, x.c.value), deps_1.FULL_INTERVAL);
+            if (intervalEq(without, full)) {
+                out.push(find('redundant-caveat', 'info', `condition on '${field}' (${e.c.op} ${String(e.c.value)}) does not tighten the authority — redundant with the other bounds on this field`, `predicates[${predIndex}].where[${e.i}]`));
+            }
+        }
+    }
+    return out;
+}
+// ---- 4. dangerous reachability --------------------------------------------------------------------
+function ruleDangerousReachability(policy, dangerous, extraTargets, opts) {
+    const out = [];
+    const input = analyzerInput(policy);
+    const { concrete } = declaredVerbs(policy.predicates);
+    const derived = concrete.filter((v) => (0, util_1.isDangerousVerb)(v, dangerous)).map((verb) => ({ verb }));
+    const targets = [...derived, ...extraTargets];
+    const gate = gateDescription(policy);
+    for (const t of targets) {
+        let proven = false;
+        let approximate = false;
+        let reason;
+        let witness;
+        if (t.resource !== undefined) {
+            const r = (0, deps_1.reachable)(input, { verb: t.verb, resource: t.resource }, opts);
+            proven = r.reachable && r.approximate !== true;
+            approximate = r.approximate === true;
+            reason = r.reason;
+            witness = `${t.verb} ${t.resource}`;
+        }
+        else {
+            const ad = (0, deps_1.alwaysDenies)(input, t.verb, opts);
+            proven = ad.alwaysDenies === false && ad.approximate !== true;
+            approximate = ad.approximate === true;
+            reason = ad.reason;
+            witness = ad.witness !== undefined ? (0, util_1.describeAction)(ad.witness) : t.verb;
+        }
+        if (approximate) {
+            out.push(find('dangerous-reachability', 'warn', `could not decide reachability of dangerous verb '${t.verb}' (undecidable${reason ? `: ${reason}` : ''})`));
+        }
+        else if (proven) {
+            if (gate === undefined) {
+                out.push(find('dangerous-reachability', 'error', `dangerous action '${witness}' is REACHABLE with no budget / rate / step-up gate`));
+            }
+            else {
+                out.push(find('dangerous-reachability', 'info', `dangerous action '${witness}' is reachable but gated by ${gate}`));
+            }
+        }
+    }
+    return out;
+}
+// ---- 5. missing safety floor ----------------------------------------------------------------------
+/** A grant is non-trivial when any predicate grants a dangerous/wildcard verb, a wildcard resource, or is unconstrained. */
+function isNonTrivial(policy, dangerous) {
+    return policy.predicates.some((p) => {
+        if (p === null || typeof p !== 'object')
+            return false;
+        const verbs = (0, util_1.verbsOf)(p.verb);
+        const hasWhere = Array.isArray(p.where) && p.where.length > 0;
+        return (verbs.includes('*') ||
+            verbs.some((v) => (0, util_1.isDangerousVerb)(v, dangerous)) ||
+            (0, util_1.isWildcardResource)(p.resource) ||
+            !hasWhere);
+    });
+}
+function ruleMissingSafetyFloor(policy, cfg, dangerous) {
+    const out = [];
+    if (policy.predicates.length === 0)
+        return out; // nothing is granted; default-deny needs no floor
+    if (cfg.requireExpiry && !(0, util_1.hasCaveatOfType)(policy.caveats, ['expires'])) {
+        out.push(find('missing-safety-floor', 'warn', 'grant has no `expires` caveat — the authority never expires'));
+    }
+    if (cfg.requireScopeGate && isNonTrivial(policy, dangerous) && !(0, util_1.hasCaveatOfType)(policy.caveats, util_1.BUDGET_GATE_CAVEATS)) {
+        out.push(find('missing-safety-floor', 'warn', `non-trivial grant has no blast-radius / rate / budget gate (${util_1.BUDGET_GATE_CAVEATS.join('/')})`));
+    }
+    return out;
+}
+//# sourceMappingURL=rules.js.map

package/dist/rules.js.map

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

package/dist/types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Public types for @atlasauth/pca-policy-ci — the shift-left policy-safety CI gate.
+ *
+ * A {@link Finding} is one problem the linter found in a PCA policy. Every rule is toggleable and
+ * every verdict is SOUND: where the underlying static analyzer cannot decide a question exactly it
+ * fails safe to a `warn`/`info` that says it is undecidable, and NEVER raises a false hard `error`.
+ */
+/** Finding severity, in increasing order of concern (`info` < `warn` < `error`). */
+export type Severity = 'error' | 'warn' | 'info';
+/** Stable rule identifiers (one per implemented check, plus the structural `malformed-policy`). */
+export type RuleId = 'over-broad-grant' | 'privilege-escalation' | 'redundant-caveat' | 'dangerous-reachability' | 'missing-safety-floor' | 'malformed-policy';
+/** A single problem the linter found. `where` is a human-readable location hint inside the policy. */
+export interface Finding {
+    rule: RuleId;
+    severity: Severity;
+    message: string;
+    /** Location hint, e.g. `predicates[0]`, `predicates[0].where[2]`, `caveats[1]`, `hop[2]`. */
+    where?: string;
+}
+/** Default set of verb substrings treated as dangerous (case-insensitive `includes` match). */
+export declare const DEFAULT_DANGEROUS_VERBS: readonly string[];
+/** A dangerous (verb, resource) target to probe for reachability. `resource` omitted = any resource. */
+export interface DangerousTarget {
+    verb: string;
+    resource?: string;
+}
+export interface OverBroadConfig {
+    /** Verb substrings treated as dangerous. Defaults to {@link DEFAULT_DANGEROUS_VERBS}. */
+    dangerousVerbs?: readonly string[];
+}
+export interface DangerousReachabilityConfig {
+    dangerousVerbs?: readonly string[];
+    /** Explicit (verb, resource) targets to probe in addition to the derived dangerous verbs. */
+    targets?: DangerousTarget[];
+}
+export interface SafetyFloorConfig {
+    /** Flag a grant with no `expires` caveat. Default true. */
+    requireExpiry?: boolean;
+    /** Flag a non-trivial grant with no `max_blast_radius` / `rate` / `budget_alloc` gate. Default true. */
+    requireScopeGate?: boolean;
+}
+/**
+ * Per-rule toggles. For each rule: omit / `true` = enabled with defaults, `false` = disabled, an
+ * object = enabled with that configuration. All rules are enabled by default.
+ */
+export interface LintRules {
+    overBroadGrant?: boolean | OverBroadConfig;
+    privilegeEscalation?: boolean;
+    redundantCaveat?: boolean;
+    dangerousReachability?: boolean | DangerousReachabilityConfig;
+    missingSafetyFloor?: boolean | SafetyFloorConfig;
+}
+/** One labeled policy's findings (used by {@link LintSummary} for multi-policy runs). */
+export interface LabeledFindings {
+    label: string;
+    findings: Finding[];
+}
+export interface SummaryOptions {
+    /**
+     * The lowest severity that fails the gate (contributes a non-zero exit code). `error` (default)
+     * fails on errors only; `warn` fails on warnings and errors; `info` fails on everything.
+     */
+    maxSeverity?: Severity;
+}
+export interface LintSummary {
+    results: LabeledFindings[];
+    counts: {
+        error: number;
+        warn: number;
+        info: number;
+    };
+    /** The threshold used to compute `ok` / `exitCode`. */
+    maxSeverity: Severity;
+    /** True when nothing at or above `maxSeverity` was found. */
+    ok: boolean;
+    /** 0 when `ok`, else 1. */
+    exitCode: number;
+}
+/** Severity ordering used for thresholds. Higher = more severe. */
+export declare const SEVERITY_RANK: Record<Severity, number>;

package/dist/types.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Public types for @atlasauth/pca-policy-ci — the shift-left policy-safety CI gate.
+ *
+ * A {@link Finding} is one problem the linter found in a PCA policy. Every rule is toggleable and
+ * every verdict is SOUND: where the underlying static analyzer cannot decide a question exactly it
+ * fails safe to a `warn`/`info` that says it is undecidable, and NEVER raises a false hard `error`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEVERITY_RANK = exports.DEFAULT_DANGEROUS_VERBS = void 0;
+// ---- rule configuration ---------------------------------------------------------------------------
+/** Default set of verb substrings treated as dangerous (case-insensitive `includes` match). */
+exports.DEFAULT_DANGEROUS_VERBS = [
+    'delete',
+    'destroy',
+    'drop',
+    'remove',
+    'purge',
+    'transfer',
+    'payout',
+    'wire',
+    'withdraw',
+    'admin',
+    'grant',
+    'revoke',
+    'deploy',
+    'shutdown',
+    'rotate',
+];
+/** Severity ordering used for thresholds. Higher = more severe. */
+exports.SEVERITY_RANK = { info: 1, warn: 2, error: 3 };
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAuBH,sGAAsG;AAEtG,+FAA+F;AAClF,QAAA,uBAAuB,GAAsB;IACxD,QAAQ;IACR,SAAS;IACT,MAAM;IACN,QAAQ;IACR,OAAO;IACP,UAAU;IACV,QAAQ;IACR,MAAM;IACN,UAAU;IACV,OAAO;IACP,OAAO;IACP,QAAQ;IACR,QAAQ;IACR,UAAU;IACV,QAAQ;CACA,CAAC;AAiEX,mEAAmE;AACtD,QAAA,aAAa,GAA6B,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC"}

package/dist/util.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Small shared helpers for the linter rules. Pure; no analyzer calls here.
+ */
+import { type AnalyzerAction } from './deps';
+import type { Caveat, Predicate } from '@atlasauth/pca';
+/** The caveat `type` that carries the signed envelope payload inside a grant. */
+export declare const ENVELOPE_CAVEAT_TYPE = "envelope";
+/** Scope-narrowing caveat types (constrain WHAT/HOW MUCH, not merely WHEN). */
+export declare const SCOPE_NARROWING_CAVEATS: readonly string[];
+/** Blast/rate/budget gate caveat types (the "safety floor" gates distinct from a time bound). */
+export declare const BUDGET_GATE_CAVEATS: readonly string[];
+/** Normalize a predicate's `verb` (string | string[] | '*') to a concrete string array. */
+export declare function verbsOf(verb: Predicate['verb']): string[];
+/** Finite-number accessor for an `unknown` caveat field. */
+export declare function num(x: unknown): number | undefined;
+/** Case-insensitive `includes` match of a verb against a dangerous-substring set. */
+export declare function isDangerousVerb(verb: string, dangerous: readonly string[]): boolean;
+/** A resource matcher that admits every resource: omitted or `'*'`. */
+export declare function isWildcardResource(resource: Predicate['resource']): boolean;
+/** Whether a caveat list contains any caveat of one of the given types. */
+export declare function hasCaveatOfType(caveats: readonly Caveat[], types: readonly string[]): boolean;
+/** A one-line, log-friendly rendering of an analyzer witness/counterexample action. */
+export declare function describeAction(a: AnalyzerAction): string;
+/** Unique, order-preserving strings. */
+export declare function uniq(xs: readonly string[]): string[];

package/dist/util.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Small shared helpers for the linter rules. Pure; no analyzer calls here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUDGET_GATE_CAVEATS = exports.SCOPE_NARROWING_CAVEATS = exports.ENVELOPE_CAVEAT_TYPE = void 0;
+exports.verbsOf = verbsOf;
+exports.num = num;
+exports.isDangerousVerb = isDangerousVerb;
+exports.isWildcardResource = isWildcardResource;
+exports.hasCaveatOfType = hasCaveatOfType;
+exports.describeAction = describeAction;
+exports.uniq = uniq;
+const deps_1 = require("./deps");
+/** The caveat `type` that carries the signed envelope payload inside a grant. */
+exports.ENVELOPE_CAVEAT_TYPE = deps_1.ENVELOPE_CAVEAT;
+/** Scope-narrowing caveat types (constrain WHAT/HOW MUCH, not merely WHEN). */
+exports.SCOPE_NARROWING_CAVEATS = [
+    'max_blast_radius',
+    'rate',
+    'reversibility_max',
+    'budget_alloc',
+    'delegation_depth',
+];
+/** Blast/rate/budget gate caveat types (the "safety floor" gates distinct from a time bound). */
+exports.BUDGET_GATE_CAVEATS = ['max_blast_radius', 'rate', 'budget_alloc'];
+/** Normalize a predicate's `verb` (string | string[] | '*') to a concrete string array. */
+function verbsOf(verb) {
+    if (typeof verb === 'string')
+        return [verb];
+    if (Array.isArray(verb))
+        return verb.filter((x) => typeof x === 'string');
+    return [];
+}
+/** Finite-number accessor for an `unknown` caveat field. */
+function num(x) {
+    return typeof x === 'number' && Number.isFinite(x) ? x : undefined;
+}
+/** Case-insensitive `includes` match of a verb against a dangerous-substring set. */
+function isDangerousVerb(verb, dangerous) {
+    const v = verb.toLowerCase();
+    return dangerous.some((kw) => v.includes(kw.toLowerCase()));
+}
+/** A resource matcher that admits every resource: omitted or `'*'`. */
+function isWildcardResource(resource) {
+    return resource === undefined || resource === '*';
+}
+/** Whether a caveat list contains any caveat of one of the given types. */
+function hasCaveatOfType(caveats, types) {
+    return caveats.some((c) => c !== null && typeof c === 'object' && typeof c.type === 'string' && types.includes(c.type));
+}
+/** A one-line, log-friendly rendering of an analyzer witness/counterexample action. */
+function describeAction(a) {
+    const parts = [a.verb, a.resource];
+    if (a.params && Object.keys(a.params).length > 0)
+        parts.push(JSON.stringify(a.params));
+    if (a.reversibilityClass !== undefined)
+        parts.push(`[${a.reversibilityClass}]`);
+    return parts.join(' ');
+}
+/** Unique, order-preserving strings. */
+function uniq(xs) {
+    const seen = new Set();
+    const out = [];
+    for (const x of xs) {
+        if (!seen.has(x)) {
+            seen.add(x);
+            out.push(x);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

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

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@atlasauth/pca-policy-ci",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "CI gate for PCA policies: statically flag over-broad grants, privilege-escalation in delegation chains, unused/redundant caveats, and reachability of dangerous actions — fail the build before an unsafe policy ships.",
+  "bin": {
+    "pca-policy-ci": "./dist/cli.js"
+  },
+  "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-analyzer": "0.1.0",
+    "@atlasauth/pca": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-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.