@velum-labs/routekit-daemon 1.0.25 → 1.1.0

package/dist/daemon-generations.d.ts

@@ -5,7 +5,7 @@ import { type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
 import { Effect } from "effect";
 import type { CliproxySidecar } from "./cliproxy-sidecar.js";
 import type { RevisionState } from "./daemon-state.js";
-import { type RunningGatewayGeneration } from "./gateway-generation.js";
+import { type RunningGatewayGeneration } from "./services/gateway-generation/service.js";
 export type DaemonGenerationStage = "prepare" | "validate" | "persist" | "commit" | "retire";
 export type DaemonGenerationMutation = {
     write: boolean;

package/dist/daemon-generations.js

@@ -4,7 +4,7 @@ import { RouteKitFailure, toRouteKitFailure } from "@velum-labs/routekit-runtime
 import { writeFileAtomic } from "@velum-labs/routekit-runtime/filesystem";
 import { Effect } from "effect";
 import { writeDaemonRevisions } from "./daemon-state.js";
-import { startGatewayGenerationEffect } from "./gateway-generation.js";
+import { startGatewayGenerationEffect } from "./services/gateway-generation/service.js";
 const tryPromise = (run) => Effect.tryPromise({
     try: async () => await run(),
     catch: toRouteKitFailure

package/dist/daemon-lifecycle.d.ts

@@ -5,7 +5,7 @@ import type { RunningControlServer } from "@velum-labs/routekit-runtime/control"
 import { type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
 import { Effect, type ManagedRuntime } from "effect";
 import type { DaemonRuntimeState } from "./daemon-runtime-state.js";
-import type { RunningGatewayGeneration } from "./gateway-generation.js";
+import type { RunningGatewayGeneration } from "./services/gateway-generation/service.js";
 import type { DaemonTelemetry, GatewayTelemetryAggregator } from "./telemetry.js";
 type Supervisor = "systemd" | "launchd" | "detached" | "unknown";
 export type DaemonLifecycleOptions = {

package/dist/effect-api.d.ts

@@ -18,8 +18,8 @@ export { DaemonState } from "./daemon-state-context.js";
 export type { DataPlaneValue } from "./data-plane-context.js";
 export { DataPlane } from "./data-plane-context.js";
 export { EvalSessions } from "./services/eval-session/service.js";
-export type { GatewayGenerationOptions, GatewayGenerationRedeemResetOptions, GatewayGenerationRedeemResetResponse, RunningGatewayGeneration } from "./gateway-generation.js";
-export { startGatewayGenerationEffect } from "./gateway-generation.js";
+export type { GatewayGenerationOptions, GatewayGenerationRedeemResetOptions, GatewayGenerationRedeemResetResponse, RunningGatewayGeneration } from "./services/gateway-generation/service.js";
+export { startGatewayGenerationEffect } from "./services/gateway-generation/service.js";
 export type { DaemonGenerationHooks } from "./services/generations/service.js";
 export { Generations } from "./services/generations/service.js";
 export type { LeaderboardValue } from "./leaderboard-context.js";

package/dist/effect-api.js

@@ -10,7 +10,7 @@ export { DaemonPolicy } from "./daemon-policy-context.js";
 export { DaemonState } from "./daemon-state-context.js";
 export { DataPlane } from "./data-plane-context.js";
 export { EvalSessions } from "./services/eval-session/service.js";
-export { startGatewayGenerationEffect } from "./gateway-generation.js";
+export { startGatewayGenerationEffect } from "./services/gateway-generation/service.js";
 export { Generations } from "./services/generations/service.js";
 export { Leaderboard } from "./leaderboard-context.js";
 export { Sidecar } from "./sidecar-context.js";

package/dist/eval-routing-policy.d.ts

@@ -1,8 +1,5 @@
 import { type CompositionalRoutingPolicyReader } from "@velum-labs/routekit-gateway";
 /** Daemon-owned location for the compact policy artifact consumed online. */
 export declare function evalRoutingSnapshotDirectory(routekitHome: string): string;
-/**
- * Read the compositional snapshot without restarting router generations. A
- * corrupt current file falls back to the last known-good publication.
- */
+/** Read the authoritative routing activation without restarting router generations. */
 export declare function makeCompositionalRoutingPolicyReader(routekitHome: string): CompositionalRoutingPolicyReader;

package/dist/eval-routing-policy.js

@@ -6,18 +6,15 @@ import { Effect } from "effect";
 export function evalRoutingSnapshotDirectory(routekitHome) {
     return join(routekitHome, "eval");
 }
-/**
- * Read the compositional snapshot without restarting router generations. A
- * corrupt current file falls back to the last known-good publication.
- */
+/** Read the authoritative routing activation without restarting router generations. */
 export function makeCompositionalRoutingPolicyReader(routekitHome) {
     const snapshots = makeRoutingActivationStore(evalRoutingSnapshotDirectory(routekitHome));
     return {
-        getSnapshot: () => snapshots.read().pipe(Effect.catch((currentCause) => snapshots
+        getActivation: () => snapshots.readDeployment().pipe(Effect.map((deployment) => deployment.authoritative?.activation), Effect.catch((currentCause) => snapshots
             .readPrevious()
             .pipe(Effect.flatMap((previous) => previous === undefined ? Effect.fail(currentCause) : Effect.succeed(previous)))), Effect.mapError((cause) => new RoutingPolicyReadError({
             profileId: "*",
-            message: "failed to read the compositional routing snapshot",
+            message: "failed to read the authoritative routing activation",
             cause
         })))
     };

package/dist/eval-routing-service.d.ts

@@ -1,5 +1,5 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
-type EvalRoutingHandlers = Pick<EffectRouteKitControlHandlers, "evalRouting.status" | "evalRouting.activate">;
+type EvalRoutingHandlers = Pick<EffectRouteKitControlHandlers, "evalRouting.status" | "evalRouting.activate" | "evalRouting.installAuthoritative" | "evalRouting.rollbackAuthoritative">;
 /** Owns target-local compositional routing status and atomic activation. */
 export declare class EvalRoutingApplicationService {
     handlers(): EvalRoutingHandlers;

package/dist/eval-routing-service.js

@@ -1,16 +1,26 @@
 import { DEFAULT_CLASSIFIER_MODEL } from "@velum-labs/routekit-config";
-import { assertPublishedRoutingActivation, PublishedRoutingActivation } from "@velum-labs/routekit-eval-contracts";
-import { makeRoutingActivationStore, RoutingActivationConflictError } from "@velum-labs/routekit-eval-store/effect";
+import { AnyPublishedRoutingActivation, assertPublishedRoutingActivation, assertPublishedRoutingActivationV3, PublishedRoutingActivation } from "@velum-labs/routekit-eval-contracts";
+import { makeRoutingActivationStore, RoutingActivationConflictError, RoutingDeploymentConflictError } from "@velum-labs/routekit-eval-store/effect";
 import { ControlError } from "@velum-labs/routekit-runtime/control";
 import { Effect, Schema } from "effect";
-import { ActiveGateway } from "./services/active-gateway/service.js";
 import { DaemonEnv } from "./daemon-env-context.js";
 import { DaemonState } from "./daemon-state-context.js";
 import { evalRoutingSnapshotDirectory } from "./eval-routing-policy.js";
+import { ActiveGateway } from "./services/active-gateway/service.js";
 function detailOf(cause) {
     return cause instanceof Error ? cause.message : String(cause);
 }
-function decodeActivation(value) {
+function identity(revision) {
+    return revision === null
+        ? null
+        : {
+            version: revision.activation.version,
+            activationRevisionDigest: revision.activationRevisionDigest,
+            basisDigest: revision.activation.basisDigest,
+            evidenceDigest: revision.activation.evidenceDigest
+        };
+}
+function decodeLegacyActivation(value) {
     return Schema.decodeUnknownEffect(PublishedRoutingActivation)(value).pipe(Effect.flatMap((activation) => Effect.try({
         try: () => {
             assertPublishedRoutingActivation(activation);
@@ -28,61 +38,123 @@ function decodeActivation(value) {
             message: `routing activation is invalid: ${detailOf(cause)}`
         })));
 }
+function decodeAnyActivation(value) {
+    return Schema.decodeUnknownEffect(AnyPublishedRoutingActivation)(value).pipe(Effect.flatMap((activation) => Effect.try({
+        try: () => {
+            if (activation.version === 2)
+                assertPublishedRoutingActivation(activation);
+            else
+                assertPublishedRoutingActivationV3(activation);
+            return activation;
+        },
+        catch: (cause) => new ControlError({
+            code: "bad_request",
+            message: `routing activation is invalid: ${detailOf(cause)}`
+        })
+    })), Effect.mapError((cause) => cause instanceof ControlError
+        ? cause
+        : new ControlError({
+            code: "bad_request",
+            message: `routing activation is invalid: ${detailOf(cause)}`
+        })));
+}
+const mapStoreError = (operation) => (cause) => cause instanceof RoutingActivationConflictError ||
+    cause instanceof RoutingDeploymentConflictError
+    ? new ControlError({ code: "conflict", message: cause.message })
+    : new ControlError({
+        code: "internal",
+        message: `failed to ${operation}: ${detailOf(cause)}`
+    });
+function validateRuntimeCompatibility(activation) {
+    return Effect.gen(function* () {
+        const state = yield* DaemonState;
+        const gateway = yield* ActiveGateway;
+        const router = gateway.router();
+        if (router === undefined)
+            return yield* Effect.fail(new ControlError({
+                code: "unavailable",
+                message: "routing activation requires a running data gateway"
+            }));
+        const classifierModel = activation.version === 2 ? activation.classifierModel : activation.classifier.model;
+        if (activation.version === 2) {
+            const configuredClassifier = state.config.classifierModel ?? DEFAULT_CLASSIFIER_MODEL;
+            if (classifierModel !== configuredClassifier)
+                return yield* Effect.fail(new ControlError({
+                    code: "unavailable",
+                    message: `routing activation classifier ${JSON.stringify(classifierModel)} does not match the running classifier ${JSON.stringify(configuredClassifier)}`
+                }));
+        }
+        else {
+            if (state.config.defaultModel !== undefined &&
+                state.config.defaultModel !== activation.defaultModel)
+                return yield* Effect.fail(new ControlError({
+                    code: "unavailable",
+                    message: "the running default model does not match the V3 activation-pinned default"
+                }));
+        }
+        const served = new Set(router.modelCatalog().map((model) => model.id));
+        const required = [
+            classifierModel,
+            ...(activation.version === 3 ? [activation.defaultModel] : []),
+            ...activation.candidateModels
+        ];
+        const unavailable = required.filter((model, index, models) => !served.has(model) && models.indexOf(model) === index);
+        if (unavailable.length > 0)
+            return yield* Effect.fail(new ControlError({
+                code: "unavailable",
+                message: `routing activation references models not served by this target: ${unavailable.map((model) => JSON.stringify(model)).join(", ")}`
+            }));
+    });
+}
 /** Owns target-local compositional routing status and atomic activation. */
 export class EvalRoutingApplicationService {
     handlers() {
         return {
             "evalRouting.status": () => Effect.gen(function* () {
                 const env = yield* DaemonEnv;
-                const store = makeRoutingActivationStore(evalRoutingSnapshotDirectory(env.home));
-                const activation = yield* store.read().pipe(Effect.mapError((cause) => new ControlError({
-                    code: "internal",
-                    message: `failed to read routing activation: ${detailOf(cause)}`
-                })));
-                return { activation: activation ?? null };
+                const deployment = yield* makeRoutingActivationStore(evalRoutingSnapshotDirectory(env.home))
+                    .readDeployment()
+                    .pipe(Effect.mapError(mapStoreError("read routing deployment")));
+                return {
+                    stateRevision: deployment.stateRevision,
+                    authoritative: identity(deployment.authoritative),
+                    previousAuthoritative: identity(deployment.previousAuthoritative)
+                };
             }),
             "evalRouting.activate": (params) => Effect.gen(function* () {
                 const env = yield* DaemonEnv;
-                const state = yield* DaemonState;
-                const gateway = yield* ActiveGateway;
-                const publication = yield* decodeActivation(params.activation);
-                const router = gateway.router();
-                if (router === undefined) {
-                    return yield* Effect.fail(new ControlError({
-                        code: "unavailable",
-                        message: "routing activation requires a running data gateway"
-                    }));
-                }
-                const configuredClassifier = state.config.classifierModel ?? DEFAULT_CLASSIFIER_MODEL;
-                if (publication.classifierModel !== configuredClassifier) {
-                    return yield* Effect.fail(new ControlError({
-                        code: "unavailable",
-                        message: `routing activation classifier ${JSON.stringify(publication.classifierModel)} does not match the running classifier ${JSON.stringify(configuredClassifier)}`
-                    }));
-                }
-                const served = new Set(router.modelCatalog().map((model) => model.id));
-                const unavailableModels = [
-                    publication.classifierModel,
-                    ...publication.candidateModels
-                ].filter((model, index, models) => !served.has(model) && models.indexOf(model) === index);
-                if (unavailableModels.length > 0) {
-                    return yield* Effect.fail(new ControlError({
-                        code: "unavailable",
-                        message: `routing activation references models not served by this target: ${unavailableModels
-                            .map((model) => JSON.stringify(model))
-                            .join(", ")}`
-                    }));
-                }
-                const store = makeRoutingActivationStore(evalRoutingSnapshotDirectory(env.home));
-                const activation = yield* store
+                const publication = yield* decodeLegacyActivation(params.activation);
+                yield* validateRuntimeCompatibility(params.activation);
+                const activation = yield* makeRoutingActivationStore(evalRoutingSnapshotDirectory(env.home))
                     .publishIfCurrent(publication, params.expectedEvidenceDigest ?? undefined)
-                    .pipe(Effect.mapError((cause) => cause instanceof RoutingActivationConflictError
-                    ? new ControlError({ code: "conflict", message: cause.message })
-                    : new ControlError({
-                        code: "internal",
-                        message: `failed to activate routing policy: ${detailOf(cause)}`
-                    })));
+                    .pipe(Effect.mapError(mapStoreError("activate routing policy")));
                 return { activated: true, activation };
+            }),
+            "evalRouting.installAuthoritative": (params) => Effect.gen(function* () {
+                const env = yield* DaemonEnv;
+                const activation = yield* decodeAnyActivation(params.activation);
+                yield* validateRuntimeCompatibility(activation);
+                const deployment = yield* makeRoutingActivationStore(evalRoutingSnapshotDirectory(env.home))
+                    .installAuthoritative(activation, params.expectedAuthoritativeRevisionDigest, params.expectedPreviousAuthoritativeRevisionDigest)
+                    .pipe(Effect.mapError(mapStoreError("install authoritative routing policy")));
+                return {
+                    installed: true,
+                    stateRevision: deployment.stateRevision,
+                    authoritative: identity(deployment.authoritative),
+                    previousAuthoritative: identity(deployment.previousAuthoritative)
+                };
+            }),
+            "evalRouting.rollbackAuthoritative": (params) => Effect.gen(function* () {
+                const env = yield* DaemonEnv;
+                const deployment = yield* makeRoutingActivationStore(evalRoutingSnapshotDirectory(env.home))
+                    .rollbackAuthoritative(params.expectedAuthoritativeRevisionDigest, params.expectedPreviousAuthoritativeRevisionDigest)
+                    .pipe(Effect.mapError(mapStoreError("roll back authoritative routing policy")));
+                return {
+                    rolledBack: true,
+                    stateRevision: deployment.stateRevision,
+                    authoritative: identity(deployment.authoritative),
+                    previousAuthoritative: identity(deployment.previousAuthoritative)
+                };
             })
         };
     }

package/dist/services/active-gateway/service.d.ts

@@ -1,7 +1,7 @@
 import type { SwitchingGatewayProxy } from "@velum-labs/routekit-gateway";
 import type { RunningControlServer } from "@velum-labs/routekit-runtime/control";
 import { Context, Layer, Ref } from "effect";
-import type { RunningGatewayGeneration } from "../../gateway-generation.js";
+import type { RunningGatewayGeneration } from "../gateway-generation/service.js";
 export type ActiveGatewayState = Readonly<{
     router?: RunningGatewayGeneration;
     proxy?: SwitchingGatewayProxy;

package/dist/{gateway-generation.d.ts → services/gateway-generation/service.d.ts}

@@ -1,10 +1,10 @@
 import type { RedeemResetCreditResult, ResetCreditSnapshot, SubscriptionAccountSetSnapshot, SubscriptionUsageResponse } from "@velum-labs/routekit-accounts";
 import type { AccountActivityService, AccountAuthService } from "@velum-labs/routekit-accounts/effect";
 import { type ProviderId, type RouterConfig } from "@velum-labs/routekit-config";
-import type { CatalogModelInfo, CompositionalRoutingObservation, CompositionalRoutingPolicyReader, Gateway, ProvenanceSink, ProviderSource, RequestDecomposerService } from "@velum-labs/routekit-gateway";
-import { RoutingBackend } from "@velum-labs/routekit-gateway";
+import type { CatalogModelInfo, CompositionalRoutingObservation, CompositionalRoutingPolicyReader, Gateway, ProvenanceSink, ProviderSource } from "@velum-labs/routekit-gateway";
+import { RequestDecomposer, RoutingBackend } from "@velum-labs/routekit-gateway";
 import { type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
-import { Effect } from "effect";
+import { Effect, Layer } from "effect";
 export type GatewayGenerationOptions = {
     config: RouterConfig;
     host?: string;
@@ -15,8 +15,8 @@ export type GatewayGenerationOptions = {
     provenance?: ProvenanceSink;
     /** Published model-by-dimension evidence used by automatic routing. */
     compositionalPolicyReader?: CompositionalRoutingPolicyReader;
-    /** Override the default small-LM semantic dimension classifier. */
-    requestDecomposer?: RequestDecomposerService;
+    /** Override the default semantic classifier Layer. */
+    requestDecomposerLayer?: Layer.Layer<RequestDecomposer>;
     /** Receives sanitized automatic-routing decisions and failures. */
     onCompositionalRoutingObservation?(observation: CompositionalRoutingObservation): void;
     /**

package/dist/{gateway-generation.js → services/gateway-generation/service.js}

@@ -1,6 +1,6 @@
 import { CLIPROXY_API_KEY_ENV, cliproxyApiKey, closeSubscriptionAccountSets, collectSubscriptionUsage, defaultSubscriptionAccountDirectory, defaultSubscriptionCredentialPath, openSubscriptionAccountSets, SubscriptionAccountBackend, snapshotsToUsage, subscriptionRelaysFromAccountSets } from "@velum-labs/routekit-accounts";
 import { DEFAULT_CLASSIFIER_MODEL, resolveCompositionalRoutingConfig } from "@velum-labs/routekit-config";
-import { AnthropicBackend, ClassificationError, CodexResponsesBackend, invokeObservedModelCall, makeLanguageModelDimensionClassifier, RoutingBackend, routingModelAvailability } from "@velum-labs/routekit-gateway";
+import { AnthropicBackend, CodexResponsesBackend, invokeObservedModelCall, lunaDirectRequestDecomposerLayer, RequestDecomposer, RoutingBackend, routingModelAvailability } from "@velum-labs/routekit-gateway";
 import { startGatewayEffect } from "@velum-labs/routekit-gateway/effect";
 import { RouteKitFailure, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
 import { assertAuthenticatedBind } from "@velum-labs/routekit-runtime/network";
@@ -130,29 +130,38 @@ const acquireGatewayGeneration = Effect.fn("GatewayGeneration.acquire")(function
     yield* addOwnedFinalizer(scope, platform, closeErrors, backend.close());
     const configuredClassifierModel = options.config.classifierModel;
     const classifierModel = configuredClassifierModel ?? DEFAULT_CLASSIFIER_MODEL;
-    const classifierComplete = (endpointId) => (body) => invokeObservedModelCall(options.provenance, {
-        dialect: "openai-chat",
-        body,
-        defaultModel: backend.defaultModel,
-        requestedModel: classifierModel,
-        endpointId,
-        invoke: (callId, signal, onAttribution) => backend.chat(body, signal, {
-            modelCallId: callId,
-            responseMode: "buffered",
-            onAttribution
-        })
-    }).pipe(Effect.provide(platform));
-    const unavailableClassifier = () => Effect.fail(new ClassificationError({
-        message: `classifier model ${JSON.stringify(configuredClassifierModel ?? DEFAULT_CLASSIFIER_MODEL)} is unavailable; configure classifierModel to a served model`
-    }));
-    const compositionalConfig = resolveCompositionalRoutingConfig(options.config);
-    const requestDecomposer = options.requestDecomposer ??
-        (backend.ports.models.serves(classifierModel)
-            ? makeLanguageModelDimensionClassifier({
-                model: classifierModel,
-                complete: classifierComplete("dimension-request-classifier")
+    const classifierComplete = (endpointId) => (body) => {
+        const requestedModel = typeof body === "object" &&
+            body !== null &&
+            !Array.isArray(body) &&
+            typeof body.model === "string"
+            ? body.model.trim()
+            : "";
+        if (requestedModel.length === 0) {
+            return Effect.fail(new RouteKitFailure({
+                message: "classifier completion requires an explicit provider/model id"
+            }));
+        }
+        return invokeObservedModelCall(options.provenance, {
+            dialect: "openai-chat",
+            body,
+            defaultModel: requestedModel,
+            requestedModel,
+            endpointId,
+            invoke: (callId, signal, onAttribution) => backend.chat(body, signal, {
+                modelCallId: callId,
+                responseMode: "buffered",
+                onAttribution
             })
-            : { classify: unavailableClassifier });
+        }).pipe(Effect.provide(platform));
+    };
+    const compositionalConfig = resolveCompositionalRoutingConfig(options.config);
+    const requestDecomposer = yield* RequestDecomposer.pipe(Effect.provide(options.requestDecomposerLayer ??
+        lunaDirectRequestDecomposerLayer({
+            model: classifierModel,
+            modelAvailable: (model) => backend.ports.models.serves(model),
+            complete: (body) => classifierComplete("dimension-request-classifier")(body)
+        })));
     const compositionalRouting = {
         policyReader: options.compositionalPolicyReader,
         classifier: requestDecomposer,

package/dist/test/application-services.test.js

@@ -97,6 +97,8 @@ test("application services expose concrete bounded handler groups", () => {
     ]);
     assert.deepEqual(Object.keys(new EvalRoutingApplicationService().handlers()).sort(), [
         "evalRouting.activate",
+        "evalRouting.installAuthoritative",
+        "evalRouting.rollbackAuthoritative",
         "evalRouting.status"
     ]);
     assert.deepEqual(Object.keys(new TelemetryApplicationService().handlers()).sort(), [

package/dist/test/eval-routing-application-service.test.js

@@ -1,8 +1,9 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
+import { parseRouterConfig } from "@velum-labs/routekit-config";
 import { ControlError } from "@velum-labs/routekit-runtime/control";
 import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
 import { Effect, Layer, Ref } from "effect";
@@ -72,9 +73,9 @@ test("routing activation handlers expose status and enforce compare-and-swap", a
         revisions: { daemon: 1, config: 1, accounts: 1 }
     });
     const activeGateway = Layer.succeed(ActiveGateway, (() => {
-        const router = ({
+        const router = {
             modelCatalog: () => ["openai/classifier", "openai/model-a"].map((id) => ({ id }))
-        });
+        };
         const state = Ref.makeUnsafe({ router, dataUrl: "http://127.0.0.1:8080" });
         return ActiveGateway.of({
             state,
@@ -89,7 +90,9 @@ test("routing activation handlers expose status and enforce compare-and-swap", a
     const run = (effect) => runRouteKitEffect(effect.pipe(Effect.provide(services)));
     try {
         assert.deepEqual(await run(handlers["evalRouting.status"]({}, undefined)), {
-            activation: null
+            stateRevision: 0,
+            authoritative: null,
+            previousAuthoritative: null
         });
         const first = await run(handlers["evalRouting.activate"]({
             expectedEvidenceDigest: null,
@@ -113,8 +116,65 @@ test("routing activation handlers expose status and enforce compare-and-swap", a
             activation: activation("evidence-second")
         }, undefined));
         assert.equal(second.activation.evidenceDigest, "evidence-second");
-        assert.equal((await run(handlers["evalRouting.status"]({}, undefined)))
-            .activation.evidenceDigest, "evidence-second");
+        assert.equal((await run(handlers["evalRouting.status"]({}, undefined))).authoritative
+            ?.evidenceDigest, "evidence-second");
+    }
+    finally {
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test("V3 authority installs when its pinned models match the running gateway", async () => {
+    const home = mkdtempSync(join(tmpdir(), "routekit-routing-v3-authority-"));
+    const activationV3 = JSON.parse(readFileSync(new URL("../../../../test/fixtures/routing-v3/examples/published-routing-activation-v3.example.json", import.meta.url), "utf8"));
+    const daemonEnv = Layer.succeed(DaemonEnv, DaemonEnv.of({
+        home,
+        configPath: join(home, "router.yaml"),
+        env: {},
+        packageVersion: "0.0.0-test",
+        generation: 1,
+        startedAt: "2026-08-23T00:00:00.000Z",
+        hosted: undefined
+    }));
+    const runtimeState = new DaemonRuntimeState({
+        config: parseRouterConfig({
+            providers: { openai: {}, anthropic: {} },
+            defaultModel: activationV3.defaultModel
+        }),
+        document: "",
+        revisions: { daemon: 1, config: 1, accounts: 1 }
+    });
+    const requiredModels = [
+        activationV3.classifier.model,
+        activationV3.defaultModel,
+        ...activationV3.candidateModels
+    ];
+    const activeGateway = Layer.succeed(ActiveGateway, (() => {
+        const router = {
+            modelCatalog: () => [...new Set(requiredModels)].map((id) => ({
+                id
+            }))
+        };
+        const state = Ref.makeUnsafe({ router, dataUrl: "http://127.0.0.1:8080" });
+        return ActiveGateway.of({
+            state,
+            router: () => router,
+            proxy: () => undefined,
+            dataUrl: () => "http://127.0.0.1:8080",
+            control: () => undefined
+        });
+    })());
+    const services = Layer.mergeAll(daemonEnv, DaemonState.layer(runtimeState), activeGateway);
+    const handler = new EvalRoutingApplicationService().handlers()["evalRouting.installAuthoritative"];
+    const run = (effect) => runRouteKitEffect(effect.pipe(Effect.provide(services)));
+    const params = {
+        expectedAuthoritativeRevisionDigest: null,
+        expectedPreviousAuthoritativeRevisionDigest: null,
+        activation: activationV3
+    };
+    try {
+        const installed = await run(handler(params, undefined));
+        assert.equal(installed.installed, true);
+        assert.equal(installed.authoritative.version, 3);
     }
     finally {
         rmSync(home, { recursive: true, force: true });

package/dist/test/eval-routing-policy.test.js

@@ -6,7 +6,7 @@ import test from "node:test";
 import { makeRoutingActivationStore } from "@velum-labs/routekit-eval-store/effect";
 import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
 import { evalRoutingSnapshotDirectory, makeCompositionalRoutingPolicyReader } from "../eval-routing-policy.js";
-test("daemon compositional reader observes publications and falls back to previous", async () => {
+test("daemon compositional reader projects authority and falls back to previous V2", async () => {
     const home = mkdtempSync(join(tmpdir(), "routekit-daemon-compositional-policy-"));
     const dimensions = [
         "code-change",
@@ -41,13 +41,13 @@ test("daemon compositional reader observes publications and falls back to previo
     });
     try {
         const reader = makeCompositionalRoutingPolicyReader(home);
-        assert.equal(await runRouteKitEffect(reader.getSnapshot()), undefined);
+        assert.equal(await runRouteKitEffect(reader.getActivation()), undefined);
         const store = makeRoutingActivationStore(evalRoutingSnapshotDirectory(home));
         await runRouteKitEffect(store.publish(publication("first")));
         await runRouteKitEffect(store.publish(publication("second")));
-        assert.equal((await runRouteKitEffect(reader.getSnapshot()))?.evidenceDigest, "second");
-        writeFileSync(join(evalRoutingSnapshotDirectory(home), "published-routing.json"), '{"version":2}');
-        assert.equal((await runRouteKitEffect(reader.getSnapshot()))?.evidenceDigest, "first");
+        assert.equal((await runRouteKitEffect(reader.getActivation()))?.evidenceDigest, "second");
+        writeFileSync(join(evalRoutingSnapshotDirectory(home), "routing-deployment.v1.json"), '{"version":2}');
+        assert.equal((await runRouteKitEffect(reader.getActivation()))?.evidenceDigest, "first");
     }
     finally {
         rmSync(home, { recursive: true, force: true });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-daemon",
   "private": false,
-  "version": "1.0.25",
+  "version": "1.1.0",
   "description": "Singleton RouteKit control daemon and stable model gateway.",
   "repository": {
     "type": "git",
@@ -44,15 +44,15 @@
     "effect": "4.0.0-rc.108",
     "posthog-node": "5.46.1",
     "yaml": "2.9.0",
-    "@velum-labs/routekit-accounts": "1.0.25",
-    "@velum-labs/routekit-config": "1.0.25",
-    "@velum-labs/routekit-control": "1.0.25",
-    "@velum-labs/routekit-eval-contracts": "1.0.25",
-    "@velum-labs/routekit-eval-store": "1.0.25",
-    "@velum-labs/routekit-gateway": "1.0.25",
-    "@velum-labs/routekit-registry": "1.0.25",
-    "@velum-labs/routekit-runtime": "1.0.25",
-    "@velum-labs/routekit-telemetry-core": "1.0.25"
+    "@velum-labs/routekit-accounts": "1.1.0",
+    "@velum-labs/routekit-config": "1.1.0",
+    "@velum-labs/routekit-control": "1.1.0",
+    "@velum-labs/routekit-eval-contracts": "1.1.0",
+    "@velum-labs/routekit-eval-store": "1.1.0",
+    "@velum-labs/routekit-gateway": "1.1.0",
+    "@velum-labs/routekit-registry": "1.1.0",
+    "@velum-labs/routekit-runtime": "1.1.0",
+    "@velum-labs/routekit-telemetry-core": "1.1.0"
   },
   "scripts": {
     "build": "tsc -b",