@gmickel/gno 1.28.0 → 1.29.1

package/src/core/context-capsule.ts

@@ -3,8 +3,10 @@ import { z } from "zod";
 import { canonicalizeIndexName } from "../app/index-name";
 import {
   contextCapsulePayloadV1Schema,
-  type ContextCapsulePayloadV1,
+  contextCapsulePayloadV1_1Schema,
+  type ContextCapsulePayload,
 } from "./context-capsule-schema";
+import { createEgressLineage, type EgressLineage } from "./egress-provenance";
 
 const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
 
@@ -51,136 +53,155 @@ const normalizeSet = (values: readonly string[]): string[] =>
   [...new Set(values.map(normalizeText))].sort(compareCodeUnits);
 
 const normalizePayload = (
-  value: ContextCapsulePayloadV1
-): ContextCapsulePayloadV1 => ({
-  ...value,
-  goal: normalizeText(value.goal),
-  query: normalizeText(value.query),
-  scope: {
-    ...value.scope,
-    indexName: canonicalizeIndexName(value.scope.indexName),
-    collections: normalizeSet(value.scope.collections),
-    uriPrefix:
-      value.scope.uriPrefix === null
-        ? null
-        : normalizeText(value.scope.uriPrefix),
-    tagsAll: normalizeSet(value.scope.tagsAll),
-    tagsAny: normalizeSet(value.scope.tagsAny),
-    categories: normalizeSet(value.scope.categories),
-    since: normalizeDate(value.scope.since),
-    until: normalizeDate(value.scope.until),
-  },
-  retrieval: {
-    ...value.retrieval,
-    facets: normalizeSet(value.retrieval.facets),
-    queryVariants: value.retrieval.queryVariants.map(normalizeText),
-    request: {
-      ...value.retrieval.request,
-      author:
-        value.retrieval.request.author === null
+  value: ContextCapsulePayload
+): ContextCapsulePayload =>
+  ({
+    ...value,
+    goal: normalizeText(value.goal),
+    query: normalizeText(value.query),
+    scope: {
+      ...value.scope,
+      indexName: canonicalizeIndexName(value.scope.indexName),
+      collections: normalizeSet(value.scope.collections),
+      uriPrefix:
+        value.scope.uriPrefix === null
           ? null
-          : normalizeText(value.retrieval.request.author),
-      lang:
-        value.retrieval.request.lang === null
-          ? null
-          : normalizeText(value.retrieval.request.lang),
-      ...(value.retrieval.request.intent === undefined
+          : normalizeText(value.scope.uriPrefix),
+      tagsAll: normalizeSet(value.scope.tagsAll),
+      tagsAny: normalizeSet(value.scope.tagsAny),
+      categories: normalizeSet(value.scope.categories),
+      since: normalizeDate(value.scope.since),
+      until: normalizeDate(value.scope.until),
+    },
+    retrieval: {
+      ...value.retrieval,
+      facets: normalizeSet(value.retrieval.facets),
+      queryVariants: value.retrieval.queryVariants.map(normalizeText),
+      request: {
+        ...value.retrieval.request,
+        author:
+          value.retrieval.request.author === null
+            ? null
+            : normalizeText(value.retrieval.request.author),
+        lang:
+          value.retrieval.request.lang === null
+            ? null
+            : normalizeText(value.retrieval.request.lang),
+        ...(value.retrieval.request.intent === undefined
+          ? {}
+          : {
+              intent:
+                value.retrieval.request.intent === null
+                  ? null
+                  : normalizeText(value.retrieval.request.intent),
+            }),
+        ...(value.retrieval.request.exclude === undefined
+          ? {}
+          : { exclude: normalizeSet(value.retrieval.request.exclude) }),
+        queryModes: value.retrieval.request.queryModes.map((mode) => ({
+          ...mode,
+          text: normalizeText(mode.text),
+        })),
+      },
+      capabilityStates: Object.fromEntries(
+        Object.entries(value.retrieval.capabilityStates).map(([key, state]) => [
+          key,
+          { ...state, fallbackReasons: normalizeSet(state.fallbackReasons) },
+        ])
+      ) as typeof value.retrieval.capabilityStates,
+    },
+    fallbacks: [...value.fallbacks].sort((left, right) =>
+      compareCodeUnits(
+        `${left.code}\0${left.capability}`,
+        `${right.code}\0${right.capability}`
+      )
+    ),
+    ...(value.schemaVersion === "1.1"
+      ? {
+          egressLineage: {
+            ...value.egressLineage,
+            sources: [...value.egressLineage.sources],
+          },
+        }
+      : {}),
+    evidence: value.evidence.map((item) => ({
+      ...item,
+      title: item.title === null ? null : normalizeText(item.title),
+      heading: item.heading === null ? null : normalizeText(item.heading),
+      modifiedAt: normalizeDate(item.modifiedAt),
+      documentDate: normalizeDocumentDate(item.documentDate),
+      observedAt: normalizeDate(item.observedAt),
+      contextIds: normalizeSet(item.contextIds),
+      ...(item.egressLineage === undefined
         ? {}
         : {
-            intent:
-              value.retrieval.request.intent === null
-                ? null
-                : normalizeText(value.retrieval.request.intent),
+            egressLineage: {
+              ...item.egressLineage,
+              sources: [...item.egressLineage.sources],
+            },
           }),
-      ...(value.retrieval.request.exclude === undefined
+      ...(item.retrievalSources === undefined
         ? {}
-        : { exclude: normalizeSet(value.retrieval.request.exclude) }),
-      queryModes: value.retrieval.request.queryModes.map((mode) => ({
-        ...mode,
-        text: normalizeText(mode.text),
-      })),
-    },
-    capabilityStates: Object.fromEntries(
-      Object.entries(value.retrieval.capabilityStates).map(([key, state]) => [
-        key,
-        { ...state, fallbackReasons: normalizeSet(state.fallbackReasons) },
-      ])
-    ) as typeof value.retrieval.capabilityStates,
-  },
-  fallbacks: [...value.fallbacks].sort((left, right) =>
-    compareCodeUnits(
-      `${left.code}\0${left.capability}`,
-      `${right.code}\0${right.capability}`
-    )
-  ),
-  evidence: value.evidence.map((item) => ({
-    ...item,
-    title: item.title === null ? null : normalizeText(item.title),
-    heading: item.heading === null ? null : normalizeText(item.heading),
-    modifiedAt: normalizeDate(item.modifiedAt),
-    documentDate: normalizeDocumentDate(item.documentDate),
-    observedAt: normalizeDate(item.observedAt),
-    contextIds: normalizeSet(item.contextIds),
-    ...(item.retrievalSources === undefined
-      ? {}
-      : {
-          retrievalSources: [...new Set(item.retrievalSources)].sort(
-            compareCodeUnits
-          ),
-        }),
-    facets: normalizeSet(item.facets),
-    ...(item.record === undefined
-      ? {}
-      : {
-          record: {
-            ...item.record,
-            anchors: item.record.anchors.map((anchor) => ({
-              ...anchor,
-              value: normalizeText(anchor.value),
-              ...(anchor.endValue === undefined
+        : {
+            retrievalSources: [...new Set(item.retrievalSources)].sort(
+              compareCodeUnits
+            ),
+          }),
+      facets: normalizeSet(item.facets),
+      ...(item.record === undefined
+        ? {}
+        : {
+            record: {
+              ...item.record,
+              anchors: item.record.anchors.map((anchor) => ({
+                ...anchor,
+                value: normalizeText(anchor.value),
+                ...(anchor.endValue === undefined
+                  ? {}
+                  : { endValue: normalizeText(anchor.endValue) }),
+              })),
+              ...(item.record.participants === undefined
                 ? {}
-                : { endValue: normalizeText(anchor.endValue) }),
-            })),
-            ...(item.record.participants === undefined
-              ? {}
-              : { participants: normalizeSet(item.record.participants) }),
-            ...(item.record.categories === undefined
-              ? {}
-              : { categories: normalizeSet(item.record.categories) }),
-          },
-        }),
-  })),
-  guidance: {
-    ...value.guidance,
-    configuredContexts: [...value.guidance.configuredContexts]
-      .map((item) => ({
-        ...item,
-        scopeKey: normalizeText(item.scopeKey),
-        text: normalizeText(item.text),
-      }))
-      .sort((left, right) => compareCodeUnits(left.contextId, right.contextId)),
-  },
-  coverage: {
-    ...value.coverage,
-    requestedFacets: normalizeSet(value.coverage.requestedFacets),
-    coveredFacets: [...value.coverage.coveredFacets]
-      .map((item) => ({
-        facet: normalizeText(item.facet),
-        evidenceIds: normalizeSet(item.evidenceIds),
-      }))
-      .sort((left, right) => compareCodeUnits(left.facet, right.facet)),
-    unresolvedFacets: normalizeSet(value.coverage.unresolvedFacets),
-    gaps: [...value.coverage.gaps].sort((left, right) =>
-      compareCodeUnits(
-        `${left.facet}\0${left.code}`,
-        `${right.facet}\0${right.code}`
-      )
+                : { participants: normalizeSet(item.record.participants) }),
+              ...(item.record.categories === undefined
+                ? {}
+                : { categories: normalizeSet(item.record.categories) }),
+            },
+          }),
+    })),
+    guidance: {
+      ...value.guidance,
+      configuredContexts: [...value.guidance.configuredContexts]
+        .map((item) => ({
+          ...item,
+          scopeKey: normalizeText(item.scopeKey),
+          text: normalizeText(item.text),
+        }))
+        .sort((left, right) =>
+          compareCodeUnits(left.contextId, right.contextId)
+        ),
+    },
+    coverage: {
+      ...value.coverage,
+      requestedFacets: normalizeSet(value.coverage.requestedFacets),
+      coveredFacets: [...value.coverage.coveredFacets]
+        .map((item) => ({
+          facet: normalizeText(item.facet),
+          evidenceIds: normalizeSet(item.evidenceIds),
+        }))
+        .sort((left, right) => compareCodeUnits(left.facet, right.facet)),
+      unresolvedFacets: normalizeSet(value.coverage.unresolvedFacets),
+      gaps: [...value.coverage.gaps].sort((left, right) =>
+        compareCodeUnits(
+          `${left.facet}\0${left.code}`,
+          `${right.facet}\0${right.code}`
+        )
+      ),
+    },
+    warnings: [...value.warnings].sort((left, right) =>
+      compareCodeUnits(left.code, right.code)
     ),
-  },
-  warnings: [...value.warnings].sort((left, right) =>
-    compareCodeUnits(left.code, right.code)
-  ),
-});
+  }) as ContextCapsulePayload;
 
 export type ContextCapsuleErrorCode =
   | "identity_mismatch"
@@ -267,9 +288,14 @@ const contractError = (
   );
 };
 
-const parsePayload = (input: unknown): ContextCapsulePayloadV1 => {
+const contextCapsulePayloadSchema = z.union([
+  contextCapsulePayloadV1Schema,
+  contextCapsulePayloadV1_1Schema,
+]);
+
+const parsePayload = (input: unknown): ContextCapsulePayload => {
   try {
-    return contextCapsulePayloadV1Schema.parse(input);
+    return contextCapsulePayloadSchema.parse(input);
   } catch (error) {
     throw contractError(input, error);
   }
@@ -279,7 +305,7 @@ export interface ContextCapsuleCreateOptions {
   countTokens?: (accountingJson: string) => number;
 }
 
-const identityPayload = (payload: ContextCapsulePayloadV1) => {
+const identityPayload = (payload: ContextCapsulePayload) => {
   const {
     usedBytes: _usedBytes,
     usedTokens: _usedTokens,
@@ -288,7 +314,7 @@ const identityPayload = (payload: ContextCapsulePayloadV1) => {
   return { ...payload, budget: stableBudget };
 };
 
-const accountingPayload = <T extends ContextCapsulePayloadV1>(value: T) => {
+const accountingPayload = <T extends ContextCapsulePayload>(value: T) => {
   const {
     usedBytes: _usedBytes,
     usedTokens: _usedTokens,
@@ -312,7 +338,7 @@ const activeTokenCount = (
 };
 
 const fixedPointCapsule = (
-  payloadInput: ContextCapsulePayloadV1,
+  payloadInput: ContextCapsulePayload,
   options: ContextCapsuleCreateOptions
 ) => {
   const capsuleId = hashCanonical(identityPayload(payloadInput));
@@ -362,9 +388,10 @@ const fixedPointCapsule = (
   );
 };
 
-const contextCapsuleBaseV1Schema = contextCapsulePayloadV1Schema.extend({
-  capsuleId: sha256Schema,
-});
+const contextCapsuleBaseV1Schema = z.union([
+  contextCapsulePayloadV1Schema.extend({ capsuleId: sha256Schema }),
+  contextCapsulePayloadV1_1Schema.extend({ capsuleId: sha256Schema }),
+]);
 
 export const contextCapsuleV1Schema = contextCapsuleBaseV1Schema.superRefine(
   (value, context) => {
@@ -470,6 +497,24 @@ export const canonicalContextCapsuleJson = (input: unknown): string =>
 export const canonicalContextCapsuleAccountingJson = (input: unknown): string =>
   canonicalJson(accountingPayload(parseContextCapsuleV1(input)));
 
+/**
+ * Runtime-only conservative projection for legacy 1.0 Capsules. Canonical
+ * bytes and capsuleId remain governed by the original schema.
+ */
+export const contextCapsuleEgressLineage = (input: unknown): EgressLineage => {
+  const capsule = parseContextCapsuleV1(input);
+  if (capsule.schemaVersion === "1.1") return capsule.egressLineage;
+  return createEgressLineage(
+    [...new Set(capsule.evidence.map(({ collection }) => collection))].map(
+      (collection) => ({
+        collection,
+        policy: "local_only" as const,
+        source: "legacy_default" as const,
+      })
+    )
+  );
+};
+
 export {
   contextCapsuleVerificationEvidenceSchema,
   contextCapsuleVerificationSchema,

package/src/core/context-evidence.ts

@@ -1,5 +1,6 @@
 /** Strict indexed-evidence loading for Context Capsule compilation. */
 
+import type { EgressPolicy } from "../config/types";
 import type { SearchResults } from "../pipeline/types";
 import type {
   ActivationIndexSnapshot,
@@ -12,7 +13,7 @@ import type {
   ContextCanonicalProjection,
   MaterializedContextCandidate,
 } from "./context-budget";
-import type { ContextCapsulePayloadV1 } from "./context-capsule-schema";
+import type { ContextCapsulePayloadV1_1 } from "./context-capsule-schema";
 import type {
   ContextCanonicalPlanDraft,
   ContextCompilerInput,
@@ -21,6 +22,7 @@ import type {
   ContextRetrievalCandidate,
   ContextRetrievalRequest,
 } from "./context-compiler";
+import type { EgressLineage } from "./egress-provenance";
 import type { RecordEvidenceMetadata } from "./record-metadata";
 
 import { decorateUriForIndex, deriveDocid, parseUri } from "../app/constants";
@@ -36,6 +38,7 @@ import {
 } from "./context-capsule-validation";
 import { planContextEvidence } from "./context-compiler";
 import { projectContextEvidenceMetadata } from "./context-evidence-metadata";
+import { createEgressLineage, resolveEgressLineage } from "./egress-provenance";
 import { projectRecordEvidenceMetadata } from "./record-metadata";
 import {
   extractInclusiveLines,
@@ -82,6 +85,7 @@ export class ContextEvidenceError extends Error {
 
 export interface ContextEvidenceSnapshot {
   collections: string[];
+  egressLineage: EgressLineage;
   contexts: ContextRow[];
   documents: ContextEvidenceSnapshotDocument[];
   contextFingerprint: string;
@@ -105,7 +109,8 @@ export interface ContextEvidenceValue {
   observedAt: null;
   contextIds: string[];
   trust: "untrusted";
-  egress: "unavailable";
+  egress: EgressPolicy | "unavailable";
+  egressLineage?: EgressLineage;
   record?: RecordEvidenceMetadata;
 }
 
@@ -117,6 +122,7 @@ export type ContextEvidenceCompilerInput = Omit<
 export interface ContextEvidenceProjectionContext {
   contextFingerprint: string;
   indexFingerprint: string;
+  egressLineage: EgressLineage;
 }
 
 export interface ContextEvidenceCompilerDeps<P> {
@@ -208,18 +214,34 @@ export const captureContextEvidenceSnapshot = async (
     "context_load_failed",
     "Failed to load configured contexts"
   ).map((row) => ({ ...row }));
+  const collectionRows = unwrapStore(
+    await store.getCollections(),
+    "collection_load_failed",
+    "Failed to load indexed collections"
+  );
   const collections =
     requestedCollections.length > 0
       ? [...new Set(requestedCollections)].sort(compareCodeUnits)
-      : [
-          ...new Set(
-            unwrapStore(
-              await store.getCollections(),
-              "collection_load_failed",
-              "Failed to load indexed collections"
-            ).map((row) => row.name)
-          ),
-        ].sort(compareCodeUnits);
+      : [...new Set(collectionRows.map((row) => row.name))].sort(
+          compareCodeUnits
+        );
+  let egressLineage: EgressLineage;
+  try {
+    egressLineage = resolveEgressLineage(
+      collectionRows.map((row) => ({
+        collection: row.name,
+        policy: row.egressPolicy,
+        source: row.egressPolicySource,
+      })),
+      collections
+    );
+  } catch (error) {
+    throw new ContextEvidenceError(
+      "collection_load_failed",
+      "Failed to resolve complete collection policy lineage",
+      error
+    );
+  }
   const indexName = canonicalizeIndexName(indexNameInput);
   const indexSnapshots: ReturnType<typeof canonicalIndexSnapshot>[] = [];
   const documents: ContextEvidenceSnapshotDocument[] = [];
@@ -248,6 +270,7 @@ export const captureContextEvidenceSnapshot = async (
   }
   return {
     collections,
+    egressLineage,
     contexts,
     documents: documents.sort(
       (left, right) =>
@@ -256,7 +279,10 @@ export const captureContextEvidenceSnapshot = async (
         compareCodeUnits(left.mirrorHash ?? "", right.mirrorHash ?? "")
     ),
     contextFingerprint: fingerprintContextRows(contexts),
-    indexFingerprint: hashJson(indexSnapshots),
+    indexFingerprint: hashJson({
+      snapshots: indexSnapshots,
+      egressLineage,
+    }),
   };
 };
 
@@ -313,6 +339,21 @@ export const materializeContextEvidenceCandidates = async (
     "document_load_failed",
     "Failed to batch-load Context evidence documents"
   );
+  const collectionRows = unwrapStore(
+    await store.getCollections(),
+    "collection_load_failed",
+    "Failed to load Context evidence policies"
+  );
+  const policyByCollection = new Map(
+    collectionRows.map((row) => [
+      row.name,
+      {
+        collection: row.name,
+        policy: row.egressPolicy,
+        source: row.egressPolicySource,
+      },
+    ])
+  );
   const alignedDocuments = candidates.map((candidate) =>
     referenceDocument(documents, candidate, indexName)
   );
@@ -343,6 +384,24 @@ export const materializeContextEvidenceCandidates = async (
   return candidates.map((candidate, index) => {
     const result = candidate.result;
     const document = alignedDocuments[index];
+    if (!document) {
+      throw new ContextEvidenceError(
+        "document_load_failed",
+        `Document identity is unavailable for ${result.uri}`
+      );
+    }
+    const fallbackPolicy = policyByCollection.get(document.collection);
+    if (!result.egressLineage && !fallbackPolicy) {
+      throw new ContextEvidenceError(
+        "collection_load_failed",
+        `Policy lineage is unavailable for ${result.uri}`
+      );
+    }
+    const egressLineage =
+      result.egressLineage ??
+      createEgressLineage([
+        fallbackPolicy as NonNullable<typeof fallbackPolicy>,
+      ]);
     const metadata = result[SEARCH_RESULT_PLANNER_METADATA];
     const snippetRange = result.snippetRange;
     if (!document?.mirrorHash || !metadata || !snippetRange) {
@@ -418,7 +477,8 @@ export const materializeContextEvidenceCandidates = async (
           observedAt: null,
           contextIds: [...candidate.contextIds],
           trust: "untrusted",
-          egress: "unavailable",
+          egress: egressLineage.effectivePolicy,
+          egressLineage,
           ...(projectRecordEvidenceMetadata(document)
             ? { record: projectRecordEvidenceMetadata(document) }
             : {}),
@@ -441,6 +501,7 @@ export const compileContextEvidence = async <P>(
   const fingerprints = {
     contextFingerprint: before.contextFingerprint,
     indexFingerprint: before.indexFingerprint,
+    egressLineage: before.egressLineage,
   };
   const plan = await planContextEvidence(
     { ...input, contextSnapshot: before.contexts, observedAt: null },
@@ -479,7 +540,16 @@ export const compileContextEvidence = async <P>(
 export const toContextCapsuleEvidence = (
   candidate: MaterializedContextCandidate<ContextEvidenceValue>,
   selectionRank: number
-): ContextCapsulePayloadV1["evidence"][number] => {
+): ContextCapsulePayloadV1_1["evidence"][number] => {
+  if (
+    candidate.value.egress === "unavailable" ||
+    candidate.value.egressLineage === undefined
+  ) {
+    throw new ContextEvidenceError(
+      "collection_load_failed",
+      `Policy lineage is unavailable for ${candidate.uri}`
+    );
+  }
   const identity = {
     uri: candidate.uri,
     docid: candidate.docid,
@@ -493,6 +563,8 @@ export const toContextCapsuleEvidence = (
     evidenceId: contextCapsuleEvidenceIdentity(identity),
     ...identity,
     ...candidate.value,
+    egress: candidate.value.egress,
+    egressLineage: candidate.value.egressLineage,
     text: candidate.text,
     retrievalRank: candidate.retrievalRank,
     selectionRank,