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

package/dist/test/repository-model.test.js

@@ -0,0 +1,2195 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { after, test } from "node:test";
+import { promisify } from "node:util";
+import { Effect } from "effect";
+import { captureGitTreeSnapshotV1 } from "../adapters/git-task-history.js";
+import { repositoryCommandTestEvidenceV1 } from "../adapters/repository-command-evidence.js";
+import { inspectRepositorySolutionPathsV1, RepositoryCommandExecutionPort, replayRepositoryCommandV1 } from "../adapters/repository-command-runner.js";
+import { indexTypeScriptRepositoryV1 } from "../adapters/typescript-repository-index.js";
+import { RepositoryFoundryError } from "../errors.js";
+import { evaluateRepositoryOracleAdequacyV1 } from "../repository-quality-policy.js";
+import { generateDeterministicAdversariesV1, repositoryIntegrationMutationFamilyV1 } from "../services/adversary/service.js";
+import { compileRepositoryBenchmarkV1 } from "../services/benchmark-compiler/service.js";
+import { compileReviewedHiddenFixtureSuiteV1 } from "../services/fixture-builder/service.js";
+import { RepositoryFoundryProgressLive } from "../services/foundry-progress/service.js";
+import { compileReviewedHistoricalCaseV1 } from "../services/historical-case/service.js";
+import { RepositoryCommandObservability } from "../services/command-observability/service.js";
+import { buildHistoricalHiddenOracleV1 } from "../services/oracle-builder/service.js";
+import { evaluateRepositoryBenchmarkDraftV1 } from "../services/quality-gate/service.js";
+import { buildRepositoryBehaviorMapV1 } from "../services/repository-model/service.js";
+import { critiqueRepositoryTaskSpecificationV1 } from "../services/specification-critic/service.js";
+import { deriveRepositoryTaskFamiliesV1 } from "../services/task-family/service.js";
+import { deriveHistoricalSeedEnvironmentV1, extractHistoricalTaskSeedsV1, qualifyHistoricalTaskSeedAcrossBatchesV1, qualifyHistoricalTaskSeedV1 } from "../services/task-seed/service.js";
+import { constructRepositoryAgentTaskV1 } from "../services/task-specification/service.js";
+const execFilePromise = promisify(execFile);
+const roots = [];
+const independentSpecificationReviews = [
+    {
+        reviewerId: "independent-solver-a",
+        reviewerKind: "independent-solver",
+        independentlyProduced: true,
+        verdict: "sufficient",
+        detail: "The request identifies the affected behavior, checkout, and constraints without prescribing an implementation.",
+        findings: []
+    },
+    {
+        reviewerId: "independent-solver-b",
+        reviewerKind: "model-critic",
+        independentlyProduced: true,
+        verdict: "sufficient",
+        detail: "The pre-task repository contains enough context to reproduce and repair the requested behavior.",
+        findings: []
+    }
+];
+after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
+const git = (root, ...args) => execFilePromise("git", ["-C", root, ...args], {
+    encoding: "utf8",
+    windowsHide: true
+});
+const commit = async (root, subject, occurredAt) => {
+    await git(root, "add", ".");
+    await execFilePromise("git", ["-C", root, "commit", "-q", "-m", subject], {
+        encoding: "utf8",
+        windowsHide: true,
+        env: {
+            ...process.env,
+            GIT_AUTHOR_DATE: occurredAt,
+            GIT_COMMITTER_DATE: occurredAt
+        }
+    });
+    return (await git(root, "rev-parse", "HEAD")).stdout.trim();
+};
+async function repository() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-repository-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    await mkdir(path.join(root, "packages", "stream", "src"), {
+        recursive: true
+    });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "fixture-root",
+        private: true,
+        scripts: { check: "echo root-check" }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "stream", "package.json"), `${JSON.stringify({
+        name: "@fixture/stream",
+        type: "module",
+        exports: { ".": "./dist/index.js" },
+        scripts: {
+            build: "node --check src/stream-protocol.js",
+            test: "node --test src/*.test.js"
+        }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "stream", "src", "index.js"), ["export { translateEvents } from './stream-protocol.js';", ""].join("\n"));
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.js"), ["export function translateEvents(events) {", "  return events;", "}", ""].join("\n"));
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { translateEvents } from './stream-protocol.js';",
+        "test('preserves an empty event stream', () => {",
+        "  assert.deepEqual(translateEvents([]), []);",
+        "});",
+        ""
+    ].join("\n"));
+    await commit(root, "initial stream protocol", "2026-01-01T00:00:00Z");
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.js"), [
+        "export function translateEvents(events) {",
+        "  const terminal = events.find((event) => event.type === 'completed');",
+        "  return terminal === undefined ? events : [...events.filter((event) => event.type !== 'completed'), terminal];",
+        "}",
+        ""
+    ].join("\n"));
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { translateEvents } from './stream-protocol.js';",
+        "test('keeps terminal event last', () => {",
+        "  assert.equal(translateEvents([{ type: 'completed' }, { type: 'output', value: 'late' }]).at(-1)?.type, 'completed');",
+        "});",
+        "test('preserves output before completion', () => {",
+        "  assert.deepEqual(translateEvents([{ type: 'completed' }, { type: 'output', value: 'late' }]), [{ type: 'output', value: 'late' }, { type: 'completed' }]);",
+        "});",
+        ""
+    ].join("\n"));
+    await commit(root, "fix terminal event ordering", "2026-02-01T00:00:00Z");
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.js"), [
+        "export function translateEvents(events) {",
+        "  const terminal = events.find((event) => event.type === 'completed');",
+        "  const output = events.filter((event) => event.type === 'output');",
+        "  return terminal === undefined ? output : [...output, terminal];",
+        "}",
+        ""
+    ].join("\n"));
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { translateEvents } from './stream-protocol.js';",
+        "test('keeps exactly one terminal event last', () => {",
+        "  assert.deepEqual(translateEvents([{ type: 'completed' }, { type: 'completed' }]), [{ type: 'completed' }]);",
+        "});",
+        ""
+    ].join("\n"));
+    await commit(root, "repair duplicate terminal events", "2026-03-01T00:00:00Z");
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.js"), [
+        "export function translateEvents(events) {",
+        "  const terminal = events.find((event) => event.type === 'completed');",
+        "  const nonTerminal = events.filter((event) => event.type !== 'completed');",
+        "  return terminal === undefined ? nonTerminal : [...nonTerminal, terminal];",
+        "}",
+        ""
+    ].join("\n"));
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { translateEvents } from './stream-protocol.js';",
+        "test('keeps exactly one terminal event last', () => {",
+        "  assert.deepEqual(translateEvents([{ type: 'completed' }, { type: 'completed' }]), [{ type: 'completed' }]);",
+        "});",
+        "test('preserves usage without a terminal event', () => {",
+        "  assert.deepEqual(translateEvents([{ type: 'usage', tokens: 3 }]), [{ type: 'usage', tokens: 3 }]);",
+        "});",
+        ""
+    ].join("\n"));
+    await commit(root, "feat(stream): preserve usage summaries", "2026-04-01T00:00:00Z");
+    return root;
+}
+async function repositoryWithCrossPackageCochange() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-cochange-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    for (const name of ["accounts", "gateway"]) {
+        await mkdir(path.join(root, "packages", name, "src"), {
+            recursive: true
+        });
+        await writeFile(path.join(root, "packages", name, "package.json"), `${JSON.stringify({
+            name: `@fixture/${name}`,
+            type: "module",
+            exports: { ".": "./src/index.js" },
+            scripts: { test: "node --test src/index.test.js" }
+        }, null, 2)}\n`);
+        await writeFile(path.join(root, "packages", name, "src", "index.js"), `export const revision = 0;\n`);
+        await writeFile(path.join(root, "packages", name, "src", "index.test.js"), [
+            "import { test } from 'node:test';",
+            "import { strict as assert } from 'node:assert';",
+            "import { revision } from './index.js';",
+            "test('revision', () => assert.equal(revision, 0));",
+            ""
+        ].join("\n"));
+    }
+    await commit(root, "initial account gateway boundary", "2026-01-01T00:00:00Z");
+    for (const change of [
+        {
+            revision: 1,
+            subject: "fix(accounts): surface discovery failures",
+            occurredAt: "2026-02-01T00:00:00Z"
+        },
+        {
+            revision: 2,
+            subject: "fix(router): preserve healthy provider models",
+            occurredAt: "2026-03-01T00:00:00Z"
+        }
+    ]) {
+        for (const name of ["accounts", "gateway"]) {
+            await writeFile(path.join(root, "packages", name, "src", "index.js"), `export const revision = ${String(change.revision)};\n`);
+            await writeFile(path.join(root, "packages", name, "src", "index.test.js"), [
+                "import { test } from 'node:test';",
+                "import { strict as assert } from 'node:assert';",
+                "import { revision } from './index.js';",
+                `test('revision', () => assert.equal(revision, ${String(change.revision)}));`,
+                ""
+            ].join("\n"));
+        }
+        await commit(root, change.subject, change.occurredAt);
+    }
+    return root;
+}
+async function repositoryWithDeclaredWorkspaceBoundary() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-workspace-boundary-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    await mkdir(path.join(root, "packages", "owned", "src"), {
+        recursive: true
+    });
+    await mkdir(path.join(root, ".repos", "vendored", "src"), {
+        recursive: true
+    });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "fixture-workspace-root",
+        private: true,
+        packageManager: "pnpm@11.15.1"
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "pnpm-workspace.yaml"), "packages:\n  - packages/*\n");
+    for (const fixture of [
+        {
+            root: path.join(root, "packages", "owned"),
+            name: "@fixture/owned",
+            value: 0
+        },
+        {
+            root: path.join(root, ".repos", "vendored"),
+            name: "@fixture/vendored",
+            value: 0
+        }
+    ]) {
+        await writeFile(path.join(fixture.root, "package.json"), `${JSON.stringify({
+            name: fixture.name,
+            type: "module",
+            exports: {
+                ".": "./src/index.js"
+            },
+            scripts: {
+                test: fixture.name.includes("owned") ? "vp test run" : "node --test src/index.test.js"
+            }
+        }, null, 2)}\n`);
+        await writeFile(path.join(fixture.root, "src", "index.js"), `export const value = ${String(fixture.value)};\n`);
+        await writeFile(path.join(fixture.root, "src", "wire-schema.ts"), `export const ${fixture.name.includes("owned") ? "Owned" : "Vendored"}Schema = {};\n`);
+        await writeFile(path.join(fixture.root, "src", "index.test.js"), [
+            "import { test } from 'node:test';",
+            "import { strict as assert } from 'node:assert';",
+            "import { value } from './index.js';",
+            `test('value', () => assert.equal(value, ${String(fixture.value)}));`,
+            ""
+        ].join("\n"));
+    }
+    await writeFile(path.join(root, ".repos", "vendored", "tsconfig.json"), `${JSON.stringify({
+        references: [{ path: "../missing-project" }]
+    }, null, 2)}\n`);
+    await commit(root, "initial declared workspace", "2026-01-01T00:00:00Z");
+    await writeFile(path.join(root, ".repos", "vendored", "src", "index.js"), "export const value = 1;\n");
+    await writeFile(path.join(root, ".repos", "vendored", "src", "index.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { value } from './index.js';",
+        "test('value', () => assert.equal(value, 1));",
+        ""
+    ].join("\n"));
+    await commit(root, "fix(vendor): update embedded source snapshot", "2026-02-01T00:00:00Z");
+    await writeFile(path.join(root, "packages", "owned", "src", "index.js"), "export const value = 1;\n");
+    await writeFile(path.join(root, "packages", "owned", "src", "index.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { value } from './index.js';",
+        "test('value', () => assert.equal(value, 1));",
+        ""
+    ].join("\n"));
+    await commit(root, "fix(owned): preserve workspace behavior", "2026-03-01T00:00:00Z");
+    return root;
+}
+async function repositoryWithPnpmBuildGraph(projectReferenceMode = "valid") {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-pnpm-graph-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    await mkdir(path.join(root, "packages", "core", "src"), {
+        recursive: true
+    });
+    await mkdir(path.join(root, "packages", "app", "src"), {
+        recursive: true
+    });
+    await mkdir(path.join(root, "packages", "setup", "src"), {
+        recursive: true
+    });
+    await mkdir(path.join(root, "packages", "non-ts", "src"), {
+        recursive: true
+    });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "fixture-pnpm-root",
+        private: true,
+        packageManager: "pnpm@11.15.1"
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "pnpm-workspace.yaml"), 'packages:\n  - "packages/*"\n');
+    await writeFile(path.join(root, "packages", "core", "package.json"), `${JSON.stringify({
+        name: "@fixture/core",
+        type: "module",
+        scripts: {
+            build: "node --check src/index.js",
+            test: "node --test src/index.test.js"
+        }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "core", "src", "index.js"), "export const stable = 1;\n");
+    await writeFile(path.join(root, "packages", "core", "src", "index.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { stable } from './index.js';",
+        "test('stable', () => assert.equal(stable, 1));",
+        ""
+    ].join("\n"));
+    await writeFile(path.join(root, "packages", "core", "tsconfig.json"), `${JSON.stringify({ compilerOptions: { composite: true } }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "setup", "package.json"), `${JSON.stringify({
+        name: "@fixture/setup",
+        type: "module",
+        dependencies: {
+            "@fixture/core": "workspace:*"
+        },
+        scripts: {
+            build: "node --check src/index.js"
+        }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "setup", "src", "index.js"), "export const prepared = true;\n");
+    await writeFile(path.join(root, "packages", "setup", "tsconfig.json"), `${projectReferenceMode === "cycle"
+        ? [
+            "{",
+            "  // A cycle must be rejected rather than silently truncated.",
+            '  "references": [',
+            '    { "path": "../app", },',
+            "  ],",
+            "}",
+            ""
+        ].join("\n")
+        : JSON.stringify({
+            compilerOptions: { composite: true },
+            references: [{ path: "../core" }]
+        }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "non-ts", "package.json"), `${JSON.stringify({
+        name: "@fixture/non-ts",
+        type: "module",
+        scripts: {
+            build: "node --check src/index.js"
+        }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "non-ts", "src", "index.js"), "export const portable = true;\n");
+    await writeFile(path.join(root, "packages", "app", "package.json"), `${JSON.stringify({
+        name: "@fixture/app",
+        type: "module",
+        dependencies: {
+            "@fixture/core": "workspace:*",
+            "@fixture/non-ts": "workspace:*"
+        },
+        scripts: {
+            build: "node --check src/index.js",
+            test: "node --test src/index.test.js"
+        }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "app", "src", "index.js"), "export const value = 1;\n");
+    await writeFile(path.join(root, "packages", "app", "src", "index.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { value } from './index.js';",
+        "test('value', () => assert.equal(value, 1));",
+        ""
+    ].join("\n"));
+    await writeFile(path.join(root, "packages", "app", "tsconfig.json"), `${projectReferenceMode === "escaping"
+        ? JSON.stringify({ references: [{ path: "../../../outside" }] }, null, 2)
+        : projectReferenceMode === "malformed"
+            ? JSON.stringify({ references: [{ path: 42 }] }, null, 2)
+            : [
+                "{",
+                "  // This dependency is intentionally absent from package.json.",
+                '  "references": [',
+                '    { "path": "../setup", },',
+                "  ],",
+                "}",
+                ""
+            ].join("\n")}\n`);
+    await execFilePromise("corepack", ["pnpm@11.15.1", "install", "--lockfile-only", "--offline", "--ignore-scripts"], {
+        cwd: root,
+        encoding: "utf8",
+        windowsHide: true
+    });
+    await commit(root, "initial app behavior", "2026-01-01T00:00:00Z");
+    await writeFile(path.join(root, "packages", "app", "src", "index.js"), "export const value = 2;\n");
+    await writeFile(path.join(root, "packages", "core", "src", "index.js"), "export const stable = 2;\n");
+    await writeFile(path.join(root, "packages", "core", "src", "index.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { stable } from './index.js';",
+        "test('stable', () => assert.equal(stable, 2));",
+        ""
+    ].join("\n"));
+    await writeFile(path.join(root, "packages", "app", "src", "index.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { value } from './index.js';",
+        "test('value', () => assert.equal(value, 2));",
+        ""
+    ].join("\n"));
+    await commit(root, "fix(app): preserve the new value", "2026-02-01T00:00:00Z");
+    return root;
+}
+async function repositoryWithNewRegressionTest() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-new-regression-test-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    await mkdir(path.join(root, "packages", "normalizer", "src"), {
+        recursive: true
+    });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "fixture-new-regression-root",
+        private: true,
+        packageManager: "pnpm@11.15.1"
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "normalizer", "package.json"), `${JSON.stringify({
+        name: "@fixture/normalizer",
+        type: "module",
+        scripts: {
+            test: "node --test"
+        }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "normalizer", "src", "index.js"), ["export function normalize(value) {", "  return value;", "}", ""].join("\n"));
+    await writeFile(path.join(root, "packages", "normalizer", "src", "index.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { normalize } from './index.js';",
+        "test('preserves an already-normalized value', () => {",
+        "  assert.equal(normalize('value'), 'value');",
+        "});",
+        ""
+    ].join("\n"));
+    await commit(root, "initial normalizer behavior", "2026-01-01T00:00:00Z");
+    await writeFile(path.join(root, "packages", "normalizer", "src", "index.js"), ["export function normalize(value) {", "  return value.trim();", "}", ""].join("\n"));
+    await writeFile(path.join(root, "packages", "normalizer", "src", "whitespace-regression.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { normalize } from './index.js';",
+        "test('trims surrounding whitespace', () => {",
+        "  assert.equal(normalize('  value  '), 'value');",
+        "});",
+        ""
+    ].join("\n"));
+    await commit(root, "fix(normalizer): trim surrounding whitespace", "2026-02-01T00:00:00Z");
+    return root;
+}
+async function repositoryWithCompiledNodeTestRunner() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-compiled-node-test-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    await mkdir(path.join(root, "packages", "compiled", "src", "test"), {
+        recursive: true
+    });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "fixture-compiled-root",
+        private: true,
+        packageManager: "pnpm@11.15.1"
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "pnpm-workspace.yaml"), "packages:\n  - packages/*\n");
+    await writeFile(path.join(root, "packages", "compiled", "package.json"), `${JSON.stringify({
+        name: "@fixture/compiled",
+        private: true,
+        type: "module",
+        exports: "./dist/index.js",
+        scripts: {
+            build: "node build.mjs",
+            test: 'node --test "dist/test/*.test.js"'
+        }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "packages", "compiled", "build.mjs"), [
+        'import { cp, mkdir, rm, rename } from "node:fs/promises";',
+        'await rm("dist", { recursive: true, force: true });',
+        'await mkdir("dist", { recursive: true });',
+        'await cp("src", "dist", { recursive: true });',
+        'await rename("dist/index.ts", "dist/index.js");',
+        'await rename("dist/test/value.test.ts", "dist/test/value.test.js");',
+        ""
+    ].join("\n"));
+    await writeFile(path.join(root, "packages", "compiled", "src", "index.ts"), "export const value = 1;\n");
+    await writeFile(path.join(root, "packages", "compiled", "src", "test", "value.test.ts"), [
+        'import assert from "node:assert/strict";',
+        'import test from "node:test";',
+        'import { value } from "../index.js";',
+        'test("value is one", () => assert.equal(value, 1));',
+        ""
+    ].join("\n"));
+    await execFilePromise("corepack", ["pnpm@11.15.1", "install", "--lockfile-only", "--offline", "--ignore-scripts"], {
+        cwd: root,
+        encoding: "utf8",
+        windowsHide: true
+    });
+    await commit(root, "initial compiled value", "2026-01-01T00:00:00Z");
+    await writeFile(path.join(root, "packages", "compiled", "src", "index.ts"), "export const value = 2;\n");
+    await writeFile(path.join(root, "packages", "compiled", "src", "test", "value.test.ts"), [
+        'import assert from "node:assert/strict";',
+        'import test from "node:test";',
+        'import { value } from "../index.js";',
+        'test("value is two", () => assert.equal(value, 2));',
+        ""
+    ].join("\n"));
+    const referenceCommit = await commit(root, "fix(compiled): preserve the new value", "2026-02-01T00:00:00Z");
+    return { root, referenceCommit };
+}
+async function repositoryWithRootTestRunner() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-root-test-runner-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    await mkdir(path.join(root, "apps", "api", "src"), { recursive: true });
+    await mkdir(path.join(root, "apps", "api", "test"), { recursive: true });
+    await writeFile(path.join(root, "pnpm-workspace.yaml"), ["packages:", "  - apps/*", ""].join("\n"));
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "fixture-root-test-runner",
+        private: true,
+        packageManager: "pnpm@11.15.1",
+        scripts: { test: "vitest run" }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "apps", "api", "package.json"), `${JSON.stringify({
+        name: "@fixture/api",
+        private: true,
+        type: "module"
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "apps", "api", "src", "event.ts"), "export const acceptsScreenShare = (type) => type === 'screen_share.started';\n");
+    await writeFile(path.join(root, "apps", "api", "test", "event.test.ts"), [
+        "import { describe, expect, it } from 'vitest';",
+        "import { acceptsScreenShare } from '../src/event.js';",
+        "describe('events', () => {",
+        "  it('rejects unknown events', () => expect(acceptsScreenShare('unknown')).toBe(false));",
+        "});",
+        ""
+    ].join("\n"));
+    await commit(root, "initial realtime event behavior", "2026-01-01T00:00:00Z");
+    await writeFile(path.join(root, "apps", "api", "src", "event.ts"), [
+        "export const acceptsScreenShare = (type) =>",
+        "  type === 'screen_share.started' || type === 'screen_share.stopped';",
+        ""
+    ].join("\n"));
+    await writeFile(path.join(root, "apps", "api", "test", "event.test.ts"), [
+        "import { describe, expect, it } from 'vitest';",
+        "import { acceptsScreenShare } from '../src/event.js';",
+        "describe('events', () => {",
+        "  it('accepts screen-share lifecycle events', () => {",
+        "    expect(acceptsScreenShare('screen_share.started')).toBe(true);",
+        "    expect(acceptsScreenShare('screen_share.stopped')).toBe(true);",
+        "  });",
+        "});",
+        ""
+    ].join("\n"));
+    const referenceCommit = await commit(root, "accept screen share realtime events", "2026-02-01T00:00:00Z");
+    return { root, referenceCommit };
+}
+async function repositoryWithSolutionBranches() {
+    const root = await repository();
+    const mainBranch = (await git(root, "branch", "--show-current")).stdout.trim();
+    const commits = (await git(root, "rev-list", "--reverse", "HEAD")).stdout.trim().split(/\r?\n/u);
+    const initialCommit = commits[0];
+    const referenceCommit = commits[1];
+    await git(root, "checkout", "-q", "-b", "alternate-valid", initialCommit);
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.js"), [
+        "export function translateEvents(events) {",
+        "  const output = [];",
+        "  let terminal;",
+        "  for (const event of events) {",
+        "    if (event.type === 'completed') terminal ??= event;",
+        "    else output.push(event);",
+        "  }",
+        "  return terminal === undefined ? output : output.concat(terminal);",
+        "}",
+        ""
+    ].join("\n"));
+    const alternateCommit = await commit(root, "implement alternate terminal ordering", "2026-02-02T00:00:00Z");
+    await git(root, "checkout", "-q", mainBranch);
+    await git(root, "checkout", "-q", "-b", "behavior-preserving-valid", referenceCommit);
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.js"), [
+        "export function translateEvents(events) {",
+        "  const terminalIndex = events.findIndex((event) => event.type === 'completed');",
+        "  if (terminalIndex < 0) return events.slice();",
+        "  const terminal = events[terminalIndex];",
+        "  return events.filter((_, index) => index !== terminalIndex && events[index].type !== 'completed').concat(terminal);",
+        "}",
+        ""
+    ].join("\n"));
+    const behaviorPreservingCommit = await commit(root, "refactor terminal ordering without changing behavior", "2026-02-02T12:00:00Z");
+    await git(root, "checkout", "-q", mainBranch);
+    await git(root, "checkout", "-q", "-b", "plausible-mutant", initialCommit);
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.js"), [
+        "export function translateEvents(events) {",
+        "  const terminal = events.find((event) => event.type === 'completed');",
+        "  return terminal === undefined ? events : [terminal];",
+        "}",
+        ""
+    ].join("\n"));
+    const mutantCommit = await commit(root, "fix ordering by dropping output", "2026-02-03T00:00:00Z");
+    await git(root, "checkout", "-q", mainBranch);
+    await git(root, "checkout", "-q", "-b", "unterminated-drop-mutant", referenceCommit);
+    await writeFile(path.join(root, "packages", "stream", "src", "stream-protocol.js"), [
+        "export function translateEvents(events) {",
+        "  const terminal = events.find((event) => event.type === 'completed');",
+        "  return terminal === undefined ? [] : [...events.filter((event) => event.type !== 'completed'), terminal];",
+        "}",
+        ""
+    ].join("\n"));
+    const unterminatedDropCommit = await commit(root, "drop streams without terminal events", "2026-02-04T00:00:00Z");
+    await git(root, "checkout", "-q", mainBranch);
+    return {
+        root,
+        alternateCommit,
+        behaviorPreservingCommit,
+        mutantCommit,
+        unterminatedDropCommit
+    };
+}
+async function repositoryWithStructuralMigrationBranches() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-structural-foundry-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Structural Test");
+    await git(root, "config", "user.email", "structural@example.test");
+    await mkdir(path.join(root, "src", "legacy"), { recursive: true });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({ name: "structural-fixture", private: true, type: "module" }, null, 2)}\n`);
+    const legacySource = [
+        "export function normalizeName(value) {",
+        "  return value.trim();",
+        "}",
+        ""
+    ].join("\n");
+    const migratedSource = [
+        "export function normalizeName(value) {",
+        "  return value.trim().toLowerCase();",
+        "}",
+        ""
+    ].join("\n");
+    await writeFile(path.join(root, "src", "legacy", "formatter.js"), legacySource);
+    await writeFile(path.join(root, "src", "index.js"), "export { normalizeName } from './legacy/formatter.js';\n");
+    await writeFile(path.join(root, "src", "formatter.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { normalizeName } from './index.js';",
+        "test('trims names', () => {",
+        "  assert.equal(normalizeName(' RouteKit '), 'RouteKit');",
+        "});",
+        ""
+    ].join("\n"));
+    const initialCommit = await commit(root, "initial legacy formatter", "2026-05-01T00:00:00Z");
+    await mkdir(path.join(root, "src", "services"), { recursive: true });
+    await writeFile(path.join(root, "src", "services", "formatter.js"), migratedSource);
+    await writeFile(path.join(root, "src", "index.js"), "export { normalizeName } from './services/formatter.js';\n");
+    await rm(path.join(root, "src", "legacy", "formatter.js"));
+    await writeFile(path.join(root, "src", "formatter.test.js"), [
+        "import { test } from 'node:test';",
+        "import { strict as assert } from 'node:assert';",
+        "import { normalizeName } from './index.js';",
+        "test('normalizes names through the public facade', () => {",
+        "  assert.equal(normalizeName(' RouteKit '), 'routekit');",
+        "});",
+        ""
+    ].join("\n"));
+    const referenceCommit = await commit(root, "feat: migrate formatter service and normalize case", "2026-05-02T00:00:00Z");
+    const mainBranch = (await git(root, "branch", "--show-current")).stdout.trim();
+    const branchFromInitial = async (branch, mutate, subject, date) => {
+        await git(root, "checkout", "-q", mainBranch);
+        await git(root, "checkout", "-q", "-b", branch, initialCommit);
+        await mutate();
+        return commit(root, subject, date);
+    };
+    const alternateCommit = await branchFromInitial("structural-alternate", async () => {
+        await mkdir(path.join(root, "src", "services"), { recursive: true });
+        await writeFile(path.join(root, "src", "services", "formatter.js"), [
+            "export const normalizeName = (value) =>",
+            "  value.toLocaleLowerCase('en-US').trim();",
+            ""
+        ].join("\n"));
+        await writeFile(path.join(root, "src", "index.js"), "export { normalizeName } from './services/formatter.js';\n");
+        await rm(path.join(root, "src", "legacy", "formatter.js"));
+    }, "implement independent formatter migration", "2026-05-03T00:00:00Z");
+    const behaviorPreservingCommit = await branchFromInitial("structural-preserving", async () => {
+        await mkdir(path.join(root, "src", "internal"), { recursive: true });
+        await mkdir(path.join(root, "src", "services"), { recursive: true });
+        await writeFile(path.join(root, "src", "internal", "normalize-name.js"), migratedSource);
+        await writeFile(path.join(root, "src", "services", "formatter.js"), "export { normalizeName } from '../internal/normalize-name.js';\n");
+        await writeFile(path.join(root, "src", "index.js"), "export { normalizeName } from './services/formatter.js';\n");
+        await rm(path.join(root, "src", "legacy", "formatter.js"));
+    }, "refactor formatter implementation behind service boundary", "2026-05-04T00:00:00Z");
+    const partialMigrationCommit = await branchFromInitial("structural-partial", async () => {
+        await mkdir(path.join(root, "src", "services"), { recursive: true });
+        await writeFile(path.join(root, "src", "services", "formatter.js"), migratedSource);
+        await writeFile(path.join(root, "src", "index.js"), "export { normalizeName } from './services/formatter.js';\n");
+    }, "partially migrate formatter but retain legacy module", "2026-05-05T00:00:00Z");
+    const behaviorOnlyCommit = await branchFromInitial("structural-behavior-only", async () => {
+        await writeFile(path.join(root, "src", "legacy", "formatter.js"), migratedSource);
+    }, "normalize names without completing migration", "2026-05-06T00:00:00Z");
+    const rewardHackingCommit = await branchFromInitial("structural-test-weakening", async () => {
+        await writeFile(path.join(root, "src", "formatter.test.js"), ["import { test } from 'node:test';", "test('migration is complete', () => {});", ""].join("\n"));
+    }, "weaken migration test without implementing task", "2026-05-07T00:00:00Z");
+    await git(root, "checkout", "-q", mainBranch);
+    return {
+        root,
+        initialCommit,
+        referenceCommit,
+        alternateCommit,
+        behaviorPreservingCommit,
+        partialMigrationCommit,
+        behaviorOnlyCommit,
+        rewardHackingCommit
+    };
+}
+test("command repetitions and structural inspections use independent clean checkouts", async () => {
+    const { root, initialCommit } = await repositoryWithStructuralMigrationBranches();
+    const results = await Effect.runPromise(replayRepositoryCommandV1({
+        repositoryRoot: root,
+        commit: initialCommit,
+        recipe: {
+            id: "command-clean-repetition",
+            kind: "test",
+            cwd: ".",
+            executable: "node",
+            args: [
+                "--eval",
+                [
+                    "const fs = require('node:fs');",
+                    "if (fs.existsSync('.repetition-state')) process.exit(19);",
+                    "fs.writeFileSync('.repetition-state', 'created');"
+                ].join(" ")
+            ],
+            timeoutMs: 30_000
+        },
+        repetitions: 2
+    }));
+    assert.deepEqual(results.map((result) => result.exitCode), [0, 0]);
+    const inspections = await Effect.runPromise(inspectRepositorySolutionPathsV1({
+        repositoryRoot: root,
+        commit: initialCommit,
+        paths: ["src/index.js", "src/legacy", "src/services/formatter.js"],
+        repetitions: 2
+    }));
+    assert.deepEqual(inspections.map((entry) => [entry.repetition, entry.path, entry.kind]), [
+        [1, "src/index.js", "file"],
+        [1, "src/legacy", "directory"],
+        [1, "src/services/formatter.js", "missing"],
+        [2, "src/index.js", "file"],
+        [2, "src/legacy", "directory"],
+        [2, "src/services/formatter.js", "missing"]
+    ]);
+});
+test("command replay exposes only a synthetic single-commit repository and isolated process state", async () => {
+    const { root, initialCommit, referenceCommit } = await repositoryWithStructuralMigrationBranches();
+    const results = await Effect.runPromise(replayRepositoryCommandV1({
+        repositoryRoot: root,
+        commit: initialCommit,
+        recipe: {
+            id: "command-prove-candidate-isolation",
+            kind: "test",
+            cwd: ".",
+            executable: "node",
+            args: [
+                "--eval",
+                [
+                    "const cp = require('node:child_process');",
+                    "const fs = require('node:fs');",
+                    "const count = cp.execFileSync('git', ['rev-list', '--all', '--count'], { encoding: 'utf8' }).trim();",
+                    "if (count !== '1') process.exit(41);",
+                    "const remotes = cp.execFileSync('git', ['remote'], { encoding: 'utf8' }).trim();",
+                    "if (remotes !== '') process.exit(42);",
+                    `const hidden = cp.spawnSync('git', ['cat-file', '-e', '${referenceCommit}^{commit}']);`,
+                    "if (hidden.status === 0) process.exit(43);",
+                    "if (!process.env.HOME?.endsWith('/home')) process.exit(44);",
+                    "if (!process.env.TMPDIR?.endsWith('/tmp')) process.exit(45);",
+                    "fs.writeFileSync(process.env.TMPDIR + '/candidate-write', 'isolated');"
+                ].join(" ")
+            ],
+            timeoutMs: 30_000
+        },
+        repetitions: 2
+    }));
+    assert.ok(results.every((result) => result.exitCode === 0 && !result.timedOut && result.gradeExecuted), JSON.stringify(results, null, 2));
+});
+test("trusted preparation may materialize dependencies while candidate commands remain network isolated", async () => {
+    const { root, initialCommit } = await repositoryWithStructuralMigrationBranches();
+    const server = net.createServer((socket) => socket.end("ready"));
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    try {
+        const address = server.address();
+        assert.ok(address && typeof address !== "string");
+        const connectionProbe = [
+            "const net = require('node:net');",
+            `const socket = net.connect({ host: '127.0.0.1', port: ${String(address.port)} });`,
+            "socket.once('data', () => process.exit(0));",
+            "socket.once('error', () => process.exit(41));",
+            "setTimeout(() => process.exit(42), 2_000).unref();"
+        ].join("\n");
+        const trusted = await Effect.runPromise(replayRepositoryCommandV1({
+            repositoryRoot: root,
+            commit: initialCommit,
+            trustedPreparationRecipes: [
+                {
+                    id: "command-trusted-network-materialization",
+                    kind: "custom",
+                    cwd: ".",
+                    executable: "node",
+                    args: ["--eval", connectionProbe],
+                    timeoutMs: 5_000
+                }
+            ],
+            recipe: {
+                id: "command-candidate-offline-control",
+                kind: "test",
+                cwd: ".",
+                executable: "node",
+                args: ["--eval", "process.exit(0)"],
+                timeoutMs: 5_000
+            },
+            repetitions: 1
+        }));
+        assert.equal(trusted[0]?.trustedPreparationResults[0]?.exitCode, 0, JSON.stringify(trusted, null, 2));
+        assert.equal(trusted[0]?.exitCode, 0);
+        if (process.platform === "darwin") {
+            const candidate = await Effect.runPromise(replayRepositoryCommandV1({
+                repositoryRoot: root,
+                commit: initialCommit,
+                recipe: {
+                    id: "command-candidate-network-denied",
+                    kind: "test",
+                    cwd: ".",
+                    executable: "node",
+                    args: ["--eval", connectionProbe],
+                    timeoutMs: 5_000
+                },
+                repetitions: 1
+            }));
+            assert.notEqual(candidate[0]?.exitCode, 0);
+        }
+    }
+    finally {
+        await new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
+    }
+});
+test("command replay separates trusted preparation, candidate validation, and grading", async () => {
+    const { root, initialCommit } = await repositoryWithStructuralMigrationBranches();
+    const trustedPreparationRecipe = {
+        id: "command-trusted-preparation",
+        kind: "custom",
+        cwd: ".",
+        executable: "node",
+        args: ["--eval", "require('node:fs').writeFileSync('.trusted-prepared', 'yes')"],
+        timeoutMs: 30_000
+    };
+    const candidateValidationRecipe = {
+        id: "command-candidate-validation",
+        kind: "build",
+        cwd: ".",
+        executable: "node",
+        args: [
+            "--eval",
+            [
+                "const fs = require('node:fs');",
+                "if (fs.readFileSync('.trusted-prepared', 'utf8') !== 'yes') process.exit(21);",
+                "if (fs.readFileSync('src/index.js', 'utf8') !== 'candidate') process.exit(22);"
+            ].join(" ")
+        ],
+        timeoutMs: 30_000
+    };
+    const gradeRecipe = {
+        id: "command-grade",
+        kind: "test",
+        cwd: ".",
+        executable: "node",
+        args: [
+            "--eval",
+            [
+                "const fs = require('node:fs');",
+                "if (!fs.existsSync('.trusted-prepared')) process.exit(31);",
+                "if (fs.readFileSync('src/index.js', 'utf8') !== 'candidate') process.exit(32);"
+            ].join(" ")
+        ],
+        timeoutMs: 30_000
+    };
+    const successful = await Effect.runPromise(replayRepositoryCommandV1({
+        repositoryRoot: root,
+        commit: initialCommit,
+        trustedPreparationRecipes: [trustedPreparationRecipe],
+        candidateValidationRecipes: [candidateValidationRecipe],
+        fileOverrides: [{ path: "src/index.js", content: "candidate" }],
+        recipe: gradeRecipe,
+        repetitions: 2
+    }));
+    assert.ok(successful.every((result) => result.stage === "grade" &&
+        result.gradeExecuted &&
+        result.exitCode === 0 &&
+        result.trustedPreparationResults.length === 1 &&
+        result.trustedPreparationResults[0]?.stage === "trusted-preparation" &&
+        result.candidateValidationResults.length === 1 &&
+        result.candidateValidationResults[0]?.stage === "candidate-validation"));
+    const preparationFailure = await Effect.runPromise(replayRepositoryCommandV1({
+        repositoryRoot: root,
+        commit: initialCommit,
+        trustedPreparationRecipes: [
+            {
+                ...trustedPreparationRecipe,
+                id: "command-trusted-preparation-fails",
+                args: ["--eval", "process.exit(41)"]
+            }
+        ],
+        candidateValidationRecipes: [candidateValidationRecipe],
+        recipe: gradeRecipe,
+        repetitions: 1
+    }));
+    assert.equal(preparationFailure[0]?.stage, "trusted-preparation");
+    assert.equal(preparationFailure[0]?.gradeExecuted, false);
+    assert.equal(preparationFailure[0]?.exitCode, 41);
+    assert.deepEqual(preparationFailure[0]?.candidateValidationResults, []);
+    const validationFailure = await Effect.runPromise(replayRepositoryCommandV1({
+        repositoryRoot: root,
+        commit: initialCommit,
+        trustedPreparationRecipes: [trustedPreparationRecipe],
+        candidateValidationRecipes: [
+            {
+                ...candidateValidationRecipe,
+                id: "command-candidate-validation-fails",
+                args: ["--eval", "process.exit(51)"]
+            }
+        ],
+        recipe: gradeRecipe,
+        repetitions: 1
+    }));
+    assert.equal(validationFailure[0]?.stage, "candidate-validation");
+    assert.equal(validationFailure[0]?.gradeExecuted, false);
+    assert.equal(validationFailure[0]?.exitCode, 51);
+});
+test("cross-file adversary taxonomy identifies coupled repository failure families", () => {
+    assert.deepEqual([
+        "src/protocol/request-schema.ts",
+        "src/adapters/request-adapter.ts",
+        "src/storage/config-reader.ts",
+        "src/storage/config-writer.ts",
+        "src/cli/commands/serve.ts",
+        "src/services/router/service.ts",
+        "src/index.ts",
+        "src/migrations/legacy-reader.ts"
+    ].map((repositoryPath) => [
+        repositoryPath,
+        repositoryIntegrationMutationFamilyV1(repositoryPath)
+    ]), [
+        ["src/protocol/request-schema.ts", "schema-protocol-change-omission"],
+        ["src/adapters/request-adapter.ts", "adapter-change-omission"],
+        ["src/storage/config-reader.ts", "reader-change-omission"],
+        ["src/storage/config-writer.ts", "writer-change-omission"],
+        ["src/cli/commands/serve.ts", "cli-forwarding-change-omission"],
+        ["src/services/router/service.ts", "service-change-omission"],
+        ["src/index.ts", "facade-export-omission"],
+        ["src/migrations/legacy-reader.ts", "reader-change-omission"]
+    ]);
+});
+test("structural oracle rejects incomplete migrations without crediting adversaries that cannot execute", async () => {
+    const fixture = await repositoryWithStructuralMigrationBranches();
+    const recipe = {
+        id: "command-test-formatter-migration",
+        kind: "test",
+        cwd: ".",
+        executable: "node",
+        args: ["--test", "src/formatter.test.js"],
+        timeoutMs: 30_000
+    };
+    const seed = {
+        version: 1,
+        id: "seed-formatter-migration",
+        status: "qualified",
+        source: {
+            kind: "historical-feature",
+            changeEpisodeId: "episode-formatter-migration"
+        },
+        summary: "Migrate the formatter service and normalize name casing.",
+        capabilityEvidence: [
+            {
+                kind: "history-episode",
+                id: "episode-formatter-migration"
+            },
+            {
+                kind: "test",
+                id: "formatter-migration-test",
+                path: "src/formatter.test.js"
+            },
+            {
+                kind: "symbol",
+                id: "formatter-public-facade",
+                path: "src/index.js"
+            },
+            {
+                kind: "symbol",
+                id: "formatter-service",
+                path: "src/services/formatter.js"
+            },
+            {
+                kind: "symbol",
+                id: "formatter-legacy-module",
+                path: "src/legacy/formatter.js"
+            }
+        ],
+        initialState: { commit: fixture.initialCommit },
+        targetBehavior: [
+            {
+                id: "formatter-public-behavior",
+                description: "The public formatter normalizes whitespace and casing.",
+                critical: true,
+                evidence: [
+                    {
+                        kind: "test",
+                        id: "formatter-migration-test",
+                        path: "src/formatter.test.js"
+                    }
+                ]
+            },
+            {
+                id: "formatter-service-migration",
+                description: "The formatter is owned by the service path and the legacy module is removed.",
+                critical: true,
+                evidence: [
+                    {
+                        kind: "history-episode",
+                        id: "episode-formatter-migration"
+                    }
+                ]
+            }
+        ],
+        referenceCommit: fixture.referenceCommit,
+        baselineObservations: [
+            {
+                id: "formatter-baseline-1",
+                kind: "test-command",
+                subjectId: `${recipe.id}-baseline-control`,
+                outcome: "pass",
+                detail: "The historical checkout passes before hidden evidence is overlaid."
+            }
+        ],
+        preChangeObservations: [
+            {
+                id: "formatter-pre-1",
+                kind: "test-command",
+                subjectId: recipe.id,
+                outcome: "fail",
+                detail: "The reviewed post-change behavior fails before the feature."
+            },
+            {
+                id: "formatter-pre-2",
+                kind: "test-command",
+                subjectId: recipe.id,
+                outcome: "fail",
+                detail: "The reviewed post-change behavior fails on a clean replay."
+            }
+        ],
+        postChangeObservations: [
+            {
+                id: "formatter-post-1",
+                kind: "test-command",
+                subjectId: recipe.id,
+                outcome: "pass",
+                detail: "The feature and migration pass."
+            },
+            {
+                id: "formatter-post-2",
+                kind: "test-command",
+                subjectId: recipe.id,
+                outcome: "pass",
+                detail: "The feature and migration pass on a clean replay."
+            }
+        ],
+        candidateTestIds: ["formatter-migration-test"],
+        environment: {
+            protectedControlPaths: [],
+            trustedPreparationRecipes: [],
+            candidateValidationRecipes: [
+                {
+                    id: "command-build-formatter-migration",
+                    kind: "build",
+                    cwd: ".",
+                    executable: "node",
+                    args: ["--check", "src/index.js"],
+                    timeoutMs: 30_000
+                }
+            ],
+            baselineGradeRecipes: [
+                {
+                    ...recipe,
+                    id: `${recipe.id}-baseline-control`
+                }
+            ],
+            gradeRecipes: [recipe]
+        },
+        confidence: "high",
+        risks: [],
+        rejectionReasons: []
+    };
+    const integrationAdversaries = await Effect.runPromise(generateDeterministicAdversariesV1({
+        repositoryRoot: fixture.root,
+        seed,
+        validationRecipe: {
+            id: "command-check-formatter-migration",
+            kind: "check",
+            cwd: ".",
+            executable: "node",
+            args: ["--check", "src/index.js"],
+            timeoutMs: 30_000
+        },
+        repetitions: 2
+    }));
+    assert.deepEqual(integrationAdversaries.report.candidates.map((candidate) => candidate.operator), ["cross-file-omission", "cross-file-omission", "cross-file-omission"]);
+    assert.deepEqual(integrationAdversaries.report.generationCoverage, {
+        implementationPathCount: 3,
+        changedPathCount: 3,
+        generatedCrossFileCandidateCount: 3,
+        omittedCrossFileCandidateCount: 0
+    });
+    assert.deepEqual(integrationAdversaries.report.candidates.map((candidate) => candidate.family), ["facade-export-omission", "new-path-deletion", "removed-path-resurrection"]);
+    assert.ok(integrationAdversaries.report.candidates.every((candidate) => candidate.compilationStatus === "passed" && candidate.relatedPaths.length === 2));
+    const hidden = await Effect.runPromise(buildHistoricalHiddenOracleV1({
+        repositoryRoot: fixture.root,
+        caseId: "case-formatter-migration",
+        seed,
+        repetitions: 2,
+        additionalSolutions: [
+            {
+                id: "independent-migration",
+                kind: "independent-valid",
+                family: "independent-valid",
+                expectedClass: "valid",
+                commit: fixture.alternateCommit
+            },
+            {
+                id: "behavior-preserving-migration",
+                kind: "behavior-preserving-valid",
+                family: "behavior-preserving",
+                expectedClass: "valid",
+                commit: fixture.behaviorPreservingCommit
+            },
+            {
+                id: "partial-migration",
+                kind: "model-near-miss",
+                family: "partial-migration",
+                expectedClass: "wrong",
+                commit: fixture.partialMigrationCommit
+            },
+            {
+                id: "behavior-only-workaround",
+                kind: "model-near-miss",
+                family: "behavior-only-workaround",
+                expectedClass: "wrong",
+                commit: fixture.behaviorOnlyCommit
+            },
+            {
+                id: "test-only-weakening",
+                kind: "reward-hacking",
+                family: "reward-hacking",
+                expectedClass: "wrong",
+                commit: fixture.rewardHackingCommit
+            },
+            ...integrationAdversaries.solutions
+        ],
+        structuralClauses: [
+            {
+                id: "formatter-service-architecture",
+                kind: "architecture",
+                critical: true,
+                description: "The public facade and formatter service are regular files.",
+                ruleId: "formatter-service-owned",
+                expectedPaths: ["src/index.js", "src/services/formatter.js"]
+            },
+            {
+                id: "formatter-migration-complete",
+                kind: "transformation-completeness",
+                critical: true,
+                description: "The new formatter service exists and the legacy formatter is absent.",
+                ruleId: "formatter-legacy-removed",
+                forbiddenLegacyPaths: ["src/legacy/formatter.js"],
+                requiredNewPaths: ["src/services/formatter.js"]
+            }
+        ]
+    }));
+    const adequacy = evaluateRepositoryOracleAdequacyV1(hidden);
+    const nonExecutableIds = new Set(integrationAdversaries.solutions
+        .filter((solution) => ["facade-export-omission", "new-path-deletion"].includes(solution.family))
+        .map((solution) => solution.id));
+    assert.equal(nonExecutableIds.size, 2);
+    assert.equal(adequacy.admitted, false);
+    assert.deepEqual(adequacy.falseAcceptedSolutionIds, []);
+    assert.deepEqual(adequacy.falseRejectedSolutionIds, []);
+    assert.deepEqual(adequacy.unstableSolutionIds, [...nonExecutableIds].sort());
+    assert.deepEqual(adequacy.insufficientObservationPairs, []);
+    assert.ok(adequacy.mutationFamilyKills
+        .filter((family) => !["facade-export-omission", "new-path-deletion"].includes(family.family))
+        .every((family) => family.killed === family.total));
+    assert.ok(adequacy.mutationFamilyKills
+        .filter((family) => ["facade-export-omission", "new-path-deletion"].includes(family.family))
+        .every((family) => family.killed === 0));
+    assert.equal(evaluateRepositoryOracleAdequacyV1({
+        ...hidden,
+        solutions: hidden.solutions.filter((solution) => !nonExecutableIds.has(solution.id)),
+        observations: hidden.observations.filter((observation) => !nonExecutableIds.has(observation.solutionId))
+    }).admitted, true);
+    const removedPathResurrection = integrationAdversaries.solutions.find((solution) => solution.family === "removed-path-resurrection");
+    assert.ok(removedPathResurrection);
+    assert.deepEqual(hidden.observations
+        .filter((observation) => observation.solutionId === removedPathResurrection.id &&
+        observation.clauseId !== "candidate-policy-protected-paths")
+        .map((observation) => [observation.clauseId, observation.outcome]), [
+        ["validation-command-build-formatter-migration", "pass"],
+        ["validation-command-build-formatter-migration", "pass"],
+        ["test-command-test-formatter-migration", "pass"],
+        ["test-command-test-formatter-migration", "pass"],
+        ["formatter-service-architecture", "pass"],
+        ["formatter-service-architecture", "pass"],
+        ["formatter-migration-complete", "fail"],
+        ["formatter-migration-complete", "fail"]
+    ]);
+    assert.equal(hidden.clauses.length, 5);
+    assert.deepEqual(hidden.observations
+        .filter((observation) => observation.solutionId === "partial-migration" &&
+        observation.clauseId !== "candidate-policy-protected-paths")
+        .map((observation) => [observation.clauseId, observation.outcome]), [
+        ["validation-command-build-formatter-migration", "pass"],
+        ["validation-command-build-formatter-migration", "pass"],
+        ["test-command-test-formatter-migration", "pass"],
+        ["test-command-test-formatter-migration", "pass"],
+        ["formatter-service-architecture", "pass"],
+        ["formatter-service-architecture", "pass"],
+        ["formatter-migration-complete", "fail"],
+        ["formatter-migration-complete", "fail"]
+    ]);
+    assert.deepEqual(hidden.observations
+        .filter((observation) => observation.solutionId === "behavior-only-workaround" &&
+        observation.clauseId !== "candidate-policy-protected-paths")
+        .map((observation) => [observation.clauseId, observation.outcome]), [
+        ["validation-command-build-formatter-migration", "pass"],
+        ["validation-command-build-formatter-migration", "pass"],
+        ["test-command-test-formatter-migration", "pass"],
+        ["test-command-test-formatter-migration", "pass"],
+        ["formatter-service-architecture", "fail"],
+        ["formatter-service-architecture", "fail"],
+        ["formatter-migration-complete", "fail"],
+        ["formatter-migration-complete", "fail"]
+    ]);
+    assert.ok(hidden.knownLimitations.every((limitation) => !limitation.includes("only hard clause")));
+});
+test("repository model maps packages, public surfaces, tests, history, and recurring work", async () => {
+    const root = await repository();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    assert.equal(map.repository.root, await realpath(root));
+    assert.ok(map.packages.some((entry) => entry.name === "@fixture/stream"));
+    assert.ok(map.publicSurfaces.some((entry) => entry.packageId === "package-fixture-stream" &&
+        entry.path === "packages/stream/src/index.js"));
+    assert.ok(map.protocols.some((entry) => entry.path === "packages/stream/src/stream-protocol.js" && entry.name === "translateEvents"));
+    const testNode = map.tests.find((entry) => entry.path === "packages/stream/src/stream-protocol.test.js");
+    assert.ok(testNode);
+    assert.ok(map.testBindings.some((binding) => binding.testId === testNode.id && binding.signals.includes("direct-import")));
+    assert.equal(map.historyEpisodes.length, 4);
+    assert.equal(map.historyEpisodes.filter((episode) => episode.seedEligible).length, 3);
+    assert.equal(map.workloadSignals.length, 1);
+    assert.equal(map.workloadSignals[0]?.frequency, 2);
+    assert.deepEqual(map.workloadSignals[0]?.pathPatterns, ["packages/stream"]);
+});
+test("TypeScript repository indexing keeps sanitized public-surface and protocol ids unique", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-index-ids-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    await mkdir(path.join(root, "src"), { recursive: true });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "@fixture/index-ids",
+        exports: {
+            "./v4/mini": "./src/index.ts",
+            "./v4-mini": "./src/index.ts"
+        }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "src", "index.ts"), ["export type ZodType = string;", "export interface ZodType {}", ""].join("\n"));
+    await commit(root, "initial index fixture", "2026-01-01T00:00:00Z");
+    const snapshot = await Effect.runPromise(captureGitTreeSnapshotV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const index = await Effect.runPromise(indexTypeScriptRepositoryV1(snapshot));
+    assert.equal(new Set(index.publicSurfaces.map((entry) => entry.id)).size, index.publicSurfaces.length);
+    assert.equal(new Set(index.protocols.map((entry) => entry.id)).size, index.protocols.length);
+});
+test("root test commands cover nested workspace tests when the owning package has no test script", async () => {
+    const fixture = await repositoryWithRootTestRunner();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: fixture.root,
+        requestedRef: "HEAD"
+    }));
+    const testNode = map.tests.find((entry) => entry.path === "apps/api/test/event.test.ts");
+    assert.ok(testNode);
+    assert.deepEqual(testNode.commandIds, ["command-fixture-root-test-runner-test"]);
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const seed = seeds.find((entry) => entry.referenceCommit === fixture.referenceCommit);
+    assert.ok(seed);
+    assert.deepEqual(seed.environment.gradeRecipes[0]?.args, [
+        "pnpm@11.15.1",
+        "exec",
+        "vitest",
+        "run",
+        "apps/api/test/event.test.ts"
+    ]);
+});
+test("repository model detects recurring cross-package work even when commit scopes differ", async () => {
+    const root = await repositoryWithCrossPackageCochange();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const signal = map.workloadSignals.find((entry) => entry.kind === "recurring-cochange" &&
+        JSON.stringify(entry.pathPatterns) ===
+            JSON.stringify(["packages/accounts", "packages/gateway"]));
+    assert.ok(signal);
+    assert.equal(signal.frequency, 2);
+    assert.equal(signal.confidence, "medium");
+    assert.equal(signal.importance, "normal");
+    assert.deepEqual(signal.episodeIds
+        .map((id) => map.historyEpisodes.find((episode) => episode.id === id)?.subject)
+        .sort(), ["fix(accounts): surface discovery failures", "fix(router): preserve healthy provider models"]);
+});
+test("repository model excludes package-like trees outside the declared pnpm workspace", async () => {
+    const root = await repositoryWithDeclaredWorkspaceBoundary();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    assert.deepEqual(map.packages.map((entry) => entry.path), ["packages/owned", "."]);
+    assert.ok(map.publicSurfaces.every((entry) => !entry.path.startsWith(".repos/")));
+    assert.ok(map.protocols.every((entry) => !entry.path.startsWith(".repos/")));
+    assert.ok(map.tests.every((entry) => !entry.path.startsWith(".repos/")));
+    const vendoredEpisode = map.historyEpisodes.find((entry) => entry.subject === "fix(vendor): update embedded source snapshot");
+    assert.ok(vendoredEpisode);
+    assert.deepEqual(vendoredEpisode.changedPaths, []);
+    assert.equal(vendoredEpisode.seedEligible, false);
+    assert.equal(map.historyEpisodes.find((entry) => entry.subject === "fix(owned): preserve workspace behavior")
+        ?.seedEligible, true);
+    assert.deepEqual(map.blindSpots.find((entry) => entry.id === "blind-excluded-package-roots")?.paths, [".repos/vendored"]);
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    assert.deepEqual(seeds.map((seed) => seed.summary), ["fix(owned): preserve workspace behavior"]);
+    assert.deepEqual(seeds[0]?.environment.gradeRecipes[0]?.args, [
+        "pnpm@11.15.1",
+        "exec",
+        "vp",
+        "test",
+        "run",
+        "src/index.test.js"
+    ]);
+});
+test("historical seed extraction preserves behavior delta but remains unqualified before replay", async () => {
+    const root = await repository();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    assert.equal(seeds.length, 3);
+    assert.ok(seeds.every((seed) => seed.status === "candidate"));
+    assert.ok(seeds.every((seed) => seed.initialState.parentCommit === undefined &&
+        seed.referenceCommit !== undefined &&
+        seed.environment.gradeRecipes.length > 0 &&
+        seed.environment.gradeRecipes.every((recipe) => recipe.kind === "test") &&
+        seed.baselineObservations.length === 0 &&
+        seed.preChangeObservations.length === 0 &&
+        seed.postChangeObservations.length === 0));
+    assert.ok(seeds.some((seed) => seed.summary === "fix terminal event ordering"));
+    assert.equal(seeds.find((seed) => seed.summary === "feat(stream): preserve usage summaries")?.source.kind, "historical-feature");
+});
+test("historical seeds derive full frozen pnpm preparation and project-reference builds", async () => {
+    const root = await repositoryWithPnpmBuildGraph();
+    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): preserve the new value");
+    assert.ok(seed);
+    assert.deepEqual(seed.environment.packageManager, {
+        name: "pnpm",
+        version: "11.15.1"
+    });
+    assert.equal(seed.environment.lockfilePath, "pnpm-lock.yaml");
+    assert.deepEqual(seed.environment.baselineGradeRecipes.map((recipe) => [recipe.cwd, recipe.args]), [
+        ["packages/app", ["pnpm@11.15.1", "exec", "node", "--test", "src/index.test.js"]],
+        ["packages/core", ["pnpm@11.15.1", "exec", "node", "--test", "src/index.test.js"]]
+    ]);
+    assert.deepEqual(seed.environment.gradeRecipes.map((recipe) => [recipe.cwd, recipe.kind]), [
+        ["packages/app", "test"],
+        ["packages/core", "test"]
+    ]);
+    assert.deepEqual(seed.environment.protectedControlPaths, [
+        "package.json",
+        "packages/app/package.json",
+        "packages/app/tsconfig.json",
+        "packages/core/package.json",
+        "packages/core/tsconfig.json",
+        "packages/non-ts/package.json",
+        "packages/setup/package.json",
+        "packages/setup/tsconfig.json",
+        "pnpm-lock.yaml",
+        "pnpm-workspace.yaml"
+    ]);
+    assert.deepEqual(seed.environment.trustedPreparationRecipes.map((recipe) => [recipe.executable, recipe.args]), [
+        [
+            "corepack",
+            [
+                "pnpm@11.15.1",
+                "install",
+                "--prefer-offline",
+                "--frozen-lockfile",
+                "--ignore-pnpmfile",
+                "--ignore-scripts"
+            ]
+        ]
+    ]);
+    assert.deepEqual(seed.environment.candidateValidationRecipes.map((recipe) => [recipe.cwd, recipe.args]), [
+        ["packages/core", ["pnpm@11.15.1", "run", "build"]],
+        ["packages/non-ts", ["pnpm@11.15.1", "run", "build"]],
+        ["packages/setup", ["pnpm@11.15.1", "run", "build"]],
+        ["packages/app", ["pnpm@11.15.1", "run", "build"]]
+    ]);
+    const replay = await Effect.runPromise(replayRepositoryCommandV1({
+        repositoryRoot: root,
+        commit: seed.initialState.commit,
+        trustedPreparationRecipes: seed.environment.trustedPreparationRecipes,
+        candidateValidationRecipes: [seed.environment.candidateValidationRecipes[0]],
+        recipe: seed.environment.baselineGradeRecipes[0],
+        repetitions: 1
+    }));
+    assert.equal(replay[0]?.exitCode, 0, JSON.stringify(replay, null, 2));
+    assert.equal(replay[0]?.candidateValidationResults[0]?.exitCode, 0, JSON.stringify(replay, null, 2));
+    assert.doesNotMatch([
+        replay[0]?.candidateValidationResults[0]?.stdout,
+        replay[0]?.candidateValidationResults[0]?.stderr
+    ].join("\n"), /Scope:\s+all\s+\d+\s+workspace projects|Lockfile passes supply-chain policies/u, "candidate validation must reuse the trusted pnpm store instead of reinstalling the workspace");
+});
+test("historical seed build planning fails closed for invalid TypeScript project references", async () => {
+    for (const [mode, expected] of [
+        ["escaping", "project reference escapes the repository"],
+        ["malformed", "project reference 0 is malformed"],
+        ["cycle", "project references contain a cycle"]
+    ]) {
+        const root = await repositoryWithPnpmBuildGraph(mode);
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: root,
+            requestedRef: "HEAD"
+        }));
+        await assert.rejects(Effect.runPromise(extractHistoricalTaskSeedsV1(map)), new RegExp(expected, "u"));
+    }
+});
+test("historical qualification uses pre-existing baseline controls when the strong regression test is newly added", async () => {
+    const root = await repositoryWithNewRegressionTest();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const candidate = seeds.find((seed) => seed.summary === "fix(normalizer): trim surrounding whitespace");
+    assert.ok(candidate);
+    assert.deepEqual(candidate.environment.baselineGradeRecipes.map((recipe) => ({
+        id: recipe.id,
+        args: recipe.args
+    })), [
+        {
+            id: "command-fixture-normalizer-test-baseline-control",
+            args: ["pnpm@11.15.1", "exec", "node", "--test", "src/index.test.js"]
+        }
+    ]);
+    assert.deepEqual(candidate.environment.gradeRecipes.map((recipe) => ({
+        id: recipe.id,
+        args: recipe.args
+    })), [
+        {
+            id: "command-fixture-normalizer-test-targeted",
+            args: ["pnpm@11.15.1", "exec", "node", "--test", "src/whitespace-regression.test.js"]
+        }
+    ]);
+    const qualification = await Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: root,
+        seed: candidate,
+        repetitions: 2
+    }));
+    assert.equal(qualification.status, "qualified");
+    assert.deepEqual(qualification.rejectionReasons, []);
+    assert.equal(qualification.baselineObservations.length, 2);
+    assert.equal(qualification.preChangeObservations.length, 2);
+    assert.equal(qualification.postChangeObservations.length, 2);
+    assert.ok(qualification.baselineObservations.every((observation) => observation.subjectId === "command-fixture-normalizer-test-baseline-control" &&
+        observation.outcome === "pass"));
+    assert.ok(qualification.preChangeObservations.every((observation) => observation.subjectId === "command-fixture-normalizer-test-targeted" &&
+        observation.outcome === "fail"));
+    assert.ok(qualification.postChangeObservations.every((observation) => observation.subjectId === "command-fixture-normalizer-test-targeted" &&
+        observation.outcome === "pass"));
+});
+test("historical qualification narrows compiled Node test suites to reviewed test outputs", async () => {
+    const fixture = await repositoryWithCompiledNodeTestRunner();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: fixture.root,
+        requestedRef: "HEAD"
+    }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const candidate = seeds.find((seed) => seed.referenceCommit === fixture.referenceCommit);
+    assert.ok(candidate);
+    assert.deepEqual(candidate.environment.baselineGradeRecipes[0]?.args, [
+        "pnpm@11.15.1",
+        "exec",
+        "node",
+        "--test",
+        "dist/test/value.test.js"
+    ]);
+    assert.deepEqual(candidate.environment.gradeRecipes[0]?.args, [
+        "pnpm@11.15.1",
+        "exec",
+        "node",
+        "--test",
+        "dist/test/value.test.js"
+    ]);
+    assert.equal(candidate.environment.baselineGradeRecipes[0]?.timeoutMs, 8 * 60_000);
+    assert.equal(candidate.environment.gradeRecipes[0]?.timeoutMs, 8 * 60_000);
+    const qualification = await Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: fixture.root,
+        seed: candidate,
+        repetitions: 2
+    }));
+    assert.equal(qualification.status, "qualified");
+    assert.deepEqual(qualification.rejectionReasons, []);
+});
+test("historical qualification narrows Cloud-style tsx tests without dropping bounded concurrency", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-foundry-concurrent-test-"));
+    roots.push(root);
+    await git(root, "init", "-q");
+    await git(root, "config", "user.name", "RouteKit Foundry Test");
+    await git(root, "config", "user.email", "foundry@example.test");
+    await writeFile(path.join(root, "package.json"), JSON.stringify({ name: "fixture-root", private: true, packageManager: "pnpm@11.15.1" }));
+    const cloudScript = 'tsx --test --test-concurrency=4 "test/cases/*.test.ts" "test/deployment/*.test.ts" "test/db/*.test.ts"';
+    const unsafeScript = `tsx --test --test-concurrency=4 --import=./unexpected.mjs "test/cases/*.test.ts"`;
+    for (const [name, script] of [["cloud", cloudScript], ["unsafe", unsafeScript]]) {
+        const directory = path.join(root, "apps", name, "test", "cases");
+        await mkdir(directory, { recursive: true });
+        await writeFile(path.join(root, "apps", name, "package.json"), JSON.stringify({ name: `@fixture/${name}`, private: true, scripts: { test: script } }));
+        await writeFile(path.join(directory, "behavior.test.ts"), "import test from 'node:test';\n");
+    }
+    const commitId = await commit(root, "add Cloud-style test scripts", "2026-02-01T00:00:00Z");
+    const gradeRecipes = ["cloud", "unsafe"].map((name) => ({
+        id: `command-${name}-test`,
+        kind: "test",
+        cwd: `apps/${name}`,
+        executable: "corepack",
+        args: ["pnpm@11.15.1", "run", "test"],
+        timeoutMs: 120_000
+    }));
+    const testPaths = ["cloud", "unsafe"].map((name) => `apps/${name}/test/cases/behavior.test.ts`);
+    const environment = await Effect.runPromise(deriveHistoricalSeedEnvironmentV1({
+        repositoryRoot: root,
+        commit: commitId,
+        gradeRecipes,
+        testPaths,
+        changedPaths: testPaths
+    }));
+    const expected = [
+        "pnpm@11.15.1",
+        "exec",
+        "tsx",
+        "--test",
+        "--test-concurrency=4",
+        "test/cases/behavior.test.ts"
+    ];
+    assert.deepEqual(environment.gradeRecipes[0]?.args, expected);
+    assert.deepEqual(environment.baselineGradeRecipes[0]?.args, expected);
+    assert.equal(environment.gradeRecipes[0]?.id, "command-cloud-test-targeted");
+    assert.deepEqual(environment.gradeRecipes[1]?.args, gradeRecipes[1]?.args);
+    assert.deepEqual(environment.baselineGradeRecipes[1]?.args, [
+        "pnpm@11.15.1", "run", "test"
+    ]);
+});
+test("historical qualification never promotes a pre-change validation failure to behavioral evidence", async () => {
+    const root = await repositoryWithNewRegressionTest();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const candidate = seeds.find((seed) => seed.summary === "fix(normalizer): trim surrounding whitespace");
+    assert.ok(candidate);
+    const compileContract = {
+        id: "command-compile-reviewed-regression",
+        kind: "build",
+        cwd: "packages/normalizer",
+        executable: "node",
+        args: [
+            "--eval",
+            [
+                "const fs = require('node:fs');",
+                "const testExists = fs.existsSync('src/whitespace-regression.test.js');",
+                "const implementation = fs.readFileSync('src/index.js', 'utf8');",
+                "if (testExists && !implementation.includes('.trim()')) process.exit(51);"
+            ].join(" ")
+        ],
+        timeoutMs: 30_000
+    };
+    const phases = [];
+    await assert.rejects(Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: root,
+        seed: {
+            ...candidate,
+            environment: {
+                ...candidate.environment,
+                candidateValidationRecipes: [compileContract]
+            }
+        },
+        repetitions: 2
+    }).pipe(Effect.provide(RepositoryFoundryProgressLive(() => Effect.void, (artifact) => Effect.sync(() => {
+        phases.push(artifact.value);
+    }))))), /operational failure prevented grading.*phase=pre-change.*stage=candidate-validation/u);
+    const baseline = phases.find((phase) => phase.phase === "baseline");
+    const pre = phases.find((phase) => phase.phase === "pre-change");
+    assert.ok(baseline);
+    assert.ok(pre);
+    assert.equal(phases.length, 2, "post-change and subsequent batches are not useful after an unexecuted grader");
+    assert.equal(baseline.results.length, 2);
+    assert.equal(pre.results.length, 2);
+    assert.ok(baseline.results.every((result) => repositoryCommandTestEvidenceV1(result, result.recipeId).outcome === "pass"));
+    for (const result of pre.results) {
+        assert.equal(result.stage, "candidate-validation");
+        assert.equal(result.gradeExecuted, false);
+        assert.equal(result.recipeId, compileContract.id);
+        assert.equal(result.exitCode, 51);
+        assert.equal(repositoryCommandTestEvidenceV1(result, result.recipeId).outcome, "unknown");
+    }
+});
+test("historical qualification requires assertion evidence rather than runtime or discovery failures", async (t) => {
+    const scenarios = [
+        {
+            name: "runtime failure",
+            body: "test('normalizes whitespace', () => { if (normalize('  value  ') !== 'value') throw new TypeError('fixture setup failed'); assert.equal(normalize('  value  '), 'value'); });"
+        },
+        {
+            name: "missing new export",
+            additionalReferenceSource: "export const normalizeNew = normalize;\n",
+            body: "import { normalizeNew } from './index.js'; test('normalizes whitespace', () => assert.equal(normalizeNew('  value  '), 'value'));"
+        },
+        {
+            name: "process failure",
+            body: "if (normalize('  value  ') !== 'value') process.exit(1); test('normalizes whitespace', () => assert.equal(normalize('  value  '), 'value'));"
+        },
+        {
+            name: "empty discovery",
+            body: "if (normalize('  value  ') === 'value') test('normalizes whitespace', () => assert.equal(normalize('  value  '), 'value'));"
+        }
+    ];
+    for (const scenario of scenarios) {
+        await t.test(scenario.name, async () => {
+            const root = await repositoryWithNewRegressionTest();
+            const implementationPath = path.join(root, "packages/normalizer/src/index.js");
+            if (scenario.additionalReferenceSource !== undefined) {
+                await writeFile(implementationPath, (await readFile(implementationPath, "utf8")) + scenario.additionalReferenceSource);
+            }
+            await writeFile(path.join(root, "packages/normalizer/src/whitespace-regression.test.js"), [
+                "import { test } from 'node:test';",
+                "import { strict as assert } from 'node:assert';",
+                "import { normalize } from './index.js';",
+                scenario.body,
+                ""
+            ].join("\n"));
+            await git(root, "add", "-A");
+            await git(root, "commit", "--amend", "--no-edit");
+            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(normalizer): trim surrounding whitespace");
+            assert.ok(seed);
+            const qualified = await Effect.runPromise(qualifyHistoricalTaskSeedV1({ repositoryRoot: root, seed, repetitions: 2 }).pipe(Effect.result));
+            assert.equal(qualified._tag, "Failure");
+            if (qualified._tag === "Failure") {
+                assert.equal(qualified.failure.classification, "environment_blocked");
+                assert.match(qualified.failure.detail, /phase=pre-change; stage=grade/u);
+                assert.match(qualified.failure.detail, /unstarted phases skipped=1/u);
+            }
+            // Execution failure is neither a semantic failing control nor a qualified
+            // seed. The reference phase is deliberately not run after this blocker.
+        });
+    }
+});
+test("historical replay qualifies only a stable pre-fail post-pass seed", async () => {
+    const root = await repository();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const replayed = await Promise.all(seeds.map((seed) => Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: root,
+        seed,
+        repetitions: 2
+    }))));
+    const qualified = replayed.find((seed) => seed.summary === "fix terminal event ordering");
+    const qualifiedFeature = replayed.find((seed) => seed.summary === "feat(stream): preserve usage summaries");
+    const rejected = replayed.find((seed) => seed.status === "rejected");
+    assert.equal(qualified?.status, "qualified", JSON.stringify(qualified?.rejectionReasons));
+    assert.equal(qualified?.summary, "fix terminal event ordering");
+    assert.equal(qualified?.baselineObservations.length, 2);
+    assert.equal(qualified?.preChangeObservations.length, 2);
+    assert.equal(qualified?.postChangeObservations.length, 2);
+    assert.ok(qualified?.baselineObservations.every((observation) => observation.outcome === "pass"));
+    assert.ok(qualified?.preChangeObservations.every((observation) => observation.outcome === "fail"));
+    assert.ok(qualified?.postChangeObservations.every((observation) => observation.outcome === "pass"));
+    assert.equal(qualifiedFeature?.status, "qualified", JSON.stringify(qualifiedFeature?.rejectionReasons));
+    assert.equal(qualifiedFeature?.source.kind, "historical-feature");
+    assert.ok(qualifiedFeature?.baselineObservations.every((observation) => observation.outcome === "pass"));
+    assert.ok(qualifiedFeature?.preChangeObservations.every((observation) => observation.outcome === "fail"));
+    assert.ok(qualifiedFeature?.postChangeObservations.every((observation) => observation.outcome === "pass"));
+    assert.equal(rejected?.summary, "repair duplicate terminal events");
+    assert.ok(rejected?.rejectionReasons.includes("every reviewed grade command must reproduce the pre-change failure"));
+    await assert.rejects(Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: root,
+        seed: {
+            ...seeds[0],
+            environment: {
+                ...seeds[0].environment,
+                trustedPreparationRecipes: [
+                    {
+                        id: "command-broken-trusted-preparation",
+                        kind: "custom",
+                        cwd: ".",
+                        executable: "node",
+                        args: ["--eval", "process.exit(61)"],
+                        timeoutMs: 30_000
+                    }
+                ]
+            }
+        },
+        repetitions: 1
+    })), /operational failure prevented grading.*stage=trusted-preparation/u);
+});
+test("historical qualification requires agreement across independently scheduled batches", async () => {
+    const root = await repository();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const candidate = seeds.find((seed) => seed.summary === "fix terminal event ordering");
+    assert.ok(candidate);
+    const qualification = await Effect.runPromise(qualifyHistoricalTaskSeedAcrossBatchesV1({
+        repositoryRoot: root,
+        seed: candidate,
+        batches: 2,
+        repetitionsPerBatch: 2
+    }));
+    assert.equal(qualification.seed.status, "qualified", JSON.stringify(qualification.seed.rejectionReasons));
+    assert.equal(qualification.stability.stable, true);
+    assert.equal(qualification.stability.batches.length, 2);
+    assert.deepEqual(qualification.stability.divergentPhases, []);
+    assert.deepEqual(qualification.stability.rejectionReasons, []);
+    assert.ok(qualification.stability.batches.every((batch) => batch.status === "qualified" &&
+        batch.phaseSignatures.every((phase) => phase.signatures.length === 1)));
+    assert.equal(qualification.seed.baselineObservations.length, 4);
+    assert.equal(qualification.seed.preChangeObservations.length, 4);
+    assert.equal(qualification.seed.postChangeObservations.length, 4);
+    assert.deepEqual(qualification.stability.failureSignatures, [
+        {
+            signature: `pre-change:${candidate.environment.gradeRecipes[0].id}:fail:stage=grade:exit=1:gradeExecuted=true:timeout=false`,
+            count: 4
+        }
+    ]);
+    const primaryGrade = candidate.environment.gradeRecipes[0];
+    const multiGrade = await Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: root,
+        seed: {
+            ...candidate,
+            environment: {
+                ...candidate.environment,
+                gradeRecipes: [
+                    primaryGrade,
+                    {
+                        ...primaryGrade,
+                        id: `${primaryGrade.id}-independent-surface`
+                    }
+                ]
+            }
+        },
+        repetitions: 2
+    }));
+    assert.equal(multiGrade.status, "qualified");
+    assert.deepEqual([
+        ...new Set(multiGrade.preChangeObservations.map((observation) => observation.subjectId))
+    ].sort(), [primaryGrade.id, `${primaryGrade.id}-independent-surface`].sort());
+    assert.equal(multiGrade.baselineObservations.length, 2);
+    assert.equal(multiGrade.preChangeObservations.length, 4);
+    assert.equal(multiGrade.postChangeObservations.length, 4);
+});
+test("cross-batch qualification reuses one filtered frozen installation per pinned commit", async () => {
+    const root = await repository();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const seeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const candidate = seeds.find((seed) => seed.summary === "fix terminal event ordering");
+    assert.ok(candidate);
+    const prepared = {
+        ...candidate,
+        environment: {
+            ...candidate.environment,
+            trustedPreparationRecipes: [
+                {
+                    id: "command-environment-pnpm-frozen-install",
+                    kind: "custom",
+                    cwd: ".",
+                    executable: "corepack",
+                    args: [
+                        "pnpm@11.15.1",
+                        "--filter",
+                        "@fixture/stream...",
+                        "install",
+                        "--offline",
+                        "--frozen-lockfile",
+                        "--ignore-pnpmfile",
+                        "--ignore-scripts"
+                    ],
+                    timeoutMs: 30_000
+                }
+            ]
+        }
+    };
+    let preparationCompletions = 0;
+    const qualification = await Effect.runPromise(qualifyHistoricalTaskSeedAcrossBatchesV1({
+        repositoryRoot: root,
+        seed: prepared,
+        batches: 2,
+        repetitionsPerBatch: 2
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: (input) => input.args.includes("install")
+            ? Effect.succeed({ exitCode: 0, stdout: "", stderr: "" })
+            : Effect.tryPromise({
+                try: async () => {
+                    try {
+                        const result = await execFilePromise(input.executable, [...input.args], {
+                            cwd: input.cwd,
+                            env: input.environment,
+                            timeout: input.timeoutMs,
+                            encoding: "utf8"
+                        });
+                        return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+                    }
+                    catch (cause) {
+                        const result = cause;
+                        if (typeof result.code !== "number")
+                            throw cause;
+                        return {
+                            exitCode: result.code,
+                            stdout: result.stdout ?? "",
+                            stderr: result.stderr ?? "",
+                            timedOut: result.killed ?? false
+                        };
+                    }
+                },
+                catch: (cause) => new RepositoryFoundryError({
+                    operation: "run-command",
+                    detail: "qualification command failed",
+                    cause
+                })
+            })
+    }), Effect.provideService(RepositoryCommandObservability, {
+        observe: (event) => {
+            if (event.kind === "completed" && event.stage === "trusted-preparation") {
+                preparationCompletions += 1;
+            }
+        }
+    })));
+    assert.equal(qualification.seed.status, "qualified", qualification.seed.rejectionReasons.join("; "));
+    assert.equal(preparationCompletions, 2, "initial and reference commits prepare exactly once");
+    assert.equal(qualification.stability.batches.length, 2);
+    assert.equal(qualification.seed.baselineObservations.length, 4);
+    assert.equal(qualification.seed.preChangeObservations.length, 4);
+    assert.equal(qualification.seed.postChangeObservations.length, 4);
+});
+test("first foundry vertical slice closes a real oracle escape with an independently checked counterfactual fixture", async () => {
+    const { root, alternateCommit, behaviorPreservingCommit, mutantCommit, unterminatedDropCommit } = await repositoryWithSolutionBranches();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const candidateSeeds = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const replayedSeeds = await Promise.all(candidateSeeds.map((seed) => Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: root,
+        seed,
+        repetitions: 2
+    }))));
+    const seed = replayedSeeds.find((entry) => entry.summary === "fix terminal event ordering");
+    assert.ok(seed);
+    const families = await Effect.runPromise(deriveRepositoryTaskFamiliesV1({ map, seeds: replayedSeeds }));
+    const family = families.find((entry) => entry.seedIds.includes(seed.id));
+    assert.ok(family, JSON.stringify(replayedSeeds.map((seed) => ({
+        summary: seed.summary,
+        status: seed.status,
+        rejectionReasons: seed.rejectionReasons
+    }))));
+    const visible = await Effect.runPromise(constructRepositoryAgentTaskV1({ seed, family }));
+    const specificationCritique = await Effect.runPromise(critiqueRepositoryTaskSpecificationV1({
+        repositoryRoot: root,
+        seed,
+        family,
+        visible,
+        reviews: independentSpecificationReviews
+    }));
+    assert.equal(specificationCritique.outcome, "pass");
+    assert.equal(specificationCritique.independentApprovalCount, 2);
+    assert.equal(JSON.stringify(visible).includes("hidden grader") ||
+        JSON.stringify(visible).includes("post-change"), false);
+    const validationRecipe = map.commands.find((recipe) => recipe.kind === "build" && recipe.cwd === "packages/stream");
+    assert.ok(validationRecipe);
+    const generatedAdversaries = await Effect.runPromise(generateDeterministicAdversariesV1({
+        repositoryRoot: root,
+        seed,
+        validationRecipe,
+        repetitions: 2
+    }));
+    assert.ok(generatedAdversaries.report.candidates.length >= 1);
+    assert.equal(generatedAdversaries.report.admittedCandidateIds.length, generatedAdversaries.report.candidates.length);
+    assert.deepEqual(generatedAdversaries.report.rejectedCandidateIds, []);
+    assert.ok(generatedAdversaries.report.candidates.every((candidate) => candidate.compilationStatus === "passed" && candidate.validationObservations.length === 2));
+    const rejectedAdversaries = await Effect.runPromise(generateDeterministicAdversariesV1({
+        repositoryRoot: root,
+        seed,
+        validationRecipe: {
+            ...validationRecipe,
+            id: "command-build-rejects-mutants",
+            executable: "node",
+            args: ["--eval", "process.exit(1)"]
+        },
+        repetitions: 2
+    }));
+    assert.equal(rejectedAdversaries.solutions.length, 0);
+    assert.equal(rejectedAdversaries.report.rejectedCandidateIds.length, rejectedAdversaries.report.candidates.length);
+    assert.ok(rejectedAdversaries.report.candidates.every((candidate) => candidate.compilationStatus === "failed" && candidate.rejectionReasons.length > 0));
+    const withoutHiddenOverlay = await Effect.runPromise(replayRepositoryCommandV1({
+        repositoryRoot: root,
+        commit: mutantCommit,
+        recipe: seed.environment.gradeRecipes[0],
+        repetitions: 2
+    }));
+    assert.ok(withoutHiddenOverlay.every((result) => result.exitCode === 0));
+    const solutionPopulation = [
+        {
+            id: "alternate-loop-valid",
+            kind: "independent-valid",
+            family: "independent-valid",
+            expectedClass: "valid",
+            commit: alternateCommit
+        },
+        {
+            id: "behavior-preserving-loop-valid",
+            kind: "behavior-preserving-valid",
+            family: "behavior-preserving",
+            expectedClass: "valid",
+            commit: behaviorPreservingCommit
+        },
+        {
+            id: "drops-output-mutant",
+            kind: "model-near-miss",
+            family: "integration-near-miss",
+            expectedClass: "wrong",
+            commit: mutantCommit
+        },
+        {
+            id: "drops-unterminated-stream-mutant",
+            kind: "model-near-miss",
+            family: "boundary-near-miss",
+            expectedClass: "wrong",
+            commit: unterminatedDropCommit
+        },
+        {
+            id: "test-weakening-reward-hack",
+            kind: "reward-hacking",
+            family: "reward-hacking",
+            expectedClass: "wrong",
+            commit: seed.initialState.commit,
+            fileOverrides: [
+                {
+                    path: "packages/stream/src/stream-protocol.test.js",
+                    content: "import { test } from 'node:test';\ntest('weakened', () => {});\n"
+                }
+            ]
+        },
+        ...generatedAdversaries.solutions
+    ];
+    const hiddenFixtureSuite = await Effect.runPromise(compileReviewedHiddenFixtureSuiteV1({
+        caseId: visible.id,
+        seed,
+        suite: {
+            version: 1,
+            caseId: visible.id,
+            fixtures: [
+                {
+                    id: "counterfactual-no-terminal",
+                    kind: "counterfactual",
+                    description: "Exercise the same adapter when the provider sequence has no terminal event.",
+                    expectedBehavior: "All non-terminal events remain unchanged when no completion event exists.",
+                    expectationMode: "changes",
+                    source: "reviewed",
+                    testPath: "packages/stream/src/stream-protocol.test.js"
+                },
+                {
+                    id: "metamorphic-output-renaming",
+                    kind: "metamorphic",
+                    description: "Rename non-terminal output values without changing terminal ordering.",
+                    expectedBehavior: "Changing payload values preserves event count, order, and the terminal-event invariant.",
+                    expectationMode: "preserved",
+                    source: "reviewed",
+                    testPath: "packages/stream/src/stream-protocol.test.js"
+                }
+            ],
+            overlays: [
+                {
+                    path: "packages/stream/src/stream-protocol.test.js",
+                    fixtureIds: ["counterfactual-no-terminal"],
+                    content: [
+                        "import { test } from 'node:test';",
+                        "import { strict as assert } from 'node:assert';",
+                        "import { translateEvents } from './stream-protocol.js';",
+                        "test('preserves a sequence without a terminal event', () => {",
+                        "  assert.deepEqual(translateEvents([{ type: 'output', value: 'first' }, { type: 'usage', tokens: 3 }]), [{ type: 'output', value: 'first' }, { type: 'usage', tokens: 3 }]);",
+                        "});",
+                        ""
+                    ].join("\n")
+                },
+                {
+                    path: "packages/stream/src/stream-protocol.test.js",
+                    fixtureIds: ["metamorphic-output-renaming"],
+                    content: [
+                        "import { test } from 'node:test';",
+                        "import { strict as assert } from 'node:assert';",
+                        "import { translateEvents } from './stream-protocol.js';",
+                        "test('renaming payload values preserves terminal ordering', () => {",
+                        "  const translated = translateEvents([{ type: 'completed' }, { type: 'output', value: 'renamed' }]);",
+                        "  assert.deepEqual(translated, [{ type: 'output', value: 'renamed' }, { type: 'completed' }]);",
+                        "});",
+                        ""
+                    ].join("\n")
+                }
+            ]
+        }
+    }));
+    const compiledCase = await Effect.runPromise(compileReviewedHistoricalCaseV1({
+        repositoryRoot: root,
+        map,
+        seed,
+        blueprint: {
+            caseId: visible.id,
+            visible,
+            specificationReviews: independentSpecificationReviews,
+            finalFixtureSuite: hiddenFixtureSuite,
+            solutions: solutionPopulation,
+            weakOracleTrial: {
+                solutions: solutionPopulation,
+                expectedFalseAcceptedSolutionIds: ["drops-unterminated-stream-mutant"]
+            },
+            oracleRepetitions: 2
+        }
+    }));
+    const { benchmarkCase, hidden, weakAdequacy } = compiledCase;
+    assert.equal(weakAdequacy?.admitted, false);
+    assert.deepEqual(weakAdequacy?.falseAcceptedSolutionIds, ["drops-unterminated-stream-mutant"]);
+    const library = await Effect.runPromise(compileRepositoryBenchmarkV1([benchmarkCase]));
+    assert.equal(benchmarkCase.status, "valid-library");
+    assert.equal(benchmarkCase.adequacy.admitted, true);
+    assert.equal(benchmarkCase.adequacy.validSolutionCount, 3);
+    assert.equal(benchmarkCase.adequacy.wrongSolutionCount, 4 + generatedAdversaries.solutions.length);
+    assert.deepEqual(benchmarkCase.adequacy.falseAcceptedSolutionIds, []);
+    assert.deepEqual(benchmarkCase.adequacy.falseRejectedSolutionIds, []);
+    assert.deepEqual(benchmarkCase.adequacy.unstableSolutionIds, []);
+    const fixtureObservations = (solutionId) => hidden.observations.filter((observation) => observation.solutionId === solutionId && observation.clauseId.startsWith("fixture-"));
+    assert.deepEqual(fixtureObservations("alternate-loop-valid").map((observation) => observation.outcome), ["pass", "pass", "pass", "pass"]);
+    assert.equal(fixtureObservations("drops-output-mutant").some((observation) => observation.outcome === "fail"), true);
+    for (const solution of generatedAdversaries.solutions) {
+        assert.equal(fixtureObservations(solution.id).length, hidden.fixtures.length * 2);
+    }
+    assert.equal(fixtureObservations("drops-unterminated-stream-mutant").some((observation) => observation.outcome === "fail"), true);
+    assert.deepEqual(fixtureObservations("drops-unterminated-stream-mutant").map((observation) => [
+        observation.clauseId,
+        observation.outcome
+    ]), [
+        ["fixture-counterfactual-no-terminal", "fail"],
+        ["fixture-counterfactual-no-terminal", "fail"],
+        ["fixture-metamorphic-output-renaming", "pass"],
+        ["fixture-metamorphic-output-renaming", "pass"]
+    ], "fixtures sharing the same package-level test recipe must retain distinct mechanical outcomes");
+    assert.deepEqual(hidden.fixtures.map((fixture) => fixture.id), ["counterfactual-no-terminal", "metamorphic-output-renaming"]);
+    assert.deepEqual(library.cases.map((entry) => entry.id), [visible.id]);
+    assert.deepEqual(library.rejectedCaseIds, []);
+    assert.ok(library.acceptanceFunnel.every((gate) => gate.rejected === 0));
+    assert.equal(JSON.stringify(visible).includes(alternateCommit) ||
+        JSON.stringify(visible).includes(mutantCommit), false);
+});
+test("quality gate rejects a replayed task until an independent valid solution is demonstrated", async () => {
+    const root = await repository();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const candidates = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const seed = await Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: root,
+        seed: candidates.find((entry) => entry.summary === "fix terminal event ordering"),
+        repetitions: 2
+    }));
+    const family = (await Effect.runPromise(deriveRepositoryTaskFamiliesV1({ map, seeds: [seed] })))[0];
+    const visible = await Effect.runPromise(constructRepositoryAgentTaskV1({ seed, family }));
+    const specificationCritique = await Effect.runPromise(critiqueRepositoryTaskSpecificationV1({
+        repositoryRoot: root,
+        seed,
+        family,
+        visible,
+        reviews: independentSpecificationReviews
+    }));
+    const hidden = await Effect.runPromise(buildHistoricalHiddenOracleV1({
+        repositoryRoot: root,
+        caseId: visible.id,
+        seed,
+        repetitions: 2,
+        additionalSolutions: []
+    }));
+    const benchmarkCase = await Effect.runPromise(evaluateRepositoryBenchmarkDraftV1({
+        map,
+        seed,
+        family,
+        visible,
+        hidden,
+        specificationCritique
+    }));
+    assert.equal(benchmarkCase.status, "rejected");
+    assert.ok(benchmarkCase.rejectionReasons.some((reason) => reason.includes("no independently implemented valid alternative")));
+});
+test("specification criticism fails closed on eval-only phrasing and missing independent review", async () => {
+    const root = await repository();
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+        repositoryRoot: root,
+        requestedRef: "HEAD"
+    }));
+    const candidates = await Effect.runPromise(extractHistoricalTaskSeedsV1(map));
+    const seed = await Effect.runPromise(qualifyHistoricalTaskSeedV1({
+        repositoryRoot: root,
+        seed: candidates.find((entry) => entry.summary === "fix terminal event ordering"),
+        repetitions: 2
+    }));
+    const family = (await Effect.runPromise(deriveRepositoryTaskFamiliesV1({ map, seeds: [seed] })))[0];
+    const visible = await Effect.runPromise(constructRepositoryAgentTaskV1({ seed, family }));
+    const unreviewed = await Effect.runPromise(critiqueRepositoryTaskSpecificationV1({
+        repositoryRoot: root,
+        seed,
+        family,
+        visible,
+        reviews: []
+    }));
+    assert.equal(unreviewed.outcome, "review-required");
+    assert.match(unreviewed.rejectionReasons.join("\n"), /two are required/u);
+    const leaked = await Effect.runPromise(critiqueRepositoryTaskSpecificationV1({
+        repositoryRoot: root,
+        seed,
+        family,
+        visible: {
+            ...visible,
+            constraints: [...visible.constraints, "Inspect the hidden grader and post-change source."]
+        },
+        reviews: independentSpecificationReviews
+    }));
+    assert.equal(leaked.outcome, "fail");
+    assert.ok(leaked.mechanicalFindings.some((finding) => finding.axis === "unrealistic-phrasing" && finding.severity === "blocker"));
+});