release(stage): Run 95 storage and graph conformance RC

package.json

@@ -65,7 +65,7 @@
     "storage:compact": "node scripts/track-b/run-command-test.mjs TB06-CMD-04",
     "test:track-b-authorization": "node scripts/track-b/run-command-test.mjs TB07-CMD-03",
     "test:rust": "cargo test --manifest-path role-model-router/rust/Cargo.toml --workspace",
-    "smoke": "corepack pnpm --filter @role-model-router/gateway-smoke exec tsx src/index.ts",
+    "smoke": "corepack pnpm --filter @role-model-router/gateway-smoke... run build && corepack pnpm --filter @role-model-router/gateway-smoke exec tsx src/index.ts",
     "ci:check": "corepack pnpm run lint && corepack pnpm run schemas:validate && corepack pnpm run build && corepack pnpm run test && corepack pnpm run runtime:test-critical && corepack pnpm run test:rust && corepack pnpm run smoke"
   },
   "devDependencies": {

packages/extension-host/index.mjs

@@ -9,6 +9,33 @@ import {
   verifySignedBundle,
 } from "../extension-sdk/index.mjs";
 
+/**
+ * Reject malformed graph-contract metadata at the host boundary.  Extension
+ * packages must not be able to treat an incomplete registry as a usable
+ * contract, even when they are loaded independently from the Track-B bundle.
+ */
+export function validateGraphRegistry(registry) {
+  if (!registry || registry.version !== 1 || !Array.isArray(registry.kinds)) {
+    throw new Error("invalid graph registry");
+  }
+  const seen = new Set();
+  const kinds = registry.kinds.map((kind) => {
+    if (
+      !kind?.id ||
+      !Number.isInteger(kind.version) ||
+      !kind.category ||
+      !Array.isArray(kind.fields)
+    ) {
+      throw new Error("incomplete graph registry entry");
+    }
+    const key = `${kind.id}@${kind.version}`;
+    if (seen.has(key)) throw new Error(`duplicate graph registry entry: ${key}`);
+    seen.add(key);
+    return Object.freeze({ ...kind, fields: Object.freeze([...kind.fields]) });
+  });
+  return Object.freeze({ version: registry.version, kinds: Object.freeze(kinds) });
+}
+
 const runtimePath = fileURLToPath(new URL("./worker-runtime.mjs", import.meta.url));
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const normalizeModuleUrl = (value) =>

role-model-router/apps/runtime-host-bridge/package.json

@@ -41,8 +41,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
-    "test:critical": "vitest run test/account-repair.test.ts test/unified-runtime-config.test.ts test/provider-overlap-metadata.test.ts test/benchmark-summary.test.ts test/validate-observability.test.ts test/validate-ui.test.ts",
-    "test:router": "vitest run test/controller-routing-contract.test.ts test/runtime-routing-model.test.ts test/request-capability-inference.test.ts test/alias-capability-routing.test.ts test/restart-rehydration.test.ts test/endpoint-rehydration.test.ts test/model-capability-resolver.test.ts test/session-readiness-api.test.ts test/downstream-openai-discovery.test.ts test/validate-restart-rehydration.test.ts test/validate-observability.test.ts",
+    "test:critical": "corepack pnpm --filter @role-model-router/profile-aggregator build && vitest run test/account-repair.test.ts test/unified-runtime-config.test.ts test/provider-overlap-metadata.test.ts test/benchmark-summary.test.ts test/validate-observability.test.ts test/validate-ui.test.ts",
+    "test:router": "corepack pnpm --filter @role-model-router/profile-aggregator build && vitest run test/controller-routing-contract.test.ts test/runtime-routing-model.test.ts test/request-capability-inference.test.ts test/alias-capability-routing.test.ts test/restart-rehydration.test.ts test/endpoint-rehydration.test.ts test/model-capability-resolver.test.ts test/session-readiness-api.test.ts test/downstream-openai-discovery.test.ts test/validate-restart-rehydration.test.ts test/validate-observability.test.ts",
     "package-sea": "tsx src/package-sea.ts",
     "validate-packaging": "corepack pnpm build && tsx src/validate-packaging.ts"
   }

role-model-router/apps/runtime-host-bridge/src/cli.ts

@@ -1007,6 +1007,13 @@ export async function main(): Promise<void> {
       ),
     });
     let postObservationOperations: ReturnType<typeof createTrackBOperations> | null = null;
+    // `createBackend` initializes this after the packaged runtime is selected.
+    // Keep that initialization boundary opaque to TypeScript's local control-flow
+    // analysis: the public-only build does not inline the private operations
+    // adapter, but startup still needs to retry a durable outbox when it is
+    // available at runtime.
+    const currentPostObservationOperations = (): ReturnType<typeof createTrackBOperations> | null =>
+      postObservationOperations;
     const drainPostObservationOutbox = async (
       runtime: Awaited<ReturnType<typeof createProductionExtensionRuntime>>,
     ) =>
@@ -1320,6 +1327,9 @@ export async function main(): Promise<void> {
           qaStartupReceipts.set(extension.descriptor.id, { ...receipt, requestId });
         }
         await drainPostObservationOutbox(extensionRuntime);
+        // A prior cloud outage must not require an unrelated new provider request
+        // before its already-authorized, durable aggregate is retried.
+        await currentPostObservationOperations()?.retryContributionAggregates();
       } catch (error) {
         console.error("[role-model] extension host failed after core runtime was ready:", error);
       }

role-model-router/apps/runtime-host-bridge/src/index.ts

@@ -25748,6 +25748,15 @@ export async function createRuntimeBridgeBackend(
       const contribution = (await operations.readContributionState()) as {
         readonly recommendationTier?: string;
       };
+      const recommendationTier = contribution.recommendationTier ?? "advanced";
+      const persistedCursor = await operations.readRecommendationCursor();
+      const activeCursor =
+        persistedCursor?.channel === channel &&
+        persistedCursor.scopeId === recommendationScopeId &&
+        persistedCursor.recommendationTier === recommendationTier
+          ? persistedCursor
+          : null;
+      const legacyRecommendationRevision = await operations.readRecommendationRevision();
       let run88CorrelationHeader: Record<string, string> = {};
       if (runtimeChannel === "stage") {
         const identity = options.run88StageIdentity;
@@ -25783,9 +25792,15 @@ export async function createRuntimeBridgeBackend(
           channel,
           runtimeChannel: channel,
           releaseTrack: "stable",
-          recommendationTier: contribution.recommendationTier ?? "advanced",
+          recommendationTier,
           clientSchemaVersions: ["1.0.0"],
-          activeChannelSequence: 0,
+          activeChannelSequence: activeCursor?.channelSequence ?? 0,
+          ...(activeCursor
+            ? {
+                activeSnapshotId: activeCursor.snapshotId,
+                activeManifestHash: activeCursor.manifestHash,
+              }
+            : {}),
           identityKind: "anonymous_public",
           scopeId: recommendationScopeId,
           boundaryProtocolVersion: "1.1",
@@ -25797,10 +25812,30 @@ export async function createRuntimeBridgeBackend(
         return operations.listRecommendations();
       if (
         resolved.status !== "available" ||
+        !Number.isSafeInteger(Number(resolved.channelSequence)) ||
+        typeof resolved.snapshotId !== "string" ||
         typeof resolved.bundleUri !== "string" ||
         typeof resolved.manifestHash !== "string"
       )
         throw new Error("recommendation resolve response did not include an available bundle");
+      const recommendationCursor = {
+        channel,
+        scopeId: recommendationScopeId,
+        recommendationTier,
+        channelSequence: Number(resolved.channelSequence),
+        snapshotId: resolved.snapshotId,
+        manifestHash: resolved.manifestHash,
+      };
+      if (!activeCursor && recommendationCursor.channelSequence === legacyRecommendationRevision) {
+        const existing = await operations.listRecommendations();
+        if (
+          existing.length > 0 &&
+          existing.every((row) => row.provenance === `cloud:${recommendationCursor.manifestHash}`)
+        ) {
+          await operations.rememberRecommendationCursor(recommendationCursor);
+          return existing;
+        }
+      }
       const manifestUrl = new URL(resolved.bundleUri);
       const manifestResponse = await fetch(manifestUrl);
       if (!manifestResponse.ok)
@@ -25840,6 +25875,7 @@ export async function createRuntimeBridgeBackend(
           signature,
         },
         verificationKey,
+        recommendationCursor,
       );
     },
     async applyRecommendation(body: Record<string, unknown>): Promise<unknown> {

role-model-router/apps/runtime-host-bridge/src/remote-health-probe.test.ts

@@ -45,6 +45,64 @@ describe("remote-health-probe", () => {
     });
   });
 
+  it("coalesces one model-list request across effort siblings on the same provider account", async () => {
+    let requestCount = 0;
+    const result = await probeRemoteEndpoints({
+      litellmHealthy: true,
+      targets: [
+        {
+          endpointId: "deepseek.personal.primary.global.deepseek-v4-flash",
+          providerAccountId: "deepseek.personal.primary",
+          modelId: "deepseek/deepseek-v4-flash",
+          apiBase: "https://api.deepseek.com/v1",
+          servingSource: "remote-service",
+        },
+        {
+          endpointId: "deepseek.personal.primary.global.deepseek-v4-flash-max",
+          providerAccountId: "deepseek.personal.primary",
+          modelId: "deepseek/deepseek-v4-flash",
+          apiBase: "https://api.deepseek.com/v1",
+          servingSource: "remote-service",
+        },
+        {
+          endpointId: "deepseek.personal.primary.global.deepseek-v4-pro-max",
+          providerAccountId: "deepseek.personal.primary",
+          modelId: "deepseek/deepseek-v4-pro",
+          apiBase: "https://api.deepseek.com/v1",
+          servingSource: "remote-service",
+        },
+      ],
+      resolveAuthorization: async () => "deepseek-live-key",
+      networkFetcher: async () => {
+        requestCount += 1;
+        return new Response(
+          JSON.stringify({ data: [{ id: "deepseek-v4-flash" }, { id: "deepseek-v4-pro" }] }),
+          { status: 200, headers: { "content-type": "application/json" } },
+        );
+      },
+    });
+
+    expect(requestCount).toBe(1);
+    expect(result).toMatchObject({ probed: 3, healthy: 3, degraded: 0 });
+    expect(result.results).toMatchObject([
+      {
+        endpointId: "deepseek.personal.primary.global.deepseek-v4-flash",
+        modelId: "deepseek/deepseek-v4-flash",
+        reason: "healthy",
+      },
+      {
+        endpointId: "deepseek.personal.primary.global.deepseek-v4-flash-max",
+        modelId: "deepseek/deepseek-v4-flash",
+        reason: "healthy",
+      },
+      {
+        endpointId: "deepseek.personal.primary.global.deepseek-v4-pro-max",
+        modelId: "deepseek/deepseek-v4-pro",
+        reason: "healthy",
+      },
+    ]);
+  });
+
   it("maps auth failures to degraded health with auth reason", async () => {
     const result = await probeRemoteEndpoints({
       litellmHealthy: true,

role-model-router/apps/runtime-host-bridge/src/remote-health-probe.ts

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+
 import { resolveOpenAIProviderUpstreamModelId } from "@role-model-router/provider-openai";
 
 export type RemoteHealthProbeReason =
@@ -297,9 +299,43 @@ async function probeTarget(
 export async function probeRemoteEndpoints(
   context: RemoteHealthProbeContext,
 ): Promise<RemoteHealthProbeSummary> {
+  const modelListRequests = new Map<string, Promise<Response>>();
+  const sharedNetworkFetcher: typeof fetch = async (input, init) => {
+    const url =
+      typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = (
+      init?.method ?? (input instanceof Request ? input.method : "GET")
+    ).toUpperCase();
+    const headers = new Headers(
+      init?.headers ?? (input instanceof Request ? input.headers : undefined),
+    );
+    const authorizationSha256 = createHash("sha256")
+      .update(headers.get("authorization") ?? "")
+      .digest("hex");
+    headers.delete("authorization");
+    const requestKey = JSON.stringify([
+      method,
+      url,
+      authorizationSha256,
+      [...headers.entries()].sort(([left], [right]) => left.localeCompare(right)),
+    ]);
+
+    let responsePromise = modelListRequests.get(requestKey);
+    if (!responsePromise) {
+      responsePromise = context.networkFetcher(input, init);
+      modelListRequests.set(requestKey, responsePromise);
+    }
+    return (await responsePromise).clone();
+  };
+
   const results: RemoteHealthProbeResult[] = [];
   for (const target of context.targets) {
-    results.push(await probeTarget(target, context));
+    results.push(
+      await probeTarget(target, {
+        ...context,
+        networkFetcher: sharedNetworkFetcher,
+      }),
+    );
   }
 
   const healthy = results.filter((result) => result.reason === "healthy").length;