@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/test/eval-session-execution.test.js

@@ -0,0 +1,356 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { mkdtempSync, readdirSync, readFileSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { HttpSubmissionError, runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
+import { Effect, FileSystem, Path, PlatformError } from "effect";
+import { makeEvalSessionExecutionStore } from "../eval-session-execution-store.js";
+import { EvalSessionManager } from "../services/eval-session/service.js";
+const sha = (value) => createHash("sha256").update(value).digest("hex");
+const run = Effect.runPromise;
+const executionDigest = sha("immutable-authoring-execution");
+const request = {
+    method: "POST",
+    destination: "https://provider.invalid/v1/responses",
+    requestDigest: sha("actual native request"),
+    model: "native-model",
+    accountIdentity: sha("private account identity")
+};
+const completed = {
+    state: "completed",
+    httpStatus: 200,
+    responseDigest: sha("actual raw response"),
+    responseBytes: 19,
+    terminal: "eof"
+};
+function openInput(maximumProviderAttempts = 3) {
+    return {
+        purpose: "authoring",
+        operationId: "test-authoring",
+        allowedModels: ["openai/native-model"],
+        limits: {
+            calls: 32,
+            inputTokens: 10_000,
+            outputTokens: 1000,
+            perCallOutputTokens: 32,
+            wallTimeMs: 60_000
+        },
+        expiresInSeconds: 60,
+        gatewayUrl: "http://127.0.0.1:8080",
+        targetIdentity: "routekit-generation:1",
+        evidenceRequired: { executionDigest, maximumProviderAttempts, policy: "strict-http-v1" }
+    };
+}
+function identity(opened) {
+    assert.ok(opened.executionGrant);
+    return {
+        sessionId: opened.sessionId,
+        grantId: opened.executionGrant.grantId,
+        executionDigest: opened.executionGrant.executionDigest,
+        issuerIdentity: opened.executionGrant.issuerIdentity
+    };
+}
+async function fixture(t) {
+    const root = mkdtempSync(join(tmpdir(), "routekit-eval-execution-"));
+    let failedRenames = 0;
+    const store = await runRouteKitEffect(Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        return yield* makeEvalSessionExecutionStore(join(root, "private")).pipe(Effect.provideService(FileSystem.FileSystem, {
+            ...fs,
+            rename: (from, to) => Effect.suspend(() => {
+                if (failedRenames > 0) {
+                    failedRenames -= 1;
+                    return Effect.fail(PlatformError.systemError({
+                        _tag: "Unknown",
+                        module: "FileSystem",
+                        method: "rename",
+                        description: "injected required evidence write failure"
+                    }));
+                }
+                return fs.rename(from, to);
+            })
+        }));
+    }));
+    let now = 0;
+    const sessions = new EvalSessionManager({ store, now: () => now });
+    await run(sessions.initialize());
+    t.after(async () => {
+        failedRenames = 0;
+        await run(sessions.shutdown().pipe(Effect.ignore));
+        rmSync(root, { recursive: true, force: true });
+    });
+    return {
+        root,
+        store,
+        sessions,
+        failRenames: (count) => {
+            failedRenames = count;
+        },
+        setNow: (value) => {
+            now = value;
+        },
+        record: () => JSON.parse(readFileSync(join(store.directory, `${executionDigest}.json`), "utf8"))
+    };
+}
+async function authority(sessions, opened, suffix = "") {
+    const binding = await run(sessions.bindIngress(opened.sessionId, {
+        requestDigest: sha(`frontend request ${suffix}`),
+        model: "openai/native-model"
+    }));
+    return { binding, authority: await run(sessions.resolveSubmission(binding)) };
+}
+async function rejectsCode(effect, code) {
+    const result = await run(effect.pipe(Effect.map(() => ({ kind: "success" })), Effect.catch((error) => Effect.succeed({ kind: "error", error }))));
+    assert.equal(result.kind, "error");
+    if (result.kind === "error") {
+        assert.ok(result.error instanceof HttpSubmissionError);
+        assert.equal(result.error.code, code);
+    }
+}
+test("strict sessions require durable awaited authority while legacy sessions remain ephemeral", async () => {
+    const sessions = new EvalSessionManager({ now: () => 0 });
+    await rejectsCode(sessions.openEffect(openInput()), "execution-unavailable");
+    assert.throws(() => sessions.open(openInput()), /awaited openEffect/u);
+    const { evidenceRequired: _, ...legacy } = openInput();
+    const opened = sessions.open(legacy);
+    assert.equal(opened.executionGrant, undefined);
+    assert.equal(sessions.resolve(opened.bearerCredential)?.evalSession?.executionGrant, undefined);
+    assert.equal(sessions.close(opened.sessionId), true);
+});
+test("the real private store persists a permit before submission and seals only after revocation", async (t) => {
+    const { store, sessions, record } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput()));
+    assert.deepEqual(sessions.resolve(opened.bearerCredential)?.evalSession?.executionGrant, opened.executionGrant);
+    assert.equal(statSync(store.directory).mode & 0o777, 0o700);
+    assert.equal(statSync(join(store.directory, `${executionDigest}.json`)).mode & 0o777, 0o600);
+    assert.throws(() => sessions.close(opened.sessionId), /awaited closeEffect/u);
+    const bound = await authority(sessions, opened);
+    let submissions = 0;
+    const attempt = await run(bound.authority.begin(request).pipe(Effect.tap(() => Effect.sync(() => {
+        assert.equal(record().evidence.receipts.length, 1);
+        submissions += 1;
+    }))));
+    assert.equal(submissions, 1);
+    let evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.receipts[0]?.state, "intent");
+    assert.equal(evidence.exposure, "unknown");
+    await run(bound.authority.settle(attempt.attemptId, completed));
+    evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "open");
+    assert.equal(evidence.exposure, "closed");
+    assert.equal(await run(sessions.closeEffect(opened.sessionId)), true);
+    evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "sealed");
+    assert.equal(evidence.exposure, "closed");
+    assert.equal(sessions.resolve(opened.bearerCredential), undefined);
+    await rejectsCode(sessions.openEffect(openInput()), "execution-consumed");
+});
+test("concurrent ingresses and retries share one non-resettable provider attempt allowance", async (t) => {
+    const { sessions } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput(3)));
+    const first = await authority(sessions, opened, "first");
+    const second = await authority(sessions, opened, "second");
+    const results = await Promise.all(Array.from({ length: 12 }, (_, index) => run((index % 2 === 0 ? first : second).authority.begin(request).pipe(Effect.map((attempt) => ({ kind: "attempt", attempt })), Effect.catch((error) => Effect.succeed({ kind: "error", code: error.code }))))));
+    assert.equal(results.filter((entry) => entry.kind === "attempt").length, 3);
+    assert.deepEqual(results.filter((entry) => entry.kind === "error").map((entry) => entry.code), Array(9).fill("provider-attempt-limit"));
+    const evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.receipts.length, 3);
+    assert.equal(new Set(evidence.receipts.map((entry) => entry.attemptId)).size, 3);
+    await rejectsCode(sessions.openEffect(openInput(3)), "execution-consumed");
+});
+test("server ingresses reject mismatches and duplicate delivery without manufacturing attempts", async (t) => {
+    const { sessions } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput()));
+    const binding = await run(sessions.bindIngress(opened.sessionId, {
+        requestDigest: sha("bound frontend"),
+        model: "openai/native-model"
+    }));
+    await rejectsCode(sessions.resolveSubmission({ ...binding, requestDigest: sha("tampered") }), "ingress-identity");
+    await rejectsCode(sessions.resolveSubmission({ ...binding, issuerIdentity: "another-issuer" }), "execution-identity");
+    await rejectsCode(sessions.resolveSubmission({ ...binding, grantId: "another-grant" }), "execution-identity");
+    await run(sessions.resolveSubmission(binding));
+    await rejectsCode(sessions.resolveSubmission(binding), "ingress-consumed");
+    await run(sessions.closeEffect(opened.sessionId));
+    const evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "sealed");
+    assert.equal(evidence.exposure, "closed");
+    assert.equal(evidence.receipts.length, 0);
+    assert.equal(evidence.ingresses[0]?.status, "no-attempt");
+    await rejectsCode(sessions.openEffect(openInput()), "execution-consumed");
+});
+test("unknown is sticky across concurrent completion and forbids another strict submission", async (t) => {
+    const { sessions } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput()));
+    const bound = await authority(sessions, opened);
+    const first = await run(bound.authority.begin(request));
+    const second = await run(bound.authority.begin(request));
+    await run(bound.authority.settle(first.attemptId, { state: "unknown", reason: "transport-error" }));
+    let evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "draining");
+    assert.equal(sessions.resolve(opened.bearerCredential), undefined);
+    await rejectsCode(bound.authority.begin(request), "execution-closed");
+    await run(bound.authority.settle(second.attemptId, completed));
+    await run(bound.authority.settle(first.attemptId, completed));
+    evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "sealed");
+    assert.equal(evidence.exposure, "unknown");
+    assert.deepEqual(evidence.receipts.map((entry) => entry.state), ["unknown", "completed"]);
+});
+test("close revokes new work but existing provider owners settle a draining grant", async (t) => {
+    const { sessions } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput()));
+    const bound = await authority(sessions, opened);
+    const { attemptId } = await run(bound.authority.begin(request));
+    assert.equal(await run(sessions.closeEffect(opened.sessionId)), true);
+    assert.equal(await run(sessions.closeEffect(opened.sessionId)), false);
+    let evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "draining");
+    assert.equal(evidence.exposure, "unknown");
+    await rejectsCode(bound.authority.begin(request), "execution-closed");
+    await run(bound.authority.settle(attemptId, completed));
+    evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "sealed");
+    assert.equal(evidence.exposure, "closed");
+});
+test("restart recovers unmatched intents as unknown and a retiring manager cannot overwrite them", async (t) => {
+    const { sessions, store } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput()));
+    const bound = await authority(sessions, opened);
+    const { attemptId } = await run(bound.authority.begin(request));
+    const reopenedStore = await runRouteKitEffect(makeEvalSessionExecutionStore(store.directory));
+    const successor = new EvalSessionManager({ store: reopenedStore, now: () => 1_000 });
+    await run(successor.initialize());
+    assert.equal(successor.resolve(opened.bearerCredential), undefined);
+    let evidence = await run(successor.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "sealed");
+    assert.equal(evidence.exposure, "unknown");
+    assert.deepEqual(evidence.receipts[0]?.outcome, { state: "unknown", reason: "daemon-restart" });
+    await run(bound.authority.settle(attemptId, completed));
+    evidence = await run(successor.executionEvidence(identity(opened)));
+    assert.deepEqual(evidence.receipts[0]?.outcome, { state: "unknown", reason: "daemon-restart" });
+    await rejectsCode(bound.authority.begin(request), "execution-closed");
+    await rejectsCode(successor.openEffect(openInput()), "execution-consumed");
+});
+test("only explicitly closed untouched readiness grants can be reissued and their history remains bound", async (t) => {
+    const { sessions, store, record } = await fixture(t);
+    const first = await run(sessions.openEffect(openInput()));
+    await run(sessions.closeEffect(first.sessionId));
+    await rejectsCode(sessions.openEffect(openInput(4)), "execution-consumed");
+    const second = await run(sessions.openEffect(openInput()));
+    assert.notEqual(first.sessionId, second.sessionId);
+    assert.notEqual(first.executionGrant?.grantId, second.executionGrant?.grantId);
+    assert.equal(record().readinessHistory.length, 1);
+    assert.equal((await run(sessions.executionEvidence(identity(first)))).state, "sealed");
+    assert.equal((await run(sessions.executionEvidence(identity(second)))).state, "open");
+    await rejectsCode(sessions.executionEvidence({
+        ...identity(second),
+        grantId: first.executionGrant.grantId
+    }), "execution-identity");
+    const successor = new EvalSessionManager({ store, now: () => 1000 });
+    await run(successor.initialize());
+    assert.equal((await run(successor.executionEvidence(identity(second)))).exposure, "closed");
+    // Recovery revokes the unclosed grant, but does not turn unresolved readiness
+    // into proof that an explicit no-request close completed.
+    await rejectsCode(successor.openEffect(openInput()), "execution-consumed");
+});
+test("required intent write failure yields zero submissions and poisons even with repeated I/O failure", async (t) => {
+    for (const failures of [1, 2]) {
+        await t.test(`${failures} failed writes`, async (t) => {
+            const { sessions, failRenames, record } = await fixture(t);
+            const opened = await run(sessions.openEffect(openInput()));
+            const bound = await authority(sessions, opened);
+            let submissions = 0;
+            failRenames(failures);
+            await rejectsCode(bound.authority.begin(request).pipe(Effect.tap(() => Effect.sync(() => {
+                submissions += 1;
+            }))), "execution-store");
+            assert.equal(submissions, 0);
+            assert.equal(record().evidence.receipts.length, 0);
+            assert.equal(sessions.resolve(opened.bearerCredential), undefined);
+            await rejectsCode(bound.authority.begin(request), "execution-closed");
+            failRenames(0);
+            const evidence = await run(sessions.executionEvidence(identity(opened)));
+            assert.equal(evidence.poisoned, true);
+            assert.equal(evidence.state, "sealed");
+            assert.equal(evidence.exposure, "unknown");
+            assert.equal(evidence.receipts.length, 0);
+        });
+    }
+});
+test("required settlement I/O failure retains the durable intent and cannot report closed exposure", async (t) => {
+    const { sessions, store, failRenames } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput()));
+    const bound = await authority(sessions, opened);
+    const { attemptId } = await run(bound.authority.begin(request));
+    failRenames(2);
+    await rejectsCode(bound.authority.settle(attemptId, completed), "execution-store");
+    failRenames(0);
+    let evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.poisoned, true);
+    assert.equal(evidence.receipts[0]?.state, "intent");
+    assert.equal(evidence.exposure, "unknown");
+    const successor = new EvalSessionManager({ store, now: () => 1000 });
+    await run(successor.initialize());
+    evidence = await run(successor.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "sealed");
+    assert.equal(evidence.exposure, "unknown");
+    assert.equal(evidence.receipts[0]?.state, "unknown");
+});
+test("two independent initialized store owners cannot mint two allowances for one execution", async (t) => {
+    const { sessions, store } = await fixture(t);
+    const otherStore = await runRouteKitEffect(makeEvalSessionExecutionStore(store.directory));
+    const other = new EvalSessionManager({ store: otherStore, now: () => 0 });
+    await run(other.initialize());
+    const results = await Promise.all([sessions, other].map((owner) => run(owner.openEffect(openInput()).pipe(Effect.map((opened) => ({ kind: "opened", opened })), Effect.catch((error) => Effect.succeed({ kind: "error", code: error.code }))))));
+    assert.equal(results.filter((entry) => entry.kind === "opened").length, 1);
+    assert.deepEqual(results.filter((entry) => entry.kind === "error").map((entry) => entry.code), ["execution-consumed"]);
+    await run(other.shutdown());
+});
+test("corrupt evidence is never treated as a missing or fresh execution", async (t) => {
+    const { sessions, store } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput()));
+    const path = join(store.directory, `${executionDigest}.json`);
+    writeFileSync(path, "{malformed private authority\n");
+    await rejectsCode(sessions.executionEvidence(identity(opened)), "execution-store");
+    assert.equal(readFileSync(path, "utf8"), "{malformed private authority\n");
+    await rejectsCode(sessions.openEffect(openInput()), "execution-store");
+    const successor = new EvalSessionManager({ store });
+    await rejectsCode(successor.initialize(), "execution-store");
+    assert.equal(sessions.resolve(opened.bearerCredential), undefined);
+});
+test("private authority rejects symlinks and persists no bearer, payload, headers or raw account identity", async (t) => {
+    const { root, sessions, store } = await fixture(t);
+    const alias = join(root, "alias");
+    symlinkSync(store.directory, alias);
+    await rejectsCode(makeEvalSessionExecutionStore(alias).pipe(Effect.provideService(FileSystem.FileSystem, await runRouteKitEffect(FileSystem.FileSystem)), Effect.provideService(Path.Path, await runRouteKitEffect(Path.Path))), "execution-store");
+    const opened = await run(sessions.openEffect(openInput()));
+    const bound = await authority(sessions, opened);
+    const { attemptId } = await run(bound.authority.begin(request));
+    await run(bound.authority.settle(attemptId, completed));
+    const text = readdirSync(store.directory)
+        .filter((file) => file.endsWith(".json"))
+        .map((file) => readFileSync(join(store.directory, file), "utf8"))
+        .join("\n");
+    for (const secret of [
+        opened.bearerCredential,
+        "actual native request",
+        "actual raw response",
+        "private account identity",
+        "authorization",
+        "headers"
+    ])
+        assert.equal(text.includes(secret), false);
+});
+test("expiry refuses another provider attempt and an authoritative read revokes the stale grant", async (t) => {
+    const { sessions, setNow } = await fixture(t);
+    const opened = await run(sessions.openEffect(openInput()));
+    const bound = await authority(sessions, opened);
+    setNow(60_000);
+    await rejectsCode(bound.authority.begin(request), "execution-closed");
+    const evidence = await run(sessions.executionEvidence(identity(opened)));
+    assert.equal(evidence.state, "sealed");
+    assert.equal(evidence.exposure, "closed");
+    assert.equal(evidence.receipts.length, 0);
+});

package/dist/test/eval-session-service.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { ManagedRuntime } from "effect";
+import { Deferred, Effect, ManagedRuntime } from "effect";
 import { EvalSessionManager, EvalSessions } from "../services/eval-session/service.js";
 const limits = {
     calls: 2,
@@ -76,6 +76,75 @@ test("eval session admission enforces call, input, output, and expiry limits", (
     now = 60_000;
     assert.equal(sessions.resolve(opened.bearerCredential), undefined);
 });
+test("concurrent eval authoring admissions cannot oversubscribe any shared budget", async (t) => {
+    for (const scenario of [
+        { reason: "call_limit", calls: 2, inputTokens: 100, outputTokens: 100 },
+        { reason: "input_limit", calls: 10, inputTokens: 8, outputTokens: 100 },
+        { reason: "output_limit", calls: 10, inputTokens: 100, outputTokens: 8 }
+    ]) {
+        await t.test(scenario.reason, async () => {
+            const sessions = new EvalSessionManager({ now: () => 0 });
+            const opened = sessions.open({
+                purpose: "authoring",
+                operationId: `concurrent-${scenario.reason}`,
+                allowedModels: ["openai/gpt-6-astra"],
+                limits: {
+                    ...limits,
+                    calls: scenario.calls,
+                    inputTokens: scenario.inputTokens,
+                    outputTokens: scenario.outputTokens
+                },
+                expiresInSeconds: 60,
+                gatewayUrl: "http://127.0.0.1:8080",
+                targetIdentity: "routekit-generation:1"
+            });
+            const admit = sessions.resolve(opened.bearerCredential)?.evalSession?.admit;
+            assert.ok(admit !== undefined);
+            const results = await Promise.all(Array.from({ length: 8 }, async () => {
+                // Queue all requests before any reservation, as concurrent HTTP handlers do.
+                await Promise.resolve();
+                return admit("openai/gpt-6-astra", 4, 4);
+            }));
+            assert.equal(results.filter((result) => result.admitted).length, 2);
+            assert.deepEqual(results.filter((result) => !result.admitted), Array.from({ length: 6 }, () => ({ admitted: false, reason: scenario.reason })));
+            sessions.closeAll();
+        });
+    }
+});
+test("failed concurrent authoring interrupts siblings without releasing admitted reservations", async () => {
+    const sessions = new EvalSessionManager({ now: () => 0 });
+    const opened = sessions.open({
+        purpose: "authoring",
+        operationId: "concurrent-authoring-cancellation",
+        allowedModels: ["openai/gpt-6-astra"],
+        limits,
+        expiresInSeconds: 60,
+        gatewayUrl: "http://127.0.0.1:8080",
+        targetIdentity: "routekit-generation:1"
+    });
+    const admit = sessions.resolve(opened.bearerCredential)?.evalSession?.admit;
+    assert.ok(admit !== undefined);
+    const bothAdmitted = Deferred.makeUnsafe();
+    let admitted = 0;
+    let siblingInterrupted = false;
+    const result = await Effect.runPromiseExit(Effect.forEach([0, 1], (index) => Effect.gen(function* () {
+        assert.deepEqual(admit("openai/gpt-6-astra", 5_000, 6), { admitted: true });
+        admitted += 1;
+        if (admitted === 2)
+            yield* Deferred.succeed(bothAdmitted, undefined);
+        yield* Deferred.await(bothAdmitted);
+        if (index === 0)
+            return yield* Effect.fail({ _tag: "TestProviderFailure" });
+        return yield* Effect.never.pipe(Effect.onInterrupt(() => Effect.sync(() => {
+            siblingInterrupted = true;
+        })));
+    }), { concurrency: 2 }).pipe(Effect.timeout("2 seconds")));
+    assert.equal(result._tag, "Failure");
+    assert.equal(admitted, 2);
+    assert.equal(siblingInterrupted, true);
+    assert.deepEqual(admit("openai/gpt-6-astra", 0, 1), { admitted: false, reason: "call_limit" });
+    sessions.closeAll();
+});
 test("eval sessions close when their Effect-owned daemon scope is disposed", async () => {
     let sequence = 20;
     const runtime = ManagedRuntime.make(EvalSessions.layer({

package/dist/test/host-worker-session.test.js

@@ -24,6 +24,7 @@ test("host worker coordinator consumes worker ready and response IPC", () => {
         workerPid: 1,
         workerStartedAt: "2026-01-01T00:00:00.000Z",
         packageVersion: "0.0.0",
+        sourceBuildId: "checkout-build",
         generation: 1,
         configRevision: 1,
         accountRevision: 1,

package/dist/test/launcher-session.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/launcher-session.test.js

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { runRouteKitEffectWith } from "@velum-labs/routekit-runtime/effect";
+import { Context, Effect, Ref } from "effect";
+import { launcherHandlers } from "../launcher-service.js";
+import { ActiveGateway } from "../services/active-gateway/service.js";
+import { LauncherSessionManager } from "../services/launcher-session/service.js";
+import { LauncherSessions } from "../services/launcher-session/service.js";
+import { Tokens } from "../services/tokens/service.js";
+test("launcher sessions bind repository context without durable token state", () => {
+    let byte = 0;
+    const sessions = new LauncherSessionManager({
+        random: (length) => Buffer.alloc(length, byte++)
+    });
+    const token = sessions.open({
+        repositoryRoot: "/workspace/repository",
+        profileName: "quality",
+        role: "owner"
+    });
+    assert.deepEqual(sessions.resolve(token), {
+        id: `launcher_${Buffer.alloc(16, 1).toString("base64url")}`,
+        label: "launcher:quality",
+        role: "owner",
+        routing: {
+            repositoryRoot: "/workspace/repository",
+            profileName: "quality"
+        }
+    });
+    assert.equal(sessions.resolve("wrong"), undefined);
+    sessions.closeAll();
+    assert.equal(sessions.resolve(token), undefined);
+});
+test("launcher preparation mints a session only after validation and response preparation", async () => {
+    const repositoryRoot = join(dirname(fileURLToPath(import.meta.url)), "../../../../test/fixtures/repository-routing-profiles");
+    let randomCalls = 0;
+    const sessions = new LauncherSessionManager({
+        random: (length) => Buffer.alloc(length, ++randomCalls)
+    });
+    const candidateToken = Buffer.alloc(32, 1).toString("base64url");
+    let failGatewayUrl = false;
+    const gateway = ActiveGateway.of({
+        state: await Effect.runPromise(Ref.make({})),
+        router: () => undefined,
+        proxy: () => undefined,
+        dataUrl: () => {
+            if (failGatewayUrl)
+                throw new Error("gateway URL unavailable");
+            return "http://127.0.0.1:8080";
+        },
+        control: () => undefined
+    });
+    const tokens = Tokens.of({
+        dataAuth: { token: "owner-token", path: "/unused" },
+        issue: () => Effect.die("unused"),
+        list: () => Effect.succeed([]),
+        revoke: () => Effect.die("unused"),
+        resolve: () => undefined,
+        dataTokenForPrincipal: () => Effect.succeed("owner-token")
+    });
+    const services = Context.empty().pipe(Context.add(ActiveGateway, gateway), Context.add(Tokens, tokens), Context.add(LauncherSessions, sessions));
+    const handler = launcherHandlers({
+        listModels: () => Effect.succeed({ models: [], revision: 0 })
+    })["launcher.prepare"];
+    const context = { requestId: "launcher-test", signal: new AbortController().signal };
+    const prepare = (input) => runRouteKitEffectWith(services, handler(input, context));
+    await assert.rejects(prepare({ tool: "claude", model: "unknown" }));
+    await assert.rejects(prepare({ tool: "codex", model: "unknown" }));
+    assert.equal(randomCalls, 0);
+    assert.equal(sessions.resolve(candidateToken), undefined);
+    failGatewayUrl = true;
+    await assert.rejects(prepare({ tool: "codex", model: "auto:quality", cwd: repositoryRoot }));
+    assert.equal(randomCalls, 0);
+    assert.equal(sessions.resolve(candidateToken), undefined);
+    failGatewayUrl = false;
+    const prepared = await prepare({
+        tool: "codex",
+        model: "auto:quality",
+        cwd: repositoryRoot
+    });
+    assert.equal(prepared.model, "auto:quality");
+    assert.equal(prepared.gatewayUrl, "http://127.0.0.1:8080");
+    assert.equal(prepared.authToken, candidateToken);
+    assert.equal(sessions.resolve(prepared.authToken)?.routing?.profileName, "quality");
+    assert.equal(randomCalls, 2);
+});

package/dist/test/leaderboard.test.js

@@ -9,6 +9,29 @@ import { aggregateInspections, defaultLeaderboardWindow, LeaderboardRollupStore
 function inspection(input) {
     return {
         callId: input.callId,
+        episodeId: input.callId,
+        hopIndex: 0,
+        role: "explicit",
+        cacheOutcome: "miss_cold",
+        episode: {
+            episodeId: input.callId,
+            hopCount: 1,
+            models: [input.model ?? "openai/gpt-5.5"],
+            cacheOutcomes: ["miss_cold"],
+            ...(input.cost === undefined ? {} : { cashUsd: input.cost }),
+            window: 0,
+            subscriptionUnitCalls: 0,
+            classifierUsd: 0,
+            classifierWindow: 0,
+            failoverUsd: 0,
+            failoverWindow: 0,
+            switchMissTokens: 0,
+            taxCashUsd: 0,
+            taxWindow: 0,
+            taxApiEquivalentUsd: 0,
+            switchMissPremiumUsd: 0,
+            stickyCounterfactuals: []
+        },
         status: input.status ?? "succeeded",
         effectiveModel: input.model ?? "openai/gpt-5.5",
         provider: input.provider ?? "openai",
@@ -23,7 +46,8 @@ function inspection(input) {
         cost: {
             ...(input.cost !== undefined ? { estimateUsd: input.cost } : {}),
             unknownUsage: false,
-            unknownCost: input.unknownCost ?? false
+            unknownCost: input.unknownCost ?? false,
+            switchMissPremiumUsd: 0
         },
         timing: {
             startedAt: input.startedAt ?? "2026-07-27T10:00:00.000Z",

package/dist/test/provider-modules.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/provider-modules.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { ProviderModuleRegistry } from "@velum-labs/routekit-provider-core";
+import { fakeOpenAi } from "@velum-labs/routekit-provider-fake-openai";
+import { startRouteKitDaemon } from "../index.js";
+import { installProviderModulesForTest, providerModules } from "../provider-modules.js";
+test("production daemon module catalog includes first-party clouds but no fixtures", () => {
+    const ids = providerModules.list().map((module) => module.id);
+    for (const id of [
+        "openai",
+        "anthropic",
+        "bedrock",
+        "google",
+        "openrouter",
+        "cliproxy",
+        "claude-code",
+        "codex",
+        "openai-compatible",
+        "custom",
+        "openai-azure",
+        "google-vertex"
+    ]) {
+        assert.ok(ids.includes(id), `missing provider module ${id}`);
+    }
+    assert.equal(ids.includes("fake-openai"), false);
+});
+test("fake provider chats through the daemon without config-core registration", async () => {
+    const root = mkdtempSync(join(tmpdir(), "routekit-fake-provider-"));
+    const restoreProviderModules = installProviderModulesForTest(new ProviderModuleRegistry([...providerModules.list(), fakeOpenAi]));
+    const configPath = join(root, "router.yaml");
+    writeFileSync(configPath, ["sources:", "  fixture:", "    use: fake-openai", "defaultModel: fixture/chat-model", ""].join("\n"));
+    const daemon = await startRouteKitDaemon({
+        packageVersion: "1.4.0-test",
+        stateHome: join(root, "state"),
+        configPath,
+        port: 0,
+        portless: false,
+        env: { HOME: root, ROUTEKIT_HOME: join(root, "state"), ROUTEKIT_PORTLESS: "0" }
+    });
+    try {
+        const dataToken = readFileSync(daemon.record.authTokenFile, "utf8").trim();
+        const response = await fetch(`${daemon.dataUrl}/v1/chat/completions`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${dataToken}`,
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({
+                model: "fixture/chat-model",
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(response.status, 200);
+        const body = (await response.json());
+        assert.equal(body.choices[0]?.message.content, "fake-openai");
+    }
+    finally {
+        await daemon.close();
+        restoreProviderModules();
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/test/routekit-upstream-sources.test.d.ts

@@ -0,0 +1 @@
+export {};