@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/daemon-control-handlers.js

@@ -1,36 +1,33 @@
-import { AccountEnrollService } from "./account-enroll-service.js";
-import { AccountMutationService } from "./account-mutation-service.js";
-import { AccountQueryService } from "./account-query-service.js";
-import { DaemonLifecycleService } from "./daemon-lifecycle-service.js";
-import { DoctorApplicationService } from "./doctor-service.js";
-import { EvalRoutingApplicationService } from "./eval-routing-service.js";
-import { EvalSessionApplicationService } from "./services/eval-session/service.js";
-import { LauncherApplicationService } from "./launcher-service.js";
-import { ProviderQueryService } from "./provider-query-service.js";
-import { RouterGenerationService } from "./router-generation-service.js";
-import { TelemetryApplicationService } from "./telemetry-application-service.js";
-import { TokenApplicationService } from "./token-application-service.js";
+import { accountEnrollHandlers } from "./account-enroll-service.js";
+import { accountMutationHandlers } from "./account-mutation-service.js";
+import { accountQueryHandlers } from "./account-query-service.js";
+import { daemonLifecycleHandlers } from "./daemon-lifecycle-service.js";
+import { doctorHandlers } from "./doctor-service.js";
+import { evalRoutingHandlers } from "./eval-routing-service.js";
+import { evalSessionHandlers } from "./services/eval-session/service.js";
+import { launcherHandlers } from "./launcher-service.js";
+import { providerHandlers } from "./provider-query-service.js";
+import { routerGenerationHandlers } from "./router-generation-service.js";
+import { telemetryHandlers } from "./telemetry-application-service.js";
+import { tokenHandlers } from "./token-application-service.js";
 /**
- * Composes owned application services into the daemon control handler map.
+ * Composes owned handler groups into the daemon control handler map.
  * Protocol policy lives in the method table; this function only binds use cases.
  * Daemon-lifetime state is yielded from `daemonLive`.
  */
 export function createDaemonControlHandlers() {
-    const providerHandlers = new ProviderQueryService().handlers();
     return {
-        ...new DaemonLifecycleService().handlers(),
-        ...new RouterGenerationService().handlers(),
+        ...daemonLifecycleHandlers,
+        ...routerGenerationHandlers,
         ...providerHandlers,
-        ...new AccountQueryService().handlers(),
-        ...new AccountEnrollService().handlers(),
-        ...new AccountMutationService().handlers(),
-        ...new TelemetryApplicationService().handlers(),
-        ...new DoctorApplicationService().handlers(),
-        ...new LauncherApplicationService({
-            listModels: providerHandlers["models.list"]
-        }).handlers(),
-        ...new TokenApplicationService().handlers(),
-        ...new EvalRoutingApplicationService().handlers(),
-        ...new EvalSessionApplicationService().handlers()
+        ...accountQueryHandlers,
+        ...accountEnrollHandlers,
+        ...accountMutationHandlers,
+        ...telemetryHandlers,
+        ...doctorHandlers,
+        ...launcherHandlers({ listModels: providerHandlers["models.list"] }),
+        ...tokenHandlers,
+        ...evalRoutingHandlers,
+        ...evalSessionHandlers
     };
 }

package/dist/daemon-generations.d.ts

@@ -1,11 +1,16 @@
-import type { AccountActivityService, AccountAuthService } from "@velum-labs/routekit-accounts/effect";
 import { type RouterConfig } from "@velum-labs/routekit-config";
-import type { CompositionalRoutingPolicyReader, ProvenanceSink, SwitchingGatewayProxy } from "@velum-labs/routekit-gateway";
+import { AccountActivity, AccountAuth } from "@velum-labs/routekit-accounts/effect";
 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 { DaemonEnv } from "./daemon-env-context.js";
+import { DaemonState } from "./daemon-state-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 { EvalSessions } from "./services/eval-session/service.js";
 import { type RunningGatewayGeneration } from "./services/gateway-generation/service.js";
+import { Telemetry } from "./services/telemetry/service.js";
+import { Sidecar } from "./sidecar-context.js";
 export type DaemonGenerationStage = "prepare" | "validate" | "persist" | "commit" | "retire";
 export type DaemonGenerationMutation = {
     write: boolean;
@@ -14,34 +19,15 @@ export type DaemonGenerationMutation = {
     /** Complete all fallible domain writes before the live target is published. */
     persist?: () => Effect.Effect<void, Error, RouteKitPlatform>;
 };
-export type DaemonGenerationManagerOptions = {
-    configPath: string;
-    home: string;
+export type DaemonGenerationSettings = {
     drainGraceMs: number;
-    sidecar: CliproxySidecar;
-    routerEnv: () => NodeJS.ProcessEnv;
-    provenance: ProvenanceSink;
-    /** Published model-by-dimension evidence used by automatic routing. */
-    compositionalPolicyReader?: CompositionalRoutingPolicyReader;
-    activity: AccountActivityService;
-    authHealth: AccountAuthService;
-    wantsSidecar(config: RouterConfig): boolean;
-    getCurrentConfig(): RouterConfig;
-    setCurrentConfig(config: RouterConfig): void;
-    getCurrentDocument(): string;
-    setCurrentDocument(document: string): void;
-    getRevisions(): RevisionState;
-    setRevisions(revisions: RevisionState): void;
-    getActiveRouter(): RunningGatewayGeneration | undefined;
-    setActiveRouter(router: RunningGatewayGeneration): Effect.Effect<void>;
-    getProxy(): SwitchingGatewayProxy | undefined;
-    activeCredentialFingerprints(): Map<string, string>;
-    /** Apply daemon-local configuration before the proxy publishes the candidate. */
-    applyConfig(config: RouterConfig): void;
     onStage?: (stage: DaemonGenerationStage) => void;
 };
 export type DaemonGenerationManager = {
     start(config: RouterConfig): Effect.Effect<RunningGatewayGeneration, Error, RouteKitPlatform>;
     replace(nextConfig: RouterConfig, nextDocument: string, mutation: DaemonGenerationMutation): Effect.Effect<void, Error, RouteKitPlatform>;
 };
-export declare function createDaemonGenerationManager(options: DaemonGenerationManagerOptions): DaemonGenerationManager;
+export declare const createDaemonGenerationManager: (settings: DaemonGenerationSettings) => Effect.Effect<{
+    start: (config: RouterConfig) => Effect.Effect<RunningGatewayGeneration, Error, RouteKitPlatform>;
+    replace: (nextConfig: RouterConfig, nextDocument: string, mutation: DaemonGenerationMutation) => Effect.Effect<void, Error, RouteKitPlatform>;
+}, never, DaemonEnv | DaemonState | Leaderboard | ActiveGateway | CallAttributions | EvalSessions | Telemetry | Sidecar | AccountActivity | AccountAuth>;

package/dist/daemon-generations.js

@@ -1,32 +1,85 @@
 import { chmodSync, readFileSync } from "node:fs";
+import { CLIPROXY_API_KEY_ENV, CLIPROXY_BASE_URL_ENV, cliproxyApiKey, cliproxyBaseUrl } from "@velum-labs/routekit-accounts";
 import { writeRouterConfig } from "@velum-labs/routekit-config";
+import { AccountActivity, AccountAuth } from "@velum-labs/routekit-accounts/effect";
 import { RouteKitFailure, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
 import { writeFileAtomic } from "@velum-labs/routekit-runtime/filesystem";
-import { Effect } from "effect";
+import { Effect, Ref } from "effect";
+import { callInspection } from "./call-attribution-store.js";
 import { writeDaemonRevisions } from "./daemon-state.js";
+import { DaemonEnv } from "./daemon-env-context.js";
+import { wantsCliproxySidecar } from "./daemon-policy-context.js";
+import { DaemonState } from "./daemon-state-context.js";
+import { makeCompositionalRoutingPolicyReader } from "./eval-routing-policy.js";
+import { Leaderboard } from "./leaderboard-context.js";
+import { ActiveGateway } from "./services/active-gateway/service.js";
+import { CallAttributions } from "./services/call-attributions/service.js";
+import { EvalSessions } from "./services/eval-session/service.js";
 import { startGatewayGenerationEffect } from "./services/gateway-generation/service.js";
+import { Telemetry } from "./services/telemetry/service.js";
+import { Sidecar } from "./sidecar-context.js";
 const tryPromise = (run) => Effect.tryPromise({
     try: async () => await run(),
     catch: toRouteKitFailure
 });
 const collectRollback = (work) => work.pipe(Effect.as(undefined), Effect.catch((error) => Effect.succeed(error)));
-export function createDaemonGenerationManager(options) {
+function 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;
+}
+export const createDaemonGenerationManager = Effect.fn("DaemonGenerations.construct")(function* (settings) {
+    const env = yield* DaemonEnv;
+    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;
+    const evalSessions = yield* EvalSessions;
+    const applyConfig = (config) => {
+        leaderboard.applyConfig(config);
+        const current = leaderboard.config();
+        callAttributions.configureBudget({
+            limit: current.liveLimit,
+            ttlMs: current.liveTtlHours * 60 * 60 * 1_000
+        });
+    };
+    const setActiveRouter = (router) => Ref.update(gateway.state, (current) => ({ ...current, router }));
+    const provenance = {
+        onModelCall(record) {
+            callAttributions.onModelCall(record);
+            const inspection = callInspection(record);
+            if (inspection !== undefined)
+                leaderboard.rollups.record(inspection);
+            telemetry.gateway.record(record);
+        }
+    };
+    const compositionalPolicyReader = makeCompositionalRoutingPolicyReader(env.home);
     const start = (config) => startGatewayGenerationEffect({
         config,
         host: "127.0.0.1",
         port: 0,
-        env: options.routerEnv(),
-        provenance: options.provenance,
-        ...(options.compositionalPolicyReader !== undefined
-            ? { compositionalPolicyReader: options.compositionalPolicyReader }
-            : {}),
-        activity: options.activity,
-        authHealth: options.authHealth,
-        drainGraceMs: options.drainGraceMs
+        env: routerEnv(env.env),
+        provenance,
+        resolveHttpSubmission: (binding) => evalSessions.resolveSubmission(binding),
+        compositionalPolicyReader,
+        activity,
+        authHealth: auth,
+        drainGraceMs: settings.drainGraceMs
     });
     const replace = (nextConfig, nextDocument, mutation) => Effect.scoped(Effect.gen(function* () {
-        const proxy = options.getProxy();
-        const previousRouter = options.getActiveRouter();
+        const proxy = gateway.proxy();
+        const previousRouter = gateway.router();
         if (proxy === undefined || previousRouter === undefined) {
             return yield* new RouteKitFailure({
                 message: "router generation cannot replace before daemon publication"
@@ -41,10 +94,10 @@ export function createDaemonGenerationManager(options) {
                 : Effect.void;
         });
         yield* Effect.gen(function* () {
-            yield* tryPromise(() => options.onStage?.("prepare"));
-            yield* options.sidecar.reconcile(options.wantsSidecar(nextConfig));
+            yield* tryPromise(() => settings.onStage?.("prepare"));
+            yield* sidecar.reconcile(wantsCliproxySidecar(nextConfig));
             candidate = yield* start(nextConfig);
-            yield* tryPromise(() => options.onStage?.("validate"));
+            yield* tryPromise(() => settings.onStage?.("validate"));
         }).pipe(Effect.catch((error) => Effect.gen(function* () {
             const rollbackFailures = [];
             if (candidate !== undefined) {
@@ -52,7 +105,7 @@ export function createDaemonGenerationManager(options) {
                 if (failure !== undefined)
                     rollbackFailures.push(failure);
             }
-            const sidecarFailure = yield* collectRollback(options.sidecar.reconcile(options.wantsSidecar(options.getCurrentConfig())));
+            const sidecarFailure = yield* collectRollback(sidecar.reconcile(wantsCliproxySidecar(state.config)));
             if (sidecarFailure !== undefined)
                 rollbackFailures.push(sidecarFailure);
             if (rollbackFailures.length > 0) {
@@ -60,9 +113,9 @@ export function createDaemonGenerationManager(options) {
             }
             return yield* Effect.fail(error);
         })));
-        const previousDocument = options.getCurrentDocument();
-        const previousConfig = options.getCurrentConfig();
-        const previousRevisions = { ...options.getRevisions() };
+        const previousDocument = state.document;
+        const previousConfig = state.config;
+        const previousRevisions = { ...state.revisions };
         const nextRevisions = { ...previousRevisions };
         if (mutation.configRevision === true)
             nextRevisions.config += 1;
@@ -71,32 +124,32 @@ export function createDaemonGenerationManager(options) {
         let committedDocument = nextDocument;
         yield* Effect.gen(function* () {
             yield* tryPromise(() => {
-                options.onStage?.("persist");
+                settings.onStage?.("persist");
                 if (mutation.write)
-                    writeRouterConfig(options.configPath, nextConfig);
-                writeDaemonRevisions(options.home, nextRevisions);
+                    writeRouterConfig(env.configPath, nextConfig);
+                writeDaemonRevisions(env.home, nextRevisions);
             });
             if (mutation.persist !== undefined)
                 yield* mutation.persist();
             committedDocument = mutation.write
-                ? readFileSync(options.configPath, "utf8")
+                ? readFileSync(env.configPath, "utf8")
                 : nextDocument;
         }).pipe(Effect.catch((error) => Effect.gen(function* () {
             const rollbackFailures = [];
             const persistFailure = yield* collectRollback(tryPromise(() => {
                 if (mutation.write) {
-                    writeFileAtomic(options.configPath, previousDocument, { mode: 0o600 });
-                    chmodSync(options.configPath, 0o600);
+                    writeFileAtomic(env.configPath, previousDocument, { mode: 0o600 });
+                    chmodSync(env.configPath, 0o600);
                 }
-                options.setRevisions(previousRevisions);
-                writeDaemonRevisions(options.home, previousRevisions);
+                state.revisions = previousRevisions;
+                writeDaemonRevisions(env.home, previousRevisions);
             }));
             if (persistFailure !== undefined)
                 rollbackFailures.push(persistFailure);
             const closeFailure = yield* collectRollback(candidate.close);
             if (closeFailure !== undefined)
                 rollbackFailures.push(closeFailure);
-            const sidecarFailure = yield* collectRollback(options.sidecar.reconcile(options.wantsSidecar(options.getCurrentConfig())));
+            const sidecarFailure = yield* collectRollback(sidecar.reconcile(wantsCliproxySidecar(state.config)));
             if (sidecarFailure !== undefined)
                 rollbackFailures.push(sidecarFailure);
             if (rollbackFailures.length > 0) {
@@ -104,43 +157,50 @@ export function createDaemonGenerationManager(options) {
             }
             return yield* Effect.fail(error);
         })));
-        // Prepare every daemon-local view before publishing the new target. These
-        // mutations are synchronous and are rolled back if the commit hook rejects.
-        // swapTarget below is deliberately the final publication operation.
+        let previousTarget;
+        // Prepare every daemon-local view before publishing the new target. The
+        // final synchronous section switches auth identity and proxy target as one
+        // publication handoff. It retains retired fingerprint evidence until after
+        // publication, so any rollback restores the exact prior runtime state.
         yield* Effect.gen(function* () {
-            yield* options.setActiveRouter(candidate);
-            options.setCurrentConfig(nextConfig);
-            options.setCurrentDocument(committedDocument);
-            options.setRevisions(nextRevisions);
-            options.applyConfig(nextConfig);
-            yield* options.authHealth.reconcileActiveCredentials(options.activeCredentialFingerprints());
-            yield* tryPromise(() => options.onStage?.("commit"));
+            yield* setActiveRouter(candidate);
+            state.config = nextConfig;
+            state.document = committedDocument;
+            state.revisions = nextRevisions;
+            applyConfig(nextConfig);
+            yield* tryPromise(() => settings.onStage?.("commit"));
+            yield* Effect.sync(() => {
+                auth.switchActiveCredentials(candidate.activeCredentialFingerprints());
+                previousTarget = proxy.swapTarget(candidate.url);
+                published = true;
+            });
         }).pipe(Effect.catch((error) => Effect.gen(function* () {
             const rollbackFailures = [];
             const viewFailure = yield* collectRollback(Effect.gen(function* () {
-                yield* options.setActiveRouter(previousRouter);
+                yield* setActiveRouter(previousRouter);
                 yield* tryPromise(() => {
-                    options.setCurrentConfig(previousConfig);
-                    options.setCurrentDocument(previousDocument);
-                    options.setRevisions(previousRevisions);
-                    options.applyConfig(previousConfig);
+                    state.config = previousConfig;
+                    state.document = previousDocument;
+                    state.revisions = previousRevisions;
+                    applyConfig(previousConfig);
                 });
+                yield* auth.reconcileActiveCredentials(previousRouter.activeCredentialFingerprints());
             }));
             if (viewFailure !== undefined)
                 rollbackFailures.push(viewFailure);
             const persistFailure = yield* collectRollback(tryPromise(() => {
                 if (mutation.write) {
-                    writeFileAtomic(options.configPath, previousDocument, { mode: 0o600 });
-                    chmodSync(options.configPath, 0o600);
+                    writeFileAtomic(env.configPath, previousDocument, { mode: 0o600 });
+                    chmodSync(env.configPath, 0o600);
                 }
-                writeDaemonRevisions(options.home, previousRevisions);
+                writeDaemonRevisions(env.home, previousRevisions);
             }));
             if (persistFailure !== undefined)
                 rollbackFailures.push(persistFailure);
             const closeFailure = yield* collectRollback(candidate.close);
             if (closeFailure !== undefined)
                 rollbackFailures.push(closeFailure);
-            const sidecarFailure = yield* collectRollback(options.sidecar.reconcile(options.wantsSidecar(previousConfig)));
+            const sidecarFailure = yield* collectRollback(sidecar.reconcile(wantsCliproxySidecar(previousConfig)));
             if (sidecarFailure !== undefined)
                 rollbackFailures.push(sidecarFailure);
             if (rollbackFailures.length > 0) {
@@ -148,18 +208,19 @@ export function createDaemonGenerationManager(options) {
             }
             return yield* Effect.fail(error);
         })));
-        const previousTarget = proxy.swapTarget(candidate.url);
-        published = true;
         const retirementFailures = [];
-        const retireFailure = yield* collectRollback(tryPromise(() => options.onStage?.("retire")));
+        const authFailure = yield* collectRollback(auth.reconcileActiveCredentials(candidate.activeCredentialFingerprints()));
+        if (authFailure !== undefined)
+            retirementFailures.push(authFailure);
+        const retireFailure = yield* collectRollback(tryPromise(() => settings.onStage?.("retire")));
         if (retireFailure !== undefined)
             retirementFailures.push(retireFailure);
         if (previousTarget !== undefined) {
-            const idleFailure = yield* collectRollback(proxy.waitForTargetIdle(previousTarget, options.drainGraceMs));
+            const idleFailure = yield* collectRollback(proxy.waitForTargetIdle(previousTarget, settings.drainGraceMs));
             if (idleFailure !== undefined)
                 retirementFailures.push(idleFailure);
         }
-        const drainFailure = yield* collectRollback(previousRouter.gateway.drain(options.drainGraceMs));
+        const drainFailure = yield* collectRollback(previousRouter.gateway.drain(settings.drainGraceMs));
         if (drainFailure !== undefined)
             retirementFailures.push(drainFailure);
         const previousCloseFailure = yield* collectRollback(previousRouter.close);
@@ -173,4 +234,4 @@ export function createDaemonGenerationManager(options) {
         }
     }));
     return { start, replace };
-}
+});

package/dist/daemon-lifecycle-service.d.ts

@@ -1,7 +1,5 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 type LifecycleHandlers = Pick<EffectRouteKitControlHandlers, "daemon.status" | "daemon.roll" | "daemon.prepareShutdown">;
 /** Owns daemon status, rolling replacement, and shutdown preparation. */
-export declare class DaemonLifecycleService {
-    handlers(): LifecycleHandlers;
-}
+export declare const daemonLifecycleHandlers: LifecycleHandlers;
 export {};

package/dist/daemon-lifecycle-service.js

@@ -9,99 +9,93 @@ import { DaemonHost } from "./daemon-host-context.js";
 import { DaemonState } from "./daemon-state-context.js";
 import { Telemetry } from "./services/telemetry/service.js";
 /** Owns daemon status, rolling replacement, and shutdown preparation. */
-export class DaemonLifecycleService {
-    handlers() {
+export const daemonLifecycleHandlers = {
+    "daemon.status": () => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const state = yield* DaemonState;
+        const gateway = yield* ActiveGateway;
         return {
-            "daemon.status": () => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const state = yield* DaemonState;
-                const gateway = yield* ActiveGateway;
-                return {
-                    pid: process.pid,
-                    workerPid: process.pid,
-                    hostPid: env.hosted?.hostPid ?? process.pid,
-                    hostStartedAt: env.hosted?.hostStartedAt ?? env.startedAt,
-                    startedAt: env.startedAt,
-                    packageVersion: env.packageVersion,
-                    protocolVersion: CONTROL_PROTOCOL_VERSION,
-                    hostProtocolVersion: env.hosted === undefined ? 0 : DAEMON_HOST_PROTOCOL_VERSION,
-                    generation: env.generation,
-                    configRevision: state.revisions.config,
-                    accountRevision: state.revisions.accounts,
-                    controlUrl: gateway.control()?.url ?? "",
-                    dataUrl: env.hosted?.dataUrl() ?? gateway.dataUrl() ?? "",
-                    dataPort: gateway.proxy()?.port() ?? 0,
-                    supervisor: supervisorFromEnv(env.env),
-                    draining: state.draining,
-                    rolling: env.hosted?.rolling() ?? false
-                };
-            }),
-            "daemon.roll": (params) => Effect.gen(function* () {
-                const env = yield* DaemonEnv;
-                const telemetry = yield* Telemetry;
-                const host = yield* DaemonHost;
-                if (host.onRollRequested === undefined) {
-                    return yield* Effect.fail(new ControlError({
-                        code: "upgrade_required",
-                        message: "this daemon does not support rolling process replacement"
-                    }));
-                }
-                const startedAt = yield* Clock.currentTimeMillis;
-                const supervisor = ["systemd", "launchd", "detached"].includes(supervisorFromEnv(env.env))
-                    ? supervisorFromEnv(env.env)
-                    : "unknown";
-                const toVersion = params.candidate?.expectedVersion ?? env.packageVersion;
-                telemetry.daemon?.capture("routekit.daemon_lifecycle", {
-                    action: "roll_started",
-                    outcome: "success",
-                    supervisor,
-                    version: env.packageVersion,
-                    reason: params.reason,
-                    from_version: env.packageVersion,
-                    to_version: toVersion
-                });
-                return yield* host.onRollRequested(params).pipe(Effect.tap((result) => Effect.gen(function* () {
-                    const finishedAt = yield* Clock.currentTimeMillis;
-                    telemetry.daemon?.capture("routekit.daemon_lifecycle", {
-                        action: "roll_committed",
-                        outcome: "success",
-                        supervisor,
-                        version: result.packageVersion,
-                        reason: params.reason,
-                        from_version: env.packageVersion,
-                        to_version: result.packageVersion,
-                        duration_bucket: durationBucket(finishedAt - startedAt)
-                    });
-                })), Effect.tapError(() => Effect.gen(function* () {
-                    const finishedAt = yield* Clock.currentTimeMillis;
-                    telemetry.daemon?.capture("routekit.daemon_lifecycle", {
-                        action: "roll_failed",
-                        outcome: "error",
-                        supervisor,
-                        version: env.packageVersion,
-                        reason: params.reason,
-                        from_version: env.packageVersion,
-                        to_version: toVersion,
-                        rollback_stage: "candidate",
-                        duration_bucket: durationBucket(finishedAt - startedAt)
-                    });
-                })));
-            }),
-            "daemon.prepareShutdown": (params) => Effect.gen(function* () {
-                const state = yield* DaemonState;
-                if (state.lifecycle === "quiescing" ||
-                    state.lifecycle === "draining" ||
-                    state.lifecycle === "closed") {
-                    return { accepted: true };
-                }
-                const host = yield* DaemonHost;
-                state.beginRetire();
-                yield* state.awaitMutations;
-                if (host.onShutdownRequested !== undefined) {
-                    yield* host.onShutdownRequested(params.reason).pipe(Effect.forkDetach);
-                }
-                return { accepted: true };
-            })
+            pid: process.pid,
+            workerPid: process.pid,
+            hostPid: env.hosted?.hostPid ?? process.pid,
+            hostStartedAt: env.hosted?.hostStartedAt ?? env.startedAt,
+            startedAt: env.startedAt,
+            packageVersion: env.packageVersion,
+            protocolVersion: CONTROL_PROTOCOL_VERSION,
+            hostProtocolVersion: env.hosted === undefined ? 0 : DAEMON_HOST_PROTOCOL_VERSION,
+            generation: env.generation,
+            configRevision: state.revisions.config,
+            accountRevision: state.revisions.accounts,
+            controlUrl: gateway.control()?.url ?? "",
+            dataUrl: env.hosted?.dataUrl() ?? gateway.dataUrl() ?? "",
+            dataPort: gateway.proxy()?.port() ?? 0,
+            supervisor: supervisorFromEnv(env.env),
+            draining: state.draining,
+            rolling: env.hosted?.rolling() ?? false
         };
-    }
-}
+    }),
+    "daemon.roll": (params) => Effect.gen(function* () {
+        const env = yield* DaemonEnv;
+        const telemetry = yield* Telemetry;
+        const host = yield* DaemonHost;
+        if (host.onRollRequested === undefined) {
+            return yield* Effect.fail(new ControlError({
+                code: "upgrade_required",
+                message: "this daemon does not support rolling process replacement"
+            }));
+        }
+        const startedAt = yield* Clock.currentTimeMillis;
+        const supervisor = supervisorFromEnv(env.env);
+        const toVersion = params.candidate?.expectedVersion ?? env.packageVersion;
+        telemetry.daemon?.capture("routekit.daemon_lifecycle", {
+            action: "roll_started",
+            outcome: "success",
+            supervisor,
+            version: env.packageVersion,
+            reason: params.reason,
+            from_version: env.packageVersion,
+            to_version: toVersion
+        });
+        return yield* host.onRollRequested(params).pipe(Effect.tap((result) => Effect.gen(function* () {
+            const finishedAt = yield* Clock.currentTimeMillis;
+            telemetry.daemon?.capture("routekit.daemon_lifecycle", {
+                action: "roll_committed",
+                outcome: "success",
+                supervisor,
+                version: result.packageVersion,
+                reason: params.reason,
+                from_version: env.packageVersion,
+                to_version: result.packageVersion,
+                duration_bucket: durationBucket(finishedAt - startedAt)
+            });
+        })), Effect.tapError(() => Effect.gen(function* () {
+            const finishedAt = yield* Clock.currentTimeMillis;
+            telemetry.daemon?.capture("routekit.daemon_lifecycle", {
+                action: "roll_failed",
+                outcome: "error",
+                supervisor,
+                version: env.packageVersion,
+                reason: params.reason,
+                from_version: env.packageVersion,
+                to_version: toVersion,
+                rollback_stage: "candidate",
+                duration_bucket: durationBucket(finishedAt - startedAt)
+            });
+        })));
+    }),
+    "daemon.prepareShutdown": (params) => Effect.gen(function* () {
+        const state = yield* DaemonState;
+        if (state.lifecycle === "quiescing" ||
+            state.lifecycle === "draining" ||
+            state.lifecycle === "closed") {
+            return { accepted: true };
+        }
+        const host = yield* DaemonHost;
+        state.beginRetire();
+        yield* state.awaitMutations;
+        if (host.onShutdownRequested !== undefined) {
+            yield* host.onShutdownRequested(params.reason).pipe(Effect.forkDetach);
+        }
+        return { accepted: true };
+    })
+};