@gmickel/gno 2.3.2 → 2.4.0

package/src/app/context-runtime.ts

@@ -63,6 +63,7 @@ export const buildContextCapsule = async (
     deps.config.collections.map((collection) => collection.name)
   );
   const noRerank = normalized.depthPolicy === "fast" || normalized.noRerank;
+  let metadataCoverageIncomplete = false;
   const plan = await compileContextEvidence<ContextCapsuleV1>(
     {
       goal: normalized.goal,
@@ -74,6 +75,7 @@ export const buildContextCapsule = async (
       tagsAll: normalized.tagsAll,
       tagsAny: normalized.tagsAny,
       categories: normalized.categories,
+      filter: normalized.filter,
       author: normalized.author ?? undefined,
       lang: normalized.lang ?? undefined,
       intent: normalized.intent ?? undefined,
@@ -104,8 +106,14 @@ export const buildContextCapsule = async (
             store: deps.store,
             hydration: deps.hydration,
             config: deps.config,
-            vectorIndex: deps.vectorIndex ?? null,
-            embedPort: deps.embedPort ?? null,
+            vectorIndex:
+              normalized.depthPolicy === "fast"
+                ? null
+                : (deps.vectorIndex ?? null),
+            embedPort:
+              normalized.depthPolicy === "fast"
+                ? null
+                : (deps.embedPort ?? null),
             expandPort: null,
             rerankPort: requestNoRerank ? null : (deps.rerankPort ?? null),
           },
@@ -124,10 +132,26 @@ export const buildContextCapsule = async (
             result.error.cause
           );
         }
+        if (
+          normalized.filter &&
+          result.value.meta.warnings?.some(
+            (warning) =>
+              warning.code === "METADATA_COVERAGE_UNKNOWN" ||
+              warning.code === "METADATA_COVERAGE_INCOMPLETE"
+          )
+        ) {
+          metadataCoverageIncomplete = true;
+        }
         return result.value;
       },
       projectCanonical: (draft, snapshots) =>
-        projectContextCapsule(draft, snapshots, normalized, deps),
+        projectContextCapsule(
+          draft,
+          snapshots,
+          normalized,
+          deps,
+          metadataCoverageIncomplete
+        ),
     }
   );
   if (!plan.projection) {

package/src/app/context-surface.ts

@@ -5,6 +5,7 @@ import { z } from "zod";
 import type { ContextCapsuleBuildInput } from "./context-runtime-types";
 
 import { ContextCapsuleContractError } from "../core/context-capsule";
+import { metadataPredicateSchema } from "../core/typed-metadata";
 
 const queryModeSchema = z
   .object({
@@ -28,6 +29,7 @@ export const contextBuildSurfaceSchema = z
     tagsAll: stringList.optional(),
     tagsAny: stringList.optional(),
     categories: stringList.optional(),
+    filter: metadataPredicateSchema.optional(),
     author: z.string().optional(),
     lang: z.string().optional(),
     intent: z.string().optional(),

package/src/app/verified-ask.ts

@@ -184,6 +184,7 @@ export const buildVerifiedAsk = async (
       tagsAll: options.tagsAll,
       tagsAny: options.tagsAny,
       categories: options.categories,
+      filter: options.filter,
       author: options.author,
       lang: options.lang,
       intent: options.intent,

package/src/cli/commands/ask.ts

@@ -323,6 +323,7 @@ export async function ask(
       until: options.until,
       categories: options.categories,
       author: options.author,
+      filter: options.filter,
       tagsAll: options.tagsAll,
       tagsAny: options.tagsAny,
       exclude: options.exclude,

package/src/cli/commands/context-build.ts

@@ -124,6 +124,7 @@ export const contextBuild = async (
         until: options.until,
         categories: options.categories,
         author: options.author,
+        filter: options.filter,
         graph: options.graph,
         candidateLimit: options.candidateLimit,
         queryModes: options.queryModes,

package/src/cli/commands/search.ts

@@ -113,6 +113,7 @@ export async function search(
         until: options.until,
         categories: options.categories,
         author: options.author,
+        filter: options.filter,
         intent: options.intent,
         exclude: options.exclude,
       },

package/src/cli/commands/status.ts

@@ -87,6 +87,11 @@ function formatTerminal(
 ): string {
   const lines: string[] = [];
 
+  if (indexStatus.typedMetadata) {
+    lines.push(
+      `Typed metadata: ${indexStatus.typedMetadata.pending} pending sync, ${indexStatus.typedMetadata.invalid} invalid`
+    );
+  }
   lines.push(`Index: ${indexStatus.indexName}`);
   lines.push(`Config: ${indexStatus.configPath}`);
   lines.push(`Database: ${indexStatus.dbPath}`);
@@ -200,6 +205,10 @@ function formatMarkdown(
   lines.push(`- **Documents**: ${indexStatus.activeDocuments}`);
   lines.push(`- **Chunks**: ${indexStatus.totalChunks}`);
   lines.push(`- **Embedding backlog**: ${indexStatus.embeddingBacklog}`);
+  if (indexStatus.typedMetadata)
+    lines.push(
+      `- **Typed metadata**: ${indexStatus.typedMetadata.pending} pending sync, ${indexStatus.typedMetadata.invalid} invalid`
+    );
   lines.push(`- **Recent errors**: ${indexStatus.recentErrors}`);
 
   const chunking = formatChunkingStatus(indexStatus.chunking);
@@ -347,6 +356,7 @@ export function formatStatus(
         totalDocuments: s.activeDocuments,
         totalChunks: s.totalChunks,
         embeddingBacklog: s.embeddingBacklog,
+        typedMetadata: s.typedMetadata,
         chunking: s.chunking,
         lastUpdated: s.lastUpdatedAt,
         healthy: isStatusHealthy(s, result.activation),

package/src/cli/options.ts

@@ -9,6 +9,10 @@ import {
   normalizeProjectAffinityValues,
   ProjectAffinityInputError,
 } from "../core/project-affinity-surface";
+import {
+  normalizeMetadataPredicate,
+  type MetadataPredicate,
+} from "../core/typed-metadata";
 import { CliError } from "./errors";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -259,3 +263,18 @@ export function parseOptionalFloat(
   }
   return num;
 }
+
+export const parseCliMetadataFilter = (
+  value: unknown
+): MetadataPredicate | undefined => {
+  if (value === undefined) return undefined;
+  try {
+    if (typeof value !== "string") throw new Error("Expected JSON text");
+    return normalizeMetadataPredicate(JSON.parse(value));
+  } catch (error) {
+    throw new CliError(
+      "VALIDATION",
+      `filter: ${error instanceof Error ? error.message : "Invalid predicate"}`
+    );
+  }
+};

package/src/cli/program.ts

@@ -49,6 +49,7 @@ import {
   collectRepeatableValue,
   getDefaultLimit,
   parseCliProjectAffinityOptions,
+  parseCliMetadataFilter,
   parseOptionalFloat,
   parsePositiveInt,
 } from "./options";
@@ -652,6 +653,7 @@ function wireSearchCommands(program: Command): void {
       "modified-at upper bound (ISO date/time or token)"
     )
     .option("--category <values>", "require category match (comma-separated)")
+    .option("--filter <json>", "typed custom metadata predicate (JSON)")
     .option("--author <text>", "filter by author (case-insensitive contains)")
     .option("--intent <text>", "disambiguating context for ambiguous queries")
     .option(
@@ -736,6 +738,7 @@ function wireSearchCommands(program: Command): void {
           until: cmdOpts.until as string | undefined,
           categories,
           author: cmdOpts.author as string | undefined,
+          filter: parseCliMetadataFilter(cmdOpts.filter),
           intent: cmdOpts.intent as string | undefined,
           exclude,
           tagsAll,
@@ -790,6 +793,7 @@ function wireSearchCommands(program: Command): void {
       "modified-at upper bound (ISO date/time or token)"
     )
     .option("--category <values>", "require category match (comma-separated)")
+    .option("--filter <json>", "typed custom metadata predicate (JSON)")
     .option("--author <text>", "filter by author (case-insensitive contains)")
     .option("--intent <text>", "disambiguating context for ambiguous queries")
     .option(
@@ -864,6 +868,7 @@ function wireSearchCommands(program: Command): void {
         until: cmdOpts.until as string | undefined,
         categories,
         author: cmdOpts.author as string | undefined,
+        filter: parseCliMetadataFilter(cmdOpts.filter),
         intent: cmdOpts.intent as string | undefined,
         exclude,
         tagsAll,
@@ -916,6 +921,7 @@ function wireSearchCommands(program: Command): void {
       "modified-at upper bound (ISO date/time or token)"
     )
     .option("--category <values>", "require category match (comma-separated)")
+    .option("--filter <json>", "typed custom metadata predicate (JSON)")
     .option("--author <text>", "filter by author (case-insensitive contains)")
     .option("--intent <text>", "disambiguating context for ambiguous queries")
     .option(
@@ -1080,6 +1086,7 @@ function wireSearchCommands(program: Command): void {
             until: cmdOpts.until as string | undefined,
             categories,
             author: cmdOpts.author as string | undefined,
+            filter: parseCliMetadataFilter(cmdOpts.filter),
             intent: cmdOpts.intent as string | undefined,
             exclude,
             tagsAll,
@@ -1116,6 +1123,7 @@ function wireSearchCommands(program: Command): void {
           until: cmdOpts.until as string | undefined,
           categories,
           author: cmdOpts.author as string | undefined,
+          filter: parseCliMetadataFilter(cmdOpts.filter),
           intent: cmdOpts.intent as string | undefined,
           exclude,
           tagsAll,
@@ -1219,6 +1227,7 @@ function wireSearchCommands(program: Command): void {
       "modified-at upper bound (ISO date/time or token)"
     )
     .option("--category <values>", "require category match (comma-separated)")
+    .option("--filter <json>", "typed custom metadata predicate (JSON)")
     .option("--author <text>", "filter by author (case-insensitive contains)")
     .option("--intent <text>", "disambiguating context for ambiguous queries")
     .option(
@@ -1350,6 +1359,7 @@ function wireSearchCommands(program: Command): void {
         until: cmdOpts.until as string | undefined,
         categories,
         author: cmdOpts.author as string | undefined,
+        filter: parseCliMetadataFilter(cmdOpts.filter),
         intent: cmdOpts.intent as string | undefined,
         exclude,
         minScore,
@@ -2695,6 +2705,7 @@ function wireManagementCommands(program: Command): void {
     .option("--tags-all <tags>", "require ALL tags (comma-separated)")
     .option("--tags-any <tags>", "require ANY tag (comma-separated)")
     .option("--category <values>", "require category match (comma-separated)")
+    .option("--filter <json>", "typed custom metadata predicate (JSON)")
     .option("--author <text>", "filter by author")
     .option("--lang <code>", "language hint (BCP-47)")
     .option("--since <date>", "modified-at lower bound")
@@ -2765,6 +2776,7 @@ function wireManagementCommands(program: Command): void {
         tagsAny: parseCsvValues(cmdOpts.tagsAny),
         categories: parseCsvValues(cmdOpts.category),
         author: cmdOpts.author as string | undefined,
+        filter: parseCliMetadataFilter(cmdOpts.filter),
         lang: cmdOpts.lang as string | undefined,
         since: cmdOpts.since as string | undefined,
         until: cmdOpts.until as string | undefined,

package/src/converters/types.ts

@@ -1,3 +1,4 @@
+import type { TypedMetadata } from "../core/typed-metadata";
 /**
  * Converter subsystem types.
  * PRD §8.2 - Converter interfaces
@@ -157,6 +158,7 @@ export const RECORD_METADATA_LIMITS = {
 
 /** Metadata shared by export adapters and later search/get projections. */
 export interface RecordMetadata {
+  custom?: TypedMetadata;
   author?: string;
   participants?: string[];
   categories?: string[];

package/src/core/context-capsule-retrieval-schema.ts

@@ -3,6 +3,7 @@
 import { z } from "zod";
 
 import { contextCapsuleIndexSnapshotSchema } from "./context-capsule-index-schema";
+import { metadataPredicateSchema } from "./typed-metadata";
 
 const nonEmptyText = z.string().min(1);
 const capabilityOutcomeSchema = z.enum([
@@ -83,3 +84,10 @@ export const contextCapsuleRetrievalSchema = z
 export type ContextCapabilityState = z.infer<
   typeof contextCapabilityStateSchema
 >;
+
+export const contextCapsuleRetrievalV1_2Schema =
+  contextCapsuleRetrievalSchema.extend({
+    request: contextCapsuleRetrievalSchema.shape.request.extend({
+      filter: metadataPredicateSchema,
+    }),
+  });

package/src/core/context-capsule-schema.ts

@@ -4,6 +4,7 @@ import { buildUri, deriveDocid, parseUri } from "../app/constants";
 import { isValidIndexName } from "../app/index-name";
 import { RECORD_METADATA_LIMITS } from "../converters/types";
 import { contextCapsuleIndexSnapshotSchema } from "./context-capsule-index-schema";
+import { contextCapsuleRetrievalV1_2Schema } from "./context-capsule-retrieval-schema";
 import { contextCapsuleRetrievalSchema } from "./context-capsule-retrieval-schema";
 import {
   contextCapsuleEvidenceIdentity,
@@ -12,11 +13,15 @@ import {
   validateContextCapsulePayload,
 } from "./context-capsule-validation";
 import { egressLineageSchema } from "./egress-provenance";
+import {
+  normalizeMetadataPredicate,
+  metadataPredicateSchema,
+} from "./typed-metadata";
 
 export { contextCapsuleIndexSnapshotSchema } from "./context-capsule-index-schema";
 
 export const CONTEXT_CAPSULE_SCHEMA_VERSION = "1.0" as const;
-export const CONTEXT_CAPSULE_CURRENT_SCHEMA_VERSION = "1.1" as const;
+export const CONTEXT_CAPSULE_CURRENT_SCHEMA_VERSION = "1.2" as const;
 export const CONTEXT_CAPSULE_COORDINATE_SPACE = "canonical_mirror" as const;
 
 const SHA256_PATTERN = /^[a-f0-9]{64}$/;
@@ -654,7 +659,7 @@ const validateContextCapsuleV1_1Lineage = (
 
 export const contextCapsulePayloadV1_1Schema = z
   .object({
-    schemaVersion: z.literal(CONTEXT_CAPSULE_CURRENT_SCHEMA_VERSION),
+    schemaVersion: z.literal("1.1"),
     coordinateSpace: z.literal(CONTEXT_CAPSULE_COORDINATE_SPACE),
     goal: nonEmptyTextSchema,
     query: nonEmptyTextSchema,
@@ -682,6 +687,45 @@ export type ContextCapsulePayloadV1_1 = z.infer<
   typeof contextCapsulePayloadV1_1Schema
 >;
 
+export const contextCapsulePayloadV1_2Schema = z
+  .object({
+    ...contextCapsulePayloadV1_1Schema.shape,
+    schemaVersion: z.literal(CONTEXT_CAPSULE_CURRENT_SCHEMA_VERSION),
+    scope: scopeSchema.extend({ filter: metadataPredicateSchema }),
+    retrieval: contextCapsuleRetrievalV1_2Schema,
+    warnings: z
+      .array(
+        z
+          .object({
+            code: z.union([
+              contextCapsuleWarningCodeSchema,
+              z.literal("metadata_coverage_incomplete"),
+            ]),
+          })
+          .strict()
+      )
+      .max(32),
+  })
+  .strict()
+  .superRefine((value, context) => {
+    validateContextCapsulePayload(value, context);
+    validateContextCapsuleV1_1Lineage(value, context);
+    if (
+      JSON.stringify(normalizeMetadataPredicate(value.scope.filter)) !==
+      JSON.stringify(normalizeMetadataPredicate(value.retrieval.request.filter))
+    ) {
+      context.addIssue({
+        code: "custom",
+        path: ["retrieval", "request", "filter"],
+        message: "Retrieval predicate must match scope predicate",
+      });
+    }
+  });
+export type ContextCapsulePayloadV1_2 = z.infer<
+  typeof contextCapsulePayloadV1_2Schema
+>;
+
 export type ContextCapsulePayload =
   | ContextCapsulePayloadV1
-  | ContextCapsulePayloadV1_1;
+  | ContextCapsulePayloadV1_1
+  | ContextCapsulePayloadV1_2;

package/src/core/context-capsule-validation.ts

@@ -318,11 +318,18 @@ const validateCoverageBindings = (
       path: ["coverage", "gaps"],
     });
   }
-  const complete = unresolved.length === 0 && value.coverage.gaps.length === 0;
+  const metadataIncomplete =
+    value.schemaVersion === "1.2" &&
+    value.warnings.some(({ code }) => code === "metadata_coverage_incomplete");
+  const complete =
+    unresolved.length === 0 &&
+    value.coverage.gaps.length === 0 &&
+    !metadataIncomplete;
   if (value.coverage.complete !== complete) {
     context.addIssue({
       code: "custom",
-      message: "complete must reflect unresolved facets and gaps",
+      message:
+        "complete must reflect unresolved facets, gaps, and metadata coverage",
       path: ["coverage", "complete"],
     });
   }
@@ -379,6 +386,11 @@ export const validateContextCapsulePayload = (
     });
   }
   const expectedWarnings = new Set<string>();
+  if (
+    value.schemaVersion === "1.2" &&
+    warningSet.has("metadata_coverage_incomplete")
+  )
+    expectedWarnings.add("metadata_coverage_incomplete");
   if (!value.coverage.complete) expectedWarnings.add("incomplete_coverage");
   if (value.omissions.truncated) expectedWarnings.add("omissions_truncated");
   if (fallbackTokenizer) expectedWarnings.add("token_estimate_used");

package/src/core/context-capsule-verification.ts

@@ -123,6 +123,7 @@ export const contextCapsuleVerificationSchema = z
   .object({
     schemaVersion: z.union([
       z.literal(CONTEXT_CAPSULE_SCHEMA_VERSION),
+      z.literal("1.1"),
       z.literal(CONTEXT_CAPSULE_CURRENT_SCHEMA_VERSION),
     ]),
     coordinateSpace: z.literal(CONTEXT_CAPSULE_COORDINATE_SPACE),

package/src/core/context-capsule.ts

@@ -4,9 +4,11 @@ import { canonicalizeIndexName } from "../app/index-name";
 import {
   contextCapsulePayloadV1Schema,
   contextCapsulePayloadV1_1Schema,
+  contextCapsulePayloadV1_2Schema,
   type ContextCapsulePayload,
 } from "./context-capsule-schema";
 import { createEgressLineage, type EgressLineage } from "./egress-provenance";
+import { normalizeMetadataPredicate } from "./typed-metadata";
 
 const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
 
@@ -61,6 +63,9 @@ const normalizePayload = (
     query: normalizeText(value.query),
     scope: {
       ...value.scope,
+      ...(value.schemaVersion === "1.2"
+        ? { filter: normalizeMetadataPredicate(value.scope.filter) }
+        : {}),
       indexName: canonicalizeIndexName(value.scope.indexName),
       collections: normalizeSet(value.scope.collections),
       uriPrefix:
@@ -79,6 +84,13 @@ const normalizePayload = (
       queryVariants: value.retrieval.queryVariants.map(normalizeText),
       request: {
         ...value.retrieval.request,
+        ...(value.schemaVersion === "1.2"
+          ? {
+              filter: normalizeMetadataPredicate(
+                value.retrieval.request.filter
+              ),
+            }
+          : {}),
         author:
           value.retrieval.request.author === null
             ? null
@@ -116,7 +128,7 @@ const normalizePayload = (
         `${right.code}\0${right.capability}`
       )
     ),
-    ...(value.schemaVersion === "1.1"
+    ...(value.schemaVersion !== "1.0"
       ? {
           egressLineage: {
             ...value.egressLineage,
@@ -291,6 +303,7 @@ const contractError = (
 const contextCapsulePayloadSchema = z.union([
   contextCapsulePayloadV1Schema,
   contextCapsulePayloadV1_1Schema,
+  contextCapsulePayloadV1_2Schema,
 ]);
 
 const parsePayload = (input: unknown): ContextCapsulePayload => {
@@ -391,6 +404,7 @@ const fixedPointCapsule = (
 const contextCapsuleBaseV1Schema = z.union([
   contextCapsulePayloadV1Schema.extend({ capsuleId: sha256Schema }),
   contextCapsulePayloadV1_1Schema.extend({ capsuleId: sha256Schema }),
+  contextCapsulePayloadV1_2Schema.extend({ capsuleId: sha256Schema }),
 ]);
 
 export const contextCapsuleV1Schema = contextCapsuleBaseV1Schema.superRefine(
@@ -503,7 +517,7 @@ export const canonicalContextCapsuleAccountingJson = (input: unknown): string =>
  */
 export const contextCapsuleEgressLineage = (input: unknown): EgressLineage => {
   const capsule = parseContextCapsuleV1(input);
-  if (capsule.schemaVersion === "1.1") return capsule.egressLineage;
+  if (capsule.schemaVersion !== "1.0") return capsule.egressLineage;
   return createEgressLineage(
     [...new Set(capsule.evidence.map(({ collection }) => collection))].map(
       (collection) => ({

package/src/core/context-compiler.ts

@@ -26,6 +26,7 @@ import type {
   MaterializedContextCandidate,
 } from "./context-budget";
 import type { ContextConfiguredGuidance } from "./context-guidance";
+import type { MetadataPredicate } from "./typed-metadata";
 
 import { decorateUriForIndex } from "../app/constants";
 import { canonicalizeIndexName } from "../app/index-name";
@@ -96,6 +97,7 @@ export interface ContextCompilerInput {
   tagsAll?: string[];
   tagsAny?: string[];
   categories?: string[];
+  filter?: MetadataPredicate;
   author?: string;
   lang?: string;
   intent?: string;
@@ -358,6 +360,7 @@ export const planContextEvidence = async <T, P>(
         tagsAll: input.tagsAll,
         tagsAny: input.tagsAny,
         categories: input.categories,
+        filter: input.filter,
         author: input.author,
         lang: input.lang,
         intent: input.intent,

package/src/core/record-metadata.ts

@@ -1,6 +1,6 @@
 import type { RecordAnchor, RecordMetadata } from "../converters/types";
 
-export interface RecordEvidenceMetadata extends RecordMetadata {
+export interface RecordEvidenceMetadata extends Omit<RecordMetadata, "custom"> {
   recordKey: string;
   sourceLocator: string;
   anchors: RecordAnchor[];

package/src/core/retrieval-replay-candidate.ts

@@ -18,6 +18,7 @@ import { searchBm25 } from "../pipeline/search";
 import { SEARCH_RESULTS_TRACE_METADATA } from "../pipeline/types";
 import { searchVector } from "../pipeline/vsearch";
 import { err, ok } from "../store/types";
+import { normalizeMetadataPredicate } from "./typed-metadata";
 
 export interface RetrievalReplayDeps extends HybridSearchDeps {
   indexName?: string;
@@ -108,6 +109,10 @@ export const buildRetrievalReplaySearchOptions = (
     categories: Array.isArray(filters.categories)
       ? (filters.categories as string[])
       : undefined,
+    filter:
+      filters.filter === undefined
+        ? undefined
+        : normalizeMetadataPredicate(filters.filter),
     author: typeof filters.author === "string" ? filters.author : undefined,
     intent: typeof filters.intent === "string" ? filters.intent : undefined,
     exclude: Array.isArray(filters.exclude)

package/src/core/retrieval-trace-filter-normalization.ts

@@ -1,5 +1,7 @@
 /** Deterministic set-like retrieval-filter normalization before persistence. */
 
+import { normalizeMetadataPredicate } from "./typed-metadata";
+
 const SET_ARRAY_KEYS = [
   "categories",
   "collections",
@@ -23,5 +25,7 @@ export const canonicalizeRetrievalTraceFilters = <
       normalized[key] = [...new Set(values)].sort(compareCodeUnits);
     }
   }
+  if (filters.filter !== undefined)
+    normalized.filter = normalizeMetadataPredicate(filters.filter);
   return normalized as Filters;
 };

package/src/core/retrieval-trace-request.ts

@@ -122,6 +122,7 @@ export const retrievalTraceFilters = (
       since: options.since,
       until: options.until,
       categories: options.categories,
+      filter: options.filter,
       author: options.author,
       intent: options.intent,
       exclude: options.exclude,

package/src/core/retrieval-trace-session.ts

@@ -380,7 +380,11 @@ export class RetrievalTraceSession {
     latencyMs?: number
   ): Promise<StoreResult<"inserted" | "duplicate" | "disabled">> {
     if (!this.hasCapacity(2)) return ok("disabled");
-    if (capsule.schemaVersion === "1.0" || capsule.schemaVersion === "1.1") {
+    if (
+      capsule.schemaVersion === "1.0" ||
+      capsule.schemaVersion === "1.1" ||
+      capsule.schemaVersion === "1.2"
+    ) {
       const widened = await this.ensureLineageCoverage([
         contextCapsuleEgressLineage(capsule),
       ]);

package/src/core/retrieval-trace.ts

@@ -29,6 +29,7 @@ import {
   legacyLocalOnlyEgressLineage,
 } from "./egress-provenance";
 import { canonicalizeRetrievalTraceFilters } from "./retrieval-trace-filter-normalization";
+import { metadataPredicateSchema } from "./typed-metadata";
 
 const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
 const gnoUriSchema = z
@@ -57,6 +58,7 @@ export const traceFiltersSchema = z
     since: z.string().max(128).optional(),
     until: z.string().max(128).optional(),
     categories: z.array(z.string().max(512)).max(1000).optional(),
+    filter: metadataPredicateSchema.optional(),
     author: z.string().max(1024).optional(),
     intent: z.string().max(8192).optional(),
     exclude: z.array(z.string().max(1024)).max(1000).optional(),