@gate-forge/core 0.1.0

package/dist/policy/evaluate.js

@@ -0,0 +1,382 @@
+/**
+ * Policy engine (plan §5.2, G2): evaluates declarative policies
+ * (`PolicyFile`) against the classified resources of a built
+ * {@link ResourceGraph} and produces obligations plus the blocking
+ * verdict entries the gate must stay visible for (invariants 1, 8).
+ *
+ * Semantics (plan §5.2 + ADR 0001):
+ * - `crud:create|read|update|delete` obligations are LIFECYCLE-GATED:
+ *   a contract is emitted only when the classification's lifecycle
+ *   flag for that operation is `true` (user-facing + `lifecycle.create`
+ *   ⇒ `crud:create`, etc.). Non-uniform lifecycles fall out naturally:
+ *   immutable/read-only resources generate only `crud:read`, append-only
+ *   resources `crud:create` + `crud:read`, archive-not-delete resources
+ *   `crud:delete` with `deleteSemantics: 'archive'` in the fingerprint.
+ * - Non-`crud:` contracts pass through ungated (the policy author
+ *   explicitly required them).
+ * - Internal resources generate NO CRUD obligations — their claims are
+ *   invalid (ADR 0001). Non-CRUD contracts still apply.
+ * - Unclassified and unresolved resources produce blocking entries and
+ *   no obligations until classified/resolved, but stay gate-visible.
+ *   So do detector/graph `findings` (a partial discovery must never
+ *   yield a green gate) and `stale` references (invariant 9).
+ * - Policies are evaluated in file order; the first policy generating
+ *   a given `<resourceId>:<contract>` owns it (obligation ids are
+ *   unique identities — pin #1's fingerprint keys on them).
+ */
+import { z } from 'zod';
+import { LocationSchema, SchemaVersionField } from '../schemas/common.js';
+import { CauseCodeSchema } from '../schemas/verdict.js';
+import { ObligationSchema } from '../schemas/obligation.js';
+import { PolicyFileSchema } from '../schemas/policy.js';
+import { ClaimSchema } from '../schemas/claim.js';
+import { HTTP_ENDPOINT_RESOURCE_KIND } from '../graph/schema.js';
+import { compareStrings } from '../graph/util.js';
+/** The CRUD contract namespace gated by lifecycle flags. */
+export const CRUD_CONTRACT_PREFIX = 'crud:';
+/**
+ * The persistence-level CRUD contract namespace (audit round 5):
+ * lifecycle-gated exactly like `crud:`, but graded on the witness's own
+ * engine-side observations (absence/presence, before/after deltas,
+ * owner-declared archive state). UI-semantic `crud:` contracts stay
+ * fail-closed in the verdict engine until a witness-controlled UI
+ * observation channel exists.
+ */
+export const PERSISTENCE_CONTRACT_PREFIX = 'persistence:';
+/** The four lifecycle-gated operations, in canonical order. */
+const CRUD_OPERATIONS = ['create', 'read', 'update', 'delete'];
+/**
+ * Fail-closed policy-engine error: thrown for policy documents that
+ * are structurally invalid (zod) or use the `crud:` namespace with an
+ * unknown operation — a config/usage problem, never a silent skip.
+ */
+export class PolicyEvaluationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PolicyEvaluationError';
+    }
+}
+/** Why a resource currently generates no obligations. */
+export const BlockingEntrySchema = z
+    .strictObject({
+    /**
+     * `unclassified` = resolved but lacking any effective classification
+     * (the classifier blocked it definitionally); `classification` = a
+     * typed classifier block (contradiction, incomplete proof scope,
+     * stale/invalid signal, missing adapter) — machine-actionable, the
+     * conservative decision stands where one exists; `unresolved`
+     * = identity not statically resolvable; `finding` = a detector/graph
+     * finding (e.g. PARSE_ERROR) — discovery only partly succeeded, so
+     * the gate cannot claim full knowledge; `stale-reference` = an
+     * artifact still pointing at a removed resource (invariant 9:
+     * nothing silently disappears).
+     */
+    kind: z.enum([
+        'unclassified',
+        'classification',
+        'unresolved',
+        'finding',
+        'stale-reference',
+    ]),
+    /** Plane-qualified id when one could be derived, else `null`. */
+    resourceId: z.string().min(1).nullable(),
+    /** Bare resource name when known, else `null`. */
+    name: z.string().min(1).nullable(),
+    /** Single-cause human explanation (invariant 8: explain every block). */
+    detail: z.string().min(1),
+    /** Source location when known, else `null`. */
+    location: LocationSchema.nullable(),
+    /**
+     * Stable plan §5.4 cause code when the entry maps to one (coverage
+     * findings → CRUD_COVERAGE_MISSING, strict-capability preflight →
+     * VERIFIER_UNSUPPORTED, strict-mode waivers → ENFORCEMENT_UNTRUSTED).
+     * Absent/null for entries without a Phase 0 mapping.
+     */
+    cause: CauseCodeSchema.nullish(),
+    /** Human next action accompanying `cause`; absent/null when unmapped. */
+    nextAction: z.string().min(1).nullish(),
+});
+/**
+ * The adopted identity of a classification-blocked resource (two-layer
+ * adoption): the ONE canonical string both `gateforge adopt` captures
+ * into the receipt's `classificationBlocked` set and the check matches
+ * against when waiving — so the two sides can never disagree.
+ *
+ * - The plane-qualified `resourceId` when the entry carries one (blocks
+ *   on otherwise-classified resources, e.g. delete-semantics).
+ * - Else the bare resource name under a `name:` namespace — a resource
+ *   with NO derivable plane (PLANE_UNRESOLVED) has no plane-qualified id
+ *   by definition, and its bare name is the stable, merge-surviving
+ *   identity. The `name:` prefix keeps the fallback out of the
+ *   plane-qualified id space (`tenant.users` et al.).
+ * - Both the `classification` entry (the typed block) AND the
+ *   `unclassified` shadow entry (the definitional "no effective
+ *   classification" block the policy engine emits for the SAME resource)
+ *   map to the same identity: waiving the resource waives its whole
+ *   adopted block, or the gate could never return to green.
+ *
+ * Returns null for entries that are never resource-scoped (document-level
+ * classifier blocks — stale targets, invalid signals — and
+ * unresolved/finding/stale-reference kinds): those can never be adopted
+ * by this layer.
+ */
+export function classificationBlockedIdentity(entry) {
+    if (entry.kind !== 'classification' && entry.kind !== 'unclassified')
+        return null;
+    if (entry.resourceId !== null)
+        return entry.resourceId;
+    if (entry.name !== null)
+        return `name:${entry.name}`;
+    return null;
+}
+/** Assessment of one watched claim against the generated obligations. */
+export const ClaimAssessmentSchema = z
+    .strictObject({
+    claim: ClaimSchema,
+    status: z.enum(['valid', 'invalid']),
+    /** Single-cause reason for `invalid`; `null` when valid. */
+    reason: z.string().min(1).nullable(),
+});
+/** The complete policy-engine result. Deterministic; fully sorted. */
+export const PolicyEvaluationResultSchema = z
+    .strictObject({
+    schemaVersion: SchemaVersionField,
+    /** Generated obligations, sorted by id (unique — first policy wins). */
+    obligations: z.array(ObligationSchema),
+    /**
+     * Entries the gate must stay visible for, sorted deterministically:
+     * unclassified + unresolved resources, detector/graph findings, and
+     * stale references (fail closed — a discovery pass that partly
+     * failed or left orphans can never yield a green run).
+     */
+    blocking: z.array(BlockingEntrySchema),
+    /** Claim assessments, sorted by obligation id then test id. */
+    claims: z.array(ClaimAssessmentSchema),
+});
+/**
+ * Whether a contract is allowed by a lifecycle. `crud:` and
+ * `persistence:` contracts map to their lifecycle flag (`crud:create` ⇔
+ * `lifecycle.create === true`, etc. — unknown operations in either
+ * namespace are a policy-authoring error); every other contract passes
+ * through ungated.
+ *
+ * Args:
+ *   contract: the required contract name, e.g. `crud:update`.
+ *   lifecycle: the classification's lifecycle flags.
+ *
+ * Returns:
+ *   boolean: true when an obligation for this contract must be generated.
+ * @throws PolicyEvaluationError for `crud:`/`persistence:` contracts
+ *   outside the four lifecycle operations.
+ */
+export function lifecycleAllowsContract(contract, lifecycle) {
+    for (const prefix of [CRUD_CONTRACT_PREFIX, PERSISTENCE_CONTRACT_PREFIX]) {
+        if (!contract.startsWith(prefix))
+            continue;
+        const operation = contract.slice(prefix.length);
+        if (!CRUD_OPERATIONS.includes(operation)) {
+            throw new PolicyEvaluationError(`policy requires '${contract}' but the namespace is limited to: ` +
+                `${CRUD_OPERATIONS.map((op) => `${prefix}${op}`).join(', ')}`);
+        }
+        return lifecycle[operation] === true;
+    }
+    return true;
+}
+/**
+ * Evaluates the policy document against a built resource graph.
+ *
+ * Args:
+ *   input: graph + policies (+ claims to assess). The policy document
+ *     is validated fail-closed; resources are consumed in the graph's
+ *     deterministic order.
+ *
+ * Returns:
+ *   PolicyEvaluationResult: obligations, blocking entries, and claim
+ *   assessments — all sorted, byte-for-byte deterministic.
+ * @throws z.ZodError when the policy document is invalid (config error).
+ * @throws PolicyEvaluationError for `crud:` contracts outside the four
+ *   lifecycle operations.
+ */
+export function evaluatePolicies(input) {
+    const policyFile = PolicyFileSchema.parse(input.policies);
+    const obligations = [];
+    const obligationIds = new Set();
+    const blocking = [];
+    for (const resource of input.graph.resources) {
+        if (resource.classification === null) {
+            blocking.push({
+                kind: 'unclassified',
+                resourceId: resource.id,
+                name: resource.name,
+                detail: `resource '${resource.id ?? resource.name}' has no effective classification ` +
+                    '(the classifier blocked it definitionally); run ' +
+                    `'gateforge explain ${resource.id ?? resource.name}' for the typed ` +
+                    'reason and its in-code resolution',
+                location: resource.location,
+            });
+            continue;
+        }
+        generateObligations(resource, policyFile.policies, obligations, obligationIds);
+    }
+    for (const entry of input.graph.unresolved) {
+        blocking.push({
+            kind: 'unresolved',
+            resourceId: null,
+            name: null,
+            detail: `${entry.reason.code}: ${entry.reason.detail}`,
+            location: entry.reason.location,
+        });
+    }
+    // Fail closed on partial discovery: findings (PARSE_ERROR and friends)
+    // mean the graph was built from incomplete knowledge — a parse failure
+    // can erase resources and obligations — and stale references mean an
+    // artifact still points at something removed (invariant 9). Both block
+    // the gate; `discover` remains the non-gating introspection surface.
+    for (const finding of input.graph.findings) {
+        blocking.push({
+            kind: 'finding',
+            resourceId: null,
+            name: null,
+            detail: `${finding.code}: ${finding.detail} (detector ${finding.detectorId})`,
+            location: finding.locations[0] ?? null,
+        });
+    }
+    for (const stale of input.graph.stale) {
+        blocking.push({
+            kind: 'stale-reference',
+            resourceId: null,
+            name: null,
+            detail: `stale ${stale.kind} reference '${stale.reference}': ${stale.detail}`,
+            location: null,
+        });
+    }
+    blocking.push(...(input.extraBlocking ?? []));
+    const claims = assessClaims(input.claims ?? [], obligationIds, input.graph.resources);
+    return {
+        schemaVersion: 1,
+        obligations: sortObligations(obligations),
+        blocking: sortBlocking(blocking),
+        claims: sortClaims(claims),
+    };
+}
+/**
+ * Generates obligations for one classified resource: every matching
+ * policy's required contract that the lifecycle allows, deduplicated
+ * by obligation id (first matching policy owns the id).
+ */
+function generateObligations(resource, policies, obligations, obligationIds) {
+    const classification = resource.classification;
+    if (classification === null || resource.id === null)
+        return;
+    const exposure = classification.exposure;
+    for (const policy of policies) {
+        if (!policyMatches(policy, resource, exposure))
+            continue;
+        for (const contract of policy.require) {
+            if (contract.startsWith(CRUD_CONTRACT_PREFIX) ||
+                contract.startsWith(PERSISTENCE_CONTRACT_PREFIX)) {
+                if (exposure === 'internal')
+                    continue; // ADR 0001: internal ⇒ no CRUD obligations
+                // ADR 0004 D8: endpoints are routes, not tables. CRUD state
+                // obligations flow through the LINKED business resource's own
+                // identity; generating persistence contracts against a route
+                // would conflate the two planes of meaning.
+                if (resource.kind === HTTP_ENDPOINT_RESOURCE_KIND)
+                    continue;
+                if (!lifecycleAllowsContract(contract, classification.lifecycle))
+                    continue;
+            }
+            const id = `${resource.id}:${contract}`;
+            if (obligationIds.has(id))
+                continue;
+            obligationIds.add(id);
+            obligations.push({
+                schemaVersion: 1,
+                id,
+                resourceId: resource.id,
+                contract,
+                policyId: policy.id,
+                lifecycle: classification.lifecycle,
+            });
+        }
+    }
+}
+function policyMatches(policy, resource, exposure) {
+    const when = policy.when;
+    if (when.kind !== undefined && when.kind !== resource.kind)
+        return false;
+    if (when.exposure !== undefined && when.exposure !== exposure)
+        return false;
+    if (when.plane !== undefined && when.plane !== resource.plane)
+        return false;
+    if (when.capability !== undefined) {
+        // Endpoint capability match: the resource must carry a `capabilities`
+        // ARRAY containing the exact string. Anything else — absent
+        // attribute, non-array value, near-miss strings — never matches
+        // (fail closed).
+        const capabilities = resource.attributes['capabilities'];
+        if (!Array.isArray(capabilities) ||
+            !capabilities.some((capability) => capability === when.capability)) {
+            return false;
+        }
+    }
+    if (when.consumed !== undefined) {
+        // Endpoint consumption match: `true` requires the attribute to be
+        // EXACTLY true; `false` matches everything else (including absent —
+        // non-endpoint resources are "not consumed", never match-excluded).
+        if (when.consumed === true && resource.attributes['frontendConsumed'] !== true) {
+            return false;
+        }
+        if (when.consumed === false && resource.attributes['frontendConsumed'] === true) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Assesses claims against the generated obligation set. Claims on
+ * internal resources are invalid outright (ADR 0001 — internal
+ * resources carry no CRUD obligations and never accept claims);
+ * claims whose obligation id was not generated are invalid as unknown;
+ * the rest are valid linkages (validity ≠ satisfaction — pin #9).
+ */
+function assessClaims(claims, obligationIds, resources) {
+    const internalIds = new Set();
+    for (const resource of resources) {
+        if (resource.id !== null && resource.classification?.exposure === 'internal') {
+            internalIds.add(resource.id);
+        }
+    }
+    return claims.map((claim) => {
+        const resourceId = claim.obligationId.slice(0, claim.obligationId.indexOf(':'));
+        if (internalIds.has(resourceId)) {
+            return {
+                claim,
+                status: 'invalid',
+                reason: `resource '${resourceId}' is internal: internal resources carry no CRUD obligations and their claims are invalid (ADR 0001)`,
+            };
+        }
+        if (!obligationIds.has(claim.obligationId)) {
+            return {
+                claim,
+                status: 'invalid',
+                reason: `claim references '${claim.obligationId}' which no policy generates`,
+            };
+        }
+        return { claim, status: 'valid', reason: null };
+    });
+}
+function sortObligations(obligations) {
+    return [...obligations].sort((a, b) => compareStrings(a.id, b.id));
+}
+function sortBlocking(blocking) {
+    return [...blocking].sort((a, b) => compareStrings(a.kind, b.kind) ||
+        compareStrings(a.resourceId ?? '', b.resourceId ?? '') ||
+        compareStrings(a.name ?? '', b.name ?? '') ||
+        compareStrings(a.detail, b.detail));
+}
+function sortClaims(claims) {
+    return [...claims].sort((a, b) => compareStrings(a.claim.obligationId, b.claim.obligationId) ||
+        compareStrings(a.claim.testId, b.claim.testId));
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/policy/evaluate.js.map

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

package/dist/policy/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Policy engine (G2): declarative policies → obligations, lifecycle
+ * gating (plan §5.2), internal-resource claim invalidation (ADR 0001),
+ * and gate-visible blocking entries for unclassified/unresolved
+ * resources (invariants 1, 8).
+ *
+ * Also (plan 2026-09-13 Phase 0): the closed-world CRUD coverage
+ * evaluator (§3.6) and the protected-policy-ownership foundation
+ * (trusted policy digest + weakening check, ADR 0005 D5/D6).
+ */
+export { CRUD_CONTRACT_PREFIX, PERSISTENCE_CONTRACT_PREFIX, BlockingEntrySchema, ClaimAssessmentSchema, PolicyEvaluationError, PolicyEvaluationResultSchema, classificationBlockedIdentity, evaluatePolicies, lifecycleAllowsContract, } from './evaluate.js';
+export type { BlockingEntry, ClaimAssessment, PolicyEvaluationInput, PolicyEvaluationResult, } from './evaluate.js';
+export { evaluateCoveragePolicy, type CoverageInventoryTable, type MappedCoverage, type CoverageConfigError, type CoverageBlockingFinding, type CoveragePolicyResult, } from './coverage.js';
+export { TRUSTED_POLICY_DOMAIN, trustedPolicyDigest, policyWeakenedCandidate, type TrustedPolicyInput, type PolicyWeakeningCheck, } from './trusted.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/policy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/policy/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,4BAA4B,EAC5B,6BAA6B,EAC7B,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,aAAa,EACb,eAAe,EACf,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC1B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,EACvB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC"}

package/dist/policy/index.js

@@ -0,0 +1,14 @@
+/**
+ * Policy engine (G2): declarative policies → obligations, lifecycle
+ * gating (plan §5.2), internal-resource claim invalidation (ADR 0001),
+ * and gate-visible blocking entries for unclassified/unresolved
+ * resources (invariants 1, 8).
+ *
+ * Also (plan 2026-09-13 Phase 0): the closed-world CRUD coverage
+ * evaluator (§3.6) and the protected-policy-ownership foundation
+ * (trusted policy digest + weakening check, ADR 0005 D5/D6).
+ */
+export { CRUD_CONTRACT_PREFIX, PERSISTENCE_CONTRACT_PREFIX, BlockingEntrySchema, ClaimAssessmentSchema, PolicyEvaluationError, PolicyEvaluationResultSchema, classificationBlockedIdentity, evaluatePolicies, lifecycleAllowsContract, } from './evaluate.js';
+export { evaluateCoveragePolicy, } from './coverage.js';
+export { TRUSTED_POLICY_DOMAIN, trustedPolicyDigest, policyWeakenedCandidate, } from './trusted.js';
+//# sourceMappingURL=index.js.map

package/dist/policy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/policy/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,4BAA4B,EAC5B,6BAA6B,EAC7B,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AAOvB,OAAO,EACL,sBAAsB,GAMvB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,GAGxB,MAAM,cAAc,CAAC"}

package/dist/policy/trusted.d.ts

@@ -0,0 +1,59 @@
+/** Domain tag separating trusted-policy digests from every other hash. */
+export declare const TRUSTED_POLICY_DOMAIN = "gateforge.trusted-policy.v1";
+/** One trusted policy/config document's effective bytes. */
+export interface TrustedPolicyInput {
+    /** Stable repo-root-relative name, e.g. `.gateforge/policies.yml`. */
+    name: string;
+    /** The exact effective bytes of the document. */
+    bytes: string;
+}
+/**
+ * Computes the trusted policy digest: a domain-separated canonical hash
+ * over the named document bytes (each byte-hashed, entries sorted by
+ * name). Deterministic — identical policy revisions produce identical
+ * digests, so a receipt can bind "evaluated under this policy revision"
+ * and any later byte change breaks the binding.
+ *
+ * Args:
+ *   inputs: the effective policy/config documents (config, policies,
+ *     classification policy, adapters, baselines, waivers, runner
+ *     definitions — the trusted-revision-owned set).
+ *
+ * Returns:
+ *   string: 64-char lowercase hex digest.
+ *
+ * Throws:
+ *   TypeError: when the same name appears twice (an ambiguous trusted
+ *     revision is a caller bug, never silently deduplicated).
+ */
+export declare function trustedPolicyDigest(inputs: readonly TrustedPolicyInput[]): string;
+/** The typed outcome of comparing a candidate revision to the trusted one. */
+export type PolicyWeakeningCheck = {
+    weakened: false;
+    trustedDigest: string;
+    candidateDigest: string;
+} | {
+    /** True when the candidate is not byte-identical to the trusted revision. */
+    weakened: true;
+    /** Single-cause fail-closed explanation. */
+    reason: string;
+    trustedDigest: string;
+    candidateDigest: string;
+};
+/**
+ * The pure weakening check (ADR 0005 D6): a candidate whose policy digest
+ * differs from the trusted revision is a WEAKENING CANDIDATE — it may
+ * only proceed after a separate trusted update is accepted, never by
+ * self-approval. Fail-closed: a missing or malformed digest cannot be
+ * verified, so it counts as weakened rather than trusted.
+ *
+ * Args:
+ *   trustedDigest: the digest of the trusted policy revision.
+ *   candidateDigest: the digest of the candidate's effective policy.
+ *
+ * Returns:
+ *   PolicyWeakeningCheck: `{weakened: false}` only for an exact, well-formed
+ *   match; otherwise `{weakened: true, reason}` naming the failure.
+ */
+export declare function policyWeakenedCandidate(trustedDigest: string, candidateDigest: string): PolicyWeakeningCheck;
+//# sourceMappingURL=trusted.d.ts.map

package/dist/policy/trusted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trusted.d.ts","sourceRoot":"","sources":["../../src/policy/trusted.ts"],"names":[],"mappings":"AAiBA,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB,gCAAgC,CAAC;AAEnE,4DAA4D;AAC5D,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,CAYjF;AAED,8EAA8E;AAC9E,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,GACnE;IACE,6EAA6E;IAC7E,QAAQ,EAAE,IAAI,CAAC;IACf,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAIN;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,MAAM,GACtB,oBAAoB,CA6BtB"}

package/dist/policy/trusted.js

@@ -0,0 +1,96 @@
+/**
+ * Protected policy ownership foundation (plan 2026-09-13 Phase 0 item 5,
+ * ADR 0005 D6). Classifiers, exclusions, mappings that suppress scope,
+ * adapters, runner definitions, gate binaries, CI jobs, baselines, and
+ * waivers are TRUSTED-REVISION-OWNED: a candidate change that edits them
+ * cannot authorize its own weaker checks. The engine therefore computes a
+ * domain-separated digest over the effective policy/config bytes and
+ * evaluates candidates against it.
+ *
+ * Phase 0 delivers the typed foundation only: the digest computation and
+ * the pure weakening check, both unit-testable. Receipt binding and real
+ * enforcement land in Phases 4-5 (plan §5.1 gate receipt: "trusted
+ * policy/verifier digest").
+ */
+import { sha256Canonical, sha256Hex } from '../canonical-json.js';
+import { compareStrings } from '../graph/util.js';
+/** Domain tag separating trusted-policy digests from every other hash. */
+export const TRUSTED_POLICY_DOMAIN = 'gateforge.trusted-policy.v1';
+/**
+ * Computes the trusted policy digest: a domain-separated canonical hash
+ * over the named document bytes (each byte-hashed, entries sorted by
+ * name). Deterministic — identical policy revisions produce identical
+ * digests, so a receipt can bind "evaluated under this policy revision"
+ * and any later byte change breaks the binding.
+ *
+ * Args:
+ *   inputs: the effective policy/config documents (config, policies,
+ *     classification policy, adapters, baselines, waivers, runner
+ *     definitions — the trusted-revision-owned set).
+ *
+ * Returns:
+ *   string: 64-char lowercase hex digest.
+ *
+ * Throws:
+ *   TypeError: when the same name appears twice (an ambiguous trusted
+ *     revision is a caller bug, never silently deduplicated).
+ */
+export function trustedPolicyDigest(inputs) {
+    const seen = new Set();
+    for (const input of inputs) {
+        if (seen.has(input.name)) {
+            throw new TypeError(`trustedPolicyDigest: duplicate policy input name '${input.name}'`);
+        }
+        seen.add(input.name);
+    }
+    const files = [...inputs]
+        .sort((a, b) => compareStrings(a.name, b.name))
+        .map((input) => ({ name: input.name, sha256: sha256Hex(input.bytes) }));
+    return sha256Canonical({ domain: TRUSTED_POLICY_DOMAIN, files });
+}
+const DIGEST_PATTERN = /^[0-9a-f]{64}$/;
+/**
+ * The pure weakening check (ADR 0005 D6): a candidate whose policy digest
+ * differs from the trusted revision is a WEAKENING CANDIDATE — it may
+ * only proceed after a separate trusted update is accepted, never by
+ * self-approval. Fail-closed: a missing or malformed digest cannot be
+ * verified, so it counts as weakened rather than trusted.
+ *
+ * Args:
+ *   trustedDigest: the digest of the trusted policy revision.
+ *   candidateDigest: the digest of the candidate's effective policy.
+ *
+ * Returns:
+ *   PolicyWeakeningCheck: `{weakened: false}` only for an exact, well-formed
+ *   match; otherwise `{weakened: true, reason}` naming the failure.
+ */
+export function policyWeakenedCandidate(trustedDigest, candidateDigest) {
+    if (!DIGEST_PATTERN.test(trustedDigest)) {
+        return {
+            weakened: true,
+            reason: `trusted policy digest is missing or malformed ('${trustedDigest}'); a candidate cannot be trusted against an unverifiable revision (fail closed)`,
+            trustedDigest,
+            candidateDigest,
+        };
+    }
+    if (!DIGEST_PATTERN.test(candidateDigest)) {
+        return {
+            weakened: true,
+            reason: `candidate policy digest is missing or malformed ('${candidateDigest}'); the candidate's effective policy cannot be verified (fail closed)`,
+            trustedDigest,
+            candidateDigest,
+        };
+    }
+    if (trustedDigest !== candidateDigest) {
+        return {
+            weakened: true,
+            reason: 'candidate policy digest differs from the trusted policy revision: candidate edits to ' +
+                'classifiers, exclusions, scope-suppressing mappings, adapters, runner definitions, ' +
+                'baselines, or waivers cannot authorize their own weaker checks (a trusted update is required)',
+            trustedDigest,
+            candidateDigest,
+        };
+    }
+    return { weakened: false, trustedDigest, candidateDigest };
+}
+//# sourceMappingURL=trusted.js.map

package/dist/policy/trusted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trusted.js","sourceRoot":"","sources":["../../src/policy/trusted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,0EAA0E;AAC1E,MAAM,CAAC,MAAM,qBAAqB,GAAG,6BAA6B,CAAC;AAUnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqC;IACvE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,SAAS,CAAC,qDAAqD,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC;QAC1F,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,GAAG,MAAM,CAAC;SACtB,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;SAC9C,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,OAAO,eAAe,CAAC,EAAE,MAAM,EAAE,qBAAqB,EAAE,KAAK,EAAE,CAAC,CAAC;AACnE,CAAC;AAcD,MAAM,cAAc,GAAG,gBAAgB,CAAC;AAExC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,uBAAuB,CACrC,aAAqB,EACrB,eAAuB;IAEvB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;QACxC,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,MAAM,EAAE,mDAAmD,aAAa,kFAAkF;YAC1J,aAAa;YACb,eAAe;SAChB,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC;QAC1C,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,MAAM,EAAE,qDAAqD,eAAe,uEAAuE;YACnJ,aAAa;YACb,eAAe;SAChB,CAAC;IACJ,CAAC;IACD,IAAI,aAAa,KAAK,eAAe,EAAE,CAAC;QACtC,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,MAAM,EACJ,uFAAuF;gBACvF,qFAAqF;gBACrF,+FAA+F;YACjG,aAAa;YACb,eAAe;SAChB,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,CAAC;AAC7D,CAAC"}