feat(storage): centralize system-record runtime authority

packages/storage/src/adapters/sparql-http.ts

@@ -75,7 +75,7 @@
   type SystemRecordLaneExecutionBindingV1,
 } from '../system-record-materializer-v1.js';
 import { createSystemRecordAtomicApplyExecutorV1 } from '../system-record-atomic-apply-executor-v1-internal.js';
-import { createSystemRecordVerifiedReplacementRegistryV1 } from '../system-record-verified-replacement-v1-internal.js';
+import { resolveOwnedSystemRecordRuntimeV1 } from '../system-record-runtime-v1-internal.js';
 import { OwnedManagedHttpClient } from './managed-http-client.js';
 import { rotateSystemRecordMaterializationEpochV1 } from '../system-record-materialization-epoch-v1-internal.js';
 import { UnsupportedTripleStoreCapabilityError } from '../unsupported-capability-error.js';
@@ -706,14 +706,14 @@
     // already carries the property.
     if (this.systemRecordLane === undefined) {
       try {
-        // Pair issuer and consumer in one private registry, but retain only the
-        // consumer at this storage boundary. The issuer is intentionally not a
-        // store property, option, facade member, or export. B3 deliberately
-        // discards it, leaving this production lane default-unused; the later
-        // structured-verifier stack must move registry creation to its private
-        // composition closure and hand this boundary the SAME consumer. Until
-        // then every caller-authored object fails before inspection/mutation.
-        const { consumer } = createSystemRecordVerifiedReplacementRegistryV1();
+        // Resolve the ownership-lease runtime and retain only its consumer at
+        // the storage boundary. Every adapter for this lease receives the same
+        // registry, and all authentic leases share one process-wide accountant.
+        // The issuer remains outside the store and has no production caller in
+        // this default-unused stack; the later lifecycle verifier captures it.
+        const { consumer } = resolveOwnedSystemRecordRuntimeV1(
+          this.ownershipLease,
+        );
         const atomicExecutor = createSystemRecordAtomicApplyExecutorV1({
           consumer,
           storeId: this,
@@ -1385,7 +1385,7 @@
   async countQuads(graphUri?: string, options?: QueryOptions): Promise<number> {
     const sparql = graphUri
       ? `SELECT (COUNT(*) AS ?c) WHERE { GRAPH <${escapeUri(graphUri)}> { ?s ?p ?o } }`
       : `SELECT (COUNT(*) AS ?c) WHERE { { ?s ?p ?o } UNION { GRAPH ?g { ?s ?p ?o } } }`;
     const r = await this.query(sparql, {
       ...options,
       source: options?.source ?? 'sparql-http.countQuads',

packages/storage/src/system-record-materializer-v1.ts

@@ -1,3 +1,5 @@
+import { types as utilTypes } from 'node:util';
+
 import {
   readManagedOxigraphOwnershipSnapshotV1,
   type ManagedOxigraphOwnershipLeaseV1,
@@ -263,12 +265,13 @@ const NETWORK_ID_PATTERN_V1 = /^[A-Za-z0-9._:-]+$/;
 const MAX_NETWORK_ID_BYTES_V1 = 128;
 const UTF8 = new TextEncoder();
 
-/** Snapshot the closed activation record without invoking caller accessors or iterators. */
+/** Snapshot the closed activation record without invoking caller traps or accessors. */
 const snapshotActivation = (activation: unknown): SystemRecordLaneActivationSnapshotV1 => {
   if (
     activation === null ||
     typeof activation !== 'object' ||
     Array.isArray(activation) ||
+    utilTypes.isProxy(activation) ||
     ![Object.prototype, null].includes(Object.getPrototypeOf(activation))
   ) {
     throw new Error('system-record lane activation must be a plain data object');
@@ -303,7 +306,7 @@ const snapshotActivation = (activation: unknown): SystemRecordLaneActivationSnap
   }
 
   const kinds = readDataField('kinds');
-  if (!Array.isArray(kinds)) {
+  if (!Array.isArray(kinds) || utilTypes.isProxy(kinds)) {
     throw new Error('system-record lane activation kinds must be the closed [agents] tuple');
   }
   const kindKeys = Reflect.ownKeys(kinds);

packages/storage/src/system-record-next-state-v1-internal.ts

@@ -51,6 +51,7 @@ import {
 import {
   assertAuthenticSystemRecordAppliedSnapshotV1,
   assertSystemRecordRootClaimSnapshotV1,
+  requiresSystemRecordSnapshotRematerializationV1,
   type SystemRecordAppliedSnapshotV1,
 } from './system-record-state-snapshot-v1-internal.js';
 import {
@@ -231,7 +232,8 @@ export function deriveSystemRecordActiveReplacementV1(input: {
     ? snapshot.ownedSubjectTable
     : Object.freeze([]) as OwnedSubjectTableObjectV1;
 
-  if (authority.equalHead) {
+  if (authority.equalHead && !(snapshot.state === 'present'
+      && requiresSystemRecordSnapshotRematerializationV1(snapshot))) {
     if (snapshot.state !== 'present') {
       throw new Error('equal system-record head cannot exist in absent state');
     }

packages/storage/src/system-record-reservation-gate-v1-internal.ts

@@ -0,0 +1,32 @@
+import {
+  SYSTEM_RECORD_MAX_RUNTIME_ACCOUNTED_BYTES,
+} from '@origintrail-official/dkg-core/system-record-v1';
+
+export interface SystemRecordRuntimeReservationGateV1 {
+  acquire(owner: object, bytes: number): void;
+  release(owner: object, bytes: number): void;
+}
+
+/** One exact, nonqueued reservation with no partial-release state. */
+export function createSystemRecordNonQueuedReservationGateV1(): SystemRecordRuntimeReservationGateV1 {
+  let liveOwner: object | null = null;
+  let accountedBytes = 0;
+  return Object.freeze({
+    acquire(owner: object, bytes: number): void {
+      if (!Number.isSafeInteger(bytes) || bytes <= 0
+          || liveOwner !== null
+          || accountedBytes + bytes > SYSTEM_RECORD_MAX_RUNTIME_ACCOUNTED_BYTES) {
+        throw new Error('system-record atomic transient reservation is already live');
+      }
+      liveOwner = owner;
+      accountedBytes += bytes;
+    },
+    release(owner: object, bytes: number): void {
+      if (liveOwner !== owner || accountedBytes !== bytes) {
+        throw new Error('system-record atomic transient accountant state is inconsistent');
+      }
+      liveOwner = null;
+      accountedBytes = 0;
+    },
+  });
+}

packages/storage/src/system-record-runtime-v1-internal.ts

@@ -0,0 +1,50 @@
+import {
+  isManagedOxigraphOwnershipLeaseV1,
+  readManagedOxigraphOwnershipSnapshotV1,
+  type ManagedOxigraphOwnershipLeaseV1,
+} from './managed-oxigraph-ownership-v1-internal.js';
+import {
+  createSystemRecordVerifiedReplacementRegistryForRuntimeV1,
+  type SystemRecordVerifiedReplacementRegistryV1,
+} from './system-record-verified-replacement-v1-internal.js';
+import { createSystemRecordNonQueuedReservationGateV1 } from './system-record-reservation-gate-v1-internal.js';
+
+/** One nonqueued process-wide gate shared by every authentic managed endpoint. */
+const PROCESS_RESERVATION_GATE = createSystemRecordNonQueuedReservationGateV1();
+
+const OWNED_RUNTIMES = new WeakMap<
+  ManagedOxigraphOwnershipLeaseV1,
+  SystemRecordVerifiedReplacementRegistryV1
+>();
+
+/**
+ * Resolve the single proof runtime bound to an authentic daemon ownership lease.
+ * Persisted options and structural look-alikes cannot mint this authority.
+ */
+export function resolveOwnedSystemRecordRuntimeV1(
+  lease: ManagedOxigraphOwnershipLeaseV1,
+): SystemRecordVerifiedReplacementRegistryV1 {
+  if (!isManagedOxigraphOwnershipLeaseV1(lease)) {
+    throw new Error('system-record runtime requires an authentic managed Oxigraph ownership lease');
+  }
+  const ownership = readManagedOxigraphOwnershipSnapshotV1(lease);
+  if (ownership?.queryEndpoint === undefined || ownership.updateEndpoint === undefined) {
+    throw new Error('system-record runtime requires an endpoint-bound managed Oxigraph ownership lease');
+  }
+  const existing = OWNED_RUNTIMES.get(lease);
+  if (existing !== undefined) return existing;
+
+  const runtime = createSystemRecordVerifiedReplacementRegistryForRuntimeV1({
+    reservationGate: PROCESS_RESERVATION_GATE,
+    assertAvailable: () => {
+      const snapshot = readManagedOxigraphOwnershipSnapshotV1(lease);
+      if (!snapshot?.ready || snapshot.terminal
+          || snapshot.queryEndpoint !== ownership.queryEndpoint
+          || snapshot.updateEndpoint !== ownership.updateEndpoint) {
+        throw new Error('system-record runtime ownership lease is not ready');
+      }
+    },
+  });
+  OWNED_RUNTIMES.set(lease, runtime);
+  return runtime;
+}

packages/storage/src/system-record-state-snapshot-v1-internal.ts

@@ -61,7 +61,10 @@ export interface SystemRecordPresentSnapshotV1 {
   readonly rootClaimSet: SystemRecordRootClaimSetV1;
   readonly capacityState: SystemRecordCapacityStateV1;
   readonly receipt: SystemRecordMaterializationReceiptV1;
+  /** Current durable epoch read from the global epoch row. */
   readonly materializationEpoch: string;
+  /** Epoch bound by the exact persisted applied-state/receipt tuple. */
+  readonly appliedTupleEpoch: string;
   readonly previousReservedQuads: readonly Readonly<Quad>[];
   readonly expectedRootClaimQuads: readonly Readonly<Quad>[];
   readonly requiredAbsentReservedSubjects: readonly string[];
@@ -110,6 +113,9 @@ export function decodeSystemRecordAppliedSnapshotV1(input: {
   if (epoch !== owned.materializationEpoch) {
     throw new Error('system-record materialization epoch changed during inspection');
   }
+  const canonicalEpochRows = epochRows.filter((quad) => (
+    quad.predicate === SYSTEM_RECORD_V1_PREDICATES.materializationEpoch
+  ));
 
   const decodedCapacity = decodeCapacityState(networkId, capacityRows);
 
@@ -119,9 +125,7 @@ export function decodeSystemRecordAppliedSnapshotV1(input: {
     }
     const expectedFirstRead = Object.freeze([
       ...capacityRows,
-      ...epochRows.filter((quad) => (
-        quad.predicate === SYSTEM_RECORD_V1_PREDICATES.materializationEpoch
-      )),
+      ...canonicalEpochRows,
     ]);
     assertExactQuadSet(quads, expectedFirstRead, 'absent reserved state');
     return markAuthenticSnapshot(Object.freeze({
@@ -171,9 +175,10 @@ export function decodeSystemRecordAppliedSnapshotV1(input: {
     'materialization receipt',
   ));
 
+  const appliedStateDigest = computeSystemRecordAppliedStateDigestV1(appliedState);
   const digests = [
     [recordRows, SYSTEM_RECORD_V1_PREDICATES.appliedStateDigest,
-      computeSystemRecordAppliedStateDigestV1(appliedState), 'applied-state digest'],
+      appliedStateDigest, 'applied-state digest'],
     [recordRows, SYSTEM_RECORD_V1_PREDICATES.ownedSubjectTableDigest,
       appliedState.ownedSubjectTableDigest, 'owned-table digest'],
     [recordRows, SYSTEM_RECORD_V1_PREDICATES.rootClaimSetDigest,
@@ -191,8 +196,12 @@ export function decodeSystemRecordAppliedSnapshotV1(input: {
   if (appliedState.networkId !== networkId || appliedState.stableKeyHash !== stableKeyHash
       || claims.networkId !== networkId || claims.stableKeyHash !== stableKeyHash
       || capacity.networkId !== networkId || receipt.networkId !== networkId
-      || receipt.stableKeyHash !== stableKeyHash || appliedState.materializationEpoch !== epoch
-      || receipt.materializationEpoch !== epoch) {
+      || receipt.stableKeyHash !== stableKeyHash
+      || receipt.materializationEpoch !== appliedState.materializationEpoch
+      || receipt.stateRevision !== appliedState.stateRevision
+      || receipt.appliedStateDigest !== appliedStateDigest
+      || receipt.headDigest !== appliedState.headDigest
+      || BigInt(appliedState.materializationEpoch) > BigInt(epoch)) {
     throw new Error('persisted system-record tuple crosses its network, key, or epoch binding');
   }
   const canonicalTableBytes = canonicalizeOwnedSubjectTableObjectV1(
@@ -228,7 +237,7 @@ export function decodeSystemRecordAppliedSnapshotV1(input: {
   const expectedFirstRead = Object.freeze([
     ...canonical.record,
     ...canonical.capacity,
-    ...canonical.epoch,
+    ...canonicalEpochRows,
     ...canonical.receipt,
   ]);
   assertExactQuadSet(quads, expectedFirstRead, 'reserved state');
@@ -241,12 +250,19 @@ export function decodeSystemRecordAppliedSnapshotV1(input: {
     capacityState: capacity,
     receipt,
     materializationEpoch: epoch,
+    appliedTupleEpoch: appliedState.materializationEpoch,
     previousReservedQuads: expectedFirstRead,
     expectedRootClaimQuads: canonical.rootClaims,
     requiredAbsentReservedSubjects: Object.freeze([]),
   }));
 }
 
+export function requiresSystemRecordSnapshotRematerializationV1(
+  snapshot: SystemRecordPresentSnapshotV1,
+): boolean {
+  return snapshot.appliedTupleEpoch !== snapshot.materializationEpoch;
+}
+
 export function assertAuthenticSystemRecordAppliedSnapshotV1(
   value: unknown,
 ): asserts value is SystemRecordAppliedSnapshotV1 {

packages/storage/src/system-record-verified-replacement-v1-internal.ts

@@ -28,14 +28,17 @@ import {
   parseCanonicalOwnedSubjectTableObjectV1,
   SYSTEM_RECORD_MAX_ATOMIC_TRANSIENT_BYTES,
   SYSTEM_RECORD_MAX_PROJECTION_BYTES,
-  SYSTEM_RECORD_MAX_RUNTIME_ACCOUNTED_BYTES,
   type AgentProfileActiveHeadObjectV1,
   type AgentProfileVerifiedAuthoritySummaryV1,
   type NetworkIdV1,
   type OwnedSubjectTableObjectV1,
 } from '@origintrail-official/dkg-core/system-record-v1';
 
 import type { Quad } from './triple-store.js';
+import {
+  createSystemRecordNonQueuedReservationGateV1,
+  type SystemRecordRuntimeReservationGateV1,
+} from './system-record-reservation-gate-v1-internal.js';
 
 declare const VERIFIED_REPLACEMENT_HANDLE_BRAND: unique symbol;
 
@@ -161,6 +164,11 @@ interface RuntimeReservationV1 {
   recoveryOwnership?: object;
 }
 
+export interface SystemRecordVerifiedReplacementRegistryDepsV1 {
+  readonly reservationGate: SystemRecordRuntimeReservationGateV1;
+  readonly assertAvailable?: () => void;
+}
+
 /** Module-private and non-enumerable by construction. Handle identity is the only lookup key. */
 const REGISTERED_REPLACEMENTS = new WeakMap<object, RegisteredReplacementV1>();
 const AUTHENTIC_VERIFIED_REPLACEMENT_FACTS = new WeakSet<object>();
@@ -563,20 +571,17 @@ function bindingsEqual(
  * Create one non-interchangeable issuer/consumer pair. Only the consumer half belongs
  * in the storage executor; only the issuer half belongs in the verifier closure.
  */
-export function createSystemRecordVerifiedReplacementRegistryV1(): SystemRecordVerifiedReplacementRegistryV1 {
+export function createSystemRecordVerifiedReplacementRegistryForRuntimeV1(
+  deps: SystemRecordVerifiedReplacementRegistryDepsV1,
+): SystemRecordVerifiedReplacementRegistryV1 {
   const registryIdentity = Object.freeze(Object.create(null) as object);
-  let accountedBytes = 0;
-  let liveAtomicReservation: RuntimeReservationV1 | null = null;
+  const { reservationGate } = deps;
 
   const reserveAtomic = (
     admittedDeadlineMs: number,
     decodedBytes: number,
   ): RuntimeReservationV1 => {
-    if (liveAtomicReservation !== null
-        || accountedBytes + SYSTEM_RECORD_MAX_ATOMIC_TRANSIENT_BYTES
-          > SYSTEM_RECORD_MAX_RUNTIME_ACCOUNTED_BYTES) {
-      throw new Error('system-record atomic transient reservation is already live');
-    }
+    deps.assertAvailable?.();
     const reservation: RuntimeReservationV1 = {
       registryIdentity,
       identity: Object.freeze(Object.create(null) as object),
@@ -590,26 +595,21 @@ export function createSystemRecordVerifiedReplacementRegistryV1(): SystemRecordV
       },
       phase: 'proof',
     };
-    accountedBytes += reservation.bytes;
-    liveAtomicReservation = reservation;
+    reservationGate.acquire(reservation.identity, reservation.bytes);
     return reservation;
   };
 
   const releaseReservation = (reservation: RuntimeReservationV1): void => {
     if (reservation.registryIdentity !== registryIdentity || reservation.phase === 'released') {
       throw new Error('system-record atomic transient reservation was already released');
     }
-    if (liveAtomicReservation !== reservation || accountedBytes !== reservation.bytes) {
-      throw new Error('system-record atomic transient accountant state is inconsistent');
-    }
+    reservationGate.release(reservation.identity, reservation.bytes);
     reservation.phase = 'released';
     reservation.charges.decoded = 0;
     reservation.charges.request = 0;
     reservation.charges.response = 0;
     reservation.charges.prepared = 0;
     reservation.recoveryOwnership = undefined;
-    accountedBytes -= reservation.bytes;
-    liveAtomicReservation = null;
   };
 
   const registeredHandle = (handle: unknown): RegisteredReplacementV1 => {
@@ -875,6 +875,17 @@ export function createSystemRecordVerifiedReplacementRegistryV1(): SystemRecordV
   return Object.freeze({ issuer, consumer });
 }
 
+/**
+ * Isolated registry for storage-internal tests and pure transaction composition.
+ * Production code must resolve the ownership-lease runtime below so every managed
+ * adapter and future lifecycle verifier shares one process-wide accountant.
+ */
+export function createSystemRecordVerifiedReplacementRegistryV1(): SystemRecordVerifiedReplacementRegistryV1 {
+  return createSystemRecordVerifiedReplacementRegistryForRuntimeV1({
+    reservationGate: createSystemRecordNonQueuedReservationGateV1(),
+  });
+}
+
 function retainedVerifiedFactsBytes(
   head: AgentProfileActiveHeadObjectV1,
   authority: AgentProfileVerifiedAuthoritySummaryV1,

packages/storage/test/system-record-materializer-lifecycle-v1.test.ts

@@ -541,6 +541,32 @@ describe('system-record lane session lifecycle V1', () => {
       expect(handoff.calls).toEqual([]);
     });
 
+    it('rejects proxied activation records and kinds before invoking traps', async () => {
+      const controller = build();
+      let objectTrapCalls = 0;
+      const activation = new Proxy({ ...ACTIVATION }, {
+        getPrototypeOf: () => {
+          objectTrapCalls += 1;
+          throw new Error('activation proxy trap ran');
+        },
+      });
+      await expect(controller.open(activation)).rejects.toThrow(/plain data object/);
+      expect(objectTrapCalls).toBe(0);
+
+      let kindsTrapCalls = 0;
+      const kinds = new Proxy(['agents'], {
+        ownKeys: () => {
+          kindsTrapCalls += 1;
+          throw new Error('kinds proxy trap ran');
+        },
+      });
+      await expect(controller.open({ ...ACTIVATION, kinds } as never)).rejects.toThrow(
+        /closed \[agents\] tuple/,
+      );
+      expect(kindsTrapCalls).toBe(0);
+      expect(handoff.calls).toEqual([]);
+    });
+
     it('rejects unknown activation fields and a non-closed kinds tuple', async () => {
       const controller = build();
       await expect(controller.open({ ...ACTIVATION, extra: true } as never)).rejects.toThrow(