@sourcey/catalog-verifier 1.1.3 → 1.1.5

package/dist/modules/agent-readiness-policy/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../modules/agent-readiness-policy/src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../modules/agent-readiness-policy/src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,iCAAiC,EACtC,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAO5B,MAAM,iDAAiD,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAIhF,OAAO,EAAyB,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAGlG,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAE9B;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAC1C,QAAQ,CAAC,mBAAmB,EAAE,iCAAiC,CAAC;IAChE,QAAQ,CAAC,uBAAuB,EAAE,cAAc,CAAC;IACjD,QAAQ,CAAC,eAAe,CAAC,EAAE,wBAAwB,GAAG,IAAI,CAAC;IAC3D,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,GAAG,wBAAwB,CA8H3B;AAYD,wEAAwE;AACxE,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,UAAU,CAAC,OAAO,8BAA8B,CAAC,CAAC,CAAC,CAAC,GAAG;IAC5D,QAAQ,CAAC,eAAe,EAAE,wBAAwB,CAAC;CACpD,GACA,wBAAwB,CAQ1B;AAED;;;GAGG;AACH,wBAAgB,qCAAqC,CAAC,KAAK,EAAE;IAC3D,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAC1C,QAAQ,CAAC,eAAe,EAAE,wBAAwB,CAAC;IACnD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,GAAG,wBAAwB,CAU3B;AAED,8EAA8E;AAC9E,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,wBAAwB,EAC/B,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAIT;AAED,mFAAmF;AACnF,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,UAAU,CAAC,OAAO,+BAA+B,CAAC,CAAC,CAAC,CAAC,GAAG;IAC7D,QAAQ,CAAC,iBAAiB,EAAE,wBAAwB,CAAC;CACtD,GACA,wBAAwB,CAM1B"}

package/dist/modules/agent-readiness-policy/src/index.js

@@ -1,55 +1,25 @@
+import { canonicalJson, digest } from "provenry/primitives";
+import { agentReadinessDeclarationRevisionCoreSchema, agentReadinessDeclarationRevisionSchema, agentReadinessProjectionCoreSchema, agentReadinessProjectionSchema, agentReadinessRevisionSchema, sameAgentReadinessScopeIdentity, } from "../../../contracts/agent-readiness/src/index.js";
+import { agentReadinessCanonicalPath } from "../../../contracts/routes/src/index.js";
+import { rateOperate } from "../../agent-readiness-engine/src/rate.js";
+import { agentReadinessJobDigest } from "../../agent-readiness-jobs/src/index.js";
+import { deriveSubjectStanding } from "../../provenance/src/index.js";
+import { priorAgentReadinessVisibility } from "./prior-projection.js";
 export * from "./current-policy.js";
-export * from "./current-policy-validation.js";
-export * from "./grading.js";
+export * from "./declaration-jobs.js";
 export * from "./impact.js";
 export * from "./offer-relations.js";
-export * from "./policy-validation.js";
+export * from "./operate-policy.js";
+export * from "./prior-projection.js";
 export * from "./revision.js";
-export * from "./standard-mapping.js";
-import { canonicalJson, compareCanonicalStrings, digest } from "provenry/primitives";
-import { agentReadinessDeclarationRevisionCoreSchema, agentReadinessDeclarationRevisionSchema, agentReadinessProjectionCoreSchema, agentReadinessProjectionSchema, agentReadinessRevisionSchema, agentReadinessStageLabel, agentReadinessStageSchema, methodCapabilityFor, sameAgentReadinessScopeIdentity, } from "../../../contracts/agent-readiness/src/index.js";
-import { agentReadinessCanonicalPath } from "../../../contracts/routes/src/index.js";
-import { deriveProvenance, evidenceStatusFor, } from "../../provenance/src/index.js";
-import { verifyStandardEvidenceResult } from "../../standard-evidence/src/index.js";
-import { deriveAgentReadinessGrade, isAgentReadinessGradingSignal, isAgentReadinessVerifiedBarrierSignal, } from "./grading.js";
-import { validateAgentReadinessPolicy } from "./policy-validation.js";
-import { priorAgentReadinessVisibility } from "./projection-lineage.js";
-import { agentReadinessValuesSupportedByStandardRequirementResults } from "./standard-mapping.js";
-import { assertAgentReadinessSignalSelectorCoverage, assertSignalSurfaceClosure, surfaceCatalogFromDeclaration, } from "./surface-selection.js";
-export { agentReadinessAssessmentTargetIdsForSurface, agentReadinessDeclarationPolicyGaps, agentReadinessSelectorGroupUsesAssessmentTargets, assertAgentReadinessDeclarationPolicyClosure, assertAgentReadinessSignalSelectorCoverage, } from "./surface-selection.js";
-export function agentReadinessValuesSupportedByStandardEvidence(input) {
-    const policy = validateAgentReadinessPolicy(input.policy);
-    const rule = policy.signal_rules.find((candidate) => candidate.stage === input.stage && candidate.signal_code === input.signalCode);
-    if (!rule) {
-        throw new Error(`Unknown Agent Readiness signal ${input.stage}:${input.signalCode} for standard evidence.`);
-    }
-    const result = verifyStandardEvidenceResult(input.result);
-    return agentReadinessValuesSupportedByStandardRequirementResults({
-        mappings: rule.standard_evidence,
-        results: result.requirements,
-    });
-}
+/**
+ * The projection a release publishes for one revision: the Operate letter the
+ * pinned policy gives its steps, its Onboard level and evidence label, the
+ * human boundaries a reader sees, and whether it is discoverable. Freshness is
+ * served from the freshness index, never released. Nothing here reads
+ * documentation or calls out.
+ */
 export function deriveAgentReadinessProjection(input) {
-    const context = deriveAgentReadinessProjectionContext(input);
-    return projectAgentReadinessProjection({
-        ...context,
-        entitySlug: input.entitySlug,
-        priorVisibility: priorAgentReadinessVisibility(context.revision, input.priorProjection),
-    });
-}
-export function deriveAgentReadinessAssessment(input) {
-    return evaluateAgentReadinessProjection(deriveAgentReadinessProjectionContext(input));
-}
-export function verifyAgentReadinessProjection(input) {
-    const projection = agentReadinessProjectionSchema.parse(input);
-    const { projection_digest: projectionDigest, ...coreInput } = projection;
-    const core = agentReadinessProjectionCoreSchema.parse(coreInput);
-    if (digest(core) !== projectionDigest) {
-        throw new Error("Agent Readiness projection digest mismatch.");
-    }
-    return projection;
-}
-function deriveAgentReadinessProjectionContext(input) {
     const revision = agentReadinessRevisionSchema.parse(input.revision);
     const declarationRevision = agentReadinessDeclarationRevisionSchema.parse(input.declarationRevision);
     const { revision_digest: declarationDigest, ...declarationCore } = declarationRevision;
@@ -58,55 +28,129 @@ function deriveAgentReadinessProjectionContext(input) {
         revision.declaration_revision_digest !== declarationDigest ||
         revision.entity_id !== declarationRevision.entity_id ||
         !sameAgentReadinessScopeIdentity(revision.scope, declarationRevision.declaration.scope)) {
-        throw new Error("Agent Readiness projection does not bind its exact declaration revision and declaration scope.");
+        throw new Error("Agent Readiness projection does not bind its exact declaration revision and scope.");
+    }
+    const { policy } = input;
+    const job = policy.job_library.jobs.find(({ job_id }) => job_id === revision.scope.job.key);
+    if (job && agentReadinessJobDigest(job) !== revision.job_digest) {
+        throw new Error(`Agent Readiness profile ${revision.agent_readiness_profile_id} ran a job this policy changed; it needs new runs.`);
+    }
+    const binding = revision.binding_id === null
+        ? null
+        : declarationRevision.declaration.job_bindings.find(({ binding_id }) => binding_id === revision.binding_id);
+    if (!job || binding === undefined) {
+        throw new Error("Agent Readiness projection names a job or binding it cannot resolve.");
     }
-    assertSignalSurfaceClosure(revision, declarationRevision);
-    const policy = validateAgentReadinessPolicy(input.policy);
     if (!Number.isFinite(Date.parse(input.policyAsOf))) {
-        throw new Error("Agent readiness projection policy time is invalid.");
+        throw new Error("Agent Readiness projection policy time is invalid.");
     }
-    const provenance = deriveProvenance({
-        revision,
+    const rating = rateOperate(policy, revision.steps);
+    const rule = policy.letters.find(({ letter }) => letter === rating.letter);
+    const latest = revision.runs.at(-1);
+    const standing = deriveSubjectStanding({
+        revisionDigest: revision.revision_digest,
         authorityEntityRevision: input.authorityEntityRevision,
         graph: input.graph,
-        coveragePolicy: policy,
-        freshnessPolicy: input.freshnessPolicy,
         policyAsOf: input.policyAsOf,
     });
-    return {
-        revision,
-        policy,
-        policyAsOf: input.policyAsOf,
-        freshnessPolicy: input.freshnessPolicy,
-        surfaceCatalog: surfaceCatalogFromDeclaration(declarationRevision),
-        provenance,
-    };
+    const reasons = [
+        ...(revision.lifecycle === "active" ? [] : ["lifecycle_not_active"]),
+        ...(standing.dispute === "open" ? ["open_dispute"] : []),
+    ];
+    const prior = priorAgentReadinessVisibility(revision, input.priorProjection);
+    const { declaration } = declarationRevision;
+    const core = agentReadinessProjectionCoreSchema.parse({
+        projection_contract: "sourcey.agent-readiness-projection/v1alpha1",
+        agent_readiness_profile_id: revision.agent_readiness_profile_id,
+        entity_id: revision.entity_id,
+        scope: revision.scope,
+        catalog_binding: revision.catalog_binding,
+        declaration_revision_digest: revision.declaration_revision_digest,
+        declaration: revision.declaration,
+        surface_catalog: {
+            participants: declaration.participants,
+            resources: declaration.resources,
+            endpoints: declaration.endpoints,
+            interfaces: declaration.interfaces,
+            relations: declaration.relations,
+            surface_exclusions: declaration.surface_exclusions,
+        },
+        lifecycle: revision.lifecycle,
+        effective_from: revision.effective_from,
+        ...(revision.effective_until ? { effective_until: revision.effective_until } : {}),
+        revision_digest: revision.revision_digest,
+        policy_digest: policy.policy_digest,
+        policy_version: policy.policy_version,
+        policy_as_of: input.policyAsOf,
+        job: {
+            job_id: job.job_id,
+            job_digest: revision.job_digest,
+            category: job.category,
+            name: job.name,
+            statement: job.statement,
+        },
+        interface_id: binding?.interface_id ?? null,
+        label: latest.label,
+        operate: {
+            letter: rating.letter,
+            statement: rating.letter === "D" || rating.letter === "F"
+                ? policy.blocked.statements[rating.letter]
+                : (rule?.statement ?? null),
+            steps: revision.steps.map(({ step, outcome, timing }) => ({ step, outcome, timing })),
+            missing: rating.missing,
+            approvals: revision.steps
+                .filter(({ outcome }) => outcome === "approval")
+                .map(({ step }) => step),
+            workarounds: revision.steps.flatMap(({ step, outcome, timing }) => outcome === "workaround" && timing ? [{ step, timing }] : []),
+        },
+        onboard: { level: revision.onboard_level },
+        discovery: revision.discovery,
+        run: {
+            ...revision.latest_run,
+            assertions: revision.latest_run.assertions.map((result) => {
+                const assertion = job.assertions.find(({ name }) => name === result.assertion);
+                if (!assertion) {
+                    throw new Error(`Agent Readiness run reports assertion ${result.assertion}, which its job lacks.`);
+                }
+                return { ...result, statement: assertion.statement };
+            }),
+        },
+        last_run_at: latest.finished_at,
+        publication: {
+            visibility: reasons.length === 0
+                ? "discoverable"
+                : prior === "discoverable" || prior === "resolvable_only"
+                    ? "resolvable_only"
+                    : "private",
+            reasons,
+        },
+        provenance: standing,
+        canonical_url: canonicalUrl(input.entitySlug, revision),
+    });
+    return agentReadinessProjectionSchema.parse({ ...core, projection_digest: digest(core) });
+}
+function verifyAgentReadinessProjection(input) {
+    const projection = agentReadinessProjectionSchema.parse(input);
+    const { projection_digest: projectionDigest, ...coreInput } = projection;
+    const core = agentReadinessProjectionCoreSchema.parse(coreInput);
+    if (digest(core) !== projectionDigest) {
+        throw new Error("Agent Readiness projection digest mismatch.");
+    }
+    return projection;
 }
+/** The same revision under a newer policy or a later policy instant. */
 export function regradeAgentReadinessProjection(input) {
     const revision = agentReadinessRevisionSchema.parse(input.revision);
     const prior = verifyAgentReadinessProjection(input.priorProjection);
-    const policy = validateAgentReadinessPolicy(input.policy);
     assertCurrentAgentReadinessProjectionRevision(prior, revision);
-    if (Date.parse(input.policyAsOf) < Date.parse(prior.policy_as_of) ||
-        prior.provenance.coverage_policy_digest !== prior.policy_digest) {
-        throw new Error("Agent Readiness regrade does not bind the exact current revision.");
+    if (Date.parse(input.policyAsOf) < Date.parse(prior.policy_as_of)) {
+        throw new Error("Agent Readiness regrade cannot move its policy instant backwards.");
     }
-    return deriveAgentReadinessProjection({
-        revision,
-        declarationRevision: input.declarationRevision,
-        authorityEntityRevision: input.authorityEntityRevision,
-        priorProjection: prior,
-        graph: input.graph,
-        policy,
-        policyAsOf: input.policyAsOf,
-        freshnessPolicy: input.freshnessPolicy,
-        entitySlug: input.entitySlug,
-    });
+    return deriveAgentReadinessProjection(input);
 }
 /**
- * Move only the public route of an immutable assessment projection. This is
- * the contract-transition path: it retains every assessed fact, grade,
- * evidence binding, policy result, and publication decision byte-for-byte.
+ * Move only the public route of an immutable projection: every assessed fact,
+ * letter and publication decision is kept byte for byte.
  */
 export function reprojectAgentReadinessCanonicalRoute(input) {
     const revision = agentReadinessRevisionSchema.parse(input.revision);
@@ -115,16 +159,9 @@ export function reprojectAgentReadinessCanonicalRoute(input) {
     const { projection_digest: _projectionDigest, ...priorCore } = prior;
     const core = agentReadinessProjectionCoreSchema.parse({
         ...priorCore,
-        canonical_url: `https://sourcey.com${agentReadinessCanonicalPath({
-            entity_slug: input.entitySlug,
-            product_key: revision.scope.product.key,
-            funnel_key: revision.scope.funnel.key,
-        })}`,
-    });
-    return agentReadinessProjectionSchema.parse({
-        ...core,
-        projection_digest: digest(core),
+        canonical_url: canonicalUrl(input.entitySlug, revision),
     });
+    return agentReadinessProjectionSchema.parse({ ...core, projection_digest: digest(core) });
 }
 /** A relocation changes the locator, never the immutable assessment facts. */
 export function isAgentReadinessRouteOnlySuccession(prior, current) {
@@ -132,6 +169,7 @@ export function isAgentReadinessRouteOnlySuccession(prior, current) {
     const { canonical_url: currentUrl, projection_digest: _currentDigest, ...currentFacts } = current;
     return priorUrl !== currentUrl && canonicalJson(priorFacts) === canonicalJson(currentFacts);
 }
+/** A route move when that is all that changed; otherwise the revision re-rated. */
 export function deriveAgentReadinessReprojection(input) {
     const routeProjection = reprojectAgentReadinessCanonicalRoute(input);
     return isAgentReadinessRouteOnlySuccession(input.priorProjection, input.currentProjection) &&
@@ -143,373 +181,21 @@ function assertCurrentAgentReadinessProjectionRevision(prior, revision) {
     if (prior.agent_readiness_profile_id !== revision.agent_readiness_profile_id ||
         prior.revision_digest !== revision.revision_digest ||
         prior.entity_id !== revision.entity_id ||
-        JSON.stringify(prior.scope) !== JSON.stringify(revision.scope) ||
-        JSON.stringify(prior.catalog_binding) !== JSON.stringify(revision.catalog_binding) ||
+        canonicalJson(prior.scope) !== canonicalJson(revision.scope) ||
+        canonicalJson(prior.catalog_binding) !== canonicalJson(revision.catalog_binding) ||
         prior.declaration_revision_digest !== revision.declaration_revision_digest ||
-        JSON.stringify(prior.declaration) !== JSON.stringify(revision.declaration) ||
+        canonicalJson(prior.declaration) !== canonicalJson(revision.declaration) ||
         prior.lifecycle !== revision.lifecycle ||
         prior.effective_from !== revision.effective_from ||
         prior.effective_until !== revision.effective_until) {
         throw new Error("Agent Readiness projection does not bind the exact current revision.");
     }
 }
-function evaluateAgentReadinessProjection(input) {
-    const { revision, policy, provenance } = input;
-    if (!Number.isFinite(Date.parse(input.policyAsOf))) {
-        throw new Error("Agent readiness projection policy time is invalid.");
-    }
-    const facts = new Map(revision.signals.map((signal, index) => [
-        `${signal.stage}:${signal.signal_code}`,
-        {
-            signal,
-            field: provenance.fields.find((candidate) => candidate.path === `/signals/${index}`),
-        },
-    ]));
-    const policySignalKeys = new Set(policy.signal_rules.map((rule) => `${rule.stage}:${rule.signal_code}`));
-    const unmodeledSignals = revision.signals
-        .map((signal) => `${signal.stage}:${signal.signal_code}`)
-        .filter((key) => !policySignalKeys.has(key));
-    if (unmodeledSignals.length > 0) {
-        throw new Error(`Agent readiness revision contains signals outside policy: ${unmodeledSignals.join(", ")}.`);
-    }
-    const stages = agentReadinessStageSchema.options.map((stage) => {
-        const rules = policy.signal_rules.filter((rule) => rule.stage === stage);
-        const evaluated = rules.map((rule) => {
-            const fact = facts.get(`${stage}:${rule.signal_code}`);
-            if (fact)
-                assertAllowedAssessmentMethod(fact.signal, rule, policy, input.surfaceCatalog);
-            const evidenceStatus = fact ? evidenceStatusFor(fact.field) : "missing";
-            const freshness = fact
-                ? assessmentFreshness(fact.signal, fact.field?.freshness ?? "unknown", policy)
-                : "unknown";
-            const currentBarrierEvidence = rule.evaluation_role !== "barrier" || freshness === "fresh";
-            const outcome = fact &&
-                evidenceStatus === "supported" &&
-                fact.signal.value !== "unknown" &&
-                currentBarrierEvidence
-                ? agentReadinessSignalOutcome(rule, fact.signal.value)
-                : "unknown";
-            const value = fact && evidenceStatus === "supported" && currentBarrierEvidence
-                ? fact.signal.value
-                : "unknown";
-            const descriptor = rule.public_findings[value];
-            const publicState = policy.public_states[outcome];
-            const blocker = outcome === "fail" && rule.blocker
-                ? { signal_code: rule.signal_code, ...rule.blocker }
-                : undefined;
-            const remediation = ["constrained", "fail"].includes(outcome) && rule.remediation
-                ? { signal_code: rule.signal_code, ...rule.remediation }
-                : undefined;
-            return {
-                rule,
-                outcome,
-                evidenceStatus,
-                signal: {
-                    signal_code: rule.signal_code,
-                    evaluation_role: rule.evaluation_role,
-                    required: rule.required,
-                    value,
-                    value_label: publicState.label,
-                    outcome,
-                    public_state: publicState.state,
-                    condition: descriptor.condition,
-                    finding: descriptor.finding,
-                    evidence_status: evidenceStatus,
-                    freshness,
-                    ...(fact
-                        ? {
-                            observed_at: fact.signal.observed_at,
-                            tested_surfaces: fact.signal.tested_surfaces,
-                            assessment_method: fact.signal.assessment_method,
-                            determination_bases: fact.signal.determination_bases,
-                            ...(fact.signal.note ? { note: fact.signal.note } : {}),
-                        }
-                        : { tested_surfaces: [], determination_bases: [] }),
-                    ...(blocker ? { blocker } : {}),
-                    ...(remediation ? { remediation } : {}),
-                },
-            };
-        });
-        const graded = evaluated.filter((entry) => isAgentReadinessGradingSignal(entry.rule));
-        const verifiedBarriers = evaluated.filter((entry) => isAgentReadinessVerifiedBarrierSignal(entry.signal));
-        const stageSignals = [...graded, ...verifiedBarriers];
-        const outcome = worstAgentReadinessOutcome(stageSignals.map((entry) => entry.outcome), policy.aggregation.outcome_precedence);
-        const orderedStageSignals = [...stageSignals].sort((left, right) => compareEvaluatedRules(left, right, policy.aggregation.outcome_precedence));
-        const primary = orderedStageSignals[0];
-        if (!primary)
-            throw new Error(`Agent readiness stage ${stage} has no graded primary finding.`);
-        const orderedSecondary = evaluated
-            .filter((entry) => entry !== primary)
-            .sort((left, right) => compareEvaluatedRules(left, right, policy.aggregation.outcome_precedence));
-        return {
-            stage,
-            stage_label: agentReadinessStageLabel(stage),
-            outcome,
-            public_state: policy.public_states[outcome].state,
-            state_label: policy.public_states[outcome].label,
-            primary_finding: projectedFinding(primary),
-            secondary_context: orderedSecondary.map(projectedFinding),
-            signals: evaluated
-                .map((entry) => entry.signal)
-                .sort((left, right) => compareCanonicalStrings(left.signal_code, right.signal_code)),
-            blockers: orderedStageSignals.flatMap((entry) => entry.signal.blocker ? [entry.signal.blocker] : []),
-            remediations: orderedStageSignals.flatMap((entry) => entry.signal.remediation ? [entry.signal.remediation] : []),
-        };
-    });
-    const signals = stages.flatMap((stage) => stage.signals);
-    const gradedSignals = signals.filter((signal) => signal.evaluation_role === "graded");
-    const coveredSignals = gradedSignals.filter((signal) => signal.evidence_status === "supported" &&
-        signal.value !== "unknown" &&
-        signal.outcome !== "unknown" &&
-        signal.freshness === "fresh");
-    const coverageRatio = gradedSignals.length === 0 ? 1 : coveredSignals.length / gradedSignals.length;
-    const coverageStatus = coverageRatio === 1 ? "complete" : "incomplete";
-    const barrierSignals = signals.filter((signal) => signal.evaluation_role === "barrier");
-    const verifiedBarrierSignals = barrierSignals.filter(isAgentReadinessVerifiedBarrierSignal);
-    const barrierRatio = barrierSignals.length === 0 ? 1 : verifiedBarrierSignals.length / barrierSignals.length;
-    const freshnessSignals = policy.freshness.aggregation === "worst-required-signal"
-        ? gradedSignals
-        : policy.freshness.aggregation === "worst-evaluated-signal"
-            ? signals.filter((signal) => signal.evaluation_role !== "informational")
-            : signals;
-    const freshness = freshnessSignals.some((signal) => signal.freshness === "unknown")
-        ? "unknown"
-        : freshnessSignals.some((signal) => signal.freshness === "stale")
-            ? "stale"
-            : "fresh";
-    const overallOutcome = worstAgentReadinessOutcome(stages.map((stage) => stage.outcome), policy.aggregation.outcome_precedence);
-    const grade = deriveAgentReadinessGrade({
-        policy,
-        stages,
-        coverageStatus,
-        freshness,
-    });
-    return {
-        stages,
-        signals,
-        gradedSignals,
-        coveredSignals,
-        coverageRatio,
-        coverageStatus,
-        barrierSignals,
-        verifiedBarrierSignals,
-        barrierRatio,
-        freshness,
-        overallOutcome,
-        grade,
-    };
-}
-function projectAgentReadinessProjection(input) {
-    const { revision, policy, provenance } = input;
-    const { stages, gradedSignals, coveredSignals, coverageRatio, coverageStatus, barrierSignals, verifiedBarrierSignals, barrierRatio, freshness, overallOutcome, grade, } = evaluateAgentReadinessProjection(input);
-    const actionableFindings = stages
-        .flatMap((stage) => stage.signals
-        .filter((signal) => signal.evaluation_role !== "informational" &&
-        signal.evidence_status === "supported" &&
-        (signal.evaluation_role === "graded" ||
-            isAgentReadinessVerifiedBarrierSignal(signal)) &&
-        (signal.public_state === "blocked" || signal.public_state === "limited"))
-        .map((signal) => ({ stage, signal })))
-        .sort((left, right) => compareActionableFindings(left, right, policy));
-    const primaryFinding = actionableFindings[0];
-    const firstBlockedStage = stages.find((stage) => stage.public_state === "blocked");
-    const limitations = actionableFindings.filter(({ signal }) => signal.public_state === "limited");
-    const publicationReasons = agentReadinessPublicationReasons({
-        revision,
-        stages,
-        coverageStatus,
-        freshness,
-        grade,
-        provenance,
-    });
-    const visibility = publicationReasons.length === 0
-        ? "discoverable"
-        : input.priorVisibility === "discoverable" || input.priorVisibility === "resolvable_only"
-            ? "resolvable_only"
-            : "private";
-    const core = agentReadinessProjectionCoreSchema.parse({
-        projection_contract: "sourcey.agent-readiness-projection/v1alpha1",
-        agent_readiness_profile_id: revision.agent_readiness_profile_id,
-        entity_id: revision.entity_id,
-        scope: revision.scope,
-        catalog_binding: revision.catalog_binding,
-        declaration_revision_digest: revision.declaration_revision_digest,
-        declaration: revision.declaration,
-        surface_catalog: input.surfaceCatalog,
-        lifecycle: revision.lifecycle,
-        effective_from: revision.effective_from,
-        ...(revision.effective_until ? { effective_until: revision.effective_until } : {}),
-        revision_digest: revision.revision_digest,
-        policy_digest: policy.policy_digest,
-        policy_version: policy.policy_version,
-        policy_as_of: input.policyAsOf,
-        assessment_basis: policy.assessment_basis,
-        overall_outcome: overallOutcome,
-        public_state: policy.public_states[overallOutcome].state,
-        state_label: policy.public_states[overallOutcome].label,
-        grade,
-        grade_derivation: policy.grade_derivation,
-        publication: {
-            visibility,
-            reasons: publicationReasons,
-        },
-        ...(primaryFinding
-            ? {
-                primary_finding: {
-                    stage: primaryFinding.stage.stage,
-                    stage_label: primaryFinding.stage.stage_label,
-                    public_state: primaryFinding.signal.public_state,
-                    finding: {
-                        signal_code: primaryFinding.signal.signal_code,
-                        condition: primaryFinding.signal.condition,
-                        finding: primaryFinding.signal.finding,
-                        ...("note" in primaryFinding.signal && primaryFinding.signal.note
-                            ? { context: primaryFinding.signal.note }
-                            : {}),
-                    },
-                    ...(primaryFinding.signal.blocker ? { blocker: primaryFinding.signal.blocker } : {}),
-                },
-            }
-            : {}),
-        ...(firstBlockedStage
-            ? {
-                first_blocked_stage: {
-                    stage: firstBlockedStage.stage,
-                    stage_label: firstBlockedStage.stage_label,
-                    finding: firstBlockedStage.primary_finding,
-                    ...(firstBlockedStage.blockers[0] ? { blocker: firstBlockedStage.blockers[0] } : {}),
-                },
-            }
-            : {}),
-        limitations: limitations.map(({ stage, signal }) => ({
-            stage: stage.stage,
-            stage_label: stage.stage_label,
-            finding: {
-                signal_code: signal.signal_code,
-                condition: signal.condition,
-                finding: signal.finding,
-                ...("note" in signal && signal.note ? { context: signal.note } : {}),
-            },
-            ...(signal.remediation ? { remediation: signal.remediation } : {}),
-        })),
-        stages,
-        coverage: {
-            status: coverageStatus,
-            required_signals: gradedSignals.length,
-            covered_signals: coveredSignals.length,
-            ratio: coverageRatio,
-            barrier_signals: barrierSignals.length,
-            verified_barrier_signals: verifiedBarrierSignals.length,
-            barrier_ratio: barrierRatio,
-        },
-        last_tested_at: latestInstant(revision.signals.map((signal) => signal.observed_at)),
-        freshness,
-        provenance,
-        canonical_url: `https://sourcey.com${agentReadinessCanonicalPath({
-            entity_slug: input.entitySlug,
-            product_key: revision.scope.product.key,
-            funnel_key: revision.scope.funnel.key,
-        })}`,
-    });
-    return agentReadinessProjectionSchema.parse({
-        ...core,
-        projection_digest: digest(core),
-    });
-}
-function latestInstant(instants) {
-    const latest = [...instants].sort((left, right) => Date.parse(left) - Date.parse(right)).at(-1);
-    if (!latest)
-        throw new Error("Agent Readiness projection requires a tested signal instant.");
-    return latest;
-}
-function agentReadinessPublicationReasons(input) {
-    const reasons = [];
-    const signals = input.stages.flatMap((stage) => stage.signals);
-    if (input.revision.lifecycle !== "active")
-        reasons.push("lifecycle_not_active");
-    if (input.coverageStatus !== "complete")
-        reasons.push("coverage_incomplete");
-    if (signals.some((signal) => signal.evaluation_role === "graded" && signal.evidence_status !== "supported")) {
-        reasons.push("required_evidence_not_supported");
-    }
-    if (input.freshness !== "fresh")
-        reasons.push("freshness_not_fresh");
-    if (input.grade === "unrated")
-        reasons.push("unrated");
-    if (!signals.some((signal) => signal.evidence_status === "supported")) {
-        reasons.push("no_useful_finding");
-    }
-    if (input.provenance.dispute === "open")
-        reasons.push("open_dispute");
-    return reasons;
-}
-function projectedFinding(entry) {
-    return {
-        signal_code: entry.rule.signal_code,
-        condition: entry.signal.condition,
-        finding: entry.signal.finding,
-        ...(entry.signal.note ? { context: entry.signal.note } : {}),
-    };
-}
-export function agentReadinessSignalOutcome(rule, value) {
-    if (rule.pass_values.includes(value))
-        return value === "not_applicable" ? "not_applicable" : "pass";
-    if (rule.constrained_values.includes(value)) {
-        return value === "not_applicable" ? "not_applicable" : "constrained";
-    }
-    if (rule.fail_values.includes(value))
-        return value === "not_applicable" ? "not_applicable" : "fail";
-    return "unknown";
-}
-export function worstAgentReadinessOutcome(outcomes, precedence) {
-    return ([...outcomes].sort((left, right) => precedence.indexOf(left) - precedence.indexOf(right))[0] ??
-        "unknown");
-}
-function assertAllowedAssessmentMethod(signal, rule, policy, surfaceCatalog) {
-    const method = policy.assessment_methods.find((candidate) => candidate.method_digest === signal.assessment_method.method_digest);
-    if (!method ||
-        method.name !== signal.assessment_method.name ||
-        method.version !== signal.assessment_method.version ||
-        !rule.allowed_method_digests.includes(method.method_digest)) {
-        throw new Error(`Agent readiness signal ${signal.stage}:${signal.signal_code} uses an unapproved assessment method.`);
-    }
-    const selectorGroup = rule.selector_groups.find((group) => group.selector_group_id === signal.selector_group_id);
-    if (!selectorGroup) {
-        throw new Error(`Agent readiness signal ${signal.stage}:${signal.signal_code} uses an unknown selector group.`);
-    }
-    assertAgentReadinessSignalSelectorCoverage(signal, selectorGroup, surfaceCatalog, rule.allow_not_applicable);
-    if (signal.tested_surfaces.some((surface) => surface.node_kind !== "surface_exclusion" &&
-        !method.surface_support.node_kinds.includes(surface.node_kind))) {
-        throw new Error(`Agent readiness signal ${signal.stage}:${signal.signal_code} uses an unsupported surface kind.`);
-    }
-    const capability = methodCapabilityFor(method, signal.stage, signal.signal_code);
-    if (!capability || (signal.value !== "unknown" && !capability.values.includes(signal.value))) {
-        throw new Error(`Agent readiness method ${method.name}@${method.version} cannot establish ${signal.stage}:${signal.signal_code}=${signal.value}.`);
-    }
-    if (signal.determination_bases.some((basis) => !capability.determination_bases.includes(basis.kind))) {
-        throw new Error(`Agent readiness signal ${signal.stage}:${signal.signal_code} uses an unsupported determination basis.`);
-    }
-}
-function assessmentFreshness(signal, evidenceFreshness, policy) {
-    const method = policy.assessment_methods.find((candidate) => candidate.method_digest === signal.assessment_method.method_digest);
-    return method?.capture.freshness_capability === "history-only" ? "stale" : evidenceFreshness;
-}
-function compareActionableFindings(left, right, policy) {
-    const severity = { blocked: 0, limited: 1 };
-    const leftRule = policy.signal_rules.find((rule) => rule.stage === left.stage.stage && rule.signal_code === left.signal.signal_code);
-    const rightRule = policy.signal_rules.find((rule) => rule.stage === right.stage.stage && rule.signal_code === right.signal.signal_code);
-    if (!leftRule || !rightRule)
-        throw new Error("Actionable finding lost its policy rule.");
-    return (severity[left.signal.public_state] -
-        severity[right.signal.public_state] ||
-        agentReadinessStageSchema.options.indexOf(left.stage.stage) -
-            agentReadinessStageSchema.options.indexOf(right.stage.stage) ||
-        leftRule.priority - rightRule.priority ||
-        compareCanonicalStrings(left.signal.signal_code, right.signal.signal_code));
-}
-function compareEvaluatedRules(left, right, precedence) {
-    return (precedence.indexOf(left.outcome) - precedence.indexOf(right.outcome) ||
-        left.rule.priority - right.rule.priority ||
-        compareCanonicalStrings(left.rule.signal_code, right.rule.signal_code));
+function canonicalUrl(entitySlug, revision) {
+    return `https://sourcey.com${agentReadinessCanonicalPath({
+        entity_slug: entitySlug,
+        product_key: revision.scope.product.key,
+        job_key: revision.scope.job.key,
+    })}`;
 }
 //# sourceMappingURL=index.js.map