@githolon/dsl 0.14.0 → 0.15.0

package/src/usd.ts

@@ -33,6 +33,7 @@ import {
   type CanonicalManifest,
   type CanonicalProjectionReturn,
 } from "./manifest.js";
+import type { AggregateHandle } from "./aggregate.js";
 import {
   mergeRequiresScope,
   CompositionViolation,
@@ -126,10 +127,46 @@ export interface UsdCombined {
   readonly returns: CanonicalProjectionReturn;
 }
 
+/** One field's read-projection descriptor: the field kind plus a map's value kind. */
+export interface UsdFieldKindDescriptor {
+  readonly kind: string;
+  readonly mapValueKind?: string;
+}
+
+export interface UsdReadProjection {
+  readonly aggregateFieldKinds: Record<string, Record<string, UsdFieldKindDescriptor>>;
+  readonly queries: { id: string; key: { field: string; kind: string }[]; returns: string }[];
+  readonly counts: { id: string; of: string; by: string | null; where?: unknown }[];
+  readonly spatials: { id: string; of: string; on: string }[];
+  readonly deriveds: { id: string; of: string; returns: CanonicalProjectionReturn }[];
+  readonly combineds: { id: string; of: string; refField: string; reads: string; returns: CanonicalProjectionReturn }[];
+  readonly sums?: { id: string; of: string; field: string; by: string | null; where?: unknown }[];
+  readonly mins?: { id: string; of: string; field: string; by: string | null; where?: unknown }[];
+  readonly maxes?: { id: string; of: string; field: string; by: string | null; where?: unknown }[];
+  readonly orderedReads?: {
+    id: string;
+    of: string;
+    orderKey: string;
+    orderDesc?: true;
+    where?: unknown;
+    limit: number;
+  }[];
+}
+
 /** One USD layer: a stage path + its prims (canonically sorted by prim path). */
 export interface UsdLayer {
   readonly path: string;
   readonly prims: UsdPrim[];
+  /**
+   * The canonical admission/merge manifest for this layer, committed inside the package.
+   * Hosts must not stage or mutate this view; holons derive it from active installed law.
+   */
+  readonly nomosIdentityManifest?: CanonicalManifest;
+  /**
+   * The projection schema/read-routing fragment for this layer, committed inside the package.
+   * It carries the projection-only field-kind data that cannot be recovered from merge drivers.
+   */
+  readonly nomosReadProjection?: UsdReadProjection;
   /**
    * The layer's NAMED, INDEXED read declarations (read-side closure step 1), SORTED
    * by id. OMITTED (`undefined`) when the module declares no query, so a query-free
@@ -363,6 +400,123 @@ function encodeModuleToPrims(layerPath: string, mod: DomainModule): UsdPrim[] {
   return sortPrims(prims);
 }
 
+function aggregateFieldKindsForModule(
+  mod: DomainModule,
+): Record<string, Record<string, UsdFieldKindDescriptor>> {
+  const out: Record<string, Record<string, UsdFieldKindDescriptor>> = {};
+  for (const agg of [...(mod.aggregates as AggregateHandle[])].sort((a, b) =>
+    a.id < b.id ? -1 : a.id > b.id ? 1 : 0,
+  )) {
+    const fields: Record<string, UsdFieldKindDescriptor> = {};
+    for (const name of Object.keys(agg.fields).sort()) {
+      const field = agg.fields[name]!;
+      fields[name] = {
+        kind: field.kind,
+        ...(field.mapValueKind !== undefined ? { mapValueKind: field.mapValueKind } : {}),
+      };
+    }
+    out[agg.id] = fields;
+  }
+  return out;
+}
+
+function readKeyFieldKind(
+  byType: Record<string, Record<string, UsdFieldKindDescriptor>>,
+  queryId: string,
+  returns: string,
+  keyField: string,
+): string {
+  const schema = byType[returns];
+  if (schema === undefined) {
+    throw new Error(
+      `usd: query '${queryId}' returns '${returns}', which has no field schema in nomosReadProjection`,
+    );
+  }
+  const lookup = keyField.includes(".") ? keyField.split(".")[0]! : keyField;
+  const descriptor = schema[lookup];
+  if (descriptor === undefined) {
+    throw new Error(
+      `usd: query '${queryId}' is keyed on '${keyField}' (field '${lookup}'), which '${returns}' does not declare`,
+    );
+  }
+  return descriptor.kind;
+}
+
+function readProjectionForModule(mod: DomainModule, manifest: CanonicalManifest): UsdReadProjection {
+  const aggregateFieldKinds = aggregateFieldKindsForModule(mod);
+  return {
+    aggregateFieldKinds,
+    queries: (manifest.queries ?? []).map((q) => ({
+      id: q.id,
+      key: q.key.map((field) => ({
+        field,
+        kind: readKeyFieldKind(aggregateFieldKinds, q.id, q.returns, field),
+      })),
+      returns: q.returns,
+    })),
+    counts: (manifest.counts ?? []).map((c) => ({
+      id: c.id,
+      of: c.of,
+      by: c.by ?? null,
+      ...(c.where !== undefined ? { where: c.where } : {}),
+    })),
+    spatials: (manifest.spatials ?? []).map((s) => ({ id: s.id, of: s.of, on: s.on })),
+    deriveds: (manifest.deriveds ?? []).map((d) => ({ id: d.id, of: d.of, returns: d.returns })),
+    combineds: (manifest.combineds ?? []).map((c) => ({
+      id: c.id,
+      of: c.of,
+      refField: c.refField,
+      reads: c.reads,
+      returns: c.returns,
+    })),
+    ...((manifest.sums ?? []).length > 0
+      ? {
+          sums: manifest.sums!.map((s) => ({
+            id: s.id,
+            of: s.of,
+            field: s.sumField,
+            by: s.by ?? null,
+            ...(s.where !== undefined ? { where: s.where } : {}),
+          })),
+        }
+      : {}),
+    ...((manifest.mins ?? []).length > 0
+      ? {
+          mins: manifest.mins!.map((e) => ({
+            id: e.id,
+            of: e.of,
+            field: e.valueField,
+            by: e.by ?? null,
+            ...(e.where !== undefined ? { where: e.where } : {}),
+          })),
+        }
+      : {}),
+    ...((manifest.maxes ?? []).length > 0
+      ? {
+          maxes: manifest.maxes!.map((e) => ({
+            id: e.id,
+            of: e.of,
+            field: e.valueField,
+            by: e.by ?? null,
+            ...(e.where !== undefined ? { where: e.where } : {}),
+          })),
+        }
+      : {}),
+    ...((manifest.orderedReads ?? []).length > 0
+      ? {
+          orderedReads: manifest.orderedReads!.map((r) => ({
+            id: r.id,
+            of: r.of,
+            orderKey: r.orderKey,
+            ...(r.orderDesc ? { orderDesc: true as const } : {}),
+            ...(r.where !== undefined ? { where: r.where } : {}),
+            limit: r.limit,
+          })),
+        }
+      : {}),
+  };
+}
+
 /**
  * Lower a layer's `relationType` decls into the canonical `nomosRelations` wire object (P1) —
  * keys SORTED for byte-determinism, omit-when-empty (the era rule). Multiple decls for one type
@@ -549,6 +703,8 @@ export function emitUsd(
       return {
         path: l.path,
         prims: encodeModuleToPrims(l.path, l.module),
+        nomosIdentityManifest: manifest,
+        nomosReadProjection: readProjectionForModule(l.module, manifest),
         ...(manifest.queries !== undefined ? { queries: manifest.queries } : {}),
         ...(manifest.deriveds !== undefined ? { deriveds: manifest.deriveds } : {}),
         ...(manifest.combineds !== undefined ? { combineds: manifest.combineds } : {}),

package/src/usd_layers.ts

@@ -143,6 +143,40 @@ function sortedSchema(schema: WireSchema): WireSchema {
   return out;
 }
 
+function domainLayerAttrLines(domain: string, layer: UsdLayer, indent: string): string[] {
+  return [
+    `${indent}custom string nomos:kind = "domain"`,
+    `${indent}custom string nomos:domain = ${usdaString(domain)}`,
+    ...(layer.nomosIdentityManifest !== undefined
+      ? [`${indent}custom string nomos:identityManifestHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosIdentityManifest)))}`]
+      : []),
+    ...(layer.nomosReadProjection !== undefined
+      ? [`${indent}custom string nomos:readProjectionHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadProjection)))}`]
+      : []),
+    ...(layer.nomosStableIds !== undefined
+      ? [`${indent}custom string nomos:stableIdsHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosStableIds)))}`]
+      : []),
+    ...(layer.nomosReadGate !== undefined
+      ? [`${indent}custom string nomos:readGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadGate)))}`]
+      : []),
+    ...(layer.nomosReadVisibility !== undefined
+      ? [`${indent}custom string nomos:readVisibilityHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadVisibility)))}`]
+      : []),
+    ...(layer.nomosEncryption !== undefined
+      ? [`${indent}custom string nomos:encryptionHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosEncryption)))}`]
+      : []),
+    ...(layer.nomosRelations !== undefined
+      ? [`${indent}custom string nomos:relationsHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosRelations)))}`]
+      : []),
+    ...(layer.nomosRelationGate !== undefined
+      ? [`${indent}custom string nomos:relationGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosRelationGate)))}`]
+      : []),
+    ...(layer.nomosAttestationGate !== undefined
+      ? [`${indent}custom string nomos:attestationGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosAttestationGate)))}`]
+      : []),
+  ];
+}
+
 // ── per-module layer emission ────────────────────────────────────────────────────────
 
 /** One authored module of a domain's ordered module list (weak → strong). */
@@ -349,31 +383,9 @@ export function usdaLayerText(
     `{`,
     `    def Scope ${usdaString(primName(domain))}`,
     `    {`,
-    `        custom string nomos:kind = "domain"`,
-    `        custom string nomos:domain = ${usdaString(domain)}`,
-    // STABLE IDS + the captured-read gate (#58): layer-level law keys, hex-carried
+    // Stable ids + holon-owned manifests: layer-level law keys, hex-carried
     // so the .usda round-trips byte-faithfully to the IR layer.
-    ...(layer.nomosStableIds !== undefined
-      ? [`        custom string nomos:stableIdsHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosStableIds)))}`]
-      : []),
-    ...(layer.nomosReadGate !== undefined
-      ? [`        custom string nomos:readGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadGate)))}`]
-      : []),
-    ...(layer.nomosReadVisibility !== undefined
-      ? [`        custom string nomos:readVisibilityHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadVisibility)))}`]
-      : []),
-    ...(layer.nomosEncryption !== undefined
-      ? [`        custom string nomos:encryptionHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosEncryption)))}`]
-      : []),
-    ...(layer.nomosRelations !== undefined
-      ? [`        custom string nomos:relationsHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosRelations)))}`]
-      : []),
-    ...(layer.nomosRelationGate !== undefined
-      ? [`        custom string nomos:relationGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosRelationGate)))}`]
-      : []),
-    ...(layer.nomosAttestationGate !== undefined
-      ? [`        custom string nomos:attestationGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosAttestationGate)))}`]
-      : []),
+    ...domainLayerAttrLines(domain, layer, "        "),
     ``,
     ...body,
     `    }`,
@@ -388,8 +400,30 @@ export function usdaLayerText(
  * list is STRONGEST-FIRST, so the list is emitted REVERSED. Same monoid, opposite
  * notation — the reversal IS the correspondence, recorded in the doc string.
  */
-export function layeredRootUsda(sublayerRelPathsWeakToStrong: readonly string[]): string {
+export function layeredRootUsda(
+  sublayerRelPathsWeakToStrong: readonly string[],
+  composed?: UsdDocument,
+): string {
   const strongestFirst = [...sublayerRelPathsWeakToStrong].reverse();
+  const composedDomainOpinions =
+    composed === undefined || composed.layers.length === 0
+      ? []
+      : [
+          ``,
+          `over "Nomos"`,
+          `{`,
+          ...composed.layers.flatMap((layer) => {
+            const domain = layer.path.slice(layer.path.lastIndexOf("/") + 1);
+            return [
+              `    over ${usdaString(primName(domain))}`,
+              `    {`,
+              ...domainLayerAttrLines(domain, layer, "        "),
+              `    }`,
+            ];
+          }),
+          `}`,
+          ``,
+        ];
   return [
     `#usda 1.0`,
     `(`,
@@ -406,6 +440,7 @@ export function layeredRootUsda(sublayerRelPathsWeakToStrong: readonly string[])
     ),
     `    ]`,
     `)`,
+    ...composedDomainOpinions,
     ``,
   ].join("\n");
 }
@@ -461,6 +496,97 @@ function foldById<T extends { readonly id: string }>(
   return [...byId.keys()].sort().map((id) => byId.get(id)!);
 }
 
+function foldByKey<T>(
+  lists: readonly (readonly T[] | undefined)[],
+  keyOf: (item: T) => string,
+): T[] | undefined {
+  const byKey = new Map<string, T>();
+  for (const list of lists) for (const item of list ?? []) byKey.set(keyOf(item), item);
+  if (byKey.size === 0) return undefined;
+  return [...byKey.keys()].sort().map((key) => byKey.get(key)!);
+}
+
+function foldRecord<T>(
+  records: readonly (Readonly<Record<string, T>> | undefined)[],
+): Record<string, T> | undefined {
+  const byKey = new Map<string, T>();
+  for (const record of records) {
+    if (record === undefined) continue;
+    for (const [key, value] of Object.entries(record)) byKey.set(key, value);
+  }
+  if (byKey.size === 0) return undefined;
+  const out: Record<string, T> = {};
+  for (const key of [...byKey.keys()].sort()) out[key] = byKey.get(key)!;
+  return out;
+}
+
+function foldIdentityManifest(
+  stack: readonly UsdLayer[],
+  stableIds: UsdLayer["nomosStableIds"],
+): UsdLayer["nomosIdentityManifest"] {
+  const manifests = stack
+    .map((l) => l.nomosIdentityManifest)
+    .filter((m): m is NonNullable<UsdLayer["nomosIdentityManifest"]> => m !== undefined);
+  if (manifests.length === 0) return undefined;
+  const domain = manifests[manifests.length - 1]!.domain;
+  const workspaceInvariants = foldById(manifests.map((m) => m.workspaceInvariants));
+  const queries = foldById(manifests.map((m) => m.queries));
+  const counts = foldById(manifests.map((m) => m.counts));
+  const spatials = foldById(manifests.map((m) => m.spatials));
+  const sums = foldById(manifests.map((m) => m.sums));
+  const deriveds = foldById(manifests.map((m) => m.deriveds));
+  const combineds = foldById(manifests.map((m) => m.combineds));
+  const mins = foldById(manifests.map((m) => m.mins));
+  const maxes = foldById(manifests.map((m) => m.maxes));
+  const orderedReads = foldById(manifests.map((m) => m.orderedReads));
+  const workspaceTypes = foldById(manifests.map((m) => m.workspaceTypes));
+  const homes = foldRecord(manifests.map((m) => m.homes));
+  const routes = foldByKey(manifests.map((m) => m.routes), (r) => r.directive);
+  return {
+    domain,
+    aggregates: foldById(manifests.map((m) => m.aggregates)) ?? [],
+    directives: foldById(manifests.map((m) => m.directives)) ?? [],
+    ...(stableIds !== undefined ? { stableIds } : {}),
+    ...(workspaceInvariants !== undefined ? { workspaceInvariants } : {}),
+    ...(queries !== undefined ? { queries } : {}),
+    ...(counts !== undefined ? { counts } : {}),
+    ...(spatials !== undefined ? { spatials } : {}),
+    ...(sums !== undefined ? { sums } : {}),
+    ...(deriveds !== undefined ? { deriveds } : {}),
+    ...(combineds !== undefined ? { combineds } : {}),
+    ...(mins !== undefined ? { mins } : {}),
+    ...(maxes !== undefined ? { maxes } : {}),
+    ...(orderedReads !== undefined ? { orderedReads } : {}),
+    ...(workspaceTypes !== undefined ? { workspaceTypes } : {}),
+    ...(homes !== undefined ? { homes } : {}),
+    ...(routes !== undefined ? { routes } : {}),
+  };
+}
+
+function foldReadProjection(stack: readonly UsdLayer[]): UsdLayer["nomosReadProjection"] {
+  const projections = stack
+    .map((l) => l.nomosReadProjection)
+    .filter((p): p is NonNullable<UsdLayer["nomosReadProjection"]> => p !== undefined);
+  if (projections.length === 0) return undefined;
+  const aggregateFieldKinds = foldRecord(projections.map((p) => p.aggregateFieldKinds)) ?? {};
+  const sums = foldById(projections.map((p) => p.sums));
+  const mins = foldById(projections.map((p) => p.mins));
+  const maxes = foldById(projections.map((p) => p.maxes));
+  const orderedReads = foldById(projections.map((p) => p.orderedReads));
+  return {
+    aggregateFieldKinds,
+    queries: foldById(projections.map((p) => p.queries)) ?? [],
+    counts: foldById(projections.map((p) => p.counts)) ?? [],
+    spatials: foldById(projections.map((p) => p.spatials)) ?? [],
+    deriveds: foldById(projections.map((p) => p.deriveds)) ?? [],
+    combineds: foldById(projections.map((p) => p.combineds)) ?? [],
+    ...(sums !== undefined ? { sums } : {}),
+    ...(mins !== undefined ? { mins } : {}),
+    ...(maxes !== undefined ? { maxes } : {}),
+    ...(orderedReads !== undefined ? { orderedReads } : {}),
+  };
+}
+
 /**
  * THE ORDERED OPINION-MAP FOLD: flatten module layers (weak → strong within each
  * stage path) into the effective single-layer-per-domain document. Strongest
@@ -509,6 +635,8 @@ export function flattenLayeredUsd(layers: readonly UsdLayer[]): UsdDocument {
         stableIds = { v: 1, domain: domainSid, aggregates };
       }
     }
+    const identityManifest = foldIdentityManifest(stack, stableIds);
+    const readProjection = foldReadProjection(stack);
     // The captured-read gate (#58): queries + per-directive read sets merged
     // later-wins, SORTED keys (matching the composed emission).
     let readGate: UsdLayer["nomosReadGate"];
@@ -606,6 +734,8 @@ export function flattenLayeredUsd(layers: readonly UsdLayer[]): UsdDocument {
     return {
       path,
       prims: [...prims.keys()].sort().map((p) => prims.get(p)!),
+      ...(identityManifest !== undefined ? { nomosIdentityManifest: identityManifest } : {}),
+      ...(readProjection !== undefined ? { nomosReadProjection: readProjection } : {}),
       ...(queries !== undefined ? { queries } : {}),
       ...(deriveds !== undefined ? { deriveds } : {}),
       ...(combineds !== undefined ? { combineds } : {}),
@@ -733,6 +863,8 @@ function attrStringArray(prim: ParsedPrim, name: string): string[] {
 export function parseUsdaDocument(text: string): UsdDocument {
   const prims = parseUsdaPrims(text);
   const domainByScope = new Map<string, string>();
+  const identityManifestByDomain = new Map<string, UsdLayer["nomosIdentityManifest"]>();
+  const readProjectionByDomain = new Map<string, UsdLayer["nomosReadProjection"]>();
   const stableIdsByDomain = new Map<string, UsdLayer["nomosStableIds"]>();
   const readGateByDomain = new Map<string, UsdLayer["nomosReadGate"]>();
   const readVisibilityByDomain = new Map<string, UsdLayer["nomosReadVisibility"]>();
@@ -744,7 +876,15 @@ export function parseUsdaDocument(text: string): UsdDocument {
     if (p.attrs.get("nomos:kind") === "domain") {
       const domain = attrString(p, "nomos:domain");
       domainByScope.set(p.path, domain);
-      // STABLE IDS + the captured-read gate (#58): the hex-carried layer-level keys.
+      // Holon-owned manifests + gates: the hex-carried layer-level law keys.
+      const idHex = p.attrs.get("nomos:identityManifestHex");
+      if (typeof idHex === "string") {
+        identityManifestByDomain.set(domain, JSON.parse(unhexUtf8(idHex)) as UsdLayer["nomosIdentityManifest"]);
+      }
+      const rpHex = p.attrs.get("nomos:readProjectionHex");
+      if (typeof rpHex === "string") {
+        readProjectionByDomain.set(domain, JSON.parse(unhexUtf8(rpHex)) as UsdLayer["nomosReadProjection"]);
+      }
       const sidHex = p.attrs.get("nomos:stableIdsHex");
       if (typeof sidHex === "string") {
         stableIdsByDomain.set(domain, JSON.parse(unhexUtf8(sidHex)) as UsdLayer["nomosStableIds"]);
@@ -865,6 +1005,8 @@ export function parseUsdaDocument(text: string): UsdDocument {
   const layers: UsdLayer[] = [...buckets.keys()]
     .map((domain) => {
       const b = buckets.get(domain)!;
+      const identity = identityManifestByDomain.get(domain);
+      const readProjection = readProjectionByDomain.get(domain);
       const sids = stableIdsByDomain.get(domain);
       const rg = readGateByDomain.get(domain);
       const rv = readVisibilityByDomain.get(domain);
@@ -875,6 +1017,8 @@ export function parseUsdaDocument(text: string): UsdDocument {
       return {
         path: `/Nomos/${domain}`,
         prims: [...b.prims].sort(byPath),
+        ...(identity !== undefined ? { nomosIdentityManifest: identity } : {}),
+        ...(readProjection !== undefined ? { nomosReadProjection: readProjection } : {}),
         ...(b.queries.length > 0 ? { queries: [...b.queries].sort(byId) } : {}),
         ...(b.deriveds.length > 0 ? { deriveds: [...b.deriveds].sort(byId) } : {}),
         ...(b.combineds.length > 0 ? { combineds: [...b.combineds].sort(byId) } : {}),

package/src/workspace_sharding.ts

@@ -10,7 +10,7 @@
  * invariants, slice 3 delta lane + least-loaded placement).
  *
  * `nomos-compile` APPENDS this module to a TAXONOMY-BEARING domain's module list —
- * both in the canonical manifests (the placement law is hash-bearing law) and in the
+ * both in the compiled package metadata (the placement law is hash-bearing law) and in the
  * generated engine entry (the plans ship in the lump). A taxonomy-FREE package never
  * imports it (subpath `@githolon/dsl/workspace-sharding`, never the runtime barrel —
  * the slice-1 hash-stability law: its bytes must not enter other tenants' lumps).
@@ -110,7 +110,7 @@ export interface ShardingRouteSpec {
 export interface ShardingLawSpec {
   readonly axes: readonly ShardingAxisSpec[];
   /**
-   * THE DERIVED ROUTES (slice 2's canonical-manifest `routes`, fed back into the law):
+   * THE DERIVED ROUTES (slice 2's package route facts, fed back into the law):
    * per routed directive, the homing invariant `nomosWrongHome:<directive>` is derived
    * so THE CHAIN GATE ITSELF refuses a wrong-home write (#41 — slice 3a; the edge
    * bailiff stays as defense-in-depth). OMITTED routes ⇒ no invariants (slice-2 shape).
@@ -317,7 +317,6 @@ export const NomosSummarySubtotal = aggregate("NomosSummarySubtotal", {
 export const NomosSummaryFrontier = aggregate("NomosSummaryFrontier", {
   shard: t.string().merge(Lww),
   frontier: t.string().merge(Lww), // the shard main oid the subtotals are true at
-  readManifestHash: t.string().merge(Lww),
   updatedAt: t.string().merge(Lww),
 });
 
@@ -530,7 +529,6 @@ export const nomosAmendSummaryFrontier = directive("nomosAmendSummaryFrontier")
     z.object({
       shard: z.string().regex(/^s\d+$/),
       frontier: z.string(),
-      readManifestHash: z.string(),
       updatedAt: z.string(),
     }),
   )
@@ -539,7 +537,6 @@ export const nomosAmendSummaryFrontier = directive("nomosAmendSummaryFrontier")
     return [
       withMarker(set(wm, "shard", p.shard), "ensures"),
       set(wm, "frontier", p.frontier),
-      set(wm, "readManifestHash", p.readManifestHash),
       set(wm, "updatedAt", p.updatedAt),
     ];
   });
@@ -656,7 +653,6 @@ export const nomosPropagateSummary = directive("nomosPropagateSummary")
       shard: z.string().regex(/^s\d+$/),
       fromOid: z.string(), // "" = the shard's first delta (a virgin coordinator record)
       toOid: z.string().min(1),
-      readManifestHash: z.string(),
       propagatedAt: z.string(),
       subtotals: z.array(summarySubtotalSchema).min(1).max(1024),
       events: z.array(summaryEventSchema).max(4096),
@@ -762,7 +758,6 @@ export const nomosPropagateSummary = directive("nomosPropagateSummary")
     ops.push(
       withMarker(set(wm, "shard", p.shard), "ensures"),
       set(wm, "frontier", p.toOid),
-      set(wm, "readManifestHash", p.readManifestHash),
       set(wm, "updatedAt", p.propagatedAt),
     );
     return ops;