@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/test/repository-vitest-reporter.test.d.ts

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

package/dist/test/repository-vitest-reporter.test.js

@@ -0,0 +1,158 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { repositoryCommandTestEvidenceV1 } from "../adapters/repository-command-evidence.js";
+import { repositoryVitestTestArgumentsV1 } from "../adapters/repository-vitest-reporter.js";
+import { VITEST_REPORTER_RESULTS } from "./fixtures/vitest-reporter-results.js";
+const recipe = {
+    id: "vitest-behavior",
+    kind: "test",
+    cwd: ".",
+    executable: "corepack",
+    args: ["pnpm@11.15.1", "exec", "vitest", "run", "test/behavior.test.ts"],
+    timeoutMs: 10000
+};
+const result = (fixture, patch = {}) => ({
+    recipeId: recipe.id,
+    commit: "synthetic-fixture",
+    repetition: 1,
+    stage: "grade",
+    gradeExecuted: true,
+    exitCode: fixture.exitCode,
+    timedOut: false,
+    outputTruncated: false,
+    stdout: fixture.stdout,
+    stderr: "",
+    durationMs: 1,
+    trustedPreparationResults: [],
+    candidateValidationResults: [],
+    testReporter: "vitest-v1",
+    ...patch
+});
+// Deliberately synthetic new-envelope data only for parser-shape mutation tests.
+// These are not converted historical transcripts or framework-execution proof.
+const schemaFixture = (failed) => ({
+    exitCode: failed ? 1 : 0,
+    stdout: "ROUTEKIT_VITEST_PHASE_EVIDENCE_V1 " + JSON.stringify({
+        version: 1, complete: true, starts: 1, ends: 1, reason: failed ? "failed" : "passed",
+        eventIntegrity: true, unfinishedHooks: false, completedTestIds: ["schema-test"], unhandledErrors: [],
+        modules: [{ id: "schema-module", state: failed ? "failed" : "passed", errors: [], hooks: [], suites: [],
+                tests: [{ id: "schema-test", name: "synthetic parser shape", state: failed ? "failed" : "passed",
+                        errors: failed ? [{ name: "AssertionError", code: "ERR_ASSERTION" }] : [], hooks: [],
+                        diagnostic: { retryCount: 0, repeatCount: 0, flaky: false, duration: 1 } }] }]
+    }) + "\n"
+});
+// Keep the raw historical captures unchanged, including their historical expected
+// outcome annotations. They can no longer prove that an assertion was in a body.
+test("legacy Vitest transcripts without phase attribution retain no semantic credit", () => {
+    for (const fixture of VITEST_REPORTER_RESULTS) {
+        const evidence = repositoryCommandTestEvidenceV1(result(fixture), recipe.id);
+        assert.equal(evidence.outcome, "unknown", fixture.name);
+        assert.equal(evidence.detail, "legacy Vitest evidence has no host-owned phase attribution");
+    }
+});
+test("candidate output cannot select the Vitest evidence adapter", () => {
+    const fixture = schemaFixture(false);
+    const untagged = result(fixture);
+    const { testReporter: _testReporter, ...withoutHostSelection } = untagged;
+    assert.equal(repositoryCommandTestEvidenceV1(withoutHostSelection, recipe.id).outcome, "unknown");
+    assert.equal(repositoryCommandTestEvidenceV1(result(fixture, { stdout: "" }), recipe.id).outcome, "unknown", "a selected reporter must emit its protocol, regardless of process success");
+});
+test("Vitest evidence cannot rescue interrupted, truncated, unexecuted or invalidated runs", () => {
+    const fixture = schemaFixture(false);
+    const invalid = [
+        { timedOut: true },
+        { outputTruncated: true },
+        { exitCode: null },
+        { gradeExecuted: false },
+        { stage: "candidate-validation" },
+        { recipeId: "different-recipe" },
+        {
+            candidateValidationResults: [
+                {
+                    recipeId: "build",
+                    commit: "synthetic-fixture",
+                    repetition: 1,
+                    stage: "candidate-validation",
+                    exitCode: 1,
+                    timedOut: false,
+                    outputTruncated: false,
+                    stdout: "",
+                    stderr: "build did not pass",
+                    durationMs: 1
+                }
+            ]
+        }
+    ];
+    for (const patch of invalid) {
+        assert.equal(repositoryCommandTestEvidenceV1(result(fixture, patch), recipe.id).outcome, "unknown", JSON.stringify(patch));
+    }
+});
+test("duplicate, malformed and incomplete Vitest completion frames remain unknown", () => {
+    const fixture = schemaFixture(false);
+    assert.equal(repositoryCommandTestEvidenceV1(result(fixture), recipe.id).outcome, "pass", "schema mutation cases must start from a valid parser shape, not already-invalid legacy data");
+    const prefix = "ROUTEKIT_VITEST_PHASE_EVIDENCE_V1 ";
+    const parse = () => JSON.parse(fixture.stdout.slice(prefix.length));
+    const altered = (patch) => `${prefix}${JSON.stringify({ ...parse(), ...patch })}\n`;
+    const invalid = [
+        fixture.stdout + fixture.stdout,
+        fixture.stdout + VITEST_REPORTER_RESULTS[0].stdout,
+        `${prefix}{incomplete\n`,
+        altered({ complete: false }),
+        altered({ starts: 2 }),
+        altered({ ends: 2 }),
+        altered({ eventIntegrity: false }),
+        altered({ unfinishedHooks: true }),
+        altered({ completedTestIds: [] }),
+        altered({ completedTestIds: ["extra-case"] }),
+        altered({ reason: "interrupted" }),
+        altered({ modules: [] }),
+        altered({ unhandledErrors: [{ name: "AssertionError" }] })
+    ];
+    for (const stdout of invalid) {
+        assert.equal(repositoryCommandTestEvidenceV1(result(fixture, { stdout }), recipe.id).outcome, "unknown", stdout);
+    }
+});
+test("Vitest assertions cannot be admitted with inconsistent process or runner status", () => {
+    const passed = schemaFixture(false);
+    const failed = schemaFixture(true);
+    assert.equal(repositoryCommandTestEvidenceV1(result(passed, { exitCode: 1 }), recipe.id).outcome, "unknown");
+    assert.equal(repositoryCommandTestEvidenceV1(result(failed, { exitCode: 0 }), recipe.id).outcome, "unknown");
+    assert.equal(repositoryCommandTestEvidenceV1(result(failed, { exitCode: 2 }), recipe.id).outcome, "unknown");
+});
+test("only canonical one-shot Vitest commands receive the host reporter", () => {
+    const reporter = "/isolated/host-reporter.mjs";
+    const hostArguments = [
+        "--api.host=127.0.0.1",
+        "--api.middlewareMode",
+        "--reporter",
+        reporter
+    ];
+    assert.deepEqual(repositoryVitestTestArgumentsV1(recipe, reporter), [
+        ...recipe.args,
+        ...hostArguments
+    ]);
+    assert.deepEqual(repositoryVitestTestArgumentsV1({
+        ...recipe,
+        args: [
+            ...recipe.args,
+            "--reporter=json",
+            "--reporter",
+            "tap",
+            "--outputFile.json=old.json",
+            "--outputFile",
+            "old.txt",
+            "--api.host=localhost",
+            "--api.middlewareMode=false"
+        ]
+    }, reporter), [...recipe.args, ...hostArguments]);
+    assert.deepEqual(repositoryVitestTestArgumentsV1({ ...recipe, executable: "pnpm", args: ["exec", "vitest", "run", "test.js"] }, reporter), ["exec", "vitest", "run", "test.js", ...hostArguments]);
+    for (const args of [
+        ["pnpm@11.15.1", "exec", "vitest"],
+        ["pnpm@11.15.1", "exec", "vitest", "watch"],
+        ["pnpm@11.15.1", "exec", "node", "--test", "test.js"],
+        ["npm", "exec", "vitest", "run"],
+        ["pnpm@11.15.1", "test"]
+    ]) {
+        assert.equal(repositoryVitestTestArgumentsV1({ ...recipe, args }, reporter), undefined);
+    }
+});

package/dist/test/repository-workspace-build.test.d.ts

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

package/dist/test/repository-workspace-build.test.js

@@ -0,0 +1,160 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { test } from "node:test";
+import { promisify } from "node:util";
+import { Effect } from "effect";
+import { replayRepositoryCommandsV1 } from "../adapters/repository-command-runner.js";
+import { buildRepositoryBehaviorMapV1 } from "../services/repository-model/service.js";
+import { extractHistoricalTaskSeedsV1 } from "../services/task-seed/service.js";
+const exec = promisify(execFile);
+async function repository(t, cycle = false, frameworkTarget = false) {
+    const root = await realpath(await mkdtemp(join(tmpdir(), "routekit-workspace-build-unit-")));
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const file = async (path, content) => {
+        await mkdir(dirname(join(root, path)), { recursive: true });
+        await writeFile(join(root, path), content);
+    };
+    const manifest = (path, value) => file(path, `${JSON.stringify(value)}\n`);
+    await manifest("package.json", {
+        name: "workspace-build-fixture",
+        private: true,
+        packageManager: "pnpm@11.15.1"
+    });
+    await file("pnpm-workspace.yaml", 'packages:\n  - "packages/*"\n  - "apps/*"\n');
+    for (const [name, dependency] of [
+        ["base", undefined],
+        ["library", "base"]
+    ]) {
+        await manifest(`packages/${name}/package.json`, {
+            name: `@fixture/${name}`,
+            type: "module",
+            exports: "./dist/index.js",
+            scripts: { build: "node build.mjs" },
+            ...(dependency !== undefined || cycle
+                ? { dependencies: { [`@fixture/${dependency ?? "library"}`]: "workspace:*" } }
+                : {})
+        });
+        await file(`packages/${name}/src/index.js`, dependency === undefined
+            ? "export const stable = 1;\n"
+            : "export { stable } from '@fixture/base';\n");
+        await file(`packages/${name}/build.mjs`, [
+            "import { mkdir, copyFile } from 'node:fs/promises';",
+            "import { execFileSync } from 'node:child_process';",
+            "import assert from 'node:assert/strict';",
+            "assert.equal(execFileSync('pnpm', ['--version'], { encoding: 'utf8' }).trim(), '11.15.1');",
+            ...(dependency === undefined
+                ? []
+                : [
+                    "import { stable } from '@fixture/base';",
+                    "assert.equal(stable, 1);"
+                ]),
+            "await mkdir('dist', { recursive: true });",
+            "await copyFile('src/index.js', 'dist/index.js');"
+        ].join("\n"));
+    }
+    await manifest("apps/app/package.json", {
+        name: "@fixture/app",
+        type: "module",
+        dependencies: { "@fixture/library": "workspace:*" },
+        scripts: frameworkTarget
+            ? {
+                build: "next build",
+                "types:check": "node typecheck.mjs",
+                test: "node --test src/*.test.js"
+            }
+            : { build: "node build.mjs", test: "node --test src/*.test.js" }
+    });
+    await file("apps/app/build.mjs", [
+        "import assert from 'node:assert/strict';",
+        "import { stable } from '@fixture/library';",
+        "assert.equal(stable, 1, 'the workspace dependency must have emitted its exported dist file');"
+    ].join("\n"));
+    await manifest("packages/unrelated/package.json", {
+        name: "@fixture/unrelated",
+        type: "module",
+        scripts: { build: "node build.mjs" }
+    });
+    await file("packages/unrelated/build.mjs", "throw new Error('unrelated workspace must not build');\n");
+    await file(".gitignore", "node_modules/\ndist/\n.routekit/\n");
+    // All dependencies are local workspaces; this creates no network dependency.
+    await exec("corepack", ["pnpm@11.15.1", "install", "--lockfile-only", "--ignore-scripts", "--ignore-pnpmfile"], { cwd: root });
+    const git = (...args) => exec("git", ["-C", root, ...args]);
+    await git("init", "-q");
+    for (const value of [1, 2]) {
+        await file("apps/app/src/index.js", `import { stable } from '@fixture/library';\nexport const protocolValue = () => stable + ${value - 1};\n`);
+        await file("apps/app/src/index.test.js", [
+            "import assert from 'node:assert/strict';",
+            "import { test } from 'node:test';",
+            "import { protocolValue } from './index.js';",
+            `test('public protocol value', () => assert.equal(protocolValue(), ${value}));`
+        ].join("\n"));
+        await git("add", ".");
+        await git("-c", "core.hooksPath=/dev/null", "-c", "commit.gpgsign=false", "-c", "user.name=Fixture", "-c", "user.email=fixture@example.test", "commit", "-qm", value === 1 ? "initial fixture" : "fix(app): protocol value regression");
+    }
+    return root;
+}
+test("manifest-only workspace dependencies build their exported artifacts before an app, excluding unrelated packages", async (t) => {
+    const root = await repository(t);
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({ repositoryRoot: root, requestedRef: "HEAD" }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const seed = seeds.find((candidate) => candidate.summary === "fix(app): protocol value regression");
+    assert.ok(seed?.referenceCommit);
+    assert.deepEqual(seed.environment.candidateValidationRecipes.map((recipe) => recipe.cwd), ["packages/base", "packages/library", "apps/app"]);
+    const frozenInstall = seed.environment.trustedPreparationRecipes.find((recipe) => recipe.id === "command-environment-pnpm-frozen-install");
+    assert.ok(frozenInstall);
+    assert.ok(!frozenInstall.args.includes("--filter"), "the frozen install must link every workspace importer before dependency repair is disabled");
+    assert.ok(seed.environment.protectedControlPaths.includes("packages/library/package.json"));
+    assert.ok(seed.environment.protectedControlPaths.includes("packages/base/package.json"));
+    assert.ok(!seed.environment.protectedControlPaths.includes("packages/unrelated/package.json"));
+    const results = await Effect.runPromise(replayRepositoryCommandsV1({
+        repositoryRoot: root,
+        commit: seed.referenceCommit,
+        recipes: seed.environment.gradeRecipes,
+        trustedPreparationRecipes: seed.environment.trustedPreparationRecipes,
+        candidateValidationRecipes: seed.environment.candidateValidationRecipes,
+        repetitions: 1
+    }));
+    assert.ok(results.length > 0);
+    for (const result of results) {
+        assert.equal(result.gradeExecuted, true, JSON.stringify(result));
+        assert.equal(result.exitCode, 0, JSON.stringify(result));
+        assert.equal(result.candidateValidationResults.length, 3);
+        assert.ok(result.candidateValidationResults.every((validation) => validation.exitCode === 0));
+    }
+});
+test("manifest workspace dependency cycles still fail before replay recipe execution", async (t) => {
+    const root = await repository(t, true);
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({ repositoryRoot: root, requestedRef: "HEAD" }));
+    await assert.rejects(Effect.runPromise(extractHistoricalTaskSeedsV1(map)), /workspace build graph contains a cycle/u);
+});
+test("framework source-test targets use hermetic type checks after building workspace dependencies", async (t) => {
+    const root = await repository(t, false, true);
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({ repositoryRoot: root, requestedRef: "HEAD" }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const seed = seeds.find((candidate) => candidate.summary === "fix(app): protocol value regression");
+    assert.ok(seed);
+    assert.deepEqual(seed.environment.candidateValidationRecipes.map((recipe) => [
+        recipe.id,
+        recipe.cwd,
+        recipe.args
+    ]), [
+        [
+            "command-environment-build-fixture-base",
+            "packages/base",
+            ["pnpm@11.15.1", "run", "build"]
+        ],
+        [
+            "command-environment-build-fixture-library",
+            "packages/library",
+            ["pnpm@11.15.1", "run", "build"]
+        ],
+        [
+            "command-environment-types-check-fixture-app",
+            "apps/app",
+            ["pnpm@11.15.1", "run", "types:check"]
+        ]
+    ]);
+});

package/dist/test/strict-authoring-schema.test.d.ts

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

package/dist/test/strict-authoring-schema.test.js

@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Effect, Layer, Schema } from "effect";
+import { strictAuthoringSchema } from "../adapters/strict-authoring-schema.js";
+import { EvalAuthoringTransport } from "../project-authoring.js";
+import { RepositorySpecificationReviewV1 } from "../repository-specification-critique-protocol.js";
+import { RepositoryFoundryLanguageModel, RepositoryFoundryLanguageModelLive } from "../services/language-model/service.js";
+function assertStrictObjects(schema) {
+    if (typeof schema !== "object" || schema === null)
+        return;
+    const node = schema;
+    if (node.type === "object") {
+        assert.equal(node.additionalProperties, false);
+        assert.deepEqual([...node.required].sort(), Object.keys(node.properties).sort());
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value))
+            value.forEach(assertStrictObjects);
+        else
+            assertStrictObjects(value);
+    }
+}
+async function generate(schema, response) {
+    const calls = [];
+    const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+        complete: (input) => Effect.sync(() => {
+            calls.push(input);
+            assertStrictObjects(input.jsonSchema);
+            return JSON.stringify(response);
+        })
+    }));
+    const result = await Effect.runPromise(Effect.gen(function* () {
+        const model = yield* RepositoryFoundryLanguageModel;
+        return yield* model.generateAssignedStructured({
+            assignment: {
+                role: "specification-critic-a",
+                model: "codex/gpt-6-astra",
+                reasoningEffort: "high"
+            },
+            operationId: "strict-schema-regression",
+            instructions: "Review the task.",
+            input: {},
+            schemaName: "strict_schema_regression",
+            outputSchema: schema,
+            maximumOutputTokens: 256
+        });
+    }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)))));
+    return { result, calls };
+}
+test("model-facing critic properties become required nullable while legacy optional reviews remain valid", async () => {
+    const legacy = {
+        reviewerId: "critic",
+        reviewerKind: "model-critic",
+        independentlyProduced: true,
+        verdict: "sufficient",
+        detail: "The visible task states its requirements.",
+        findings: []
+    };
+    assert.deepEqual(Schema.decodeUnknownSync(RepositorySpecificationReviewV1)(legacy), legacy);
+    const { result, calls } = await generate(RepositorySpecificationReviewV1, {
+        ...legacy,
+        criticalBehaviorCoverage: null,
+        dimensionFit: null
+    });
+    assert.deepEqual(result.value, legacy);
+    assert.equal(calls.length, 1);
+    const properties = calls[0]?.jsonSchema.properties;
+    for (const name of ["criticalBehaviorCoverage", "dimensionFit"])
+        assert.ok((properties[name]?.anyOf).some((branch) => branch.type === "null"));
+    assert.deepEqual(Schema.decodeUnknownSync(RepositorySpecificationReviewV1)(legacy), legacy);
+});
+test("strict response normalization preserves genuine nullable values and required field failures", async () => {
+    const output = Schema.Struct({
+        required: Schema.String,
+        requiredNullable: Schema.NullOr(Schema.String),
+        optionalNullable: Schema.optionalKey(Schema.NullOr(Schema.String)),
+        optional: Schema.optionalKey(Schema.String)
+    });
+    const response = {
+        required: "yes",
+        requiredNullable: null,
+        optionalNullable: null,
+        optional: null
+    };
+    const { result } = await generate(output, response);
+    assert.deepEqual(result.value, {
+        required: "yes",
+        requiredNullable: null,
+        optionalNullable: null
+    });
+    assert.equal(response.optional, null, "response evidence is not mutated");
+    await assert.rejects(generate(output, { ...response, required: null }), /violated strict_schema_regression/u);
+});
+test("strict conversion and normalization follow nested references, arrays, and discriminated anyOf branches", async () => {
+    const detail = Schema.Struct({ note: Schema.optionalKey(Schema.String) }).annotate({
+        identifier: "SharedDetail"
+    });
+    const output = Schema.Struct({
+        entries: Schema.Array(Schema.Union([
+            Schema.Struct({
+                kind: Schema.Literal("omitted"),
+                detail,
+                value: Schema.optionalKey(Schema.String)
+            }),
+            Schema.Struct({
+                kind: Schema.Literal("nullable"),
+                detail,
+                value: Schema.NullOr(Schema.String)
+            })
+        ]))
+    });
+    const { result, calls } = await generate(output, {
+        entries: [
+            { kind: "omitted", detail: { note: null }, value: null },
+            { kind: "nullable", detail: { note: null }, value: null }
+        ]
+    });
+    assert.deepEqual(result.value, {
+        entries: [
+            { kind: "omitted", detail: {} },
+            { kind: "nullable", detail: {}, value: null }
+        ]
+    });
+    assert.ok(calls[0]?.jsonSchema.$defs);
+});
+test("recursive references preserve required structure while restoring optional descendants", () => {
+    const original = {
+        type: "object",
+        properties: { tree: { $ref: "#/$defs/Tree" } },
+        required: ["tree"],
+        additionalProperties: false,
+        $defs: {
+            Tree: {
+                type: "object",
+                properties: { name: { type: "string" }, child: { $ref: "#/$defs/Tree" } },
+                required: ["name"],
+                additionalProperties: false
+            }
+        }
+    };
+    const before = JSON.stringify(original);
+    const adapted = strictAuthoringSchema(original);
+    assertStrictObjects(adapted.jsonSchema);
+    assert.deepEqual(adapted.normalizeResponse({ tree: { name: "a", child: { name: "b", child: null } } }), { tree: { name: "a", child: { name: "b" } } });
+    assert.equal(JSON.stringify(original), before, "domain schema is not mutated");
+});
+test("unsupported open objects fail before model transport", async () => {
+    let calls = 0;
+    const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+        complete: () => Effect.sync(() => {
+            calls++;
+            return "{}";
+        })
+    }));
+    const result = Effect.gen(function* () {
+        const model = yield* RepositoryFoundryLanguageModel;
+        return yield* model.generateAssignedStructured({
+            assignment: { role: "critic", model: "codex/gpt-6-astra", reasoningEffort: "high" },
+            operationId: "open-schema",
+            instructions: "Return data.",
+            input: {},
+            schemaName: "open_schema",
+            outputSchema: Schema.Record(Schema.String, Schema.String),
+            maximumOutputTokens: 256
+        });
+    }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport))));
+    await assert.rejects(Effect.runPromise(result), /not strict-provider compatible/u);
+    assert.equal(calls, 0);
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-eval-setup",
   "private": false,
-  "version": "1.3.2",
+  "version": "1.5.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -18,6 +18,42 @@
     "./effect": {
       "types": "./dist/effect-api.d.ts",
       "default": "./dist/effect-api.js"
+    },
+    "./agentic-capabilities-protocol": {
+      "types": "./dist/agentic-capabilities-protocol.d.ts",
+      "default": "./dist/agentic-capabilities-protocol.js"
+    },
+    "./eval-capability-policy": {
+      "types": "./dist/eval-capability-policy.d.ts",
+      "default": "./dist/eval-capability-policy.js"
+    },
+    "./eval-capability-execution-envelope": {
+      "types": "./dist/eval-capability-execution-envelope.d.ts",
+      "default": "./dist/eval-capability-execution-envelope.js"
+    },
+    "./services/eval-candidate/service": {
+      "types": "./dist/services/eval-candidate/service.d.ts",
+      "default": "./dist/services/eval-candidate/service.js"
+    },
+    "./services/eval-environment/service": {
+      "types": "./dist/services/eval-environment/service.d.ts",
+      "default": "./dist/services/eval-environment/service.js"
+    },
+    "./services/eval-capabilities/service": {
+      "types": "./dist/services/eval-capabilities/service.d.ts",
+      "default": "./dist/services/eval-capabilities/service.js"
+    },
+    "./case-checkpoint-store": {
+      "types": "./dist/case-checkpoint-store.d.ts",
+      "default": "./dist/case-checkpoint-store.js"
+    },
+    "./services/command-observability/service": {
+      "types": "./dist/services/command-observability/service.d.ts",
+      "default": "./dist/services/command-observability/service.js"
+    },
+    "./adapters/repository-command-runner": {
+      "types": "./dist/adapters/repository-command-runner.d.ts",
+      "default": "./dist/adapters/repository-command-runner.js"
     }
   },
   "files": [
@@ -31,9 +67,13 @@
   },
   "dependencies": {
     "effect": "4.0.0-rc.108",
-    "@velum-labs/routekit-eval-contracts": "1.3.2",
-    "@velum-labs/routekit-eval-core": "1.3.2",
-    "@velum-labs/routekit-runtime": "1.3.2"
+    "typescript": "6.0.3",
+    "yaml": "2.9.0",
+    "zod": "4.4.3",
+    "@velum-labs/routekit-eval-contracts": "1.5.0",
+    "@velum-labs/routekit-eval-core": "1.5.0",
+    "@velum-labs/routekit-registry": "1.5.0",
+    "@velum-labs/routekit-runtime": "1.5.0"
   },
   "keywords": [
     "routekit",
@@ -42,11 +82,13 @@
     "routing"
   ],
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-rc.108"
+    "@effect/platform-node": "4.0.0-rc.108",
+    "vite": "7.3.6",
+    "vitest": "3.2.7"
   },
   "scripts": {
     "build": "tsc -b",
     "clean": "tsc -b --clean",
-    "test": "node --test \"dist/test/*.test.js\""
+    "test": "node --test --test-concurrency=1 \"dist/test/*.test.js\""
   }
 }