@usefragments/core 1.11.0 → 2.0.0

package/dist/index.js

@@ -66,7 +66,7 @@ import {
 } from "./chunk-SH4KPIYH.js";
 import {
   resolveArea
-} from "./chunk-3LLRNCPX.js";
+} from "./chunk-MZ2FS7U4.js";
 import {
   generateContext
 } from "./chunk-X34IA4LR.js";
@@ -113,12 +113,6 @@ import {
   factEvidenceSchema,
   factId,
   factLocationSchema,
-  featurePlanIdFromEntropy,
-  featurePlanIdSchema,
-  featurePlanIdStringSchema,
-  featureRevisionIdFromDigest,
-  featureRevisionIdSchema,
-  featureRevisionIdStringSchema,
   findingFixSchema,
   findingReplaceClassTokenFixSchema,
   findingReplaceComponentFixSchema,
@@ -194,10 +188,9 @@ import {
   ownedImportMatchesRoot,
   ownedImportsEqual,
   parseAnalysisPlanId,
+  parseComponentGovernancePolicyJson,
   parseDigestHex,
   parseEvaluationReceiptId,
-  parseFeaturePlanId,
-  parseFeatureRevisionId,
   policyExcludeMatchesPath,
   policyExcludeSchema,
   projectSupersededImportPathPreferences,
@@ -208,7 +201,7 @@ import {
   suppressionDirectiveSchema,
   validatorResultSchema,
   violationSchema
-} from "./chunk-RPSEABY3.js";
+} from "./chunk-BMPYIUZE.js";
 import {
   isPortableRepoPath,
   normalizeConfigPath,
@@ -1346,14 +1339,14 @@ function rgbToLab(rgb) {
   b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
   let x = (r * 0.4124564 + g2 * 0.3575761 + b * 0.1804375) / 0.95047;
   let y = r * 0.2126729 + g2 * 0.7151522 + b * 0.072175;
-  let z12 = (r * 0.0193339 + g2 * 0.119192 + b * 0.9503041) / 1.08883;
+  let z11 = (r * 0.0193339 + g2 * 0.119192 + b * 0.9503041) / 1.08883;
   x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
   y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
-  z12 = z12 > 8856e-6 ? Math.pow(z12, 1 / 3) : 7.787 * z12 + 16 / 116;
+  z11 = z11 > 8856e-6 ? Math.pow(z11, 1 / 3) : 7.787 * z11 + 16 / 116;
   return {
     l: 116 * y - 16,
     a: 500 * (x - y),
-    b: 200 * (y - z12)
+    b: 200 * (y - z11)
   };
 }
 
@@ -9389,11 +9382,11 @@ function collectPassthroughRecordValues(authored, path, allowed, diagnostics) {
   }
 }
 function stableConfigDiagnostics(diagnostics) {
-  const unique3 = /* @__PURE__ */ new Map();
+  const unique2 = /* @__PURE__ */ new Map();
   for (const diagnostic of diagnostics) {
-    unique3.set(`${diagnostic.code}\0${diagnostic.path}`, diagnostic);
+    unique2.set(`${diagnostic.code}\0${diagnostic.path}`, diagnostic);
   }
-  return [...unique3.values()].sort(
+  return [...unique2.values()].sort(
     (left, right) => left.path.localeCompare(right.path) || left.code.localeCompare(right.code) || left.message.localeCompare(right.message)
   );
 }
@@ -10889,607 +10882,12 @@ function coverageArtifactDigestV1(rawPlan, rawCoverage) {
   );
 }
 
-// src/feature-plan/types.ts
-import { z as z10 } from "zod";
-var FEATURE_PLAN_MAX_EVIDENCE_REFS_V1 = 200;
-var FEATURE_PLAN_MAX_USES_PER_KIND_V1 = 100;
-var FEATURE_PLAN_MAX_GAPS_V1 = 50;
-var FEATURE_PLAN_MAX_DECISIONS_V1 = 50;
-var FEATURE_PLAN_MAX_SCENARIOS_V1 = 50;
-var FEATURE_PLAN_MAX_ACCEPTANCE_ITEMS_V1 = 100;
-var FEATURE_PLAN_MAX_TEXT_BYTES_V1 = 32 * 1024;
-var AGENT_FEATURE_CONTEXT_MAX_BYTES_V1 = 64 * 1024;
-var utf8Length2 = (value) => new TextEncoder().encode(value).byteLength;
-var boundedString2 = (maxBytes = FEATURE_PLAN_MAX_TEXT_BYTES_V1) => z10.string().min(1).refine((value) => utf8Length2(value) <= maxBytes, `Value exceeds ${maxBytes} UTF-8 bytes`);
-var shortString = () => boundedString2(4096);
-var unique = (values) => new Set(values).size === values.length;
-var uniqueIdArray = (max = FEATURE_PLAN_MAX_EVIDENCE_REFS_V1) => z10.array(shortString()).max(max).refine(unique, "ID references must be unique");
-var evidenceRefV1Schema = z10.object({
-  evidenceId: shortString(),
-  kind: z10.enum(["user_intent", "image", "source", "contract", "pattern", "model"]),
-  authority: z10.enum(["user_asserted", "source_observed", "contract_approved", "model_inferred"]),
-  ref: boundedString2(),
-  digest: digestHexStringSchema
-}).strict();
-var placementDecisionV1Schema = z10.object({
-  targetKind: z10.enum(["page", "section"]),
-  targetRef: shortString(),
-  routeRef: shortString().optional(),
-  parentSlotRef: shortString(),
-  evidenceRefIds: uniqueIdArray()
-}).strict();
-var propValueSchema = z10.union([boundedString2(), z10.number().finite(), z10.boolean(), z10.null()]);
-var componentUseDecisionV1Schema = z10.object({
-  useId: shortString(),
-  componentId: shortString(),
-  importPath: shortString(),
-  purpose: boundedString2(),
-  props: z10.record(shortString(), propValueSchema).refine((props) => Object.keys(props).length <= 100, "Component props exceed V1 limit"),
-  evidenceRefIds: uniqueIdArray()
-}).strict();
-var tokenUseDecisionV1Schema = z10.object({
-  useId: shortString(),
-  tokenId: shortString(),
-  role: shortString(),
-  evidenceRefIds: uniqueIdArray()
-}).strict();
-var patternStatusV1Schema = z10.enum([
-  "observed",
-  "candidate",
-  "approved_guidance",
-  "contract_canonical",
-  "deprecated"
-]);
-var patternUseDecisionV1Schema = z10.object({
-  useId: shortString(),
-  patternId: shortString(),
-  patternRevisionDigest: digestHexStringSchema,
-  status: patternStatusV1Schema,
-  disposition: z10.enum(["reuse", "reference", "reject"]),
-  evidenceRefIds: uniqueIdArray()
-}).strict().superRefine((pattern, context) => {
-  if (pattern.disposition === "reuse" && pattern.status !== "approved_guidance" && pattern.status !== "contract_canonical") {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: ["disposition"],
-      message: "Only approved-guidance or contract-canonical patterns may be reused"
-    });
-  }
-});
-var layoutConcernV1Schema = z10.enum([
-  "outer_inline_spacing",
-  "outer_block_spacing",
-  "inner_padding",
-  "child_gap",
-  "max_inline_size",
-  "scroll_x",
-  "scroll_y",
-  "sticky_offset",
-  "breakpoint_switching"
-]);
-var layoutConcernOwnerV1Schema = z10.object({
-  concern: layoutConcernV1Schema,
-  ownerLayer: z10.enum([
-    "application_shell",
-    "route_shell",
-    "page",
-    "section",
-    "pattern",
-    "primitive"
-  ]),
-  ownerRef: shortString(),
-  childAction: z10.enum(["consume", "own", "override"]),
-  tokenRef: shortString().optional(),
-  breakpointRef: shortString().optional(),
-  evidenceRefIds: uniqueIdArray(),
-  overrideDecisionId: shortString().optional()
-}).strict().superRefine((row, context) => {
-  if (row.childAction === "override" && !row.overrideDecisionId) {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: ["overrideDecisionId"],
-      message: "A layout override must reference an approved decision"
-    });
-  }
-  if (row.childAction !== "override" && row.overrideDecisionId) {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: ["overrideDecisionId"],
-      message: "Only an override may reference an override decision"
-    });
-  }
-});
-var layoutOwnershipV1Schema = z10.object({
-  concerns: z10.array(layoutConcernOwnerV1Schema).max(32).refine(
-    (rows) => new Set(rows.map((row) => row.concern)).size === rows.length,
-    "Each layout concern must have exactly one owner"
-  )
-}).strict();
-var responsiveDecisionV1Schema = z10.object({
-  decisionId: shortString(),
-  source: z10.enum(["contract", "observed", "desktop_only"]),
-  breakpointRef: shortString().optional(),
-  behavior: boundedString2(),
-  evidenceRefIds: uniqueIdArray()
-}).strict().superRefine((decision, context) => {
-  if (decision.source !== "desktop_only" && !decision.breakpointRef) {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: ["breakpointRef"],
-      message: "Responsive contract/observed decisions must pin a breakpoint"
-    });
-  }
-});
-var scenarioRequirementV1Schema = z10.object({
-  scenarioId: shortString(),
-  viewportRef: shortString().optional(),
-  themeRef: shortString().optional(),
-  actorRole: shortString().optional(),
-  dataState: z10.enum(["default", "loading", "empty", "partial", "error"]),
-  interactionState: z10.enum(["pristine", "dirty", "validating", "saving", "saved", "disabled"]).optional(),
-  acceptanceIds: uniqueIdArray(FEATURE_PLAN_MAX_ACCEPTANCE_ITEMS_V1)
-}).strict();
-var gapDispositionV1Schema = z10.enum([
-  "canonical_reuse",
-  "approved_pattern",
-  "local_composition",
-  "intentional_one_off",
-  "proposed_contract_addition",
-  "unresolved"
-]);
-var capabilityGapV1Schema = z10.object({
-  gapId: shortString(),
-  capability: boundedString2(),
-  required: z10.boolean(),
-  disposition: gapDispositionV1Schema,
-  reason: boundedString2(),
-  evidenceRefIds: uniqueIdArray(),
-  proposedContractCandidateId: shortString().optional()
-}).strict().superRefine((gap, context) => {
-  if (gap.disposition === "proposed_contract_addition" && !gap.proposedContractCandidateId) {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: ["proposedContractCandidateId"],
-      message: "A proposed contract addition must pin its candidate"
-    });
-  }
-  if (gap.disposition !== "proposed_contract_addition" && gap.proposedContractCandidateId) {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: ["proposedContractCandidateId"],
-      message: "Only a proposed contract addition may carry a candidate ID"
-    });
-  }
-});
-var featureAcceptanceItemV1Schema = z10.object({
-  acceptanceId: shortString(),
-  statement: boundedString2(),
-  proof: z10.enum(["unit", "integration", "browser", "governance", "manual"]),
-  required: z10.boolean(),
-  evidenceRefIds: uniqueIdArray()
-}).strict();
-var decisionOptionV1Schema = z10.object({ optionId: shortString(), label: boundedString2(), consequence: boundedString2() }).strict();
-var decisionRequestV1Schema = z10.object({
-  decisionId: shortString(),
-  kind: z10.enum(["placement", "reuse", "gap", "layout_override", "responsive", "scope"]),
-  question: boundedString2(),
-  options: z10.array(decisionOptionV1Schema).min(2).max(20).refine(
-    (options) => new Set(options.map((option) => option.optionId)).size === options.length,
-    "Decision option IDs must be unique"
-  ),
-  recommendedOptionId: shortString().optional(),
-  required: z10.boolean(),
-  evidenceRefIds: uniqueIdArray()
-}).strict().superRefine((decision, context) => {
-  if (decision.recommendedOptionId && !decision.options.some((option) => option.optionId === decision.recommendedOptionId)) {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: ["recommendedOptionId"],
-      message: "Recommended option must resolve inside the decision"
-    });
-  }
-});
-var decisionResolutionV1Schema = z10.object({ decisionId: shortString(), selectedOptionId: shortString() }).strict();
-var featurePinsV1Schema = z10.object({
-  bindingId: shortString(),
-  grounding: z10.object({
-    sourceCommitId: shortString(),
-    analysisPlanDigest: digestHexStringSchema,
-    contextSliceDigest: digestHexStringSchema
-  }).strict(),
-  authority: z10.object({
-    fcid: digestHexStringSchema,
-    contractArtifactDigest: digestHexStringSchema,
-    analysisObligationsDigest: digestHexStringSchema
-  }).strict(),
-  evidenceDigest: digestHexStringSchema
-}).strict();
-var commonRevisionShape = {
-  pins: featurePinsV1Schema,
-  placement: placementDecisionV1Schema,
-  componentUses: z10.array(componentUseDecisionV1Schema).max(FEATURE_PLAN_MAX_USES_PER_KIND_V1),
-  tokenUses: z10.array(tokenUseDecisionV1Schema).max(FEATURE_PLAN_MAX_USES_PER_KIND_V1),
-  patternUses: z10.array(patternUseDecisionV1Schema).max(FEATURE_PLAN_MAX_USES_PER_KIND_V1),
-  layout: layoutOwnershipV1Schema,
-  responsive: z10.array(responsiveDecisionV1Schema).max(FEATURE_PLAN_MAX_DECISIONS_V1),
-  scenarios: z10.array(scenarioRequirementV1Schema).max(FEATURE_PLAN_MAX_SCENARIOS_V1),
-  gaps: z10.array(capabilityGapV1Schema).max(FEATURE_PLAN_MAX_GAPS_V1),
-  acceptance: z10.array(featureAcceptanceItemV1Schema).max(FEATURE_PLAN_MAX_ACCEPTANCE_ITEMS_V1),
-  evidenceRefs: z10.array(evidenceRefV1Schema).max(FEATURE_PLAN_MAX_EVIDENCE_REFS_V1)
-};
-function addUniqueIdIssue(rows, key, path, context) {
-  const values = rows.map((row) => row[key]).filter((value) => typeof value === "string");
-  if (new Set(values).size !== values.length) {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: [path],
-      message: `${path} IDs must be unique`
-    });
-  }
-}
-function validateCommonGraph(graph, context, decisionIds) {
-  addUniqueIdIssue(graph.evidenceRefs, "evidenceId", "evidenceRefs", context);
-  addUniqueIdIssue(graph.componentUses, "useId", "componentUses", context);
-  addUniqueIdIssue(graph.tokenUses, "useId", "tokenUses", context);
-  addUniqueIdIssue(graph.patternUses, "useId", "patternUses", context);
-  addUniqueIdIssue(graph.responsive, "decisionId", "responsive", context);
-  addUniqueIdIssue(graph.scenarios, "scenarioId", "scenarios", context);
-  addUniqueIdIssue(graph.gaps, "gapId", "gaps", context);
-  addUniqueIdIssue(graph.acceptance, "acceptanceId", "acceptance", context);
-  const evidenceIds = new Set(graph.evidenceRefs.map((evidence) => evidence.evidenceId));
-  const acceptanceIds = new Set(graph.acceptance.map((acceptance) => acceptance.acceptanceId));
-  const evidenceReferences = [
-    [graph.placement.evidenceRefIds, "placement.evidenceRefIds"],
-    ...graph.componentUses.map(
-      (row, index) => [row.evidenceRefIds, `componentUses.${index}.evidenceRefIds`]
-    ),
-    ...graph.tokenUses.map(
-      (row, index) => [row.evidenceRefIds, `tokenUses.${index}.evidenceRefIds`]
-    ),
-    ...graph.patternUses.map(
-      (row, index) => [row.evidenceRefIds, `patternUses.${index}.evidenceRefIds`]
-    ),
-    ...graph.layout.concerns.map(
-      (row, index) => [row.evidenceRefIds, `layout.concerns.${index}.evidenceRefIds`]
-    ),
-    ...graph.responsive.map(
-      (row, index) => [row.evidenceRefIds, `responsive.${index}.evidenceRefIds`]
-    ),
-    ...graph.gaps.map(
-      (row, index) => [row.evidenceRefIds, `gaps.${index}.evidenceRefIds`]
-    ),
-    ...graph.acceptance.map(
-      (row, index) => [row.evidenceRefIds, `acceptance.${index}.evidenceRefIds`]
-    )
-  ];
-  for (const [references, path] of evidenceReferences) {
-    for (const reference of references) {
-      if (!evidenceIds.has(reference)) {
-        context.addIssue({
-          code: z10.ZodIssueCode.custom,
-          path: path.split("."),
-          message: `Unknown evidence reference: ${reference}`
-        });
-      }
-    }
-  }
-  for (const [index, scenario] of graph.scenarios.entries()) {
-    for (const acceptanceId of scenario.acceptanceIds) {
-      if (!acceptanceIds.has(acceptanceId)) {
-        context.addIssue({
-          code: z10.ZodIssueCode.custom,
-          path: ["scenarios", index, "acceptanceIds"],
-          message: `Unknown acceptance reference: ${acceptanceId}`
-        });
-      }
-    }
-  }
-  for (const [index, row] of graph.layout.concerns.entries()) {
-    if (row.overrideDecisionId && !decisionIds.has(row.overrideDecisionId)) {
-      context.addIssue({
-        code: z10.ZodIssueCode.custom,
-        path: ["layout", "concerns", index, "overrideDecisionId"],
-        message: `Unknown decision reference: ${row.overrideDecisionId}`
-      });
-    }
-  }
-}
-var proposalInputShape = {
-  schemaVersion: z10.literal(1),
-  kind: z10.literal("proposal"),
-  planId: featurePlanIdStringSchema,
-  parentRevisionDigest: digestHexStringSchema.optional(),
-  ...commonRevisionShape,
-  questions: z10.array(decisionRequestV1Schema).max(FEATURE_PLAN_MAX_DECISIONS_V1)
-};
-function validateProposal(proposal, context) {
-  addUniqueIdIssue(proposal.questions, "decisionId", "questions", context);
-  const decisionIds = new Set(proposal.questions.map((question) => question.decisionId));
-  validateCommonGraph(proposal, context, decisionIds);
-  const evidenceIds = new Set(proposal.evidenceRefs.map((evidence) => evidence.evidenceId));
-  for (const [index, question] of proposal.questions.entries()) {
-    for (const reference of question.evidenceRefIds) {
-      if (!evidenceIds.has(reference)) {
-        context.addIssue({
-          code: z10.ZodIssueCode.custom,
-          path: ["questions", index, "evidenceRefIds"],
-          message: `Unknown evidence reference: ${reference}`
-        });
-      }
-    }
-  }
-}
-var featureProposalInputV1Schema = z10.object(proposalInputShape).strict().superRefine(validateProposal);
-var featureProposalV1Schema = z10.object({
-  ...proposalInputShape,
-  revisionId: featureRevisionIdStringSchema,
-  revisionDigest: digestHexStringSchema
-}).strict().superRefine(validateProposal);
-var manifestInputShape = {
-  schemaVersion: z10.literal(1),
-  kind: z10.literal("approved_manifest"),
-  planId: featurePlanIdStringSchema,
-  parentRevisionDigest: digestHexStringSchema,
-  proposalRevisionDigest: digestHexStringSchema,
-  ...commonRevisionShape,
-  validatedGrounding: z10.object({
-    sourceCommitId: shortString(),
-    analysisPlanDigest: digestHexStringSchema,
-    contextSliceDigest: digestHexStringSchema
-  }).strict(),
-  decisions: z10.array(decisionResolutionV1Schema).max(FEATURE_PLAN_MAX_DECISIONS_V1),
-  approval: z10.object({
-    approverUserId: shortString(),
-    decisionDigest: digestHexStringSchema,
-    approvedAt: z10.string().datetime({ offset: true }),
-    expiresAt: z10.string().datetime({ offset: true }).optional()
-  }).strict()
-};
-var portableRepositoryPathSchema = shortString().refine(
-  (value) => !value.startsWith("/") && !value.includes("\\") && !value.split("/").includes(".."),
-  "Expected a portable repository-relative path"
-);
-function validateManifest(manifest, context) {
-  addUniqueIdIssue(manifest.decisions, "decisionId", "decisions", context);
-  validateCommonGraph(manifest, context, new Set(manifest.decisions.map((row) => row.decisionId)));
-  if (manifest.validatedGrounding.contextSliceDigest !== manifest.pins.grounding.contextSliceDigest) {
-    context.addIssue({
-      code: z10.ZodIssueCode.custom,
-      path: ["validatedGrounding", "contextSliceDigest"],
-      message: "Validated material context must match the pinned proposal context"
-    });
-  }
-  for (const [index, gap] of manifest.gaps.entries()) {
-    if (gap.required && (gap.disposition === "unresolved" || gap.disposition === "proposed_contract_addition")) {
-      context.addIssue({
-        code: z10.ZodIssueCode.custom,
-        path: ["gaps", index, "disposition"],
-        message: "A required unresolved or proposed-contract gap blocks approval until it is resolved"
-      });
-    }
-  }
-}
-var approvedFeatureManifestInputV1Schema = z10.object(manifestInputShape).strict().superRefine(validateManifest);
-var approvedFeatureManifestV1Schema = z10.object({
-  ...manifestInputShape,
-  revisionId: featureRevisionIdStringSchema,
-  revisionDigest: digestHexStringSchema
-}).strict().superRefine(validateManifest);
-var agentFeatureContextV1Schema = z10.object({
-  schemaVersion: z10.literal(1),
-  planId: featurePlanIdStringSchema,
-  manifestDigest: digestHexStringSchema,
-  pins: featurePinsV1Schema,
-  validatedGrounding: manifestInputShape.validatedGrounding,
-  target: placementDecisionV1Schema,
-  componentUses: commonRevisionShape.componentUses,
-  tokenUses: commonRevisionShape.tokenUses,
-  patternUses: commonRevisionShape.patternUses,
-  layout: layoutOwnershipV1Schema,
-  responsive: commonRevisionShape.responsive,
-  scenarios: commonRevisionShape.scenarios,
-  acceptedGaps: commonRevisionShape.gaps,
-  acceptance: commonRevisionShape.acceptance,
-  decisions: manifestInputShape.decisions,
-  relevantFiles: z10.array(portableRepositoryPathSchema).max(500).refine(unique, "relevantFiles must be unique"),
-  commands: z10.array(boundedString2()).max(100)
-}).strict().superRefine((contextValue, context) => {
-  const graph = {
-    pins: contextValue.pins,
-    placement: contextValue.target,
-    componentUses: contextValue.componentUses,
-    tokenUses: contextValue.tokenUses,
-    patternUses: contextValue.patternUses,
-    layout: contextValue.layout,
-    responsive: contextValue.responsive,
-    scenarios: contextValue.scenarios,
-    gaps: contextValue.acceptedGaps,
-    acceptance: contextValue.acceptance,
-    evidenceRefs: []
-  };
-  addUniqueIdIssue(contextValue.decisions, "decisionId", "decisions", context);
-  addUniqueIdIssue(graph.componentUses, "useId", "componentUses", context);
-  addUniqueIdIssue(graph.tokenUses, "useId", "tokenUses", context);
-  addUniqueIdIssue(graph.patternUses, "useId", "patternUses", context);
-  addUniqueIdIssue(graph.scenarios, "scenarioId", "scenarios", context);
-  addUniqueIdIssue(graph.acceptance, "acceptanceId", "acceptance", context);
-  const decisions = new Set(contextValue.decisions.map((row) => row.decisionId));
-  for (const [index, row] of contextValue.layout.concerns.entries()) {
-    if (row.overrideDecisionId && !decisions.has(row.overrideDecisionId)) {
-      context.addIssue({
-        code: z10.ZodIssueCode.custom,
-        path: ["layout", "concerns", index, "overrideDecisionId"],
-        message: `Unknown decision reference: ${row.overrideDecisionId}`
-      });
-    }
-  }
-  for (const [index, gap] of contextValue.acceptedGaps.entries()) {
-    if (gap.required && (gap.disposition === "unresolved" || gap.disposition === "proposed_contract_addition")) {
-      context.addIssue({
-        code: z10.ZodIssueCode.custom,
-        path: ["acceptedGaps", index],
-        message: "Agent context cannot contain a required unresolved or proposed-contract gap"
-      });
-    }
-  }
-});
-
-// src/feature-plan/digest.ts
-var sortedUnique2 = (values) => [...new Set(values)].sort();
-function normalizeEvidenceRefs(row) {
-  return { ...row, evidenceRefIds: sortedUnique2(row.evidenceRefIds) };
-}
-function normalizeCommon(value) {
-  return {
-    ...value,
-    placement: normalizeEvidenceRefs(value.placement),
-    componentUses: value.componentUses.map(normalizeEvidenceRefs).sort((left, right) => compareCanonicalStrings(left.useId, right.useId)),
-    tokenUses: value.tokenUses.map(normalizeEvidenceRefs).sort((left, right) => compareCanonicalStrings(left.useId, right.useId)),
-    patternUses: value.patternUses.map(normalizeEvidenceRefs).sort((left, right) => compareCanonicalStrings(left.useId, right.useId)),
-    layout: {
-      concerns: value.layout.concerns.map(normalizeEvidenceRefs).sort((left, right) => compareCanonicalStrings(left.concern, right.concern))
-    },
-    responsive: value.responsive.map(normalizeEvidenceRefs).sort((left, right) => compareCanonicalStrings(left.decisionId, right.decisionId)),
-    scenarios: value.scenarios.map((scenario) => ({ ...scenario, acceptanceIds: sortedUnique2(scenario.acceptanceIds) })).sort((left, right) => compareCanonicalStrings(left.scenarioId, right.scenarioId)),
-    gaps: value.gaps.map(normalizeEvidenceRefs).sort((left, right) => compareCanonicalStrings(left.gapId, right.gapId)),
-    acceptance: value.acceptance.map(normalizeEvidenceRefs).sort((left, right) => compareCanonicalStrings(left.acceptanceId, right.acceptanceId)),
-    evidenceRefs: [...value.evidenceRefs].sort(
-      (left, right) => compareCanonicalStrings(left.evidenceId, right.evidenceId)
-    )
-  };
-}
-function normalizeFeatureProposalInputV1(value) {
-  const parsed = featureProposalInputV1Schema.parse(value);
-  return normalizeCommon({
-    ...parsed,
-    questions: parsed.questions.map((question) => ({ ...normalizeEvidenceRefs(question), options: [...question.options] })).sort((left, right) => compareCanonicalStrings(left.decisionId, right.decisionId))
-  });
-}
-function proposalProjection(proposal) {
-  return {
-    schema: "feature-revision.v1",
-    kind: proposal.kind,
-    planId: proposal.planId,
-    parentRevisionDigest: proposal.parentRevisionDigest,
-    pins: proposal.pins,
-    placement: proposal.placement,
-    componentUses: proposal.componentUses,
-    tokenUses: proposal.tokenUses,
-    patternUses: proposal.patternUses,
-    layout: proposal.layout,
-    responsive: proposal.responsive,
-    scenarios: proposal.scenarios,
-    gaps: proposal.gaps,
-    acceptance: proposal.acceptance,
-    questions: proposal.questions,
-    evidenceRefs: proposal.evidenceRefs
-  };
-}
-function featureProposalRevisionDigestV1(value) {
-  const proposal = normalizeFeatureProposalInputV1(value);
-  return sha256Hex(canonicalPreimage(proposalProjection(proposal)));
-}
-function buildFeatureProposalV1(value) {
-  const proposal = normalizeFeatureProposalInputV1(value);
-  const revisionDigest = sha256Hex(canonicalPreimage(proposalProjection(proposal)));
-  return featureProposalV1Schema.parse({
-    ...proposal,
-    revisionId: featureRevisionIdFromDigest(revisionDigest),
-    revisionDigest
-  });
-}
-function parseFeatureProposalV1(value) {
-  const parsed = featureProposalV1Schema.parse(value);
-  const { revisionId, revisionDigest, ...input } = parsed;
-  const rebuilt = buildFeatureProposalV1(input);
-  if (revisionId !== rebuilt.revisionId || revisionDigest !== rebuilt.revisionDigest) {
-    throw new TypeError("Feature proposal derived identity does not match its semantic projection");
-  }
-  return rebuilt;
-}
-function normalizeApprovedFeatureManifestInputV1(value) {
-  const parsed = approvedFeatureManifestInputV1Schema.parse(value);
-  return normalizeCommon({
-    ...parsed,
-    decisions: [...parsed.decisions].sort(
-      (left, right) => compareCanonicalStrings(left.decisionId, right.decisionId)
-    ),
-    approval: { ...parsed.approval },
-    validatedGrounding: { ...parsed.validatedGrounding }
-  });
-}
-function manifestProjection(manifest) {
-  return {
-    schema: "feature-revision.v1",
-    kind: manifest.kind,
-    planId: manifest.planId,
-    parentRevisionDigest: manifest.parentRevisionDigest,
-    proposalRevisionDigest: manifest.proposalRevisionDigest,
-    pins: manifest.pins,
-    validatedGrounding: manifest.validatedGrounding,
-    placement: manifest.placement,
-    componentUses: manifest.componentUses,
-    tokenUses: manifest.tokenUses,
-    patternUses: manifest.patternUses,
-    layout: manifest.layout,
-    responsive: manifest.responsive,
-    scenarios: manifest.scenarios,
-    gaps: manifest.gaps,
-    acceptance: manifest.acceptance,
-    evidenceRefs: manifest.evidenceRefs,
-    decisions: manifest.decisions,
-    approval: {
-      approverUserId: manifest.approval.approverUserId,
-      decisionDigest: manifest.approval.decisionDigest,
-      expiresAt: manifest.approval.expiresAt
-    }
-  };
-}
-function approvedFeatureManifestRevisionDigestV1(value) {
-  const manifest = normalizeApprovedFeatureManifestInputV1(value);
-  return sha256Hex(canonicalPreimage(manifestProjection(manifest)));
-}
-function buildApprovedFeatureManifestV1(value) {
-  const manifest = normalizeApprovedFeatureManifestInputV1(value);
-  const revisionDigest = sha256Hex(canonicalPreimage(manifestProjection(manifest)));
-  return approvedFeatureManifestV1Schema.parse({
-    ...manifest,
-    revisionId: featureRevisionIdFromDigest(revisionDigest),
-    revisionDigest
-  });
-}
-function parseApprovedFeatureManifestV1(value) {
-  const parsed = approvedFeatureManifestV1Schema.parse(value);
-  const { revisionId, revisionDigest, ...input } = parsed;
-  const rebuilt = buildApprovedFeatureManifestV1(input);
-  if (revisionId !== rebuilt.revisionId || revisionDigest !== rebuilt.revisionDigest) {
-    throw new TypeError(
-      "Approved manifest derived identity does not match its semantic projection"
-    );
-  }
-  return rebuilt;
-}
-var agentFeatureContextV1Schema2 = agentFeatureContextV1Schema.superRefine(
-  (value, context) => {
-    const bytes = new TextEncoder().encode(canonicalPreimage(value)).byteLength;
-    if (bytes > AGENT_FEATURE_CONTEXT_MAX_BYTES_V1) {
-      context.addIssue({
-        code: "custom",
-        message: `Agent feature context exceeds ${AGENT_FEATURE_CONTEXT_MAX_BYTES_V1} UTF-8 bytes`
-      });
-    }
-  }
-);
-function parseAgentFeatureContextV1(value) {
-  return agentFeatureContextV1Schema2.parse(value);
-}
-
 // src/evaluation/types.ts
 var EVALUATOR_VERSION = "evaluation-kernel:v1";
 var EVALUATOR_VERSION_V2 = "evaluation-kernel:v2";
 
 // src/evaluation/receipt.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 var EVALUATION_MAX_WAIVERS_V2 = 1e3;
 var EVALUATION_MAX_WAIVER_MATCHES_V2 = 1e4;
 var EVALUATION_MAX_FINDINGS_V2 = 1e4;
@@ -11497,112 +10895,112 @@ var EVALUATION_MAX_REASON_CODES_V2 = 64;
 var EVALUATION_MAX_MAP_ENTRIES_V2 = 1e5;
 var EVALUATION_MAX_POLICY_RULES_V2 = 1e4;
 var EVALUATION_RECEIPT_STRING_MAX_BYTES_V1 = 4096;
-var utf8Length3 = (value) => new TextEncoder().encode(value).byteLength;
-var boundedString3 = (maxBytes = EVALUATION_RECEIPT_STRING_MAX_BYTES_V1) => z11.string().min(1).refine((value) => utf8Length3(value) <= maxBytes, `Value exceeds ${maxBytes} UTF-8 bytes`);
-var unique2 = (values) => new Set(values).size === values.length;
-var contractPreimageV1Schema = z11.object({
-  schema: z11.literal(CONTRACT_PREIMAGE_SCHEMA),
-  domains: z11.object({
+var utf8Length2 = (value) => new TextEncoder().encode(value).byteLength;
+var boundedString2 = (maxBytes = EVALUATION_RECEIPT_STRING_MAX_BYTES_V1) => z10.string().min(1).refine((value) => utf8Length2(value) <= maxBytes, `Value exceeds ${maxBytes} UTF-8 bytes`);
+var unique = (values) => new Set(values).size === values.length;
+var contractPreimageV1Schema = z10.object({
+  schema: z10.literal(CONTRACT_PREIMAGE_SCHEMA),
+  domains: z10.object({
     components: digestHexStringSchema,
     tokens: digestHexStringSchema,
     canonicalMap: digestHexStringSchema,
     policy: digestHexStringSchema
   }).strict()
 }).strict();
-var effectiveRulePolicySchema = z11.object({ trust: z11.enum(["canonical", "evidence", "none"]).optional() }).strict();
-var effectivePolicySchema = z11.object({
-  failOnWarnings: z11.boolean(),
-  failOnInert: z11.boolean().optional(),
-  rules: z11.record(boundedString3(), effectiveRulePolicySchema).refine(
+var effectiveRulePolicySchema = z10.object({ trust: z10.enum(["canonical", "evidence", "none"]).optional() }).strict();
+var effectivePolicySchema = z10.object({
+  failOnWarnings: z10.boolean(),
+  failOnInert: z10.boolean().optional(),
+  rules: z10.record(boundedString2(), effectiveRulePolicySchema).refine(
     (rules) => Object.keys(rules).length <= EVALUATION_MAX_POLICY_RULES_V2,
     "Policy rule map exceeds the V2 limit"
   ).optional()
 }).strict();
-var evaluationTrustSchema = z11.object({
-  source: z11.enum(["verified", "unverified", "unknown"]),
-  sources: z11.record(boundedString3(), z11.enum(["verified", "unverified", "unknown"])).refine(
+var evaluationTrustSchema = z10.object({
+  source: z10.enum(["verified", "unverified", "unknown"]),
+  sources: z10.record(boundedString2(), z10.enum(["verified", "unverified", "unknown"])).refine(
     (sources) => Object.keys(sources).length <= EVALUATION_MAX_MAP_ENTRIES_V2,
     "Source trust map exceeds the V2 limit"
   ).optional(),
-  mappings: z11.record(boundedString3(), z11.enum(["confirmed", "unconfirmed", "unknown"])).refine(
+  mappings: z10.record(boundedString2(), z10.enum(["confirmed", "unconfirmed", "unknown"])).refine(
     (mappings) => Object.keys(mappings).length <= EVALUATION_MAX_MAP_ENTRIES_V2,
     "Mapping trust map exceeds the V2 limit"
   )
 }).strict();
-var waiverScopeSchema = z11.discriminatedUnion("kind", [
-  z11.object({ kind: z11.literal("finding"), fingerprint: boundedString3() }).strict(),
-  z11.object({ kind: z11.literal("rule"), ruleId: boundedString3() }).strict(),
-  z11.object({ kind: z11.literal("path"), pathPattern: boundedString3() }).strict(),
-  z11.object({ kind: z11.literal("rule_path"), ruleId: boundedString3(), pathPattern: boundedString3() }).strict()
+var waiverScopeSchema = z10.discriminatedUnion("kind", [
+  z10.object({ kind: z10.literal("finding"), fingerprint: boundedString2() }).strict(),
+  z10.object({ kind: z10.literal("rule"), ruleId: boundedString2() }).strict(),
+  z10.object({ kind: z10.literal("path"), pathPattern: boundedString2() }).strict(),
+  z10.object({ kind: z10.literal("rule_path"), ruleId: boundedString2(), pathPattern: boundedString2() }).strict()
 ]);
-var effectiveEvaluationWaiverV2Schema = z11.object({
-  waiverId: boundedString3(),
+var effectiveEvaluationWaiverV2Schema = z10.object({
+  waiverId: boundedString2(),
   scope: waiverScopeSchema,
-  matchedFindingFingerprints: z11.array(boundedString3()).min(1).max(EVALUATION_MAX_WAIVER_MATCHES_V2).refine(unique2, "matched finding fingerprints must be unique"),
-  reason: boundedString3(),
-  expiresAt: z11.number().finite().optional()
+  matchedFindingFingerprints: z10.array(boundedString2()).min(1).max(EVALUATION_MAX_WAIVER_MATCHES_V2).refine(unique, "matched finding fingerprints must be unique"),
+  reason: boundedString2(),
+  expiresAt: z10.number().finite().optional()
 }).strict();
-var evaluationIntegrityInputV2Schema = z11.object({
-  governance: z11.enum(["healthy", "inert"]),
-  inertConfigDiagnosticCount: z11.number().int().nonnegative(),
-  profile: z11.discriminatedUnion("state", [
-    z11.object({
-      state: z11.literal("known"),
-      profileId: boundedString3(),
-      profileVersion: boundedString3()
+var evaluationIntegrityInputV2Schema = z10.object({
+  governance: z10.enum(["healthy", "inert"]),
+  inertConfigDiagnosticCount: z10.number().int().nonnegative(),
+  profile: z10.discriminatedUnion("state", [
+    z10.object({
+      state: z10.literal("known"),
+      profileId: boundedString2(),
+      profileVersion: boundedString2()
     }).strict(),
-    z11.object({
-      state: z11.literal("unknown"),
-      profileId: boundedString3(),
-      profileVersion: boundedString3().optional()
+    z10.object({
+      state: z10.literal("unknown"),
+      profileId: boundedString2(),
+      profileVersion: boundedString2().optional()
     }).strict()
   ]),
   facts: canonicalFactIntegrityV1Schema
 }).strict();
-var baselineSchema = z11.object({
-  identity: z11.object({
+var baselineSchema = z10.object({
+  identity: z10.object({
     bindingDigest: digestHexStringSchema,
-    repositoryExternalId: boundedString3(),
+    repositoryExternalId: boundedString2(),
     fcid: digestHexStringSchema,
-    sourceCommitId: boundedString3(),
-    generationId: boundedString3()
+    sourceCommitId: boundedString2(),
+    generationId: boundedString2()
   }).strict(),
-  findingStates: z11.record(boundedString3(), z11.enum(["introduced", "existing", "unknown"])).refine(
+  findingStates: z10.record(boundedString2(), z10.enum(["introduced", "existing", "unknown"])).refine(
     (states) => Object.keys(states).length <= EVALUATION_MAX_MAP_ENTRIES_V2,
     "Baseline finding-state map exceeds the V2 limit"
   )
 }).strict();
-var evaluationInputV2RawSchema = z11.object({
-  schemaVersion: z11.literal(2),
+var evaluationInputV2RawSchema = z10.object({
+  schemaVersion: z10.literal(2),
   binding: repositoryBindingKeyV1Schema,
   analysisPlan: analysisPlanV1Schema,
-  contract: z11.object({
+  contract: z10.object({
     fcid: digestHexStringSchema,
     preimage: contractPreimageV1Schema,
-    active: z11.boolean()
+    active: z10.boolean()
   }).strict(),
-  factSchemaVersion: boundedString3(256),
-  facts: z11.instanceof(FactIndex),
+  factSchemaVersion: boundedString2(256),
+  facts: z10.instanceof(FactIndex),
   factsDigest: digestHexStringSchema,
-  coverage: z11.array(coverageRegionV1Schema).max(1e3),
+  coverage: z10.array(coverageRegionV1Schema).max(1e3),
   policy: effectivePolicySchema,
   baseline: baselineSchema.optional(),
-  adoption: z11.union([z11.literal("unavailable"), z11.object({ regressed: z11.boolean() }).strict()]).optional(),
+  adoption: z10.union([z10.literal("unavailable"), z10.object({ regressed: z10.boolean() }).strict()]).optional(),
   trust: evaluationTrustSchema.optional(),
-  waivers: z11.array(effectiveEvaluationWaiverV2Schema).max(EVALUATION_MAX_WAIVERS_V2).refine(
+  waivers: z10.array(effectiveEvaluationWaiverV2Schema).max(EVALUATION_MAX_WAIVERS_V2).refine(
     (waivers) => new Set(waivers.map((waiver) => waiver.waiverId)).size === waivers.length,
     "waiver IDs must be unique"
   ),
   integrity: evaluationIntegrityInputV2Schema,
-  evaluatedAt: z11.number().finite(),
-  evaluatorVersion: boundedString3(256)
+  evaluatedAt: z10.number().finite(),
+  evaluatorVersion: boundedString2(256)
 }).strict().superRefine((input, context) => {
   let plan;
   try {
     plan = parseAnalysisPlanV1(input.analysisPlan);
   } catch (error) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["analysisPlan"],
       message: error instanceof Error ? error.message : "Invalid analysis plan identity"
     });
@@ -11610,35 +11008,35 @@ var evaluationInputV2RawSchema = z11.object({
   }
   if (repositoryBindingDigestV1(plan.binding) !== repositoryBindingDigestV1(input.binding)) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["binding"],
       message: "Evaluation binding does not match the analysis plan binding"
     });
   }
   if (plan.contract.fcid !== input.contract.fcid) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["contract", "fcid"],
       message: "Evaluation FCID does not match the analysis plan"
     });
   }
   if (contractHash(input.contract.preimage) !== input.contract.fcid) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["contract", "preimage"],
       message: "Contract preimage does not reproduce the pinned FCID"
     });
   }
   if (plan.evaluatorVersion !== input.evaluatorVersion) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["evaluatorVersion"],
       message: "Evaluator version does not match the analysis plan"
     });
   }
   if (input.integrity.profile.state === "known" && (input.integrity.profile.profileId !== plan.profile.id || input.integrity.profile.profileVersion !== plan.profile.version)) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["integrity", "profile"],
       message: "Known profile identity does not match the analysis plan"
     });
@@ -11647,7 +11045,7 @@ var evaluationInputV2RawSchema = z11.object({
     const expectedBindingDigest = repositoryBindingDigestV1(input.binding);
     if (input.baseline.identity.bindingDigest !== expectedBindingDigest || input.baseline.identity.repositoryExternalId !== input.binding.repositoryExternalId || input.baseline.identity.fcid !== input.contract.fcid) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z10.ZodIssueCode.custom,
         path: ["baseline", "identity"],
         message: "Baseline identity does not match the evaluation binding and FCID"
       });
@@ -11655,7 +11053,7 @@ var evaluationInputV2RawSchema = z11.object({
   }
   if (input.facts.size() > plan.limits.maxFacts) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["facts"],
       message: "Fact count exceeds the analysis-plan limit"
     });
@@ -11664,7 +11062,7 @@ var evaluationInputV2RawSchema = z11.object({
     deriveCoverageSummaryV1(plan, input.coverage);
   } catch (error) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["coverage"],
       message: error instanceof Error ? error.message : "Coverage does not match the plan"
     });
@@ -11677,7 +11075,7 @@ var evaluationInputV2Schema = evaluationInputV2RawSchema.transform(
     analysisPlan: parseAnalysisPlanV1(input.analysisPlan)
   })
 );
-var evaluationReasonV2Schema = z11.enum([
+var evaluationReasonV2Schema = z10.enum([
   "zeroFileScan",
   "governanceInert",
   "contractUnpinned",
@@ -11696,33 +11094,33 @@ var evaluationReasonV2Schema = z11.enum([
   "factConflict",
   "unknownAnalysisProfile"
 ]);
-var evaluationResultV2Schema = z11.object({
-  schemaVersion: z11.literal(2),
-  verdict: z11.enum(["pass", "block", "indeterminate"]),
-  reasons: z11.array(evaluationReasonV2Schema).max(EVALUATION_MAX_REASON_CODES_V2).refine(unique2, "Evaluation reason codes must be unique"),
-  findings: z11.array(
-    z11.object({
-      fingerprint: boundedString3(),
-      ruleId: boundedString3(),
-      severity: z11.enum(["error", "warn", "info"]),
-      state: z11.enum(["blocked", "advisory", "pending_cloud_trust"]),
-      stateReasons: z11.array(boundedString3()).max(256)
+var evaluationResultV2Schema = z10.object({
+  schemaVersion: z10.literal(2),
+  verdict: z10.enum(["pass", "block", "indeterminate"]),
+  reasons: z10.array(evaluationReasonV2Schema).max(EVALUATION_MAX_REASON_CODES_V2).refine(unique, "Evaluation reason codes must be unique"),
+  findings: z10.array(
+    z10.object({
+      fingerprint: boundedString2(),
+      ruleId: boundedString2(),
+      severity: z10.enum(["error", "warn", "info"]),
+      state: z10.enum(["blocked", "advisory", "pending_cloud_trust"]),
+      stateReasons: z10.array(boundedString2()).max(256)
     }).strict()
   ).max(EVALUATION_MAX_FINDINGS_V2),
-  counts: z11.object({
-    blocked: z11.number().int().nonnegative().max(EVALUATION_MAX_FINDINGS_V2),
-    advisory: z11.number().int().nonnegative().max(EVALUATION_MAX_FINDINGS_V2),
-    pendingCloudTrust: z11.number().int().nonnegative().max(EVALUATION_MAX_FINDINGS_V2)
+  counts: z10.object({
+    blocked: z10.number().int().nonnegative().max(EVALUATION_MAX_FINDINGS_V2),
+    advisory: z10.number().int().nonnegative().max(EVALUATION_MAX_FINDINGS_V2),
+    pendingCloudTrust: z10.number().int().nonnegative().max(EVALUATION_MAX_FINDINGS_V2)
   }).strict(),
-  derived: z11.object({ warnPresent: z11.boolean(), gatingFindingsPresent: z11.boolean() }).strict(),
+  derived: z10.object({ warnPresent: z10.boolean(), gatingFindingsPresent: z10.boolean() }).strict(),
   coverageSummary: coverageSummaryV1Schema,
-  integrity: z11.object({
-    fcidVerified: z11.boolean(),
-    analysisPlanVerified: z11.boolean(),
-    factIntegrity: z11.enum(["healthy", "conflict"]),
-    requiredCoverage: z11.enum(["complete", "incomplete", "no_required_regions"]),
-    governance: z11.enum(["healthy", "inert"]),
-    profile: z11.enum(["known", "unknown"])
+  integrity: z10.object({
+    fcidVerified: z10.boolean(),
+    analysisPlanVerified: z10.boolean(),
+    factIntegrity: z10.enum(["healthy", "conflict"]),
+    requiredCoverage: z10.enum(["complete", "incomplete", "no_required_regions"]),
+    governance: z10.enum(["healthy", "inert"]),
+    profile: z10.enum(["known", "unknown"])
   }).strict(),
   inputDigest: digestHexStringSchema,
   resultDigest: digestHexStringSchema
@@ -11736,7 +11134,7 @@ var evaluationResultV2Schema = z11.object({
     if (finding.severity === "warn") emittedWarnPresent = true;
     if (new Set(finding.stateReasons).size !== finding.stateReasons.length) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z10.ZodIssueCode.custom,
         path: ["findings", index, "stateReasons"],
         message: "Finding state reasons must be unique"
       });
@@ -11744,7 +11142,7 @@ var evaluationResultV2Schema = z11.object({
   }
   if (new Set(result.findings.map((finding) => finding.fingerprint)).size !== result.findings.length) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["findings"],
       message: "Evaluation finding fingerprints must be unique"
     });
@@ -11752,7 +11150,7 @@ var evaluationResultV2Schema = z11.object({
   for (const key of ["blocked", "advisory", "pendingCloudTrust"]) {
     if (result.counts[key] !== expectedCounts[key]) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z10.ZodIssueCode.custom,
         path: ["counts", key],
         message: `Evaluation ${key} count must match findings`
       });
@@ -11760,14 +11158,14 @@ var evaluationResultV2Schema = z11.object({
   }
   if (emittedWarnPresent && !result.derived.warnPresent) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["derived", "warnPresent"],
       message: "An emitted warning finding requires warnPresent"
     });
   }
   if (result.derived.gatingFindingsPresent !== expectedCounts.blocked > 0) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["derived", "gatingFindingsPresent"],
       message: "gatingFindingsPresent must match blocked findings"
     });
@@ -11789,14 +11187,14 @@ var evaluationResultV2Schema = z11.object({
   );
   if (requiredCount !== result.coverageSummary.requiredRegions || requiredCount + optionalCount !== result.coverageSummary.observedRegions || result.coverageSummary.observedRegions !== result.coverageSummary.plannedRegions) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["coverageSummary"],
       message: "Coverage summary counts must reconcile with planned and observed regions"
     });
   }
   if (result.coverageSummary.analyzedFiles > result.coverageSummary.eligibleFiles) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["coverageSummary", "analyzedFiles"],
       message: "Analyzed files cannot exceed eligible files"
     });
@@ -11804,7 +11202,7 @@ var evaluationResultV2Schema = z11.object({
   const expectedRequiredCoverage = result.coverageSummary.requiredRegions === 0 ? "no_required_regions" : result.coverageSummary.requiredByState.analyzed === result.coverageSummary.requiredRegions ? "complete" : "incomplete";
   if (result.integrity.requiredCoverage !== expectedRequiredCoverage) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["integrity", "requiredCoverage"],
       message: "Required coverage integrity must match the derived coverage summary"
     });
@@ -11813,7 +11211,7 @@ var evaluationResultV2Schema = z11.object({
   const requireReason = (reason, required, path) => {
     if (reasons.has(reason) !== required) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z10.ZodIssueCode.custom,
         path,
         message: `${reason} must match the evaluation result`
       });
@@ -11861,76 +11259,76 @@ var evaluationResultV2Schema = z11.object({
   const expectedVerdict = !integrityHealthy || result.reasons.some((reason) => integrityReasons.has(reason)) ? "indeterminate" : result.reasons.some((reason) => blockingReasons.has(reason)) ? "block" : result.reasons.length > 0 ? "indeterminate" : "pass";
   if (result.verdict !== expectedVerdict) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["verdict"],
       message: `Evaluation verdict must be ${expectedVerdict} for its reasons and integrity`
     });
   }
 });
-var providerProofSemanticV1Schema = z11.object({
-  schemaVersion: z11.literal(1),
-  adapterId: boundedString3(),
-  adapterVersion: boundedString3(),
-  providerInstanceId: boundedString3(),
+var providerProofSemanticV1Schema = z10.object({
+  schemaVersion: z10.literal(1),
+  adapterId: boundedString2(),
+  adapterVersion: boundedString2(),
+  providerInstanceId: boundedString2(),
   bindingDigest: digestHexStringSchema,
-  repositoryExternalId: boundedString3(),
-  sourceCommitId: boundedString3(),
-  eventExternalId: boundedString3(),
-  changeExternalId: boundedString3().optional(),
-  publisherExternalId: boundedString3()
+  repositoryExternalId: boundedString2(),
+  sourceCommitId: boundedString2(),
+  eventExternalId: boundedString2(),
+  changeExternalId: boundedString2().optional(),
+  publisherExternalId: boundedString2()
 }).strict();
 function providerProofDigestV1(value) {
   const proof = providerProofSemanticV1Schema.parse(value);
   return sha256Hex(canonicalPreimage({ schema: "provider-proof.v1", ...proof }));
 }
-var providerProofV1Schema = z11.object({
-  schemaVersion: z11.literal(1),
-  adapterId: boundedString3(),
-  adapterVersion: boundedString3(),
-  providerInstanceId: boundedString3(),
+var providerProofV1Schema = z10.object({
+  schemaVersion: z10.literal(1),
+  adapterId: boundedString2(),
+  adapterVersion: boundedString2(),
+  providerInstanceId: boundedString2(),
   bindingDigest: digestHexStringSchema,
-  repositoryExternalId: boundedString3(),
-  sourceCommitId: boundedString3(),
-  eventExternalId: boundedString3(),
-  changeExternalId: boundedString3().optional(),
-  publisherExternalId: boundedString3(),
+  repositoryExternalId: boundedString2(),
+  sourceCommitId: boundedString2(),
+  eventExternalId: boundedString2(),
+  changeExternalId: boundedString2().optional(),
+  publisherExternalId: boundedString2(),
   proofDigest: digestHexStringSchema
 }).strict().superRefine((proof, context) => {
   const { proofDigest, ...semantic } = proof;
   if (providerProofDigestV1(semantic) !== proofDigest) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["proofDigest"],
       message: "Provider proof digest mismatch"
     });
   }
 });
 var receiptSemanticShape = {
-  schemaVersion: z11.literal(1),
-  trust: z11.enum(["source_verified", "ci_attested", "local", "unknown"]),
-  authority: z11.enum(["advisory", "enforcement_eligible"]),
+  schemaVersion: z10.literal(1),
+  trust: z10.enum(["source_verified", "ci_attested", "local", "unknown"]),
+  authority: z10.enum(["advisory", "enforcement_eligible"]),
   binding: repositoryBindingKeyV1Schema,
-  sourceCommitId: boundedString3(),
+  sourceCommitId: boundedString2(),
   fcid: digestHexStringSchema,
   analysisPlanDigest: digestHexStringSchema,
   factsDigest: digestHexStringSchema,
   inputDigest: digestHexStringSchema,
   resultDigest: digestHexStringSchema,
-  evaluatorVersion: boundedString3(),
+  evaluatorVersion: boundedString2(),
   providerProof: providerProofV1Schema.optional()
 };
 function validateReceiptSemantics(receipt, context) {
   if (receipt.authority === "enforcement_eligible") {
     if (receipt.trust !== "source_verified") {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z10.ZodIssueCode.custom,
         path: ["authority"],
         message: "Only source-verified evidence can enforce"
       });
     }
     if (!receipt.providerProof) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z10.ZodIssueCode.custom,
         path: ["providerProof"],
         message: "Source-verified enforcement requires provider proof"
       });
@@ -11938,14 +11336,14 @@ function validateReceiptSemantics(receipt, context) {
   }
   if (receipt.trust === "source_verified" && !receipt.providerProof) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["providerProof"],
       message: "Source-verified trust requires provider proof"
     });
   }
   if (receipt.trust !== "source_verified" && receipt.providerProof) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["providerProof"],
       message: "Provider proof is reserved for source-verified trust"
     });
@@ -11955,34 +11353,34 @@ function validateReceiptSemantics(receipt, context) {
   const binding = normalizeRepositoryBindingKeyV1(receipt.binding);
   if (proof.bindingDigest !== repositoryBindingDigestV1(binding)) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["providerProof", "bindingDigest"],
       message: "Provider proof binding mismatch"
     });
   }
   if (proof.providerInstanceId !== binding.providerInstanceId) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["providerProof", "providerInstanceId"],
       message: "Provider proof instance mismatch"
     });
   }
   if (proof.repositoryExternalId !== binding.repositoryExternalId) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["providerProof", "repositoryExternalId"],
       message: "Provider proof repository mismatch"
     });
   }
   if (proof.sourceCommitId !== receipt.sourceCommitId) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["providerProof", "sourceCommitId"],
       message: "Provider proof source mismatch"
     });
   }
 }
-var evaluationReceiptSemanticV1Schema = z11.object(receiptSemanticShape).strict().superRefine(validateReceiptSemantics);
+var evaluationReceiptSemanticV1Schema = z10.object(receiptSemanticShape).strict().superRefine(validateReceiptSemantics);
 function evaluationReceiptDigestV1(value) {
   const receipt = evaluationReceiptSemanticV1Schema.parse(value);
   return sha256Hex(
@@ -12002,10 +11400,10 @@ function evaluationReceiptDigestV1(value) {
     })
   );
 }
-var evaluationReceiptV1Schema = z11.object({
+var evaluationReceiptV1Schema = z10.object({
   receiptId: evaluationReceiptIdStringSchema,
   ...receiptSemanticShape,
-  mintedAt: z11.string().datetime({ offset: true }),
+  mintedAt: z10.string().datetime({ offset: true }),
   digest: digestHexStringSchema
 }).strict().superRefine((receipt, context) => {
   validateReceiptSemantics(receipt, context);
@@ -12015,21 +11413,21 @@ var evaluationReceiptV1Schema = z11.object({
     digest = evaluationReceiptDigestV1(semantic);
   } catch (error) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       message: error instanceof Error ? error.message : "Invalid receipt semantics"
     });
     return;
   }
   if (digest !== receipt.digest) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["digest"],
       message: "Receipt digest mismatch"
     });
   }
   if (evaluationReceiptIdFromDigest(digest) !== receipt.receiptId) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       path: ["receiptId"],
       message: "Receipt ID mismatch"
     });
@@ -12038,17 +11436,17 @@ var evaluationReceiptV1Schema = z11.object({
 function parseEvaluationReceiptV1(value) {
   return evaluationReceiptV1Schema.parse(value);
 }
-var evaluationReceiptMintInputV1Schema = z11.object({
-  schemaVersion: z11.literal(1),
-  trust: z11.enum(["ci_attested", "local", "unknown"]),
+var evaluationReceiptMintInputV1Schema = z10.object({
+  schemaVersion: z10.literal(1),
+  trust: z10.enum(["ci_attested", "local", "unknown"]),
   binding: repositoryBindingKeyV1Schema,
-  sourceCommitId: boundedString3(),
+  sourceCommitId: boundedString2(),
   fcid: digestHexStringSchema,
   analysisPlanDigest: digestHexStringSchema,
   factsDigest: digestHexStringSchema,
   inputDigest: digestHexStringSchema,
   resultDigest: digestHexStringSchema,
-  evaluatorVersion: boundedString3()
+  evaluatorVersion: boundedString2()
 }).strict();
 
 // src/evaluation/evaluate.ts
@@ -12247,9 +11645,7 @@ function evaluateV2(rawInput) {
   if (orderedReasons.some((reason) => V2_INTEGRITY_REASONS.has(reason))) {
     verdict = "indeterminate";
   }
-  const inputDigest = sha256Hex(
-    canonicalPreimage(normalizeInputV2ForDigest(input, coverageSummary))
-  );
+  const inputDigest = evaluationInputDigestV2(input);
   const partial = {
     schemaVersion: 2,
     verdict,
@@ -12263,11 +11659,19 @@ function evaluateV2(rawInput) {
     coverageSummary,
     integrity
   };
-  const resultDigest = sha256Hex(
-    canonicalPreimage({ schema: "evaluation-result:v2", ...partial, inputDigest })
-  );
+  const resultDigest = evaluationResultDigestV2({ ...partial, inputDigest });
   return evaluationResultV2Schema.parse({ ...partial, inputDigest, resultDigest });
 }
+function evaluationInputDigestV2(input) {
+  return sha256Hex(
+    canonicalPreimage(
+      normalizeInputV2ForDigest(input, deriveCoverageSummaryV1(input.analysisPlan, input.coverage))
+    )
+  );
+}
+function evaluationResultDigestV2(result) {
+  return sha256Hex(canonicalPreimage({ schema: "evaluation-result:v2", ...result }));
+}
 function normalizeInputV2ForDigest(input, coverageSummary) {
   const {
     analysisPlanId: _analysisPlanId,
@@ -12475,14 +11879,24 @@ function canonicalWaivers(waivers) {
     (waiver, index) => index === 0 || waiver.fingerprint !== sorted[index - 1].fingerprint || expiryOf(waiver) !== expiryOf(sorted[index - 1])
   );
 }
+
+// src/approved-contract-tokens.ts
+var APPROVED_CONTRACT_TOKEN_MAX_NAMES = 1e4;
+var APPROVED_CONTRACT_TOKEN_MAX_NAME_LENGTH = 512;
+function isApprovedContractTokenNames(value) {
+  return Array.isArray(value) && value.length <= APPROVED_CONTRACT_TOKEN_MAX_NAMES && value.every(
+    (name) => typeof name === "string" && name.startsWith("--") && name.length > 2 && name.length <= APPROVED_CONTRACT_TOKEN_MAX_NAME_LENGTH
+  );
+}
 export {
   AGENT_CONTEXT_RELATIVE_PATH,
-  AGENT_FEATURE_CONTEXT_MAX_BYTES_V1,
   AGENT_FORMAT_SCHEMA_VERSION,
   ANALYSIS_LIMIT_CEILINGS_V1,
   ANALYSIS_PLAN_MAX_CAPABILITIES_V1,
   ANALYSIS_PLAN_MAX_DIALECTS_PER_REGION_V1,
   ANALYSIS_PLAN_MAX_REGIONS_V1,
+  APPROVED_CONTRACT_TOKEN_MAX_NAMES,
+  APPROVED_CONTRACT_TOKEN_MAX_NAME_LENGTH,
   BLOCKING_RULE_ALLOWLIST,
   BRAND,
   CANONICAL_FACT_MAX_CONFLICTS_V1,
@@ -12514,13 +11928,6 @@ export {
   EVALUATOR_VERSION_V2,
   EVIDENCE_ORDER,
   EXPLAIN_URL_BASE,
-  FEATURE_PLAN_MAX_ACCEPTANCE_ITEMS_V1,
-  FEATURE_PLAN_MAX_DECISIONS_V1,
-  FEATURE_PLAN_MAX_EVIDENCE_REFS_V1,
-  FEATURE_PLAN_MAX_GAPS_V1,
-  FEATURE_PLAN_MAX_SCENARIOS_V1,
-  FEATURE_PLAN_MAX_TEXT_BYTES_V1,
-  FEATURE_PLAN_MAX_USES_PER_KIND_V1,
   FRAGMENTS_INTERNAL_RULE_IDS,
   FRAGMENTS_MANIFEST_FILENAME,
   FRAGMENTS_MANIFEST_SCHEMA_VERSION,
@@ -12555,7 +11962,6 @@ export {
   SEVERITY_RANK,
   SEVERITY_WEIGHTS,
   agentErrorEnvelopeSchema,
-  agentFeatureContextV1Schema2 as agentFeatureContextV1Schema,
   agentFormatSchema,
   agentIntegritySchema,
   agentOutputSchema,
@@ -12570,9 +11976,6 @@ export {
   analysisPlanV1Schema,
   analysisRegionV1Schema,
   analyzeComposition,
-  approvedFeatureManifestInputV1Schema,
-  approvedFeatureManifestRevisionDigestV1,
-  approvedFeatureManifestV1Schema,
   artifactContentHash,
   asComponentId,
   assembleRegistryArtifact,
@@ -12585,9 +11988,7 @@ export {
   budgetBar,
   buildAgentFormat,
   buildAnalysisPlanV1,
-  buildApprovedFeatureManifestV1,
   buildComponentKey,
-  buildFeatureProposalV1,
   buildRegistryArtifact,
   buildRegistryFile,
   buildRegistryInstallPlan,
@@ -12618,7 +12019,6 @@ export {
   canonicalizeOwnedComponentId,
   canonicalizeOwnedImport,
   capConfiguredSeverity,
-  capabilityGapV1Schema,
   catalogFixtureA,
   catalogFixtureAContractPayload,
   catalogFixtureATokensDtcg,
@@ -12646,7 +12046,6 @@ export {
   componentGovernanceRecordsSchema,
   componentId,
   componentRelationSchema,
-  componentUseDecisionV1Schema,
   compositionAuthoringEntrySchema,
   compositionMetadataSchema,
   compositionPatternSchema,
@@ -12665,8 +12064,6 @@ export {
   coverageStateV1Schema,
   coverageSummaryV1Schema,
   customerDefaultRuleStates,
-  decisionRequestV1Schema,
-  decisionResolutionV1Schema,
   defaultRegistryShardPath,
   defineBlock,
   defineConfig,
@@ -12687,6 +12084,7 @@ export {
   emptyVocabularyConfigFile,
   evaluate2 as evaluate,
   evaluateGovernanceIntegrity,
+  evaluationInputDigestV2,
   evaluationInputV2Schema,
   evaluationReceiptDigestV1,
   evaluationReceiptIdFromDigest,
@@ -12694,8 +12092,8 @@ export {
   evaluationReceiptIdStringSchema,
   evaluationReceiptMintInputV1Schema,
   evaluationReceiptV1Schema,
+  evaluationResultDigestV2,
   evaluationResultV2Schema,
-  evidenceRefV1Schema,
   excludeGlobToRegExp,
   expandRegistryComponentClosure,
   explainUrlForCode,
@@ -12703,17 +12101,6 @@ export {
   factId,
   factLocationSchema,
   familyDistance,
-  featureAcceptanceItemV1Schema,
-  featurePinsV1Schema,
-  featurePlanIdFromEntropy,
-  featurePlanIdSchema,
-  featurePlanIdStringSchema,
-  featureProposalInputV1Schema,
-  featureProposalRevisionDigestV1,
-  featureProposalV1Schema,
-  featureRevisionIdFromDigest,
-  featureRevisionIdSchema,
-  featureRevisionIdStringSchema,
   figma,
   figmaPropMappingSchema,
   finalizeRegistryManifest,
@@ -12758,7 +12145,6 @@ export {
   fragmentsManifestSchema,
   fragmentsPresetRuleStates,
   g,
-  gapDispositionV1Schema,
   gatesCi,
   generateCSSCustomProperties,
   generateContext,
@@ -12783,6 +12169,7 @@ export {
   indexComponentIdentityUsage,
   inferTokenCategory,
   inferTokenGroup,
+  isApprovedContractTokenNames,
   isColorLike,
   isCompositionPattern,
   isContractFile,
@@ -12797,8 +12184,6 @@ export {
   isRawHtmlAdvisoryTier,
   isReactComponent,
   isRuleFamilyId,
-  layoutConcernV1Schema,
-  layoutOwnershipV1Schema,
   localCanonicalContractMappings,
   lowerCompositionContract,
   makeA11yNameRequiredFact,
@@ -12870,12 +12255,10 @@ export {
   nearestByDeltaE,
   nearestSignedScaleValue,
   normalizeAnalysisPlanInputV1,
-  normalizeApprovedFeatureManifestInputV1,
   normalizeCanonicalFactIntegrityV1,
   normalizeColor,
   normalizeConfigPath,
   normalizeExcludePath,
-  normalizeFeatureProposalInputV1,
   normalizeFinding,
   normalizeGovernanceConfig,
   normalizePolicyExcludes,
@@ -12889,14 +12272,13 @@ export {
   normalizeViolation,
   overriddenRecordSeverityDiagnostic,
   ownedImportEquivalents,
-  parseAgentFeatureContextV1,
   parseAnalysisPlanId,
   parseAnalysisPlanV1,
-  parseApprovedFeatureManifestV1,
   parseColor,
   parseColorToRgb,
   parseCompiledFragmentsFile,
   parseComponentContract,
+  parseComponentGovernancePolicyJson,
   parseContractStamp,
   parseCssTokens,
   parseDtcgTokens as parseDTCGFile,
@@ -12905,9 +12287,6 @@ export {
   parseDtcgTokens,
   parseEvaluationReceiptId,
   parseEvaluationReceiptV1,
-  parseFeaturePlanId,
-  parseFeatureProposalV1,
-  parseFeatureRevisionId,
   parseFragmentsManifest,
   parseRgb,
   parseScssTokens,
@@ -12915,9 +12294,6 @@ export {
   parseTailwindV4Theme,
   parseTokenFile,
   parseTokens,
-  patternStatusV1Schema,
-  patternUseDecisionV1Schema,
-  placementDecisionV1Schema,
   policyExcludeMatchesPath,
   policyExcludeSchema,
   portableRepoPathError,
@@ -12977,7 +12353,6 @@ export {
   resolveRegistryInstallSources,
   resolveSpacingValue,
   resolveTokenValue,
-  responsiveDecisionV1Schema,
   rgbToHex,
   ruleA11yRequiredAccessibleName,
   ruleA11yStandard,
@@ -13003,7 +12378,6 @@ export {
   ruleTokensRequireDualFallback,
   runRules,
   scaleGovernanceRecordSchema,
-  scenarioRequirementV1Schema,
   serializeContractStamp,
   severityLevel,
   severitySchema,
@@ -13014,7 +12388,6 @@ export {
   suppressionDirectiveSchema,
   tierFor,
   tokenIncludesFromConfig,
-  tokenUseDecisionV1Schema,
   topologyBase,
   validatorResultSchema,
   verifiedContractPreimageFromPin,