approval-md 0.0.1 → 0.2.0

package/dist/src/core/policy-match.js

@@ -0,0 +1,478 @@
+/**
+ * Class matching and autonomy resolution (SPEC.md §5.2, §7).
+ *
+ * Given a loaded policy and an action class, decide the autonomy level that
+ * governs the action, and say *why* — which rule matched, which rules were
+ * considered, and whether the irreversibility floor overrode the match.
+ *
+ * This module is pure and deterministic: no I/O, no clock, no randomness, no
+ * caching. The same `(load, actionClass, options)` always yields a deeply equal
+ * `Resolution`. Every ordering decision below is total, so candidate order and
+ * winner selection never depend on object key insertion order beyond what is
+ * explicitly documented.
+ *
+ * ## Matching grammar (SPEC.md §5.2, `schema/policy.schema.json` `classPattern`)
+ *
+ * Patterns and classes are dot-separated segments. Within a pattern:
+ *
+ * - a literal segment matches exactly that segment;
+ * - `*` in a non-final position matches exactly one segment;
+ * - a **trailing** `.*` matches **one or more** remaining segments of any depth.
+ *
+ * The "one or more" is a deliberate choice: `read.*` matches `read.web` and
+ * `read.web.page` but **not** the bare class `read`. The schema's
+ * `classPattern` admits `read` and `read.*` as two distinct keys a policy may
+ * list separately with different autonomy, so they must not be aliases of one
+ * another; and §7 introduces `read.*` as a *namespace*, i.e. the things under
+ * `read`, not `read` itself. A policy that wants the bare class covered writes
+ * it as its own rule (or relies on `defaults.autonomy`).
+ *
+ * A bare `*` pattern is a single-segment pattern whose only segment is a
+ * wildcard, and it is not "trailing `.*`" — it matches any single-segment class
+ * (`read`, `deploy`) and nothing deeper. `*.*` is a wildcard followed by a
+ * trailing wildcard, so it matches any class of TWO OR MORE segments. (APRV-137
+ * corrects this line, which read "exactly two". The trailing `.*` consumes one
+ * or more, so `*.*` matches `a.b` and `a.b.c` alike. `matchesPattern` always
+ * behaved this way; only the comment was wrong.)
+ *
+ * ## Specificity (SPEC.md §5.2, Specificity bullet)
+ *
+ * Candidates are ordered by the two-part key
+ * `(literalSegments DESC, wildcardSegments ASC)`. A trailing `.*` counts as one
+ * wildcard segment and contributes no literals. Patterns still tied are equally
+ * specific, and then "deny beats allow" decides: the strictest autonomy among
+ * the tied rules wins.
+ *
+ * ## Fail-closed
+ *
+ * ## The autonomy split (amended SPEC.md §5.2, APRV-127)
+ *
+ * A rule may declare `supervised-live` (with a `live_rate`) or `supervised-retro`
+ * as well as the pre-split `supervised`. Both collapse onto the one enforced
+ * `supervised` autonomy, and the difference travels beside it as
+ * `Resolution.supervision`: `"live"` means a `live_rate` fraction of the class's
+ * actions stop at the human gate BEFORE executing, `"retro"` means every action
+ * proceeds and a fraction is reviewed AFTERWARDS. Bare `supervised` is `"retro"`,
+ * with a load-time note from `policy-load.ts` naming the alias.
+ *
+ * Nothing about the SELECTION lives here: this module is pure, and selection
+ * needs an operator-held secret. `core/sampler.ts` derives it, and `core/gate.ts`
+ * applies it at intake.
+ *
+ * A not-ok {@link PolicyLoadResult} resolves **every** class to `manual` with
+ * provenance `"fail-closed"` — see `policy-load.ts`. An absent
+ * `defaults.autonomy` is likewise `manual` (provenance `"default"`): the schema
+ * permits omitting `defaults`, and the absence of a grant is not a grant.
+ *
+ * ## `human-only` (amended SPEC.md §5.2, APRV-185)
+ *
+ * A fourth level, and the strictest: an action reserved to human hands, taken
+ * outside agent execution entirely. It resolves like any other level and
+ * nothing here refuses anything — this module is pure — but every enforcement
+ * path downstream refuses it with the code `class-human-only`, so a resolution
+ * carrying it authorizes no request, no decision, no token and no run.
+ *
+ * The fail-closed target stays `manual` and deliberately does not follow the
+ * new head of the strictness table. A policy that cannot be parsed must remain
+ * recoverable through its own gate, and a broken file whose every class became
+ * `human-only` would put the repair behind a level that admits no gated repair.
+ * Failing closed raises the scrutiny an action gets; it does not remove the
+ * path by which a human fixes the file.
+ */
+/**
+ * Strictness order, strictest first (SPEC.md §5.2 "deny beats allow"), over the
+ * DECLARED vocabulary.
+ *
+ * `supervised-live` sits between `manual` and the retrospective modes because it
+ * is the only supervised mode that can stop an action before it happens: at rate
+ * 1 it is `manual`, at any lower rate it is strictly more scrutiny than review
+ * after the fact. `supervised` and `supervised-retro` share a rank because they
+ * are the same level under two spellings; the lexicographic tie-break in
+ * {@link compareCandidates} then decides between two equally specific rules that
+ * spell it differently, deterministically and without preferring either word.
+ *
+ * Exported because `core/policy-explain.ts` needs the same order to name the
+ * tie-break in its trace, and a private mirror of this table there is exactly
+ * the drift a decision trace must never have from the decision.
+ *
+ * The RATE is not part of the order. A tie between `supervised-live 0.5` and
+ * `supervised-live 0.01` is a tie between two equally specific rules that
+ * disagree about a fraction, and ordering by rate would let a policy author move
+ * a rule's precedence by editing a number they were only tuning. The
+ * lexicographic tie-break settles it, exactly as it settles every other tie.
+ *
+ * APRV-185 puts `human-only` above `manual` at the head of the table, and this
+ * table is the one place the ordering exists: the tie-break below,
+ * `core/policy-explain.ts`'s trace, and `core/agents-md.ts`'s draft merge all
+ * read it and hold no copy. It sits above `manual` because it is strictly more
+ * scrutiny — `manual` says a human decides and an agent then acts, `human-only`
+ * says the human acts — so a tie between the two must resolve to the level that
+ * lets no agent execute.
+ */
+export const STRICTNESS = {
+    "human-only": 0,
+    manual: 1,
+    "supervised-live": 2,
+    supervised: 3,
+    "supervised-retro": 3,
+    autonomous: 4,
+};
+/**
+ * Collapse a declared level onto the enforced {@link Autonomy} plus its
+ * supervision mode and live rate.
+ *
+ * Pure and total. A `supervised-live` rule whose `live_rate` is absent, or is
+ * not a usable proportion, resolves to **1** — every action in the class is
+ * gated. `policy.schema.json` requires the key, so this branch is unreachable
+ * for a policy that loaded; it is here as the fail-closed backstop, and the
+ * direction is the one the rest of this runtime takes everywhere else. The
+ * alternative reading, "a rate we could not understand means gate none of them",
+ * would turn a typo into a silently disabled control, which is the failure this
+ * project exists to prevent.
+ *
+ * `human-only` (APRV-185) collapses onto itself carrying nothing, exactly as
+ * `manual` and `autonomous` do. It names no supervision because it describes no
+ * agent execution to supervise, and the schema forbids both rates on it, so
+ * there is no fraction here for a reader to misread as live.
+ */
+export function supervisionOf(declared, rule) {
+    if (declared === "human-only" || declared === "manual" || declared === "autonomous") {
+        return { autonomy: declared, supervision: null, liveRate: null, retroRate: null };
+    }
+    // APRV-183. A `retro_rate` is carried by every supervised mode, live included:
+    // the fraction a live draw does not gate executes and stays in the
+    // retrospective pool, so that pool has a rate whether or not the class also
+    // gates some of its actions. An unusable value is read as absent, which leaves
+    // the class on the global rate rather than on an invented one.
+    const retro = rule?.retro_rate;
+    const retroRate = typeof retro === "number" && Number.isFinite(retro) && retro > 0 && retro <= 1 ? retro : null;
+    if (declared !== "supervised-live") {
+        return { autonomy: "supervised", supervision: "retro", liveRate: null, retroRate };
+    }
+    const rate = rule?.live_rate;
+    const usable = typeof rate === "number" && Number.isFinite(rate) && rate > 0 && rate <= 1;
+    return { autonomy: "supervised", supervision: "live", liveRate: usable ? rate : 1, retroRate };
+}
+/**
+ * The refusal every enforcement path prints for a `human-only` class (APRV-185).
+ *
+ * One text, in one place, for the same reason `STRICTNESS` is one table: the
+ * code `class-human-only` is frozen in four separate unions (`core/gate.ts`,
+ * `core/token.ts`, `core/execute.ts`, and the hook's own), and four hand-written
+ * explanations of one condition would disagree about what a caller should do the
+ * first time one of them was edited.
+ *
+ * `whatWasRefused` is the verb's own half of the sentence, so the message names
+ * the thing that did not happen as well as the reason it cannot.
+ */
+export function humanOnlyRefusal(actionClass, whatWasRefused) {
+    return (`class ${actionClass} resolves to human-only (amended SPEC.md §5.2, APRV-185), so ${whatWasRefused}. ` +
+        `A human performs this action outside agent execution: the policy reserves the class to human hands rather than routing it through the gate, so there is no approval to seek, no approver to ask, and no token that could exist for it. ` +
+        `This is not a rejection — nobody decided anything, and asking again with a better summary will get the same answer. ` +
+        `Nothing was appended. If the class should be gated rather than reserved, amend APPROVAL.md and re-attest it.`);
+}
+const WILDCARD = "*";
+/** Split a dotted class or pattern into segments. */
+function segments(text) {
+    return text.split(".");
+}
+/**
+ * Does `pattern` match `actionClass`?
+ *
+ * See the module header for the grammar. Both are split on `.`; the pattern's
+ * final segment is the only one that may span more than one class segment, and
+ * only when the pattern has more than one segment (a bare `*` is single-span).
+ */
+export function matchesPattern(pattern, actionClass) {
+    const patternSegments = segments(pattern);
+    const classSegments = segments(actionClass);
+    const lastIndex = patternSegments.length - 1;
+    const hasTrailingWildcard = patternSegments.length > 1 && patternSegments[lastIndex] === WILDCARD;
+    if (hasTrailingWildcard) {
+        // Trailing `.*` consumes ONE OR MORE segments: the class must be strictly
+        // deeper than the pattern's literal prefix.
+        if (classSegments.length < patternSegments.length)
+            return false;
+    }
+    else if (classSegments.length !== patternSegments.length) {
+        return false;
+    }
+    const fixedCount = hasTrailingWildcard ? lastIndex : patternSegments.length;
+    for (let index = 0; index < fixedCount; index += 1) {
+        const patternSegment = patternSegments[index];
+        if (patternSegment === WILDCARD)
+            continue;
+        if (patternSegment !== classSegments[index])
+            return false;
+    }
+    return true;
+}
+/**
+ * Specificity key of a pattern (SPEC.md §5.2). A trailing `.*` is one wildcard
+ * segment contributing no literals — which is exactly how it is already counted
+ * by segment splitting, so no special case is needed here.
+ */
+export function specificityOf(pattern) {
+    const patternSegments = segments(pattern);
+    let wildcards = 0;
+    for (const segment of patternSegments) {
+        if (segment === WILDCARD)
+            wildcards += 1;
+    }
+    return [patternSegments.length - wildcards, wildcards, patternSegments.length];
+}
+/**
+ * Compare two specificity keys; negative when `a` is MORE specific.
+ *
+ * There are only two ordering legs, not three. Every segment is either a
+ * literal or a wildcard, so `totalSegments === literalSegments +
+ * wildcardSegments` for every pattern. Two keys that tie on literals and again
+ * on wildcards therefore have equal totals by arithmetic, and a third leg
+ * comparing totals could never separate them. SPEC.md §5.2 used to list that
+ * comparison as criterion (3); it was removed as dead text (APRV-136). Keys
+ * reaching the end of this function are genuinely equal, and the caller
+ * resolves them with the strictest-autonomy rule.
+ */
+function compareSpecificity(a, b) {
+    if (a[0] !== b[0])
+        return b[0] - a[0]; // more literals first
+    if (a[1] !== b[1])
+        return a[1] - b[1]; // fewer wildcards first
+    return 0; // equal literals and wildcards implies equal totals: a real tie
+}
+/**
+ * Total order over candidates: specificity first, then pattern name ascending.
+ *
+ * The lexicographic tail is not policy semantics — it exists so `candidates`
+ * has one canonical order for equally specific rules, independent of YAML key
+ * order, making the trace byte-stable.
+ */
+function compareCandidates(a, b) {
+    const bySpecificity = compareSpecificity(a.specificity, b.specificity);
+    if (bySpecificity !== 0)
+        return bySpecificity;
+    return a.pattern < b.pattern ? -1 : a.pattern > b.pattern ? 1 : 0;
+}
+const FAIL_CLOSED = {
+    autonomy: "manual",
+    declaredAutonomy: "manual",
+    supervision: null,
+    liveRate: null,
+    retroRate: null,
+    provenance: "fail-closed",
+    matched: null,
+    approvers: null,
+    limits: null,
+    floorApplied: false,
+    allowIrreversible: false,
+    irreversiblePatterns: [],
+    candidates: [],
+};
+/**
+ * Resolve the autonomy governing `actionClass` under `load`.
+ *
+ * 1. A not-ok load resolves `manual` / `"fail-closed"` for every class.
+ * 2. Otherwise collect matching `classes` rules, order them by specificity, and
+ *    take the most specific; among a full specificity tie the strictest
+ *    autonomy wins, and among equally strict tied rules the lexicographically
+ *    smallest pattern is chosen so the outcome is deterministic.
+ * 3. With no matching rule, a class in the `policy.edit.*` namespace (APRV-266)
+ *    inherits the `policy.edit` line when that line is a rule, with provenance
+ *    `"inherited"`; otherwise the result is `defaults.autonomy` — or `manual`
+ *    when `defaults` or `defaults.autonomy` is absent — with provenance
+ *    `"default"`.
+ * 4. Finally, `options.reversible === false` engages the §7 floor: a resolved
+ *    `autonomous` or `supervised` becomes `manual` with `floorApplied: true`
+ *    and provenance `"floor"`. An already-`manual` outcome is untouched, and
+ *    keeps its original provenance, because the floor did not decide it.
+ *
+ * `approvers` and `limits` are carried from the matched rule only; they are
+ * `null` when the rule omits them or when no rule matched.
+ */
+export function resolve(load, actionClass, options = {}) {
+    if (!load.ok)
+        return { ...FAIL_CLOSED, candidates: [] };
+    const classes = load.policy.classes ?? {};
+    const candidates = [];
+    for (const pattern of Object.keys(classes)) {
+        const rule = classes[pattern];
+        if (rule === undefined)
+            continue;
+        if (!matchesPattern(pattern, actionClass))
+            continue;
+        candidates.push({ pattern, rule, specificity: specificityOf(pattern) });
+    }
+    candidates.sort(compareCandidates);
+    const resolution = candidates.length === 0
+        ? fromParentOrDefaults(load, actionClass, candidates)
+        : fromRules(candidates);
+    return applyFloor(resolution, options);
+}
+/**
+ * The `policy.edit` sub-class namespace (APRV-266), as a resolution rule.
+ *
+ * A routed `protected_paths` entry names a class the policy MAY declare and
+ * need not: routing `design/` to `policy.edit.design` and then writing no
+ * `policy.edit.design` line is a reasonable first step, and the answer to it
+ * should be the `policy.edit` line — the line that governed that path before
+ * the routing existed — rather than `defaults.autonomy`.
+ *
+ * That is not just ergonomics. A repository whose `policy.edit` is
+ * `supervised-live 0.1` and whose default is `manual` would find every routed
+ * path GATED the moment it adopted routing, which reads as the feature being
+ * broken and invites the author to fix it by loosening something. Falling back
+ * to the line the path is a sub-class of makes the adoption a no-op until the
+ * author declares otherwise, which is what an additive key should be.
+ *
+ * Deliberately not generalized to "any dotted class falls back to its parent".
+ * §5.2's matching grammar already gives an author `policy.edit.*` for that, and
+ * a universal parent walk would silently change the resolution of every class
+ * in the taxonomy — `read` is `manual` in this repository BECAUSE `read.*` does
+ * not cover it, and a parent walk would make that pin unstatable. One
+ * namespace, because one namespace is what the runtime itself synthesizes
+ * classes in.
+ */
+const ROUTED_NAMESPACE = "policy.edit.";
+/** The line a routed class inherits from, or the ordinary default. */
+function fromParentOrDefaults(load, actionClass, candidates) {
+    if (!actionClass.startsWith(ROUTED_NAMESPACE))
+        return fromDefaults(load, candidates);
+    const parent = resolve(load, "policy.edit");
+    // Only a RULE is inherited. When the `policy.edit` line is itself absent the
+    // sub-class has nothing to inherit and falls to `defaults.autonomy`, which is
+    // the same answer by a shorter road and keeps `"inherited"` meaning "a
+    // `policy.edit` rule decided this".
+    if (parent.provenance !== "rule")
+        return fromDefaults(load, candidates);
+    return {
+        ...parent,
+        provenance: "inherited",
+        // `candidates` is this class's own, which is empty: nothing matched it.
+        // The parent's matched rule stays in `matched`, so a trace can name the
+        // line that decided without claiming it matched.
+        candidates,
+    };
+}
+/** Build the no-rule-matched resolution. */
+function fromDefaults(load, candidates) {
+    // Absent `defaults.autonomy` is `manual`: the schema allows omitting
+    // `defaults` entirely, and by the fail-closed principle the absence of a
+    // grant is not a grant.
+    const declared = load.policy.defaults?.autonomy ?? "manual";
+    return {
+        ...supervisionOf(declared, null),
+        declaredAutonomy: declared,
+        provenance: "default",
+        matched: null,
+        approvers: null,
+        limits: null,
+        floorApplied: false,
+        allowIrreversible: false,
+        irreversiblePatterns: [],
+        candidates,
+    };
+}
+/** Build the rule-matched resolution from a specificity-sorted candidate list. */
+function fromRules(candidates) {
+    const best = candidates[0];
+    if (best === undefined)
+        throw new Error("unreachable: empty candidate list");
+    // Everything tied with the head on the full specificity key competes; among
+    // them the strictest autonomy wins ("deny beats allow"). `candidates` is
+    // already sorted by pattern within a tie, so the first strictest is the
+    // lexicographically smallest strictest — deterministic regardless of the
+    // policy file's key order.
+    let winner = best;
+    const governing = [];
+    for (const candidate of candidates) {
+        if (compareSpecificity(candidate.specificity, best.specificity) !== 0)
+            break;
+        governing.push(candidate);
+        if (STRICTNESS[candidate.rule.autonomy] < STRICTNESS[winner.rule.autonomy]) {
+            winner = candidate;
+        }
+    }
+    return {
+        ...supervisionOf(winner.rule.autonomy, winner.rule),
+        declaredAutonomy: winner.rule.autonomy,
+        provenance: "rule",
+        matched: { pattern: winner.pattern, rule: winner.rule },
+        approvers: winner.rule.approvers ?? null,
+        limits: winner.rule.limits ?? null,
+        floorApplied: false,
+        // APRV-317: lexicographic order and strictness still select the ordinary
+        // winner, but neither may silently discard a tied rule's refusal to waive
+        // the floor. The capability is the intersection of the governing group.
+        allowIrreversible: governing.every((candidate) => candidate.rule.allow_irreversible === true),
+        irreversiblePatterns: governing.map((candidate) => candidate.pattern),
+        candidates,
+    };
+}
+/**
+ * SPEC.md §7 irreversibility floor, applied *after* class resolution: an action
+ * declared `reversible: false` resolves to `manual` unless the attested class
+ * rule group explicitly permits it. When no permission exists, the resolution
+ * records that the floor, rather than the matched rule, determined the outcome.
+ *
+ * ## The floor is a floor, not a proof (amended SPEC.md §7, APRV-127)
+ *
+ * This remains the enforcement point for APRV-127's default: a supervised rule
+ * with no APRV-317 opt-in sends a truthful irreversible action to manual. The
+ * only exception is the unanimous capability computed from operator policy
+ * above; action metadata has no field that can supply it.
+ *
+ * What the floor is NOT is evidence that anything else is reversible.
+ * `reversible` is SELF-REPORTED by the action's own declaration. A truthful
+ * `false` raises scrutiny to `manual`, which is the safe direction and the only
+ * direction this field is allowed to move anything (global invariant 4). A false
+ * claim of `reversible: true` — or an omitted claim — simply fails to raise it,
+ * leaving the class's declared autonomy in force. So the floor catches the
+ * honest declaration of irreversibility; it cannot catch a lie, and no code here
+ * pretends otherwise. The control that answers the lie is the class rule: an
+ * author who does not trust a class's declarations writes `manual` for the
+ * class, which no declaration can loosen.
+ *
+ * The floor also clears `supervision`, `liveRate` and `retroRate`. An action
+ * pushed to `manual` is not a supervised action with a mode; it is gated, and
+ * leaving either fraction on it would tell a downstream reader that a draw still
+ * applies to an action every one of whose instances stops for a human.
+ *
+ * ## The floor stops at `manual` (amended SPEC.md §7, APRV-185)
+ *
+ * The floor raises to `manual` and never to `human-only`, in either direction.
+ * It never raises a class TO `human-only`, because the floor is a runtime
+ * escalation computed from a self-reported field, and `human-only` is a
+ * declaration a policy author makes about who performs an action. Deriving one
+ * from the other would let a `reversible: false` on an envelope reserve a class
+ * to human hands that its author put behind an ordinary gate. And it never
+ * lowers a `human-only` class either: the early return below covers it, so an
+ * irreversible action in a human-only class stays human-only rather than being
+ * "raised" to the weaker level.
+ */
+function applyFloor(resolution, options) {
+    if (options.reversible !== false)
+        return resolution;
+    if (resolution.autonomy === "manual" || resolution.autonomy === "human-only")
+        return resolution;
+    if (resolution.allowIrreversible)
+        return resolution;
+    return {
+        ...resolution,
+        autonomy: "manual",
+        // Every field says manual, including the declared one. A resolution whose
+        // `autonomy` read `manual` while its `declaredAutonomy` still read
+        // `autonomous` would be one field a consumer could read and get the
+        // pre-floor answer. What the rule actually said is not lost: it is in
+        // `matched.rule.autonomy`, and `core/policy-explain.ts` records it as the
+        // grant the floor overrode.
+        declaredAutonomy: "manual",
+        supervision: null,
+        liveRate: null,
+        // A gated action has no retrospective pool to be drawn from, so it carries
+        // no retrospective rate either.
+        retroRate: null,
+        provenance: "floor",
+        floorApplied: true,
+    };
+}
+//# sourceMappingURL=policy-match.js.map

package/dist/src/core/policy-match.js.map

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