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

package/dist/adapters/repository-seed-selection.js

@@ -0,0 +1,79 @@
+// Natural-language dimension descriptions contain the same function words as
+// nearly every test name. They are not evidence of a shared behavior. Keep
+// actual domain terms and zero-overlap candidates: this remains retrieval, not
+// a semantic eligibility or admission decision.
+const grammaticalWords = new Set([
+    "across",
+    "all",
+    "and",
+    "any",
+    "are",
+    "for",
+    "from",
+    "has",
+    "have",
+    "into",
+    "its",
+    "that",
+    "the",
+    "their",
+    "then",
+    "there",
+    "these",
+    "this",
+    "those",
+    "was",
+    "were",
+    "when",
+    "where",
+    "which",
+    "while",
+    "with"
+]);
+const words = (value) => new Set((value
+    .normalize("NFKC")
+    .toLowerCase()
+    .match(/[\p{L}\p{N}]+/gu) ?? [])
+    .filter((word) => word.length >= 3 && !grammaticalWords.has(word))
+    .map((word) => (word.endsWith("s") && word.length > 4 ? word.slice(0, -1) : word)));
+const behaviorPaths = (episode) => [
+    ...new Set([...episode.implementationPaths, ...episode.protocolPaths, ...episode.testPaths])
+];
+/** Retrieval heuristic only; executable qualification and dimension critics remain mandatory. */
+export function rankRepositorySeedCandidatesV1(map, requestedDimension) {
+    const terms = [...words(requestedDimension)];
+    return map.historyEpisodes
+        .filter((episode) => episode.seedEligible &&
+        episode.parentCommit !== undefined &&
+        // Historical extraction overlays every changed test at its post-change
+        // path. Deleted tests cannot be read there, and moved tests require
+        // explicit old/new path handling that this replay lane does not provide.
+        !episode.changedPaths.some((entry) => entry.kind === "test" && ["deleted", "renamed"].includes(entry.status)) &&
+        behaviorPaths(episode).every((path) => !path.split("/").some((segment) => /^(?:docs?|examples?)$/iu.test(segment))))
+        .map((episode) => {
+        const subject = words(episode.subject);
+        const paths = words(behaviorPaths(episode).join(" "));
+        const names = words(map.tests
+            .filter((test) => episode.testPaths.includes(test.path))
+            .flatMap((test) => test.names)
+            .join(" "));
+        const matchedTerms = terms.filter((term) => subject.has(term) || paths.has(term) || names.has(term));
+        const relevance = terms.reduce((total, term) => total +
+            // Commit descriptions often name broad goals. Prefer concrete path
+            // evidence over wording alone when spending a bounded replay budget.
+            (subject.has(term) ? 1 : 0) +
+            (paths.has(term) ? 2 : 0) +
+            (names.has(term) ? 1 : 0), 0);
+        return { episode, relevance, matchedTerms };
+    })
+        .sort((left, right) => 
+    // Broad refactors touch many plausible keywords without isolating one
+    // behavior. Rank relevance per behavior/test path before raw overlap;
+    // incidental documentation neither supplies evidence nor expands scope.
+    right.relevance / Math.max(1, behaviorPaths(right.episode).length) -
+        left.relevance / Math.max(1, behaviorPaths(left.episode).length) ||
+        behaviorPaths(left.episode).length - behaviorPaths(right.episode).length ||
+        right.relevance - left.relevance ||
+        right.episode.occurredAt.localeCompare(left.episode.occurredAt) ||
+        left.episode.commit.localeCompare(right.episode.commit));
+}

package/dist/adapters/repository-solution-edits.d.ts

@@ -0,0 +1,49 @@
+import { Effect, Schema } from "effect";
+import { RepositoryFoundryError } from "../errors.js";
+export declare const RepositorySolutionFileOutputV1: Schema.Union<readonly [Schema.Struct<{
+    readonly path: Schema.String;
+    readonly content: Schema.String;
+}>, Schema.Struct<{
+    readonly path: Schema.String;
+    readonly edits: Schema.$Array<Schema.Struct<{
+        readonly search: Schema.String;
+        readonly replace: Schema.String;
+    }>>;
+}>]>;
+export type RepositorySolutionFileOutputV1 = typeof RepositorySolutionFileOutputV1.Type;
+export type RepositorySolutionEditSourceV1 = {
+    readonly path: string;
+    readonly content: string;
+    readonly visibleExcerpt: string;
+    /** Separate excerpts actually supplied to the same model request; never concatenated. */
+    readonly additionalVisibleExcerpts?: readonly string[];
+};
+export declare const loadPinnedSolutionEditSourcesV1: (input: {
+    readonly repositoryRoot: string;
+    readonly initialCommit: string;
+    readonly visibleSources: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    readonly allowedPaths: ReadonlySet<string>;
+}) => Effect.Effect<RepositorySolutionEditSourceV1[], RepositoryFoundryError, never>;
+export declare const materializeSolutionFileOverridesV1: (input: {
+    readonly fileOverrides: readonly RepositorySolutionFileOutputV1[];
+    readonly sources: readonly RepositorySolutionEditSourceV1[];
+    readonly allowedPaths: ReadonlySet<string>;
+}) => {
+    fileOverrides: {
+        path: string;
+        content: string;
+    }[];
+    provenance: {
+        path: string;
+        mode: "legacy-full-file" | "exact-edits";
+        baseSha256?: string;
+        resultSha256: string;
+        ranges: readonly {
+            start: number;
+            end: number;
+        }[];
+    }[];
+};

package/dist/adapters/repository-solution-edits.js

@@ -0,0 +1,136 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { RepositoryFoundryError } from "../errors.js";
+import { captureGitTreeSnapshotV1, readGitTreeFileV1 } from "./git-task-history.js";
+export const RepositorySolutionFileOutputV1 = Schema.Union([
+    Schema.Struct({ path: Schema.String, content: Schema.String }),
+    Schema.Struct({
+        path: Schema.String,
+        edits: Schema.Array(Schema.Struct({ search: Schema.String, replace: Schema.String }))
+    })
+]);
+const MAXIMUM_FILE_BYTES = 256_000;
+const MAXIMUM_EDITS_PER_FILE = 32;
+const fail = (detail) => {
+    throw new RepositoryFoundryError({ operation: "compile-reviewed-case", detail });
+};
+const safePath = (path) => path.length > 0 &&
+    path.length <= 1_024 &&
+    !path.includes("\0") &&
+    !path.includes("\\") &&
+    !path.split("/").some((part) => part === "" || part === "." || part === "..");
+const hash = (text) => createHash("sha256").update(text).digest("hex");
+export const loadPinnedSolutionEditSourcesV1 = Effect.fn("CaseGeneration.loadPinnedSolutionEditSources")(function* (input) {
+    const snapshot = yield* captureGitTreeSnapshotV1({
+        repositoryRoot: input.repositoryRoot,
+        requestedRef: input.initialCommit
+    });
+    const sources = [];
+    const visibleByPath = new Map();
+    for (const source of input.visibleSources) {
+        const excerpts = visibleByPath.get(source.path) ?? new Set();
+        excerpts.add(source.content);
+        visibleByPath.set(source.path, excerpts);
+    }
+    for (const [path, suppliedExcerpts] of visibleByPath) {
+        if (!input.allowedPaths.has(path) || !snapshot.files.includes(path))
+            continue;
+        if (!safePath(path)) {
+            return yield* new RepositoryFoundryError({
+                operation: "compile-reviewed-case",
+                detail: "solution edit base has an unsafe path"
+            });
+        }
+        const content = yield* readGitTreeFileV1({ snapshot, path });
+        // Oversized sources can still be read as context, but cannot become an
+        // executable full-file override under the existing solution size policy.
+        if (Buffer.byteLength(content) > MAXIMUM_FILE_BYTES)
+            continue;
+        const excerpts = [...suppliedExcerpts];
+        const superset = excerpts.find(excerpt => excerpts.every(other => excerpt.includes(other)));
+        sources.push({
+            path,
+            content,
+            visibleExcerpt: superset ?? excerpts[0],
+            ...(superset === undefined ? { additionalVisibleExcerpts: excerpts.slice(1) } : {})
+        });
+    }
+    return sources;
+});
+export const materializeSolutionFileOverridesV1 = (input) => {
+    const sources = new Map(input.sources.map((source) => [source.path, source]));
+    const seen = new Set();
+    const provenance = [];
+    const fileOverrides = input.fileOverrides.map((override) => {
+        const { path } = override;
+        if (!safePath(path) || !input.allowedPaths.has(path) || seen.has(path)) {
+            fail("solution edit targets a duplicate, unsafe, or unreviewed path");
+        }
+        seen.add(path);
+        const source = sources.get(path);
+        if ("content" in override) {
+            if ("edits" in override)
+                fail("solution override cannot combine content and edits");
+            if (override.content.trim().length === 0 ||
+                Buffer.byteLength(override.content) > MAXIMUM_FILE_BYTES) {
+                fail("solution full-file override is empty or oversized");
+            }
+            provenance.push({
+                path,
+                mode: "legacy-full-file",
+                ...(source === undefined ? {} : { baseSha256: hash(source.content) }),
+                resultSha256: hash(override.content),
+                ranges: []
+            });
+            return { path, content: override.content };
+        }
+        if (source === undefined)
+            fail("solution exact edits require a reviewed, visible, complete pinned pre-change base");
+        if (override.edits.length === 0 || override.edits.length > MAXIMUM_EDITS_PER_FILE) {
+            fail("solution exact edits require between one and 32 replacements per file");
+        }
+        const ranges = override.edits
+            .map(({ search, replace }) => {
+            if (search.length === 0 || search === replace)
+                fail("solution exact search must be nonempty and change its matched text");
+            const start = source.content.indexOf(search);
+            const visibleOnce = [source.visibleExcerpt, ...(source.additionalVisibleExcerpts ?? [])]
+                .some(excerpt => {
+                const visibleStart = excerpt.indexOf(search);
+                return visibleStart >= 0 && excerpt.indexOf(search, visibleStart + 1) === -1;
+            });
+            if (start < 0 ||
+                source.content.indexOf(search, start + 1) !== -1 ||
+                !visibleOnce) {
+                fail("solution exact search must match once in both the visible excerpt and pinned full source");
+            }
+            return { start, end: start + search.length, replace };
+        })
+            .sort((a, b) => a.start - b.start);
+        if (ranges.some((range, index) => index > 0 && range.start < ranges[index - 1].end)) {
+            fail("solution exact replacements overlap in the original pre-change source");
+        }
+        const resultBytes = Buffer.byteLength(source.content) +
+            ranges.reduce((change, range) => change +
+                Buffer.byteLength(range.replace) -
+                Buffer.byteLength(source.content.slice(range.start, range.end)), 0);
+        if (resultBytes > MAXIMUM_FILE_BYTES) {
+            fail("materialized solution override exceeds the existing file size bound");
+        }
+        let content = source.content;
+        for (const range of [...ranges].reverse()) {
+            content = content.slice(0, range.start) + range.replace + content.slice(range.end);
+        }
+        if (content.trim().length === 0)
+            fail("materialized solution override is empty");
+        provenance.push({
+            path,
+            mode: "exact-edits",
+            baseSha256: hash(source.content),
+            resultSha256: hash(content),
+            ranges: ranges.map(({ start, end }) => ({ start, end }))
+        });
+        return { path, content };
+    });
+    return { fileOverrides, provenance };
+};

package/dist/adapters/repository-vitest-phase-adapter.d.ts

@@ -0,0 +1,8 @@
+/** Static platform inspection only. Missing/changed dependencies do not gain semantic credit. */
+export declare function repositoryVitestPhaseAdapterV1(input: {
+    readonly cwd: string;
+    readonly checkout: string;
+}): Promise<{
+    readonly supported: boolean;
+    readonly source: string;
+}>;

package/dist/adapters/repository-vitest-phase-adapter.js

@@ -0,0 +1,310 @@
+import { createHash } from "node:crypto";
+import { readFile, realpath } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+// These hashes describe the published 3.2.7 implementation, not an arbitrary
+// package claiming that version. No dependency/cache bytes are modified.
+const VITEST_FILES = {
+    "dist/index.js": "d207c396b9e41b3987bc24e335e808d9bd09c5841044d33b073cebbbc0154a37",
+    "dist/runners.js": "95c2e3dd20803ad53e56d545840dac9b954546324c918e5fcffcbdb3a62c3de3",
+    "dist/chunks/index.CwejwG0H.js": "5a92953a14e89edddf7470e49689dda55f9af902f1ca598af2433560f3dd70b4",
+    "dist/chunks/cli-api.DVe0nWUx.js": "4c2fecfeb976ee9cdf00cf4a03daef462cefd08e0e502b2ce7c1daf3ac540135"
+};
+const RUNNER_FILES = {
+    "dist/index.js": "1802b89f2c5ab0344e0d5777d063e5ef3b019af7efed9d3db23460970bd6416c",
+    "dist/chunk-hooks.js": "5e0b0ece2242e3475a0312a375fac6e47287602792d7f4999d2d733ecda2d69a"
+};
+/** Static platform inspection only. Missing/changed dependencies do not gain semantic credit. */
+export async function repositoryVitestPhaseAdapterV1(input) {
+    try {
+        const checkout = await realpath(input.checkout);
+        const fromCheckout = createRequire(join(input.cwd, "package.json"));
+        const vitestManifest = await realpath(fromCheckout.resolve("vitest/package.json"));
+        const fromVitest = createRequire(vitestManifest);
+        const runnerManifest = await realpath(fromVitest.resolve("@vitest/runner/package.json"));
+        const viteManifest = await realpath(fromVitest.resolve("vite/package.json"));
+        for (const [path, version] of [
+            [vitestManifest, "3.2.7"],
+            [runnerManifest, "3.2.7"],
+            [viteManifest, "7.3.6"]
+        ]) {
+            const local = relative(checkout, path);
+            if (local === ".." || local.startsWith(`..${sep}`) || isAbsolute(local)) {
+                return { supported: false, source: "" };
+            }
+            const manifest = JSON.parse(await readFile(path, "utf8"));
+            if (manifest.version !== version)
+                return { supported: false, source: "" };
+        }
+        for (const [root, inventory] of [
+            [dirname(vitestManifest), VITEST_FILES],
+            [dirname(runnerManifest), RUNNER_FILES]
+        ]) {
+            for (const [path, expected] of Object.entries(inventory)) {
+                const actual = createHash("sha256").update(await readFile(join(root, path))).digest("hex");
+                if (actual !== expected)
+                    return { supported: false, source: "" };
+            }
+        }
+        return {
+            supported: true,
+            source: `import { VitestTestRunner } from ${JSON.stringify(join(dirname(vitestManifest), "dist/runners.js"))};\n` +
+                `import { getCurrentSuite, getFn, getHooks } from ${JSON.stringify(join(dirname(runnerManifest), "dist/index.js"))};\n` +
+                REPOSITORY_VITEST_PHASE_SOURCE
+        };
+    }
+    catch {
+        return { supported: false, source: "" };
+    }
+}
+// A framework adapter, not an execution/resource owner. The original Vitest
+// collector and lifecycle still run. The host wraps only an observed raw
+// callback BEFORE Vitest's withFixtures/timeout/assertion wrappers.
+const REPOSITORY_VITEST_PHASE_SOURCE = String.raw `
+const apply = Reflect.apply;
+const arrayPush = Array.prototype.push;
+const own = Object.prototype.hasOwnProperty;
+const cleanupMetadata = [
+  Symbol.for("VITEST_CLEANUP_TIMEOUT"),
+  Symbol.for("VITEST_CLEANUP_STACK_TRACE")
+];
+const plain = value => value != null && typeof value === "object" &&
+  (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const cleanOptions = value => value === undefined || typeof value === "number" ||
+  (plain(value) && Object.entries(Object.getOwnPropertyDescriptors(value)).every(([key, descriptor]) =>
+    key === "timeout" && "value" in descriptor && typeof descriptor.value === "number"));
+const errorsOf = test => test.result?.errors ?? [];
+const thrownErrorCount = error => Array.isArray(error) ? error.length : 1;
+const healthyHooks = test => Object.values(test.result?.hooks ?? {}).every(state => state === "pass");
+class PhaseAttributionError extends Error {
+  name = "RouteKitVitestPhaseAttributionError";
+  code = "ROUTEKIT_VITEST_PHASE_UNATTRIBUTED";
+}
+export default class RepositoryVitestPhaseAdapter extends VitestTestRunner {
+  #facts = new WeakMap();
+  #tests = [];
+  #collections = 0;
+  #invalid = false;
+  #pendingCleanup = 0;
+  #wrappedHooks = new WeakSet();
+
+  constructor(config) {
+    super(config);
+    if (this.pool !== "forks" || this.workerState.environment?.name !== "node" ||
+        config.mode !== "test" || config.isolate !== true) {
+      throw new PhaseAttributionError("unsupported worker configuration");
+    }
+  }
+
+  #observeCleanup(callback) {
+    if (typeof callback !== "function") {
+      this.#invalid = true;
+      return callback;
+    }
+    const adapter = this;
+    const wrapped = async function(...args) {
+      adapter.#pendingCleanup += 1;
+      try {
+        const value = await apply(callback, this, args);
+        return typeof value === "function" ? adapter.#observeCleanup(value) : value;
+      } catch (error) {
+        // Keep the actual cleanup throw outside mutable task.result inventory.
+        adapter.#invalid = true;
+        throw error;
+      } finally {
+        adapter.#pendingCleanup -= 1;
+      }
+    };
+    // The pinned framework reads these descriptors from the invoked suite
+    // hook when constructing its returned-cleanup timeout wrapper. Replacing
+    // the callback must not replace a local timeout with the global default
+    // or discard the original registration stack.
+    for (const key of cleanupMetadata) {
+      const descriptor = Object.getOwnPropertyDescriptor(callback, key);
+      if (descriptor !== undefined) Object.defineProperty(wrapped, key, descriptor);
+    }
+    return wrapped;
+  }
+
+  #observeTestHooks(test) {
+    const adapter = this;
+    for (const name of ["onFinished", "onFailed"]) {
+      const callbacks = test[name] ?? [];
+      if (!Array.isArray(callbacks)) {
+        this.#invalid = true;
+        continue;
+      }
+      if (this.#wrappedHooks.has(callbacks)) continue;
+      if (callbacks.push !== arrayPush) {
+        this.#invalid = true;
+        continue;
+      }
+      this.#wrappedHooks.add(callbacks);
+      for (let index = 0; index < callbacks.length; index += 1) {
+        callbacks[index] = this.#observeCleanup(callbacks[index]);
+      }
+      // Both context methods and exported globals push an already timeout-
+      // wrapped callback here. Keep the actual arrays and native push return
+      // value/receiver; Vitest alone still chooses when/how to iterate them.
+      // This also observes registrations after the body, including onFailed
+      // registered by an onFinished callback before failed hooks are selected.
+      Object.defineProperty(callbacks, "push", {
+        configurable: true, enumerable: false, writable: true,
+        value: function(...items) {
+          return apply(arrayPush, this, items.map(callback => adapter.#observeCleanup(callback)));
+        }
+      });
+      test[name] = callbacks;
+    }
+  }
+
+  async onBeforeRunSuite(suite) {
+    await super.onBeforeRunSuite(suite);
+    // Match the pinned runSuite early-failure branch after the superclass hook.
+    // Collection failure can leave no hook map; preserve its original result.
+    if (suite.result?.state === "fail") {
+      this.#invalid = true;
+      return;
+    }
+    for (const callbacks of Object.values(getHooks(suite))) {
+      if (this.#wrappedHooks.has(callbacks)) continue;
+      this.#wrappedHooks.add(callbacks);
+      for (let index = 0; index < callbacks.length; index += 1) {
+        callbacks[index] = this.#observeCleanup(callbacks[index]);
+      }
+    }
+  }
+
+  async importFile(filepath, source) {
+    if (source !== "collect" && source !== "setup") {
+      this.#invalid = true;
+      return super.importFile(filepath, source);
+    }
+    // clearCollectorContext has run before importFile in the pinned framework.
+    // Nested collectors are deliberately unobserved and therefore abstain.
+    const collector = getCurrentSuite();
+    const original = collector.test.fn;
+    const adapter = this;
+    const registration = function(name, optionsOrFn, fnOrOptions) {
+      const callbackIndex = typeof optionsOrFn === "function" ? 1 :
+        typeof fnOrOptions === "function" ? 2 : -1;
+      const callback = callbackIndex === 1 ? optionsOrFn : fnOrOptions;
+      const options = callbackIndex === 1 ? fnOrOptions : optionsOrFn;
+      const contextKeys = Reflect.ownKeys(this ?? {});
+      const supported = callbackIndex !== -1 && cleanOptions(options) && plain(this) &&
+        contextKeys.every(key => key === "sequential") &&
+        !collector.fixtures()?.length &&
+        !apply(own, callback, ["__VITEST_FIXTURE_INDEX__"]);
+      if (!supported) return apply(original, this, [name, optionsOrFn, fnOrOptions]);
+      const fact = { entries: 0, returns: 0, throws: 0, thrownCount: 0, cleanEntry: false,
+        beforeCleanup: undefined, finalized: false, task: undefined, fn: undefined };
+      const wrapped = async function(...args) {
+        fact.entries += 1;
+        fact.cleanEntry = fact.task !== undefined && errorsOf(fact.task).length === 0 &&
+          fact.task.result?.state === "run";
+        try {
+          const value = await apply(callback, this, args);
+          fact.returns += 1;
+          return value;
+        } catch (error) {
+          fact.throws += 1;
+          fact.thrownCount = thrownErrorCount(error);
+          throw error;
+        }
+      };
+      const args = [name, optionsOrFn, fnOrOptions];
+      args[callbackIndex] = wrapped;
+      const before = collector.tasks.length;
+      const value = apply(original, this, args);
+      const task = collector.tasks[before];
+      if (collector.tasks.length !== before + 1 || task?.type !== "test") {
+        adapter.#invalid = true;
+        return value;
+      }
+      fact.task = task;
+      fact.fn = getFn(task);
+      adapter.#facts.set(task, fact);
+      return value;
+    };
+    collector.test.fn = registration;
+    try {
+      return await super.importFile(filepath, source);
+    } finally {
+      if (collector.test.fn !== registration) this.#invalid = true;
+      else collector.test.fn = original;
+    }
+  }
+
+  onCollected(files) {
+    this.#collections += 1;
+    const visit = tasks => {
+      for (const task of tasks) {
+        if (task.type === "test") this.#tests.push(task);
+        else { this.#invalid = true; visit(task.tasks ?? []); }
+      }
+    };
+    for (const file of files) visit(file.tasks);
+  }
+
+  async onBeforeRunTask(test) {
+    await super.onBeforeRunTask(test);
+    const fact = this.#facts.get(test);
+    if (!fact || getFn(test) !== fact.fn || test.fails || test.concurrent ||
+        (test.retry ?? 0) !== 0 || (test.repeats ?? 0) !== 0 ||
+        (test.mode !== "run" && test.mode !== "queued")) {
+      this.#invalid = true;
+      return;
+    }
+    this.#observeTestHooks(test);
+  }
+
+  // This is the framework boundary AFTER its try/catch and BEFORE afterEach,
+  // returned-hook cleanup, fixture teardown, onTestFinished and onTestFailed.
+  // A body wrapper alone cannot certify that these later phases stayed clean.
+  onTaskFinished(test) {
+    const fact = this.#facts.get(test);
+    if (!fact || fact.beforeCleanup !== undefined || fact.entries !== 1 ||
+        fact.returns + fact.throws !== 1 || !fact.cleanEntry || !healthyHooks(test)) {
+      this.#invalid = true;
+      return;
+    }
+    const values = errorsOf(test);
+    if (!Array.isArray(values) || values.length !== (fact.throws === 1 ? fact.thrownCount : 0) ||
+        (fact.throws === 1 && (fact.thrownCount < 1 || test.result?.state !== "fail")) ||
+        (fact.returns === 1 && test.result?.state !== "pass")) {
+      this.#invalid = true;
+      return;
+    }
+    // Preserve identity and immutable primitive snapshots, not test.meta or a
+    // candidate-supplied phase label. No stack/message inspection is used.
+    fact.beforeCleanup = values.map(error => ({ error, name: error?.name, code: error?.code }));
+  }
+
+  async onAfterRunTask(test) {
+    await super.onAfterRunTask(test);
+    const fact = this.#facts.get(test);
+    const before = fact?.beforeCleanup;
+    const after = errorsOf(test);
+    if (!fact || !before || getFn(test) !== fact.fn || !healthyHooks(test) ||
+        !Array.isArray(after) || before.length !== after.length ||
+        !before.every((item, index) => item.error === after[index] &&
+          item.name === after[index]?.name && item.code === after[index]?.code) ||
+        test.result?.state !== (fact.throws === 1 ? "fail" : "pass")) {
+      this.#invalid = true;
+      return;
+    }
+    fact.finalized = true;
+  }
+
+  async onAfterRunFiles() {
+    await super.onAfterRunFiles();
+    if (this.#invalid || this.#pendingCleanup !== 0 || this.#collections !== 1 || this.#tests.length === 0 ||
+        this.#tests.some(test => this.#facts.get(test)?.finalized !== true)) {
+      // Deliberately AFTER normal test cleanup; never use an arbitrary launch or
+      // import failure as this attribution refusal. The existing reporter's
+      // unhandled-error/completion guards turn this host error into unknown.
+      throw new PhaseAttributionError("test callback or cleanup phase was not attributable");
+    }
+  }
+}
+`;

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

@@ -0,0 +1,24 @@
+import type { RepositoryCommandRecipeV1 } from "../repository-behavior-protocol.js";
+/** Only the explicitly recognized, one-shot Vitest execution receives this reporter. */
+export declare function repositoryVitestTestArgumentsV1(recipe: RepositoryCommandRecipeV1, reporterPath: string): readonly string[] | undefined;
+/**
+ * Written outside the candidate-writable checkout. The parent reporter observes
+ * worker results; a completed process or assertion-looking console text is not
+ * sufficient evidence. The private phased frame is emitted only after installing
+ * the pinned host callback adapter at the resolved-config boundary. Historical
+ * unphased frames are preserved but cannot retain semantic credit.
+ */
+export declare function repositoryVitestReporterSourceV1(input: {
+    readonly phaseAdapterPath: string;
+    readonly runtimeSupported: boolean;
+}): string;
+type Evidence = {
+    readonly outcome: "pass" | "fail" | "unknown";
+    readonly detail: string;
+    readonly inconclusiveReason?: "unattributed-test-failure";
+};
+/** Undefined means that this command did not emit the host's Vitest protocol. */
+export declare function repositoryVitestTestEvidenceV1(result: {
+    readonly exitCode: number | null;
+}, output: string): Evidence | undefined;
+export {};