chainlesschain 0.166.92 → 0.166.94

package/src/lib/evolution/rrsi-registry-store-policy.js

@@ -33,6 +33,7 @@ import {
 import { deriveSkillCandidateTenantKey } from "./skill-candidate-registry.js";
 import { deriveSkillReleaseTenantKey } from "./skill-release-registry.js";
 import { captureSkillReleaseOperationReader } from "./evolution-ledger-ports.js";
+import { captureRrsiRegistryRuntimePolicy } from "./rrsi-registry-runtime-policy.js";
 import {
   snapshotRrsiData,
   rrsiExact,
@@ -129,7 +130,13 @@ function assertPrivateParent(expected) {
   assertDirectory(expected);
   const permission = inspectPrivatePath(expected.path);
   if (permission?.ok !== true || permission.exists !== true)
-    hold("provisioning parent must have verified owner-only permissions");
+    hold(
+      "provisioning parent must have verified owner-only permissions",
+      new Error(
+        permission?.error ||
+          "owner-only permission inspection was not successful",
+      ),
+    );
   assertDirectory(expected);
 }
 function syncDirectory(value) {
@@ -950,20 +957,32 @@ export function createRrsiRegistryStorePolicy(input) {
   const policy = Object.freeze({
     descriptor,
     bindComponent(input) {
-      const request = snapshotRrsiData(input);
-      rrsiExact(
-        request,
-        ["operationId", "component"],
-        "Registry component binding",
-      );
+      if (
+        !input ||
+        isProxy(input) ||
+        Object.getPrototypeOf(input) !== Object.prototype
+      )
+        hold("Registry component binding requires plain own fields");
+      const names = ["operationId", "component"];
+      if (Object.hasOwn(input ?? {}, "runtimePolicy"))
+        names.push("runtimePolicy");
+      const request = ownOptions(input, names);
       rrsiId(request.operationId, "provision operation ID");
       if (!["candidate", "release"].includes(request.component))
         rrsiFail("Registry binding component is invalid");
       // Do not take a policy operation lock or repair any Registry path. The
       // retained head and both physical markers bookend this read-only open.
-      let original;
+      let original,
+        runtime = null;
+      if (request.runtimePolicy !== undefined) {
+        runtime = captureRrsiRegistryRuntimePolicy(request.runtimePolicy);
+        if (!runtime.matchesPolicy(policy))
+          hold("runtime attachment requires the original store policy");
+      }
       try {
-        original = status(load(), request.operationId);
+        original = status(load(), request.operationId, {
+          boundaryOnly: runtime !== null,
+        });
       } catch (cause) {
         if (["ENOENT", "ENOTDIR"].includes(cause?.code))
           hold("an authenticated Registry binding boundary is missing", cause);
@@ -976,6 +995,7 @@ export function createRrsiRegistryStorePolicy(input) {
       const store = prepared[component];
       const peer =
         prepared[component === "candidate" ? "release" : "candidate"];
+      const runtimeOriginal = runtime?.read(request.operationId) ?? null;
       const componentDescriptor = freezeRrsiData({
         schema: "chainlesschain.rrsi-registry-component-binding/v1",
         operationId: request.operationId,
@@ -986,7 +1006,10 @@ export function createRrsiRegistryStorePolicy(input) {
         journalIdentity: prepared.journalIdentity,
         committedRecordDigest: original.records.at(-1).recordDigest,
         writerFloor: RRSI_REGISTRY_STORE_WRITER_FLOOR,
-        registryRuntimeMode: "uninitialized-read-only",
+        registryRuntimeMode: runtime
+          ? "authenticated-empty-read-only"
+          : "uninitialized-read-only",
+        runtimeRecordDigest: runtimeOriginal?.committedRecordDigest ?? null,
         persistentStoreIdentityAuthenticated: true,
         originCutoverAuthenticated: false,
         originClassificationAvailable: false,
@@ -994,7 +1017,8 @@ export function createRrsiRegistryStorePolicy(input) {
       });
       function recheckUnchecked() {
         // Invalid existing physical state needs no journal recovery or locks.
-        assertLayout(prepared, [true, true]);
+        if (runtime) runtime.read(request.operationId);
+        else assertLayout(prepared, [true, true]);
         if (!equal(markerProof(prepared, true), original.markers))
           hold("Registry marker identity changed after capture");
         const result = status(load(), request.operationId, {
@@ -1007,9 +1031,17 @@ export function createRrsiRegistryStorePolicy(input) {
           !equal(result.records, original.records)
         )
           hold("Registry component binding changed after capture");
-        // No origin or runtime attachment exists yet. Unknown content and
-        // even empty runtime containers remain HOLD, with no adoption/cleanup.
-        assertLayout(prepared, [true, true]);
+        // An explicit runtime attachment authenticates only its empty layout.
+        // Unknown content remains HOLD, with no adoption or cleanup.
+        if (runtime) {
+          const current = runtime.read(request.operationId);
+          if (
+            !equal(current.directories, runtimeOriginal.directories) ||
+            current.committedRecordDigest !==
+              runtimeOriginal.committedRecordDigest
+          )
+            hold("runtime attachment changed after component capture");
+        } else assertLayout(prepared, [true, true]);
         if (!equal(markerProof(prepared, true), original.markers))
           hold("Registry markers changed during uninitialized inventory read");
         if (!equal(result.currentHead, headData(methods.verify())))
@@ -1047,10 +1079,15 @@ export function createRrsiRegistryStorePolicy(input) {
             identity: original.markers[component].identity,
             marker: markerFor(prepared, component),
           }),
+          runtimeDirectories:
+            component === "release"
+              ? (runtimeOriginal?.directories ?? null)
+              : null,
           recheck,
           recheckForOpen() {
             try {
               assertPrivateParent(prepared.parent);
+              runtime?.verifyPrivateDirectories(request.operationId);
               return recheck();
             } catch (cause) {
               if (["ENOENT", "ENOTDIR"].includes(cause?.code))
@@ -1084,7 +1121,7 @@ export function createRrsiRegistryStorePolicy(input) {
           },
           assertMutationAllowed() {
             hold(
-              "Registry origin admission and runtime initialization are not implemented",
+              "Registry origin admission and business mutation are not implemented",
             );
           },
         }),
@@ -1145,6 +1182,49 @@ export function createRrsiRegistryStorePolicy(input) {
       matchesArtifactPorts: (value) => value === options.artifactPorts,
       matchesArtifactResolver: (value) => value === resolver,
       read: policy.read,
+      captureCommittedBoundary(operationId) {
+        rrsiId(operationId, "provision operation ID");
+        try {
+          const state = load();
+          const result = status(state, operationId, {
+            boundaryOnly: true,
+            verifyPermissions: false,
+          });
+          if (!result.freshPhysicalPairProvisioningCommitted)
+            hold("runtime requires committed store provisioning");
+          return Object.freeze({
+            snapshot: result,
+            recheck() {
+              // Reuse only this authenticated immutable history at its exact
+              // captured head. No caller-supplied state or newer head is used.
+              try {
+                return status(state, operationId, {
+                  boundaryOnly: true,
+                  verifyPermissions: false,
+                });
+              } catch (cause) {
+                if (["ENOENT", "ENOTDIR"].includes(cause?.code))
+                  hold("an authenticated store boundary is missing", cause);
+                throw cause;
+              }
+            },
+          });
+        } catch (cause) {
+          if (["ENOENT", "ENOTDIR"].includes(cause?.code))
+            hold("an authenticated store boundary is missing", cause);
+          throw cause;
+        }
+      },
+      maintain(operation) {
+        if (typeof operation !== "function" || isProxy(operation))
+          hold("runtime maintenance requires an original synchronous callback");
+        return locked((assertOwnership) => {
+          const result = operation(assertOwnership);
+          if (result && typeof result.then === "function")
+            hold("runtime maintenance cannot return a Promise");
+          return result;
+        });
+      },
     }),
   );
   return policy;

package/src/lib/evolution/rrsi-tenant-index-anchor-contracts.js

@@ -0,0 +1,223 @@
+/** Signed anchor declarations. A valid signature is never tenant authority. */
+import { createHash, createPublicKey, verify } from "node:crypto";
+import {
+  rrsiCanonical,
+  rrsiHash,
+  rrsiExact,
+  rrsiId,
+  rrsiDigest,
+  rrsiInteger,
+  rrsiEnvelope,
+  verifyRrsiEnvelope,
+  snapshotRrsiData,
+  rrsiFail,
+} from "./rrsi-data.js";
+
+export const RRSI_TENANT_INDEX_ANCHOR_SCHEMA =
+  "chainlesschain.rrsi-tenant-index-anchor/v1";
+export const RRSI_TENANT_INDEX_ANCHOR_SIGNATURE_SCHEMA =
+  "chainlesschain.rrsi-tenant-index-anchor-signature-check/v1";
+export const RRSI_TENANT_INDEX_ANCHOR_HOLD_CODE =
+  "CC_RRSI_TENANT_INDEX_ANCHOR_HOLD";
+const SIGNATURE_DOMAIN = "chainlesschain.rrsi-tenant-index-anchor-signature/v1";
+const INPUT_KEYS = [
+  "deploymentId",
+  "tenantId",
+  "routingScope",
+  "indexId",
+  "ledgerIdentity",
+  "artifactScope",
+  "storageGraphDigest",
+  "rootPublicKeyDigest",
+  "revision",
+  "previousAnchorDigest",
+  "checkpoint",
+  "restrictionHistory",
+];
+const sha = (bytes) =>
+  `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+const same = (a, b) => rrsiCanonical(a) === rrsiCanonical(b);
+function hold(message) {
+  rrsiFail(message, RRSI_TENANT_INDEX_ANCHOR_HOLD_CODE);
+}
+function ledgerId(value, label) {
+  if (
+    typeof value !== "string" ||
+    !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,159}$/u.test(value)
+  )
+    hold(`${label} is not a Ledger identifier`);
+}
+function journalIdentity(value) {
+  rrsiExact(
+    value,
+    ["ledgerId", "identityDigest", "epoch"],
+    "anchor journal identity",
+  );
+  ledgerId(value.ledgerId, "ledgerId");
+  ledgerId(value.epoch, "epoch");
+  rrsiDigest(value.identityDigest, "identity digest");
+}
+
+export function buildRrsiTenantIndexAnchor(input) {
+  const value = snapshotRrsiData(input);
+  rrsiExact(value, INPUT_KEYS, "tenant index anchor input");
+  rrsiId(value.deploymentId, "deployment ID");
+  rrsiId(value.tenantId, "tenant ID");
+  if (!["installation", "shared-tenant-authority"].includes(value.routingScope))
+    hold("anchor routing scope must be explicit");
+  const expectedIndex = `rrsi-text.${rrsiHash("chainlesschain.rrsi-observed-text-index/v1", value.tenantId).slice(7)}`;
+  if (value.indexId !== expectedIndex)
+    hold("anchor index ID must derive only from tenant");
+  journalIdentity(value.ledgerIdentity);
+  rrsiExact(
+    value.artifactScope,
+    ["artifactTenantId", "audience", "purpose"],
+    "anchor artifact scope",
+  );
+  for (const [name, entry] of Object.entries(value.artifactScope))
+    rrsiId(entry, name);
+  if (value.artifactScope.purpose !== "evolution-ledger")
+    hold("anchor requires original Ledger retention purpose");
+  rrsiDigest(value.storageGraphDigest, "storage graph digest");
+  rrsiDigest(value.rootPublicKeyDigest, "declared root public key digest");
+  rrsiInteger(value.revision, "anchor revision", 1, 2 ** 31 - 1);
+  if (value.revision === 1) {
+    if (value.previousAnchorDigest !== null)
+      hold("first anchor must not claim a predecessor");
+  } else rrsiDigest(value.previousAnchorDigest, "previous anchor digest");
+  rrsiExact(
+    value.checkpoint,
+    ["ledgerId", "identityDigest", "epoch", "sequence", "headDigest"],
+    "anchor checkpoint",
+  );
+  const checkpointIdentity = Object.fromEntries(
+    ["ledgerId", "identityDigest", "epoch"].map((name) => [
+      name,
+      value.checkpoint[name],
+    ]),
+  );
+  if (!same(checkpointIdentity, value.ledgerIdentity))
+    hold("anchor checkpoint belongs to another journal");
+  rrsiInteger(value.checkpoint.sequence, "checkpoint sequence", 0);
+  rrsiDigest(value.checkpoint.headDigest, "checkpoint head digest");
+  rrsiExact(
+    value.restrictionHistory,
+    ["recordCount", "tailRecordDigest", "restrictionsDigest"],
+    "anchor restriction history",
+  );
+  rrsiInteger(
+    value.restrictionHistory.recordCount,
+    "restriction record count",
+    0,
+    256,
+  );
+  if (value.restrictionHistory.recordCount > value.checkpoint.sequence)
+    hold("restriction count exceeds the declared journal checkpoint");
+  if (value.restrictionHistory.recordCount === 0) {
+    if (value.restrictionHistory.tailRecordDigest !== null)
+      hold("empty restriction history must have no tail");
+  } else
+    rrsiDigest(
+      value.restrictionHistory.tailRecordDigest,
+      "restriction tail digest",
+    );
+  rrsiDigest(
+    value.restrictionHistory.restrictionsDigest,
+    "restriction set digest",
+  );
+  return rrsiEnvelope(RRSI_TENANT_INDEX_ANCHOR_SCHEMA, "anchorDigest", value);
+}
+
+export function verifyRrsiTenantIndexAnchor(input) {
+  return verifyRrsiEnvelope(
+    input,
+    RRSI_TENANT_INDEX_ANCHOR_SCHEMA,
+    "anchorDigest",
+    INPUT_KEYS,
+    buildRrsiTenantIndexAnchor,
+  );
+}
+
+/** Exact domain-separated bytes for an external signer; no signer default. */
+export function serializeRrsiTenantIndexAnchorSignatureMessage(anchor) {
+  const checked = verifyRrsiTenantIndexAnchor(anchor);
+  return Buffer.from(`${SIGNATURE_DOMAIN}\0${rrsiCanonical(checked)}`, "utf8");
+}
+
+/**
+ * Mathematical verification against an explicitly supplied public key only.
+ * This deliberately creates no trusted-root brand, pin store or routing grant.
+ */
+export function verifyRrsiTenantIndexAnchorSignature(input) {
+  const value = snapshotRrsiData(input);
+  rrsiExact(
+    value,
+    ["anchor", "publicKeySpki", "signature"],
+    "anchor signature input",
+  );
+  const anchor = verifyRrsiTenantIndexAnchor(value.anchor);
+  if (
+    typeof value.publicKeySpki !== "string" ||
+    value.publicKeySpki.length > 128
+  )
+    hold("anchor public key must be bounded canonical Ed25519 SPKI");
+  const publicBytes = Buffer.from(value.publicKeySpki, "base64url");
+  if (
+    publicBytes.length !== 44 ||
+    publicBytes.toString("base64url") !== value.publicKeySpki
+  )
+    hold("anchor public key SPKI encoding differs");
+  let publicKey;
+  try {
+    publicKey = createPublicKey({
+      key: publicBytes,
+      format: "der",
+      type: "spki",
+    });
+  } catch {
+    hold("anchor public key SPKI cannot be parsed");
+  }
+  if (
+    publicKey.asymmetricKeyType !== "ed25519" ||
+    !publicKey.export({ format: "der", type: "spki" }).equals(publicBytes)
+  )
+    hold("anchor public key must be exact Ed25519 SPKI");
+  if (sha(publicBytes) !== anchor.rootPublicKeyDigest)
+    hold("anchor public key differs from the declared root digest");
+  if (typeof value.signature !== "string" || value.signature.length !== 86)
+    hold("anchor signature must be bounded canonical Ed25519 bytes");
+  const signatureBytes = Buffer.from(value.signature, "base64url");
+  if (
+    signatureBytes.length !== 64 ||
+    signatureBytes.toString("base64url") !== value.signature
+  )
+    hold("anchor signature encoding differs");
+  if (
+    !verify(
+      null,
+      serializeRrsiTenantIndexAnchorSignatureMessage(anchor),
+      publicKey,
+      signatureBytes,
+    )
+  )
+    hold("anchor signature was rejected");
+  return rrsiEnvelope(
+    RRSI_TENANT_INDEX_ANCHOR_SIGNATURE_SCHEMA,
+    "signatureCheckDigest",
+    {
+      anchorDigest: anchor.anchorDigest,
+      publicKeyDigest: anchor.rootPublicKeyDigest,
+      declaredDeploymentId: anchor.deploymentId,
+      declaredTenantId: anchor.tenantId,
+      declaredRoutingScope: anchor.routingScope,
+      signatureVerifiedRelativeToKey: true,
+      rootAuthorityVerified: false,
+      routingPinVerified: false,
+      historyTransferVerified: false,
+      tenantWideIndexAuthorityVerified: false,
+      generationProvenanceVerified: false,
+      grantsMutationOrPromotionAuthority: false,
+      decision: "HOLD",
+    },
+  );
+}

package/src/lib/evolution/rrsi-tenant-index-anchor-history.js

@@ -0,0 +1,157 @@
+/** Real local history prefixes. Installation/root/routing authority remains HOLD. */
+import { isProxy } from "node:util/types";
+import { captureRrsiObservedTextIndex } from "./rrsi-observed-text-index.js";
+import { verifyRrsiTenantIndexAnchorSignature } from "./rrsi-tenant-index-anchor-contracts.js";
+import { rrsiCanonical, rrsiEnvelope, snapshotRrsiData } from "./rrsi-data.js";
+
+export const RRSI_TENANT_INDEX_ANCHOR_HISTORY_HOLD_CODE =
+  "CC_RRSI_ANCHOR_HISTORY_HOLD";
+const same = (a, b) => rrsiCanonical(a) === rrsiCanonical(b);
+const FIXED_KEYS = [
+  "deploymentId",
+  "tenantId",
+  "routingScope",
+  "indexId",
+  "ledgerIdentity",
+  "artifactScope",
+  "storageGraphDigest",
+  "rootPublicKeyDigest",
+];
+function hold(message, cause) {
+  throw Object.assign(new Error(message, cause ? { cause } : undefined), {
+    code: RRSI_TENANT_INDEX_ANCHOR_HISTORY_HOLD_CODE,
+  });
+}
+function guard(operation) {
+  try {
+    return operation();
+  } catch (cause) {
+    if (cause?.code === RRSI_TENANT_INDEX_ANCHOR_HISTORY_HOLD_CODE) throw cause;
+    hold(
+      "anchor history could not authenticate the original local prefix",
+      cause,
+    );
+  }
+}
+function own(value, names) {
+  if (
+    !value ||
+    isProxy(value) ||
+    Object.getPrototypeOf(value) !== Object.prototype ||
+    Reflect.ownKeys(value).length !== names.length
+  )
+    hold("anchor history requires exact plain own fields");
+  return Object.fromEntries(
+    names.map((name) => {
+      const field = Object.getOwnPropertyDescriptor(value, name);
+      if (!field?.enumerable || !("value" in field))
+        hold("anchor history cannot use accessors");
+      return [name, field.value];
+    }),
+  );
+}
+
+export function inspectRrsiTenantIndexHistory(input) {
+  return guard(() => {
+    const request = own(input, ["observedTextIndex"]);
+    const captured = captureRrsiObservedTextIndex(request.observedTextIndex);
+    const history = captured.captureHistoryCheckpoints({ checkpoints: [] });
+    history.recheck();
+    return history.snapshot;
+  });
+}
+
+export function verifyRrsiTenantIndexAnchorHistory(input) {
+  return guard(() => {
+    const request = own(input, ["observedTextIndex", "previous", "current"]);
+    const index = captureRrsiObservedTextIndex(request.observedTextIndex);
+    const data = snapshotRrsiData({
+      previous: request.previous,
+      current: request.current,
+    });
+    verifyRrsiTenantIndexAnchorSignature(data.previous);
+    verifyRrsiTenantIndexAnchorSignature(data.current);
+    const previous = data.previous.anchor,
+      current = data.current.anchor;
+    if (
+      previous.routingScope !== "installation" ||
+      current.routingScope !== "installation"
+    )
+      hold("local history verification requires installation scope");
+    if (data.previous.publicKeySpki !== data.current.publicKeySpki)
+      hold("local anchor history cannot change root key");
+    for (const key of FIXED_KEYS)
+      if (!same(previous[key], current[key]))
+        hold(`local anchor history cannot change ${key}`);
+    if (current.revision === previous.revision) {
+      if (current.anchorDigest !== previous.anchorDigest)
+        hold("same revision has a different history anchor");
+    } else if (
+      current.revision !== previous.revision + 1 ||
+      current.previousAnchorDigest !== previous.anchorDigest
+    )
+      hold("local history anchor must be the exact declared successor");
+    for (const anchor of [previous, current]) {
+      if (
+        anchor.tenantId !== index.descriptor.tenantId ||
+        anchor.indexId !== index.descriptor.indexId ||
+        !same(anchor.ledgerIdentity, index.descriptor.ledgerIdentity) ||
+        !same(anchor.artifactScope, {
+          artifactTenantId: index.descriptor.artifactTenantId,
+          audience: index.descriptor.audience,
+          purpose: index.descriptor.purpose,
+        })
+      )
+        hold("history anchor differs from the original observed index scope");
+    }
+    if (previous.checkpoint.sequence > current.checkpoint.sequence)
+      hold("local history anchor cannot move its checkpoint backward");
+    const history = index.captureHistoryCheckpoints({
+      checkpoints: [previous.checkpoint, current.checkpoint],
+    });
+    const snapshot = history.snapshot;
+    if (!same(current.checkpoint, snapshot.current.checkpoint))
+      hold("current anchor is not the actual captured journal head");
+    for (const [anchor, prefix] of [
+      [previous, snapshot.prefixes[0]],
+      [current, snapshot.prefixes[1]],
+    ])
+      if (!same(anchor.restrictionHistory, prefix.restrictionHistory))
+        hold(
+          "anchor restriction declaration differs from retained prefix history",
+        );
+    history.recheck();
+    return rrsiEnvelope(
+      "chainlesschain.rrsi-tenant-index-anchor-history-check/v1",
+      "historyCheckDigest",
+      {
+        previousAnchorDigest: previous.anchorDigest,
+        currentAnchorDigest: current.anchorDigest,
+        indexDescriptorDigest: snapshot.indexDescriptorDigest,
+        localCompositionDigest: snapshot.localCompositionDigest,
+        artifactStoreDirectoryBoundaryDigest:
+          snapshot.artifactStoreDirectoryBoundaryDigest,
+        artifactStoreDirectoryBoundaryRechecked: true,
+        artifactStoreBoundaryScope: "root-and-files-directories",
+        previous: snapshot.prefixes[0],
+        current: snapshot.current,
+        signaturesVerifiedRelativeToExplicitKey: true,
+        localJournalPrefixVerified: true,
+        localRestrictionPrefixVerified: true,
+        localRetainedHistoryReplayed: true,
+        selectedContextOnly: true,
+        storageGraphDigestVerified: false,
+        rootAuthorityVerified: false,
+        installationBindingSignatureVerified: false,
+        routingPinVerified: false,
+        crossProcessRollbackProtectionVerified: false,
+        historyTransferVerified: false,
+        originCutoverAuthenticated: false,
+        tenantWideIndexAuthorityVerified: false,
+        generationProvenanceVerified: false,
+        grantsMutationOrPromotionAuthority: false,
+        decision: "HOLD",
+      },
+    );
+  });
+}

package/src/lib/evolution/skill-release-registry.js

@@ -2775,7 +2775,9 @@ export class SkillReleaseRegistry {
       // Authenticate the original port object before reading any caller method.
       this.#storeBinding.assertTransactionLedger(transactionLedger);
       this.#storeBinding.recheckForOpen();
-      this.#runtimeMode = "uninitialized";
+      this.#runtimeMode = this.#storeBinding.runtimeDirectories
+        ? "authenticated-empty-read-only"
+        : "uninitialized";
     } else assertOutsideRrsiRegistryNamespace(requestedBase);
     if (
       !transactionLedger ||
@@ -2832,7 +2834,8 @@ export class SkillReleaseRegistry {
         this.#rootIdentity = this.#boundaries.tenantRoot.identity;
         this.#markerPath = path.join(this.rootDir, TENANT_MARKER_FILE);
         this.#markerIdentity = this.#storeBinding.marker.identity;
-        this.#directories = deepFreeze({});
+        this.#directories =
+          this.#storeBinding.runtimeDirectories ?? deepFreeze({});
         this.#assertBoundary();
       } else {
         const base = this.#initializeDirectory(requestedBase, {
@@ -3972,7 +3975,11 @@ export class SkillReleaseRegistry {
 
   #readRelease(releaseDigest) {
     const expected = digest(releaseDigest, "releaseDigest");
-    if (this.#runtimeMode === "uninitialized") {
+    if (
+      ["uninitialized", "authenticated-empty-read-only"].includes(
+        this.#runtimeMode,
+      )
+    ) {
       this.#assertBoundary();
       throw failure("SKILL_RELEASE_NOT_FOUND", "release was not found");
     }
@@ -4011,7 +4018,11 @@ export class SkillReleaseRegistry {
 
   #readStateRaw(name) {
     const normalizedName = skillName(name);
-    if (this.#runtimeMode === "uninitialized") {
+    if (
+      ["uninitialized", "authenticated-empty-read-only"].includes(
+        this.#runtimeMode,
+      )
+    ) {
       this.#assertBoundary();
       return initialState(normalizedName, this.tenantId);
     }
@@ -4190,7 +4201,11 @@ export class SkillReleaseRegistry {
 
   #readInventory() {
     this.#assertBoundary();
-    if (this.#runtimeMode === "uninitialized")
+    if (
+      ["uninitialized", "authenticated-empty-read-only"].includes(
+        this.#runtimeMode,
+      )
+    )
       return deepFreeze({ active: [], releases: [] });
     const releasePattern = /^[a-f0-9]{64}\.json$/u;
     const statePattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*\.json$/u;