@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/effect/daemon-live.js

@@ -1,41 +1,39 @@
 import { join } from "node:path";
-import { CLIPROXY_API_KEY_ENV, CLIPROXY_BASE_URL_ENV, cliproxyApiKey, cliproxyBaseUrl, subscriptionAccountIdentity, subscriptionCredentialFingerprint } from "@velum-labs/routekit-accounts";
 import { AccountActivity, AccountAuth } from "@velum-labs/routekit-accounts/effect";
 import { resolveLeaderboardConfig } from "@velum-labs/routekit-config";
 import { ROUTEKIT_CONTROL_CAPABILITY, ROUTEKIT_DAEMON_ROLL_CAPABILITY } from "@velum-labs/routekit-control";
+import { toPromiseControlHandlers } from "@velum-labs/routekit-control/effect";
 import { createWorkloadJwtVerifier } from "@velum-labs/routekit-gateway";
 import { startSwitchingGatewayProxyEffect } from "@velum-labs/routekit-gateway/effect";
 import { CONTROL_PROTOCOL_VERSION, ControlError, generateControlToken } from "@velum-labs/routekit-runtime/control";
-import { RouteKitLive, startControlServerEffect, toRouteKitFailure, withAbortSignal } from "@velum-labs/routekit-runtime/effect";
+import { RouteKitLive, startControlServerEffect, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
 import { createPortlessSession } from "@velum-labs/routekit-runtime/network";
 import { nextServiceGeneration, processIdentity, supervisorFromEnv } from "@velum-labs/routekit-runtime/service";
 import { Context, Effect, Layer, Ref } from "effect";
-import { callInspection } from "../call-attribution-store.js";
+import { AccountRecovery } from "../account-recovery-context.js";
 import { createCliproxySidecar, createHostedCliproxySidecar } from "../cliproxy-sidecar.js";
 import { createDaemonControlDispatch } from "../control-dispatch.js";
 import { prepareDaemonBootstrap } from "../daemon-bootstrap-preflight.js";
 import { createDaemonControlHandlers } from "../daemon-control-handlers.js";
-import { createDaemonGenerationManager } from "../daemon-generations.js";
-import { accountEntriesWithPaths, canonicalConfigDocument, redactedProcessArgs } from "../daemon-maintenance.js";
+import { DaemonEnv } from "../daemon-env-context.js";
+import { DaemonHost } from "../daemon-host-context.js";
+import { canonicalConfigDocument, redactedProcessArgs } from "../daemon-maintenance.js";
+import { DaemonPolicy, wantsCliproxySidecar } from "../daemon-policy-context.js";
 import { healthyControl, removeDaemonPublicRecord, workloadJwtOptions, writeDaemonPublicRecord, writeDaemonRevisions } from "../daemon-state.js";
-import { makeCompositionalRoutingPolicyReader } from "../eval-routing-policy.js";
+import { DaemonState } from "../daemon-state-context.js";
+import { DataPlane } from "../data-plane-context.js";
+import { makeEvalSessionExecutionStore } from "../eval-session-execution-store.js";
 import { LeaderboardRollupStore } from "../leaderboard.js";
-import { AccountRecovery } from "../account-recovery-context.js";
+import { Leaderboard } from "../leaderboard-context.js";
 import { ActiveGateway } from "../services/active-gateway/service.js";
 import { CallAttributions } from "../services/call-attributions/service.js";
-import { DaemonEnv } from "../daemon-env-context.js";
-import { DaemonHost } from "../daemon-host-context.js";
-import { DaemonPolicy } from "../daemon-policy-context.js";
 import { DaemonRuntime } from "../services/daemon-runtime/service.js";
-import { DaemonState } from "../daemon-state-context.js";
-import { DataPlane } from "../data-plane-context.js";
 import { EvalSessions } from "../services/eval-session/service.js";
 import { Generations } from "../services/generations/service.js";
 import { LauncherSessions } from "../services/launcher-session/service.js";
-import { Leaderboard } from "../leaderboard-context.js";
-import { Sidecar } from "../sidecar-context.js";
 import { Telemetry } from "../services/telemetry/service.js";
 import { Tokens } from "../services/tokens/service.js";
+import { Sidecar } from "../sidecar-context.js";
 const ROUTEKIT_DAEMON_KIND = "daemon";
 const ROUTEKIT_PRODUCT = "routekit";
 class DaemonFoundation extends Context.Service()("@velum-labs/routekit-daemon/DaemonFoundation") {
@@ -73,37 +71,6 @@ const prepareFoundation = (options) => Effect.acquireRelease(Effect.tryPromise({
 }), (foundation) => Effect.sync(() => {
     foundation.authority?.release();
 }));
-const wantsSidecar = (config) => config.providers.cliproxy !== undefined;
-const activeCredentialFingerprints = (env) => new Map(accountEntriesWithPaths(env).flatMap((entry) => entry.connector === "native"
-    ? [
-        [
-            subscriptionAccountIdentity(entry.subscriptionKind, entry.label),
-            subscriptionCredentialFingerprint(entry.path)
-        ]
-    ]
-    : []));
-const routerEnv = (env) => {
-    const injected = { ...env };
-    if ((env[CLIPROXY_API_KEY_ENV] ?? "").length === 0) {
-        const key = cliproxyApiKey(env);
-        if (key !== undefined)
-            injected[CLIPROXY_API_KEY_ENV] = key;
-    }
-    if ((env[CLIPROXY_BASE_URL_ENV] ?? "").length === 0) {
-        injected[CLIPROXY_BASE_URL_ENV] = cliproxyBaseUrl(env);
-    }
-    return injected;
-};
-function promiseHandlers(handlers, context) {
-    return new Proxy(handlers, {
-        get(target, method, receiver) {
-            const handler = Reflect.get(target, method, receiver);
-            if (typeof handler !== "function")
-                return handler;
-            return (params, handlerContext) => Effect.runPromiseWith(context)(withAbortSignal(handler(params, handlerContext), handlerContext.signal));
-        }
-    });
-}
 const acquireRunningDaemon = Effect.fn("Daemon.acquireRunning")(function* (options) {
     const foundation = yield* DaemonFoundation;
     const state = yield* DaemonState;
@@ -116,16 +83,15 @@ const acquireRunningDaemon = Effect.fn("Daemon.acquireRunning")(function* (optio
     const telemetry = yield* Telemetry;
     const auth = yield* AccountAuth;
     const context = yield* Effect.context();
-    const provideRuntime = (effect) => effect.pipe(Effect.provide(context));
     yield* Effect.addFinalizer(() => Effect.sync(() => foundation.runtimeState.markClosed()));
-    yield* sidecar.reconcile(wantsSidecar(state.config));
+    yield* sidecar.reconcile(wantsCliproxySidecar(state.config));
     const router = yield* generations.start(state.config);
     yield* Ref.update(gateway.state, (current) => ({ ...current, router }));
     yield* Effect.addFinalizer(() => {
         const active = gateway.router();
         return active === undefined ? Effect.void : active.close.pipe(Effect.ignore);
     });
-    yield* auth.reconcileActiveCredentials(activeCredentialFingerprints(foundation.env));
+    yield* auth.reconcileActiveCredentials(router.activeCredentialFingerprints());
     const workloadJwt = workloadJwtOptions(options.workloadJwt, foundation.env);
     const verifyWorkloadJwt = workloadJwt === undefined ? undefined : createWorkloadJwtVerifier(workloadJwt);
     const proxy = yield* startSwitchingGatewayProxyEffect({
@@ -134,6 +100,7 @@ const acquireRunningDaemon = Effect.fn("Daemon.acquireRunning")(function* (optio
         host: options.host ?? "127.0.0.1",
         port: options.port ?? 8080,
         authToken: tokens.dataAuth.token,
+        bindEvalSubmission: (sessionId, request) => evalSessions.bindIngress(sessionId, request),
         resolveDataPrincipal: (presented) => {
             const launcherPrincipal = launcherSessions.resolve(presented);
             if (launcherPrincipal !== undefined)
@@ -164,7 +131,7 @@ const acquireRunningDaemon = Effect.fn("Daemon.acquireRunning")(function* (optio
     const dataUrl = foundation.hosted?.dataUrl() ??
         (portless?.enabled === true ? portless.register("gateway", proxy.port()) : proxy.url());
     yield* Ref.update(gateway.state, (current) => ({ ...current, proxy, dataUrl }));
-    const handlers = promiseHandlers(createDaemonControlHandlers(), context);
+    const handlers = toPromiseControlHandlers(createDaemonControlHandlers(), context);
     const dispatch = createDaemonControlDispatch({
         handlers,
         runtimeState: foundation.runtimeState,
@@ -197,16 +164,17 @@ const acquireRunningDaemon = Effect.fn("Daemon.acquireRunning")(function* (optio
     });
     yield* Effect.addFinalizer(() => control.close.pipe(Effect.ignore));
     yield* Ref.update(gateway.state, (current) => ({ ...current, control }));
+    const identity = processIdentity(process.pid);
+    const supervisor = supervisorFromEnv(foundation.env);
     const recordInput = {
         kind: ROUTEKIT_DAEMON_KIND,
         pid: process.pid,
-        ...(processIdentity(process.pid) === undefined
-            ? {}
-            : { processIdentity: processIdentity(process.pid) }),
+        ...(identity === undefined ? {} : { processIdentity: identity }),
         url: control.url,
         port: control.port,
         startedAt: foundation.startedAt,
         version: options.packageVersion,
+        ...(options.sourceBuildId === undefined ? {} : { sourceBuildId: options.sourceBuildId }),
         protocolVersion: CONTROL_PROTOCOL_VERSION,
         controlToken: control.token,
         dataUrl,
@@ -216,7 +184,7 @@ const acquireRunningDaemon = Effect.fn("Daemon.acquireRunning")(function* (optio
         drainGraceMs: foundation.drainGraceMs,
         authTokenFile: tokens.dataAuth.path,
         generation: foundation.generation,
-        supervisor: supervisorFromEnv(foundation.env),
+        supervisor,
         ...(process.argv[1] === undefined ? {} : { binPath: process.argv[1] }),
         args: redactedProcessArgs(process.argv.slice(2)),
         cwd: process.cwd()
@@ -241,31 +209,28 @@ const acquireRunningDaemon = Effect.fn("Daemon.acquireRunning")(function* (optio
             removeDaemonPublicRecord(foundation.home);
         }));
     }
-    telemetry.daemon.capture("routekit.daemon_lifecycle", {
-        action: "started",
+    const lifecycleProperties = {
         outcome: "success",
-        supervisor: ["systemd", "launchd", "detached"].includes(supervisorFromEnv(foundation.env))
-            ? supervisorFromEnv(foundation.env)
-            : "unknown",
+        supervisor,
         version: options.packageVersion
+    };
+    telemetry.daemon.capture("routekit.daemon_lifecycle", {
+        ...lifecycleProperties,
+        action: "started"
     });
     const prepareClose = Effect.gen(function* () {
         foundation.runtimeState.beginShutdown();
-        yield* foundation.runtimeState.awaitMutations();
+        yield* foundation.runtimeState.awaitMutations;
         telemetry.daemon.capture("routekit.daemon_lifecycle", {
-            action: "stopped",
-            outcome: "success",
-            supervisor: ["systemd", "launchd", "detached"].includes(supervisorFromEnv(foundation.env))
-                ? supervisorFromEnv(foundation.env)
-                : "unknown",
-            version: options.packageVersion
+            ...lifecycleProperties,
+            action: "stopped"
         });
         foundation.runtimeState.markDraining();
         yield* proxy.drain(foundation.drainGraceMs);
     });
     const prepareRetire = (graceMs = foundation.drainGraceMs) => Effect.gen(function* () {
         foundation.runtimeState.beginRetire();
-        yield* foundation.runtimeState.awaitMutations();
+        yield* foundation.runtimeState.awaitMutations;
         foundation.runtimeState.markDraining();
         yield* Effect.all([proxy.retire(graceMs), control.retire(Math.min(graceMs, 2_000))], {
             concurrency: "unbounded"
@@ -282,20 +247,19 @@ const acquireRunningDaemon = Effect.fn("Daemon.acquireRunning")(function* (optio
         record,
         dataUrl,
         controlUrl: control.url,
-        prepareClose: provideRuntime(prepareClose),
-        prepareRetire: (graceMs) => provideRuntime(prepareRetire(graceMs)),
-        pauseMutations: provideRuntime(Effect.gen(function* () {
+        prepareClose,
+        prepareRetire,
+        pauseMutations: Effect.gen(function* () {
             foundation.runtimeState.pause();
-            yield* foundation.runtimeState.awaitMutations();
+            yield* foundation.runtimeState.awaitMutations;
             return foundation.runtimeState.snapshot();
-        })),
-        resumeMutations: provideRuntime(Effect.sync(() => foundation.runtimeState.resume())),
-        snapshot: provideRuntime(Effect.sync(() => foundation.runtimeState.snapshot())),
-        reload: provideRuntime(reload)
+        }),
+        resumeMutations: Effect.sync(() => foundation.runtimeState.resume()),
+        snapshot: Effect.sync(() => foundation.runtimeState.snapshot()),
+        reload: Effect.provide(reload, context)
     });
 });
-/** Construct and own the complete daemon worker lifetime. */
-export function daemonLive(options) {
+function daemonLayers(options) {
     const foundation = Layer.effect(DaemonFoundation, prepareFoundation(options));
     const platform = RouteKitLive.pipe(Layer.provideMerge(foundation));
     const owned = Layer.mergeAll(Layer.effect(Sidecar, Effect.flatMap(DaemonFoundation, (value) => Effect.acquireRelease(Effect.sync(() => value.hosted === undefined
@@ -328,7 +292,11 @@ export function daemonLive(options) {
                 });
             }
         });
-    }), (leaderboard) => Effect.sync(() => leaderboard.rollups.flush())))), EvalSessions.layer(), LauncherSessions.layer()).pipe(Layer.provideMerge(platform));
+    }), (leaderboard) => Effect.sync(() => leaderboard.rollups.flush())))), Layer.unwrap(Effect.gen(function* () {
+        const foundation = yield* DaemonFoundation;
+        const store = yield* makeEvalSessionExecutionStore(join(foundation.home, "eval-sessions", "execution-v1"));
+        return EvalSessions.layer({ store });
+    })), LauncherSessions.layer()).pipe(Layer.provideMerge(platform));
     const staticServices = Layer.mergeAll(Layer.effect(DaemonEnv, Effect.map(DaemonFoundation, (value) => DaemonEnv.of({
         home: value.home,
         configPath: value.configPath,
@@ -340,7 +308,7 @@ export function daemonLive(options) {
     }))), Layer.unwrap(Effect.map(DaemonFoundation, (value) => DaemonState.layer(value.runtimeState))), Layer.effect(DataPlane, Effect.map(Tokens, (tokens) => ({
         token: tokens.dataAuth.token,
         path: tokens.dataAuth.path
-    }))), Layer.effect(AccountRecovery, Effect.map(DaemonFoundation, (value) => value.accountRecovery)), Layer.unwrap(Effect.map(DaemonFoundation, (value) => CallAttributions.layer(resolveLeaderboardConfig(value.runtimeState.config)))), Layer.effect(DaemonPolicy, Effect.succeed({ wantsCliproxySidecar: wantsSidecar })), Layer.effect(DaemonHost, Effect.map(DaemonFoundation, (value) => ({
+    }))), Layer.effect(AccountRecovery, Effect.map(DaemonFoundation, (value) => value.accountRecovery)), Layer.unwrap(Effect.map(DaemonFoundation, (value) => CallAttributions.layer(resolveLeaderboardConfig(value.runtimeState.config)))), Layer.succeed(DaemonPolicy, { wantsCliproxySidecar }), Layer.effect(DaemonHost, Effect.map(DaemonFoundation, (value) => ({
         ...(options.onShutdownRequested === undefined
             ? {}
             : {
@@ -358,61 +326,15 @@ export function daemonLive(options) {
             ? {}
             : { onAccountTransactionPhase: options.onAccountTransactionPhase })
     }))), ActiveGateway.layer, Layer.unwrap(Effect.map(DaemonFoundation, (value) => AccountActivity.layer({ statePath: join(value.home, "usage", "account-activity.v1.json") }))), Layer.unwrap(Effect.map(DaemonFoundation, (value) => AccountAuth.layer({ statePath: join(value.home, "subscriptions", "account-auth.v1.json") })))).pipe(Layer.provideMerge(owned));
-    const generations = Layer.effect(Generations, Effect.gen(function* () {
-        const foundation = yield* DaemonFoundation;
-        const state = yield* DaemonState;
-        const sidecar = yield* Sidecar;
-        const activity = yield* AccountActivity;
-        const auth = yield* AccountAuth;
-        const gateway = yield* ActiveGateway;
-        const callAttributions = yield* CallAttributions;
-        const leaderboard = yield* Leaderboard;
-        const telemetry = yield* Telemetry;
-        return createDaemonGenerationManager({
-            configPath: foundation.configPath,
-            home: foundation.home,
-            drainGraceMs: foundation.drainGraceMs,
-            sidecar,
-            routerEnv: () => routerEnv(foundation.env),
-            provenance: {
-                onModelCall(record) {
-                    callAttributions.onModelCall(record);
-                    const inspection = callInspection(record);
-                    if (inspection !== undefined)
-                        leaderboard.rollups.record(inspection);
-                    telemetry.gateway.record(record);
-                }
-            },
-            compositionalPolicyReader: makeCompositionalRoutingPolicyReader(foundation.home),
-            activity,
-            authHealth: auth,
-            wantsSidecar,
-            getCurrentConfig: () => state.config,
-            setCurrentConfig: (config) => {
-                state.config = config;
-            },
-            getCurrentDocument: () => state.document,
-            setCurrentDocument: (document) => {
-                state.document = document;
-            },
-            getRevisions: () => state.revisions,
-            setRevisions: (revisions) => {
-                state.revisions = revisions;
-            },
-            getActiveRouter: () => gateway.router(),
-            setActiveRouter: (router) => Ref.update(gateway.state, (current) => ({ ...current, router })),
-            getProxy: () => gateway.proxy(),
-            activeCredentialFingerprints: () => activeCredentialFingerprints(foundation.env),
-            applyConfig: (config) => {
-                leaderboard.applyConfig(config);
-                const current = leaderboard.config();
-                callAttributions.configureBudget({
-                    limit: current.liveLimit,
-                    ttlMs: current.liveTtlHours * 60 * 60 * 1_000
-                });
-            },
-            ...(options.onGenerationStage === undefined ? {} : { onStage: options.onGenerationStage })
-        });
-    })).pipe(Layer.provideMerge(staticServices));
-    return Layer.effect(DaemonRuntime, acquireRunningDaemon(options)).pipe(Layer.provideMerge(generations));
+    const generations = Layer.unwrap(Effect.map(DaemonFoundation, (foundation) => Generations.layer({
+        drainGraceMs: foundation.drainGraceMs,
+        ...(options.onGenerationStage === undefined ? {} : { onStage: options.onGenerationStage })
+    }))).pipe(Layer.provideMerge(staticServices));
+    return generations;
+}
+/** Construct and own the complete daemon worker lifetime. */
+export function daemonLive(options) {
+    // The published service union deliberately excludes platform/foundation and
+    // private launcher credentials. Runtime composition still owns all of them.
+    return Layer.effect(DaemonRuntime, acquireRunningDaemon(options)).pipe(Layer.provideMerge(daemonLayers(options)));
 }

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

@@ -1,7 +1,5 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 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;
-}
+export declare const evalRoutingHandlers: EvalRoutingHandlers;
 export {};

package/dist/eval-routing-service.js

@@ -1,8 +1,7 @@
 import { DEFAULT_CLASSIFIER_MODEL } from "@velum-labs/routekit-config";
-import { AnyPublishedRoutingActivation, assertPublishedRoutingActivation, assertPublishedRoutingActivationV3 } 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 { Effect } from "effect";
 import { DaemonEnv } from "./daemon-env-context.js";
 import { DaemonState } from "./daemon-state-context.js";
 import { evalRoutingSnapshotDirectory } from "./eval-routing-policy.js";
@@ -20,26 +19,6 @@ function identity(revision) {
             evidenceDigest: revision.activation.evidenceDigest
         };
 }
-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 })
@@ -47,6 +26,7 @@ const mapStoreError = (operation) => (cause) => cause instanceof RoutingActivati
         code: "internal",
         message: `failed to ${operation}: ${detailOf(cause)}`
     });
+const routingStore = Effect.map(DaemonEnv, ({ home }) => makeRoutingActivationStore(evalRoutingSnapshotDirectory(home)));
 function validateRuntimeCompatibility(activation) {
     return Effect.gen(function* () {
         const state = yield* DaemonState;
@@ -89,52 +69,48 @@ function validateRuntimeCompatibility(activation) {
     });
 }
 /** Owns target-local compositional routing status and atomic activation. */
-export class EvalRoutingApplicationService {
-    handlers() {
+export const evalRoutingHandlers = {
+    "evalRouting.status": () => Effect.gen(function* () {
+        const store = yield* routingStore;
+        const deployment = yield* store
+            .readDeployment()
+            .pipe(Effect.mapError(mapStoreError("read routing deployment")));
         return {
-            "evalRouting.status": () => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                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.fail(new ControlError({
-                code: "bad_request",
-                message: "Classification V2 activation is rollback-only; install a qualified Classification V3 activation or restore the retained V2 revision with evalRouting.rollbackAuthoritative"
-            })),
-            "evalRouting.installAuthoritative": (params) => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const activation = yield* makeRoutingActivationStore(evalRoutingSnapshotDirectory(env.home))
-                    .readActivation(params.activationPath)
-                    .pipe(Effect.mapError(mapStoreError("read authoritative routing policy")));
-                yield* validateRuntimeCompatibility(activation);
-                const deployment = yield* makeRoutingActivationStore(evalRoutingSnapshotDirectory(env.home))
-                    .installAuthoritative(activation, params.activationPath, 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)
-                };
-            })
+            stateRevision: deployment.stateRevision,
+            authoritative: identity(deployment.authoritative),
+            previousAuthoritative: identity(deployment.previousAuthoritative)
         };
-    }
-}
+    }),
+    "evalRouting.activate": () => Effect.fail(new ControlError({
+        code: "bad_request",
+        message: "Classification V2 activation is rollback-only; install a qualified Classification V3 activation or restore the retained V2 revision with evalRouting.rollbackAuthoritative"
+    })),
+    "evalRouting.installAuthoritative": (params) => Effect.gen(function* () {
+        const store = yield* routingStore;
+        const activation = yield* store
+            .readActivation(params.activationPath)
+            .pipe(Effect.mapError(mapStoreError("read authoritative routing policy")));
+        yield* validateRuntimeCompatibility(activation);
+        const deployment = yield* store
+            .installAuthoritative(activation, params.activationPath, 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 store = yield* routingStore;
+        const deployment = yield* store
+            .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/eval-session-execution-store.d.ts

@@ -0,0 +1,24 @@
+import type { EvalSessionExecutionEvidence } from "@velum-labs/routekit-control";
+import { HttpSubmissionError } from "@velum-labs/routekit-runtime/effect";
+import { Effect, FileSystem, Path } from "effect";
+export type EvalSessionExecutionStore = {
+    readonly directory: string;
+    readonly create: (evidence: EvalSessionExecutionEvidence) => Effect.Effect<EvalSessionExecutionEvidence, HttpSubmissionError>;
+    readonly read: (executionDigest: string, sessionId?: string) => Effect.Effect<EvalSessionExecutionEvidence | undefined, HttpSubmissionError>;
+    readonly update: (executionDigest: string, update: (current: EvalSessionExecutionEvidence) => EvalSessionExecutionEvidence, options?: {
+        readonly allowReadinessReopen?: boolean;
+    }) => Effect.Effect<EvalSessionExecutionEvidence, HttpSubmissionError>;
+    readonly recover: (now: string) => Effect.Effect<readonly EvalSessionExecutionEvidence[], HttpSubmissionError>;
+};
+/** Derive closure without ever converting a pending or unknown receipt to success. */
+export declare function normalizeExecutionEvidence(evidence: EvalSessionExecutionEvidence): EvalSessionExecutionEvidence;
+/**
+ * Private payload-free authority store. Each operation reads current durable
+ * state under the existing process-identity lifecycle lock before an atomic
+ * replacement. A retiring worker therefore cannot overwrite a successor's
+ * revocation, recovered unknown receipt, or consumed execution identity.
+ *
+ * The lock is transaction-scoped, not another gateway/request resource owner.
+ * Atomic rename covers interruption and reported I/O faults, not power loss.
+ */
+export declare const makeEvalSessionExecutionStore: (inputDirectory: string) => Effect.Effect<EvalSessionExecutionStore, HttpSubmissionError, FileSystem.FileSystem | Path.Path>;