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

package/dist/services/task-seed/service.js

@@ -0,0 +1,1406 @@
+import { posix as path } from "node:path";
+import { Clock, Context, Effect, Layer } from "effect";
+import { captureGitTreeSnapshotV1, readGitTreeFileV1 } from "../../adapters/git-task-history.js";
+import { repositoryCommandTestEvidenceV1 } from "../../adapters/repository-command-evidence.js";
+import { encodeRepositoryCommandDiagnosticV1, sanitizeRepositoryCommandDiagnosticV1 } from "../../adapters/repository-command-diagnostic.js";
+import { makeRepositoryPreparationCacheV1, replayRepositoryCommandsV1 } from "../../adapters/repository-command-runner.js";
+import { selectTypeScriptWorkspaceManifestPathsV1 } from "../../adapters/typescript-repository-index.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { assertRepositoryHiddenFixtureSuiteV1 } from "../../repository-fixture-protocol.js";
+import { assertRepositorySeedCrossBatchQualificationV1, assertRepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import { RepositoryFoundryEvidenceReconstruction } from "../evidence-reconstruction/service.js";
+import { reportFoundryAuthoringArtifactV1, reportFoundryHeartbeatV1 } from "../foundry-progress/service.js";
+const failure = (detail) => new RepositoryFoundryError({
+    operation: "extract-task-seeds",
+    detail
+});
+/**
+ * Qualification and oracle admission consume the same executed test evidence.
+ * Passing baseline/reference builds cannot turn an unexecuted pre-change grader
+ * into a behavioral failure, even when an overlay imports a newly added API.
+ */
+const qualificationExecutionBlocked = (result) => repositoryCommandTestEvidenceV1(result, result.recipeId).outcome === "unknown";
+const qualificationExecutionFailure = (phase, result) => {
+    const diagnostic = sanitizeRepositoryCommandDiagnosticV1(result.stdout, result.stderr, result.outputTruncated);
+    return new RepositoryFoundryError({
+        operation: "extract-task-seeds",
+        classification: "environment_blocked",
+        detail: `historical qualification stopped after operational failure prevented grading: phase=${phase}; stage=${result.stage}; recipe=${result.recipeId}; exit=${String(result.exitCode)}; timeout=${String(result.timedOut)}; outputTruncated=${String(result.outputTruncated)}${diagnostic === undefined ? "" :
+            `; diagnostic=${encodeRepositoryCommandDiagnosticV1(diagnostic.text)}; diagnosticTruncated=${String(diagnostic.truncated)}`}; evidence=${repositoryCommandTestEvidenceV1(result, result.recipeId).detail}; unstarted phases skipped; later batches were not started. Qualification requires executable reviewed tests on both revisions and attributable pre-change assertion failures. Repair the execution environment or select another candidate; repeating this unchanged plan cannot establish qualification.`
+    });
+};
+const hiddenQualificationOverlays = Effect.fnUntraced(function* (seed, fixture) {
+    const hiddenTestOverlays = seed.capabilityEvidence
+        .filter((evidence) => evidence.kind === "test" && evidence.path !== undefined)
+        .map((evidence) => ({
+        path: evidence.path,
+        sourceCommit: seed.referenceCommit
+    }));
+    const hiddenContentOverlays = fixture?.overlays.map((overlay) => ({
+        path: overlay.path,
+        content: overlay.content
+    })) ?? [];
+    if (fixture !== undefined) {
+        assertRepositoryHiddenFixtureSuiteV1(fixture);
+        const reviewedTestPaths = new Set(seed.capabilityEvidence.flatMap((evidence) => evidence.kind === "test" && evidence.path !== undefined ? [evidence.path] : []));
+        const outOfScopePath = fixture.overlays.find((overlay) => !reviewedTestPaths.has(overlay.path))?.path;
+        if (outOfScopePath !== undefined) {
+            return yield* failure(`qualification fixture targets a path outside the reviewed test scope: ${outOfScopePath}`);
+        }
+    }
+    return { hiddenTestOverlays, hiddenContentOverlays };
+});
+const packageRoot = (map, paths) => [...map.packages]
+    .filter((entry) => paths.some((path) => entry.path === "." || path === entry.path || path.startsWith(`${entry.path}/`)))
+    .sort((left, right) => right.path.length - left.path.length)[0]?.path;
+const commandsFor = (map, testPaths, changedPaths) => {
+    const commandIds = new Set(map.tests.filter((test) => testPaths.includes(test.path)).flatMap((test) => test.commandIds));
+    const bound = map.commands
+        .filter((command) => command.kind === "test" && commandIds.has(command.id))
+        .sort((left, right) => left.cwd.localeCompare(right.cwd) || left.id.localeCompare(right.id));
+    if (bound.length > 0) {
+        const scoped = bound.filter((command) => command.cwd !== ".");
+        // A root workspace test command is a broad fallback, not an additional
+        // package-level grade. Keeping it beside specifically bound package tests
+        // expands replay preparation to unrelated deployment applications (and
+        // their environment-only builds), making a focused historical seed depend
+        // on credentials that are intentionally unavailable in the sandbox.
+        return scoped.length > 0 ? scoped : bound;
+    }
+    const root = packageRoot(map, changedPaths);
+    const fallback = map.commands.find((command) => command.kind === "test" && command.cwd === root);
+    return fallback === undefined ? [] : [fallback];
+};
+const manifestPathFor = (cwd) => cwd === "." ? "package.json" : `${cwd}/package.json`;
+const manifestRootFor = (path) => path === "package.json" ? "." : path.slice(0, -"/package.json".length);
+const recipeSafeId = (value) => value
+    .replace(/^@/u, "")
+    .replace(/[^A-Za-z0-9]+/gu, "-")
+    .replace(/^-|-$/gu, "");
+/**
+ * Historical qualification replays one reviewed grade at a time inside a
+ * ten-minute resumable capability slice. Package discovery's two-minute test
+ * default is appropriate for a quick repository probe, but it is too short
+ * for a focused test file that legitimately contains several integration
+ * cases. Leave two minutes in the slice for preparation, durable checkpoint
+ * persistence, and command teardown.
+ */
+const HISTORICAL_QUALIFICATION_GRADE_TIMEOUT_MS_V1 = 8 * 60_000;
+const qualificationGradeRecipe = (recipe) => recipe.kind === "test"
+    ? {
+        ...recipe,
+        timeoutMs: Math.max(recipe.timeoutMs, HISTORICAL_QUALIFICATION_GRADE_TIMEOUT_MS_V1)
+    }
+    : recipe;
+const recipeReadsEmittedArtifacts = (recipe) => recipe.args.some((argument) => /(?:^|[/\\])dist(?:[/\\]|$)/u.test(argument));
+const candidateValidationScript = (input) => {
+    const build = input.scripts.build;
+    if (typeof build !== "string")
+        return undefined;
+    if (!input.targetRoots.has(input.root) ||
+        !/\bnext\s+build\b/u.test(build) ||
+        input.gradeRecipes.some((recipe) => recipe.cwd === input.root && recipeReadsEmittedArtifacts(recipe))) {
+        return "build";
+    }
+    return (["types:check", "typecheck"].find((script) => typeof input.scripts[script] === "string") ??
+        "build");
+};
+const compiledTestExtensions = {
+    ".ts": ".js",
+    ".tsx": ".js",
+    ".mts": ".mjs",
+    ".cts": ".cjs"
+};
+const compiledNodeTestPath = (relativeTestPath) => {
+    if (!relativeTestPath.startsWith("src/test/"))
+        return undefined;
+    const extension = path.extname(relativeTestPath);
+    const outputExtension = compiledTestExtensions[extension];
+    if (outputExtension === undefined)
+        return undefined;
+    return `dist/${relativeTestPath.slice("src/".length, -extension.length)}${outputExtension}`;
+};
+const historicalTestScript = (manifest) => {
+    if (manifest?.scripts === null || typeof manifest?.scripts !== "object")
+        return undefined;
+    const test = manifest.scripts.test;
+    return typeof test === "string" ? test : undefined;
+};
+const recognizedPnpmTestRunner = (testScript) => {
+    if (testScript === undefined)
+        return undefined;
+    const normalized = testScript.trim().replace(/\s+/gu, " ");
+    if (normalized === "vp test run") {
+        return { argv: ["vp", "test", "run"] };
+    }
+    if (normalized === "pnpm vitest run") {
+        return {
+            argv: ["vitest", "run"],
+            runFromRepositoryRoot: true
+        };
+    }
+    if (normalized === "vitest" || normalized === "vitest run") {
+        return { argv: ["vitest", "run"] };
+    }
+    if (!normalized.startsWith("node --test") && !normalized.startsWith("tsx --test")) {
+        return undefined;
+    }
+    const concurrencyFlag = /^(?:node|tsx) --test (--test-concurrency=[1-9]\d{0,2})(?= |$)/u.exec(normalized)?.[1];
+    const suiteScript = concurrencyFlag === undefined ? normalized : normalized.replace(` ${concurrencyFlag}`, "");
+    const nodeRunner = normalized.startsWith("tsx ") ? "tsx" : "node";
+    const compiledSuite = /^(?:node|tsx) --test (?:"|')?dist\/test\/\*\.test\.js(?:"|')?$/u.test(suiteScript);
+    const sourceSuite = suiteScript === "node --test" ||
+        suiteScript === "tsx --test" ||
+        /^(?:node|tsx) --test (?!["']?-)(?:[\w./*?{}-]+|"[\w./*?{}-]+"|'[\w./*?{}-]+')(?: (?!["']?-)(?:[\w./*?{}-]+|"[\w./*?{}-]+"|'[\w./*?{}-]+'))*$/u.test(suiteScript);
+    if (!compiledSuite && !sourceSuite)
+        return undefined;
+    return {
+        argv: concurrencyFlag === undefined
+            ? [nodeRunner, "--test"]
+            : [nodeRunner, "--test", concurrencyFlag],
+        compiledTests: compiledSuite ? true : undefined
+    };
+};
+const relativeRecipeTestPaths = (input) => input.testPaths
+    .filter((testPath) => input.recipe.cwd === "." || testPath.startsWith(`${input.recipe.cwd}/`))
+    .map((testPath) => input.recipe.cwd === "." ? testPath : path.relative(input.recipe.cwd, testPath))
+    .filter((testPath) => testPath.length > 0 && testPath !== ".." && !testPath.startsWith("../"))
+    .sort();
+const targetedPnpmTestRecipe = (input) => {
+    const testPaths = input.runner.runFromRepositoryRoot
+        ? [...input.testPaths].sort()
+        : relativeRecipeTestPaths(input);
+    if (testPaths.length === 0)
+        return undefined;
+    const projectedTestPaths = input.runner.compiledTests
+        ? testPaths.map(compiledNodeTestPath)
+        : testPaths;
+    if (!projectedTestPaths.every((testPath) => testPath !== undefined)) {
+        return undefined;
+    }
+    let executable = "node";
+    let args = [...input.runner.argv.slice(1), ...projectedTestPaths];
+    if (input.packageManagerVersion !== undefined) {
+        executable = "corepack";
+        args = [
+            `pnpm@${input.packageManagerVersion}`,
+            "exec",
+            ...input.runner.argv,
+            ...projectedTestPaths
+        ];
+    }
+    return qualificationGradeRecipe({
+        ...input.recipe,
+        id: input.id,
+        cwd: input.runner.runFromRepositoryRoot ? "." : input.recipe.cwd,
+        executable,
+        args
+    });
+};
+const narrowPnpmTestRecipe = (input) => {
+    if (input.recipe.kind !== "test") {
+        return input.recipe;
+    }
+    const runner = recognizedPnpmTestRunner(historicalTestScript(input.manifest));
+    if (runner === undefined)
+        return qualificationGradeRecipe(input.recipe);
+    if (input.packageManagerVersion === undefined && runner.argv[0] !== "node")
+        return qualificationGradeRecipe(input.recipe);
+    return targetedPnpmTestRecipe({
+        recipe: input.recipe,
+        id: `${input.recipe.id}-targeted`,
+        runner,
+        packageManagerVersion: input.packageManagerVersion,
+        testPaths: input.testPaths
+    }) ?? qualificationGradeRecipe(input.recipe);
+};
+const historicalBaselineRecipe = (input) => {
+    const baselineId = `${input.recipe.id}-baseline-control`;
+    const testScript = historicalTestScript(input.manifest);
+    const runner = recognizedPnpmTestRunner(testScript);
+    const baselineRecipe = qualificationGradeRecipe({ ...input.recipe, id: baselineId });
+    if (input.recipe.kind !== "test" ||
+        (input.packageManagerVersion === undefined && runner?.argv[0] !== "node") ||
+        testScript === undefined) {
+        return baselineRecipe;
+    }
+    if (runner !== undefined) {
+        const targeted = targetedPnpmTestRecipe({
+            recipe: input.recipe,
+            id: baselineId,
+            runner,
+            packageManagerVersion: input.packageManagerVersion,
+            testPaths: input.controlTestPaths
+        });
+        if (targeted !== undefined)
+            return targeted;
+    }
+    if (input.packageManagerVersion === undefined)
+        return baselineRecipe;
+    return qualificationGradeRecipe({
+        ...input.recipe,
+        id: baselineId,
+        executable: "corepack",
+        args: [`pnpm@${input.packageManagerVersion}`, "run", "test"]
+    });
+};
+const repositoryTestPath = (value) => {
+    const lower = value.toLowerCase();
+    const base = lower.split("/").at(-1) ?? lower;
+    return (/\.(?:[cm]?[jt]sx?|py|go|rs)$/u.test(lower) &&
+        (/(?:^|[._-])(?:test|spec)(?:[._-]|$)/u.test(base) ||
+            /(^|\/)(?:test|tests|__tests__)(\/|$)/u.test(lower)));
+};
+const semanticTokens = (content) => {
+    const ignored = new Set([
+        "assert",
+        "async",
+        "await",
+        "boolean",
+        "catch",
+        "class",
+        "const",
+        "describe",
+        "effect",
+        "else",
+        "error",
+        "expect",
+        "export",
+        "false",
+        "finally",
+        "from",
+        "function",
+        "import",
+        "input",
+        "interface",
+        "length",
+        "message",
+        "never",
+        "node",
+        "null",
+        "number",
+        "object",
+        "process",
+        "readonly",
+        "return",
+        "shared",
+        "string",
+        "sync",
+        "test",
+        "t3tools",
+        "true",
+        "type",
+        "undefined",
+        "unknown",
+        "value",
+        "void",
+        "while",
+        "yield"
+    ]);
+    return new Set([...content.matchAll(/[A-Za-z_$][A-Za-z0-9_$]*/gu)]
+        .map((match) => match[0].toLowerCase())
+        .filter((token) => token.length >= 3 && !ignored.has(token)));
+};
+const selectHistoricalBaselineControlPathsV1 = Effect.fn("TaskSeed.selectHistoricalBaselineControls")(function* (input) {
+    const withinRecipe = (candidate) => input.recipe.cwd === "." || candidate.startsWith(`${input.recipe.cwd}/`);
+    const changedSources = input.changedPaths.filter((candidate) => withinRecipe(candidate) &&
+        input.snapshot.files.includes(candidate) &&
+        !repositoryTestPath(candidate));
+    const existingChangedTests = input.testPaths.filter((candidate) => withinRecipe(candidate) &&
+        input.snapshot.files.includes(candidate) &&
+        repositoryTestPath(candidate));
+    if (existingChangedTests.length > 0) {
+        return [...new Set(existingChangedTests)].sort();
+    }
+    const allPackageTests = input.snapshot.files.filter((candidate) => withinRecipe(candidate) && repositoryTestPath(candidate));
+    if (allPackageTests.length === 0)
+        return [];
+    const changedDirectories = new Set(changedSources.map((candidate) => path.dirname(candidate)));
+    const sameDirectoryTests = allPackageTests.filter((candidate) => changedDirectories.has(path.dirname(candidate)));
+    const candidates = sameDirectoryTests.length > 0 ? sameDirectoryTests : allPackageTests;
+    const changedContents = yield* Effect.forEach(changedSources, (candidate) => readGitTreeFileV1({
+        snapshot: input.snapshot,
+        path: candidate
+    }));
+    const sourceTokens = semanticTokens(changedContents.join("\n"));
+    const candidateContents = yield* Effect.forEach(candidates, (candidate) => readGitTreeFileV1({
+        snapshot: input.snapshot,
+        path: candidate
+    }).pipe(Effect.map((content) => ({
+        path: candidate,
+        content,
+        tokens: semanticTokens(content)
+    }))));
+    const documentFrequency = new Map();
+    for (const candidate of candidateContents) {
+        for (const token of candidate.tokens) {
+            documentFrequency.set(token, (documentFrequency.get(token) ?? 0) + 1);
+        }
+    }
+    const score = (candidate) => {
+        const semantic = [...sourceTokens]
+            .filter((token) => candidate.tokens.has(token))
+            .reduce((total, token) => total +
+            Math.log((candidateContents.length + 1) / ((documentFrequency.get(token) ?? 0) + 1)) +
+            1, 0);
+        return semantic / Math.sqrt(Math.max(1, candidate.content.length));
+    };
+    return candidateContents
+        .sort((left, right) => score(right) - score(left) ||
+        left.content.length - right.content.length ||
+        left.path.localeCompare(right.path))
+        .slice(0, 1)
+        .map((candidate) => candidate.path);
+});
+const readJsonObject = Effect.fn("TaskSeed.readEnvironmentManifest")(function* (input) {
+    if (!input.snapshot.files.includes(input.path))
+        return undefined;
+    const content = yield* readGitTreeFileV1(input);
+    return yield* Effect.try({
+        try: () => JSON.parse(content),
+        catch: () => failure(`historical environment manifest is invalid JSON: ${input.path}`)
+    });
+});
+const stripJsonComments = (content) => {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < content.length; index += 1) {
+        const character = content[index];
+        const next = content[index + 1];
+        if (inString) {
+            result += character;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+            result += character;
+            continue;
+        }
+        if (character === "/" && next === "/") {
+            result += "  ";
+            index += 1;
+            while (index + 1 < content.length && content[index + 1] !== "\n") {
+                result += " ";
+                index += 1;
+            }
+            continue;
+        }
+        if (character === "/" && next === "*") {
+            result += "  ";
+            index += 1;
+            let closed = false;
+            while (index + 1 < content.length) {
+                const commentCharacter = content[index + 1];
+                const commentNext = content[index + 2];
+                if (commentCharacter === "*" && commentNext === "/") {
+                    result += "  ";
+                    index += 2;
+                    closed = true;
+                    break;
+                }
+                result += commentCharacter === "\n" ? "\n" : " ";
+                index += 1;
+            }
+            if (!closed) {
+                throw new Error("unterminated block comment");
+            }
+            continue;
+        }
+        result += character;
+    }
+    return result;
+};
+const stripTrailingJsonCommas = (content) => {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < content.length; index += 1) {
+        const character = content[index];
+        if (inString) {
+            result += character;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+            result += character;
+            continue;
+        }
+        if (character === ",") {
+            let lookahead = index + 1;
+            while (lookahead < content.length && /\s/u.test(content[lookahead])) {
+                lookahead += 1;
+            }
+            if (content[lookahead] === "]" || content[lookahead] === "}") {
+                continue;
+            }
+        }
+        result += character;
+    }
+    return result;
+};
+const readJsoncObject = Effect.fn("TaskSeed.readTypeScriptProjectConfig")(function* (input) {
+    if (!input.snapshot.files.includes(input.path))
+        return undefined;
+    const content = yield* readGitTreeFileV1(input);
+    return yield* Effect.try({
+        try: () => JSON.parse(stripTrailingJsonCommas(stripJsonComments(content))),
+        catch: () => failure(`historical TypeScript project config is invalid JSONC: ${input.path}`)
+    });
+});
+const normalizeProjectReference = (configPath, referencePath) => {
+    const portableReference = referencePath.replaceAll("\\", "/").trim();
+    if (portableReference.length === 0 ||
+        portableReference.includes("\0") ||
+        path.isAbsolute(portableReference) ||
+        /^[A-Za-z]:\//u.test(portableReference)) {
+        throw failure(`historical TypeScript project reference is not repository-relative: ${configPath} -> ${JSON.stringify(referencePath)}`);
+    }
+    const resolved = path.normalize(path.join(path.dirname(configPath), portableReference));
+    if (resolved === ".." || resolved.startsWith("../")) {
+        throw failure(`historical TypeScript project reference escapes the repository: ${configPath} -> ${JSON.stringify(referencePath)}`);
+    }
+    return resolved.endsWith(".json") ? resolved : path.join(resolved, "tsconfig.json");
+};
+export const deriveHistoricalSeedEnvironmentV1 = Effect.fn("TaskSeed.deriveHistoricalEnvironment")(function* (input) {
+    const snapshot = yield* captureGitTreeSnapshotV1({
+        repositoryRoot: input.repositoryRoot,
+        requestedRef: input.commit
+    });
+    const { selectedManifestPaths } = yield* selectTypeScriptWorkspaceManifestPathsV1(snapshot);
+    const selectedManifestPathSet = new Set(selectedManifestPaths);
+    const rootManifest = yield* readJsonObject({
+        snapshot,
+        path: "package.json"
+    });
+    const targetManifests = yield* Effect.forEach(input.gradeRecipes, (gradeRecipe) => readJsonObject({
+        snapshot,
+        path: manifestPathFor(gradeRecipe.cwd)
+    }).pipe(Effect.map((manifest) => ({
+        root: gradeRecipe.cwd,
+        manifest
+    }))));
+    const packageManager = typeof rootManifest?.packageManager === "string"
+        ? /^pnpm@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?)$/u.exec(rootManifest.packageManager)
+        : null;
+    const lockfilePath = snapshot.files.includes("pnpm-lock.yaml") ? "pnpm-lock.yaml" : undefined;
+    const gradeRecipes = input.gradeRecipes.map((recipe) => narrowPnpmTestRecipe({
+        recipe,
+        manifest: targetManifests.find((target) => target.root === recipe.cwd)?.manifest,
+        packageManagerVersion: packageManager?.[1],
+        testPaths: input.testPaths
+    }));
+    const baselineGradeRecipes = yield* Effect.forEach(input.gradeRecipes, (recipe) => selectHistoricalBaselineControlPathsV1({
+        snapshot,
+        recipe,
+        changedPaths: input.changedPaths,
+        testPaths: input.testPaths
+    }).pipe(Effect.map((controlTestPaths) => historicalBaselineRecipe({
+        recipe,
+        manifest: targetManifests.find((target) => target.root === recipe.cwd)?.manifest,
+        packageManagerVersion: packageManager?.[1],
+        controlTestPaths
+    }))));
+    const trustedPreparationRecipes = [];
+    const candidateValidationRecipes = [];
+    const referencedProjectConfigPaths = new Set();
+    if (packageManager?.[1] !== undefined && lockfilePath !== undefined) {
+        const pnpm = `pnpm@${packageManager[1]}`;
+        const packageManifests = new Map();
+        for (const path of snapshot.files.filter((candidate) => selectedManifestPathSet.has(candidate))) {
+            const manifest = yield* readJsonObject({ snapshot, path });
+            if (typeof manifest?.name !== "string")
+                continue;
+            const manifestScripts = manifest.scripts !== null && typeof manifest.scripts === "object"
+                ? manifest.scripts
+                : {};
+            const dependencies = [
+                manifest.dependencies,
+                manifest.devDependencies,
+                manifest.optionalDependencies,
+                manifest.peerDependencies
+            ].flatMap((value) => value !== null && typeof value === "object"
+                ? Object.keys(value)
+                : []);
+            packageManifests.set(manifest.name, {
+                root: manifestRootFor(path),
+                scripts: manifestScripts,
+                manifestDependencies: dependencies,
+                emitsArtifacts: /(?:^|[\/])(?:dist|build|lib)[\/]/u.test(JSON.stringify([manifest.main, manifest.module, manifest.exports]))
+            });
+        }
+        const packageByRoot = new Map([...packageManifests].map(([name, manifest]) => [manifest.root, name]));
+        const owningPackageName = (projectConfigPath) => [...packageByRoot]
+            .filter(([root]) => root === "."
+            ? !projectConfigPath.includes("/")
+            : projectConfigPath === `${root}/tsconfig.json` ||
+                projectConfigPath.startsWith(`${root}/`))
+            .sort(([left], [right]) => right.length - left.length || left.localeCompare(right))[0]?.[1];
+        const projectReferences = new Map();
+        const loadProjectReferences = Effect.fn("TaskSeed.loadTypeScriptProjectReferences")(function* (configPath) {
+            const existing = projectReferences.get(configPath);
+            if (existing !== undefined)
+                return existing;
+            const config = yield* readJsoncObject({
+                snapshot,
+                path: configPath
+            });
+            if (config === undefined) {
+                return yield* failure(`historical TypeScript project reference target is missing: ${configPath}`);
+            }
+            if (config.references !== undefined && !Array.isArray(config.references)) {
+                return yield* failure(`historical TypeScript project references must be an array: ${configPath}`);
+            }
+            const references = [];
+            for (const [index, entry] of (config.references ?? []).entries()) {
+                if (entry === null ||
+                    typeof entry !== "object" ||
+                    typeof entry.path !== "string") {
+                    return yield* failure(`historical TypeScript project reference ${String(index)} is malformed: ${configPath}`);
+                }
+                const referencedConfigPath = yield* Effect.try({
+                    try: () => normalizeProjectReference(configPath, entry.path),
+                    catch: (cause) => cause instanceof RepositoryFoundryError
+                        ? cause
+                        : failure(`failed to resolve historical TypeScript project reference ${String(index)}: ${configPath}`)
+                });
+                if (!snapshot.files.includes(referencedConfigPath)) {
+                    return yield* failure(`historical TypeScript project reference target is missing: ${configPath} -> ${referencedConfigPath}`);
+                }
+                references.push(referencedConfigPath);
+            }
+            const ordered = [...new Set(references)].sort();
+            projectReferences.set(configPath, ordered);
+            referencedProjectConfigPaths.add(configPath);
+            for (const reference of ordered) {
+                referencedProjectConfigPaths.add(reference);
+            }
+            return ordered;
+        });
+        const projectDependencies = new Map();
+        const visitedProjectConfigs = new Set();
+        const visitingProjectConfigs = [];
+        const visitProjectConfig = (configPath, inheritedPackageName) => Effect.gen(function* () {
+            const sourcePackageName = owningPackageName(configPath) ?? inheritedPackageName;
+            const visitKey = `${sourcePackageName}\0${configPath}`;
+            if (visitedProjectConfigs.has(visitKey))
+                return;
+            const cycleIndex = visitingProjectConfigs.indexOf(visitKey);
+            if (cycleIndex >= 0) {
+                return yield* failure(`historical TypeScript project references contain a cycle: ${[
+                    ...visitingProjectConfigs.slice(cycleIndex),
+                    visitKey
+                ]
+                    .map((entry) => entry.split("\0")[1])
+                    .join(" -> ")}`);
+            }
+            visitingProjectConfigs.push(visitKey);
+            const references = yield* loadProjectReferences(configPath);
+            for (const referencedConfigPath of references) {
+                const dependencyPackageName = owningPackageName(referencedConfigPath);
+                if (sourcePackageName !== undefined &&
+                    dependencyPackageName !== undefined &&
+                    sourcePackageName !== dependencyPackageName) {
+                    const dependencies = projectDependencies.get(sourcePackageName) ?? new Set();
+                    dependencies.add(dependencyPackageName);
+                    projectDependencies.set(sourcePackageName, dependencies);
+                }
+                yield* visitProjectConfig(referencedConfigPath, dependencyPackageName ?? sourcePackageName);
+            }
+            visitingProjectConfigs.pop();
+            visitedProjectConfigs.add(visitKey);
+        });
+        const targetPackageNames = targetManifests.flatMap(({ manifest }) => typeof manifest?.name === "string" ? [manifest.name] : []);
+        const targetRoots = new Set(targetManifests.map(({ root }) => root));
+        const orderedPackageNames = [];
+        const visited = new Set();
+        const visiting = [];
+        const visit = (name) => Effect.gen(function* () {
+            if (visited.has(name))
+                return;
+            const cycleIndex = visiting.indexOf(name);
+            if (cycleIndex >= 0) {
+                return yield* failure(`historical workspace build graph contains a cycle: ${[
+                    ...visiting.slice(cycleIndex),
+                    name
+                ].join(" -> ")}`);
+            }
+            const manifest = packageManifests.get(name);
+            if (manifest === undefined)
+                return;
+            visiting.push(name);
+            const configPath = manifest.root === "." ? "tsconfig.json" : `${manifest.root}/tsconfig.json`;
+            if (snapshot.files.includes(configPath)) {
+                yield* visitProjectConfig(configPath, name);
+            }
+            const dependencies = [
+                ...new Set([...manifest.manifestDependencies, ...(projectDependencies.get(name) ?? [])])
+            ]
+                .filter((candidate) => packageManifests.has(candidate))
+                .sort();
+            for (const dependency of dependencies) {
+                yield* visit(dependency);
+            }
+            visiting.pop();
+            visited.add(name);
+            orderedPackageNames.push(name);
+        });
+        for (const name of [...new Set(targetPackageNames)].sort()) {
+            yield* visit(name);
+        }
+        // The topological traversal already includes both manifest dependencies and
+        // TypeScript references. Framework apps may have no project references,
+        // while their workspace dependencies still export generated build artifacts.
+        const validationPackageNames = new Set(orderedPackageNames);
+        trustedPreparationRecipes.push({
+            id: "command-environment-pnpm-frozen-install",
+            kind: "custom",
+            cwd: ".",
+            executable: "corepack",
+            args: [
+                pnpm,
+                ...(input.executionMode === undefined
+                    ? []
+                    : targetPackageNames.flatMap((name) => ["--filter", `${name}...`])),
+                "install",
+                "--prefer-offline",
+                "--frozen-lockfile",
+                "--ignore-pnpmfile",
+                "--ignore-scripts"
+            ],
+            timeoutMs: 10 * 60_000
+        });
+        for (const name of orderedPackageNames) {
+            if (!validationPackageNames.has(name))
+                continue;
+            const manifest = packageManifests.get(name);
+            if (input.executionMode !== undefined) {
+                const target = targetRoots.has(manifest.root);
+                const targetNeedsBuild = input.executionMode === "emitted" ||
+                    gradeRecipes.some((recipe) => recipe.cwd === manifest.root && recipeReadsEmittedArtifacts(recipe));
+                // Source-capable targets do not need their own compiler. Dependencies
+                // still build when their package surface resolves to emitted artifacts.
+                if (target ? !targetNeedsBuild : !manifest.emitsArtifacts)
+                    continue;
+            }
+            const script = candidateValidationScript({
+                root: manifest.root,
+                scripts: manifest.scripts,
+                targetRoots,
+                gradeRecipes
+            });
+            if (script === undefined)
+                continue;
+            candidateValidationRecipes.push({
+                id: `command-environment-${recipeSafeId(script)}-${recipeSafeId(name)}`,
+                kind: "build",
+                cwd: manifest.root,
+                executable: "corepack",
+                args: [pnpm, "run", script],
+                timeoutMs: 10 * 60_000
+            });
+        }
+    }
+    const environment = {
+        ...(packageManager?.[1] === undefined || lockfilePath === undefined
+            ? {}
+            : {
+                packageManager: {
+                    name: "pnpm",
+                    version: packageManager[1]
+                },
+                lockfilePath
+            }),
+        protectedControlPaths: [
+            ...new Set([
+                "package.json",
+                "pnpm-lock.yaml",
+                "pnpm-workspace.yaml",
+                ".npmrc",
+                "turbo.json",
+                "tsconfig.base.json",
+                ...[
+                    ...input.gradeRecipes.map((recipe) => recipe.cwd),
+                    ...candidateValidationRecipes.map((recipe) => recipe.cwd)
+                ].flatMap((cwd) => [
+                    manifestPathFor(cwd),
+                    cwd === "." ? "tsconfig.json" : `${cwd}/tsconfig.json`
+                ]),
+                ...referencedProjectConfigPaths
+            ].filter((path) => snapshot.files.includes(path) && !input.changedPaths.includes(path)))
+        ].sort(),
+        trustedPreparationRecipes,
+        candidateValidationRecipes,
+        baselineGradeRecipes,
+        gradeRecipes
+    };
+    return environment;
+});
+const historicalSourceKind = (subject) => {
+    if (/^(?:feat)(?:\([^)]+\))?[!:]/iu.test(subject) || /^(?:add|implement)\b/iu.test(subject)) {
+        return "historical-feature";
+    }
+    if (/^(?:refactor)(?:\([^)]+\))?[!:]/iu.test(subject) ||
+        /^(?:refactor|migrate|restructure)\b/iu.test(subject)) {
+        return "historical-refactor";
+    }
+    return "historical-fix";
+};
+export class TaskSeed extends Context.Service()("@velum-labs/routekit-eval-setup/TaskSeed") {
+}
+export const extractHistoricalTaskSeedsV1 = Effect.fn("TaskSeed.extractHistorical")(function* (map, options) {
+    const seeds = [];
+    for (const episode of map.historyEpisodes.filter((entry) => entry.seedEligible)) {
+        if (episode.parentCommit === undefined)
+            continue;
+        const gradeRecipes = commandsFor(map, episode.testPaths, [
+            ...episode.implementationPaths,
+            ...episode.protocolPaths,
+            ...episode.testPaths
+        ]);
+        if (gradeRecipes.length === 0) {
+            continue;
+        }
+        const environment = options?.deferEnvironment === true
+            ? {
+                protectedControlPaths: [],
+                trustedPreparationRecipes: [],
+                candidateValidationRecipes: [],
+                baselineGradeRecipes: [],
+                gradeRecipes
+            }
+            : yield* deriveHistoricalSeedEnvironmentV1({
+                repositoryRoot: map.repository.root,
+                commit: episode.parentCommit,
+                gradeRecipes,
+                testPaths: episode.testPaths,
+                changedPaths: episode.changedPaths.flatMap(({ path, previousPath }) => previousPath === undefined ? [path] : [previousPath, path])
+            });
+        const testIds = map.tests
+            .filter((test) => episode.testPaths.includes(test.path))
+            .map((test) => test.id);
+        const changedProductionPaths = [...episode.implementationPaths, ...episode.protocolPaths];
+        const owningPackageIds = new Set(map.packages
+            .filter((entry) => changedProductionPaths.some((changedPath) => entry.path === "." ||
+            changedPath === entry.path ||
+            changedPath.startsWith(`${entry.path}/`)))
+            .map((entry) => entry.id));
+        const publicSurfaceEvidence = map.publicSurfaces
+            .filter((surface) => surface.packageId !== undefined &&
+            owningPackageIds.has(surface.packageId) &&
+            !episode.testPaths.includes(surface.path))
+            .map((surface) => ({
+            kind: "public-surface",
+            id: surface.id,
+            path: surface.path
+        }));
+        const targetEvidence = [
+            ...episode.implementationPaths.map((path) => ({
+                kind: "symbol",
+                id: `path-${path}`,
+                path
+            })),
+            ...episode.protocolPaths.map((path) => ({
+                kind: "protocol",
+                id: `path-${path}`,
+                path
+            })),
+            ...episode.testPaths.map((path) => ({
+                kind: "test",
+                id: map.tests.find((test) => test.path === path)?.id ?? `path-${path}`,
+                path
+            })),
+            ...publicSurfaceEvidence
+        ];
+        const seed = {
+            version: 1,
+            id: `seed-${episode.commit}`,
+            status: "candidate",
+            source: {
+                kind: historicalSourceKind(episode.subject),
+                changeEpisodeId: episode.id
+            },
+            summary: episode.subject,
+            capabilityEvidence: [{ kind: "history-episode", id: episode.id }, ...targetEvidence],
+            initialState: { commit: episode.parentCommit },
+            targetBehavior: [
+                {
+                    id: "historical-regression",
+                    description: episode.subject.trim().length > 0
+                        ? episode.subject
+                        : "Preserve the behavior established by the historical change.",
+                    critical: true,
+                    evidence: targetEvidence
+                }
+            ],
+            referenceCommit: episode.commit,
+            baselineObservations: [],
+            preChangeObservations: [],
+            postChangeObservations: [],
+            candidateTestIds: testIds,
+            environment,
+            confidence: testIds.length > 0 ? "medium" : "review-required",
+            risks: ["review-required", ...(testIds.length > 0 ? [] : ["weak-test-delta"])],
+            rejectionReasons: []
+        };
+        // Source drafts intentionally have no selected baseline environment yet.
+        // Only legacy/executable seeds satisfy the stronger environment assertions.
+        if (options?.deferEnvironment !== true)
+            assertRepositoryTaskSeedV1(seed);
+        seeds.push(seed);
+    }
+    if (seeds.length === 0 && map.historyEpisodes.length === 0) {
+        return yield* failure("repository contains no historical episodes");
+    }
+    return seeds;
+});
+export const qualifyHistoricalTaskSeedV1 = Effect.fn("TaskSeed.qualifyHistorical")(function* (input) {
+    if ((input.seed.source.kind !== "historical-fix" &&
+        input.seed.source.kind !== "historical-feature" &&
+        input.seed.source.kind !== "historical-refactor") ||
+        input.seed.referenceCommit === undefined) {
+        return yield* failure("historical qualification requires a historical change seed with a reference commit");
+    }
+    const { hiddenTestOverlays, hiddenContentOverlays } = yield* hiddenQualificationOverlays(input.seed, input.hiddenFixtureSuite);
+    const operationalFailures = [];
+    const replayErrors = [];
+    const replayPhase = Effect.fnUntraced(function* (phase, replayInput) {
+        // Already-started phases finish normally. Only queued phases are skipped,
+        // so their sibling's failure cannot discard replay rows or cleanup work.
+        if (operationalFailures.length > 0 || replayErrors.length > 0)
+            return undefined;
+        const startedAt = yield* Clock.currentTimeMillis;
+        const replay = yield* replayRepositoryCommandsV1(replayInput).pipe(Effect.match({
+            onFailure: (error) => ({ results: [], error }),
+            onSuccess: (results) => ({ results, error: undefined })
+        }));
+        if (replay.error !== undefined)
+            replayErrors.push(replay.error);
+        for (const result of replay.results) {
+            if (qualificationExecutionBlocked(result)) {
+                const diagnostic = sanitizeRepositoryCommandDiagnosticV1(result.stdout, result.stderr, result.outputTruncated);
+                const failure = {
+                    phase,
+                    recipeId: result.recipeId,
+                    repetition: result.repetition,
+                    stage: result.stage,
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    evidenceDetail: repositoryCommandTestEvidenceV1(result, result.recipeId).detail,
+                    ...(diagnostic === undefined
+                        ? {}
+                        : {
+                            commandDiagnostic: diagnostic.text,
+                            diagnosticTruncated: diagnostic.truncated
+                        })
+                };
+                operationalFailures.push(failure);
+            }
+        }
+        // The scoped replay has completed its finalizers before these unchanged
+        // rows are recorded, so isolation timings include checkout cleanup.
+        const wallMs = (yield* Clock.currentTimeMillis) - startedAt;
+        const batch = input.diagnosticBatch ?? 1;
+        const report = {
+            diagnosticOnly: true,
+            admissionEvidence: false,
+            seedId: input.seed.id,
+            referenceCommit: input.seed.referenceCommit,
+            batch,
+            phase,
+            wallMs,
+            ...replay
+        };
+        yield* reportFoundryAuthoringArtifactV1({
+            version: 1,
+            operationId: `seed-qualification:${input.seed.id}:${input.seed.referenceCommit}:batch-${batch}:${phase}`,
+            role: "seed-qualifier",
+            model: "local-replay",
+            reasoningEffort: "none",
+            schemaName: "routekit_repository_seed_qualification_phase_v1",
+            validation: "validated",
+            request: {
+                instructions: "Private qualification phase diagnostics; no model request or independent admission evidence.",
+                input: replayInput,
+                jsonSchema: { type: "object", properties: {}, additionalProperties: false },
+                maximumOutputTokens: 0
+            },
+            response: { text: JSON.stringify(report) },
+            value: report
+        });
+        yield* reportFoundryHeartbeatV1({
+            role: "seed-qualifier",
+            detail: `qualification phase complete; batch=${batch}; phase=${phase}; results=${replay.results.length}; wallMs=${wallMs}`
+        });
+        return replay.results;
+    });
+    // Repository validation commands can be full production builds. A standard
+    // sandbox has enough memory for one such build, but not two independent
+    // phase replays at once. Keep phases sequential within each already
+    // sequential batch; campaign-level sandbox concurrency remains unchanged.
+    const [baseline, pre, post] = yield* Effect.all([
+        replayPhase("baseline", {
+            repositoryRoot: input.repositoryRoot,
+            commit: input.seed.initialState.commit,
+            recipes: input.seed.environment.baselineGradeRecipes,
+            trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes,
+            candidateValidationRecipes: input.seed.environment.candidateValidationRecipes,
+            ...(input.preparationCache === undefined
+                ? {}
+                : { preparationCache: input.preparationCache }),
+            ...(input.repetitions === undefined ? {} : { repetitions: input.repetitions })
+        }),
+        replayPhase("pre-change", {
+            repositoryRoot: input.repositoryRoot,
+            commit: input.seed.initialState.commit,
+            recipes: input.seed.environment.gradeRecipes,
+            trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes,
+            candidateValidationRecipes: input.seed.environment.candidateValidationRecipes,
+            overlays: hiddenTestOverlays,
+            contentOverlays: hiddenContentOverlays,
+            ...(input.preparationCache === undefined
+                ? {}
+                : { preparationCache: input.preparationCache }),
+            ...(input.repetitions === undefined ? {} : { repetitions: input.repetitions })
+        }),
+        replayPhase("post-change", {
+            repositoryRoot: input.repositoryRoot,
+            commit: input.seed.referenceCommit,
+            recipes: input.seed.environment.gradeRecipes,
+            trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes,
+            candidateValidationRecipes: input.seed.environment.candidateValidationRecipes,
+            overlays: hiddenTestOverlays,
+            contentOverlays: hiddenContentOverlays,
+            ...(input.preparationCache === undefined
+                ? {}
+                : { preparationCache: input.preparationCache }),
+            ...(input.repetitions === undefined ? {} : { repetitions: input.repetitions })
+        })
+    ], { concurrency: 1 });
+    // Throw only after Effect.all joins every started phase and its diagnostic
+    // recorder. A partial run must never be presented as completed qualification.
+    if (operationalFailures.length > 0) {
+        const reasons = [
+            ...new Set(operationalFailures.map((entry) => `phase=${entry.phase}; stage=${entry.stage}; recipe=${entry.recipeId}; exit=${String(entry.exitCode)}; timeout=${String(entry.timedOut)}${entry.commandDiagnostic === undefined
+                ? ""
+                : `; diagnostic=${encodeRepositoryCommandDiagnosticV1(entry.commandDiagnostic)}; diagnosticTruncated=${String(entry.diagnosticTruncated ?? false)}`}; evidence=${entry.evidenceDetail}`))
+        ];
+        const detail = `historical qualification stopped after operational failure prevented grading: ${reasons.join(" | ")}; unstarted phases skipped=${[baseline, pre, post].filter((results) => results === undefined).length}; later batches were not started; qualification requires executable reviewed tests on both revisions and attributable pre-change assertion failures`;
+        yield* reportFoundryHeartbeatV1({ role: "seed-qualifier", detail });
+        return yield* new RepositoryFoundryError({
+            operation: "extract-task-seeds",
+            classification: "environment_blocked",
+            detail,
+            cause: { operationalFailures, ...(replayErrors.length === 0 ? {} : { replayErrors }) }
+        });
+    }
+    if (replayErrors.length > 0)
+        return yield* replayErrors[0];
+    if (baseline === undefined || pre === undefined || post === undefined) {
+        return yield* failure("historical qualification stopped before all required phases completed");
+    }
+    const resultSignature = (result) => [
+        result.recipeId,
+        result.stage,
+        String(result.exitCode),
+        String(result.timedOut),
+        String(result.gradeExecuted),
+        repositoryCommandTestEvidenceV1(result, result.recipeId).outcome
+    ].join(":");
+    const stableByRecipe = (results, recipeId) => new Set(results.filter((result) => result.recipeId === recipeId).map(resultSignature))
+        .size === 1;
+    const allBaselineGradeRecipeIds = input.seed.environment.baselineGradeRecipes.map((recipe) => recipe.id);
+    const allGradeRecipeIds = input.seed.environment.gradeRecipes.map((recipe) => recipe.id);
+    const baselineStable = allBaselineGradeRecipeIds.every((recipeId) => stableByRecipe(baseline, recipeId));
+    const postStable = allGradeRecipeIds.every((recipeId) => stableByRecipe(post, recipeId));
+    const prePrepared = pre.every((result) => result.stage !== "trusted-preparation" ||
+        (result.gradeExecuted && result.exitCode === 0 && !result.timedOut));
+    const postPrepared = post.every((result) => result.stage !== "trusted-preparation" ||
+        (result.gradeExecuted && result.exitCode === 0 && !result.timedOut));
+    const everyRecipeHasOutcome = (results, recipeIds, outcome) => recipeIds.every((recipeId) => {
+        const observations = results.filter((result) => result.recipeId === recipeId);
+        return (observations.length > 0 &&
+            observations.every((result) => repositoryCommandTestEvidenceV1(result, recipeId).outcome === outcome));
+    });
+    const baselinePasses = everyRecipeHasOutcome(baseline, allBaselineGradeRecipeIds, "pass");
+    const postPasses = everyRecipeHasOutcome(post, allGradeRecipeIds, "pass");
+    const preStable = allGradeRecipeIds.every((recipeId) => stableByRecipe(pre, recipeId));
+    const preFails = everyRecipeHasOutcome(pre, allGradeRecipeIds, "fail");
+    const preInconclusive = pre.some((result) => repositoryCommandTestEvidenceV1(result, result.recipeId).outcome === "unknown");
+    const rejectionReasons = [
+        ...(baselineStable ? [] : ["one or more initial baseline commands are unstable"]),
+        ...(baselinePasses
+            ? []
+            : ["initial baseline does not pass before reviewed hidden evidence is overlaid"]),
+        ...(prePrepared ? [] : ["pre-change trusted preparation failed"]),
+        ...(postPrepared ? [] : ["post-change trusted preparation failed"]),
+        ...(preStable ? [] : ["one or more pre-change commands are unstable"]),
+        ...(postStable ? [] : ["one or more post-change commands are unstable"]),
+        ...(preFails ? [] : ["every reviewed grade command must reproduce the pre-change failure"]),
+        ...(preInconclusive
+            ? [
+                "pre-change grading is inconclusive; setup, compilation, runtime, and discovery failures do not establish a behavioral regression"
+            ]
+            : []),
+        ...(postPasses ? [] : ["one or more post-change commands do not pass"])
+    ];
+    const observation = (phase, results) => results.flatMap((result) => {
+        const diagnostic = result.exitCode === 0 && !result.timedOut
+            ? undefined
+            : sanitizeRepositoryCommandDiagnosticV1(result.stdout, result.stderr, result.outputTruncated)?.text;
+        const expectedRecipeIds = phase === "baseline" ? allBaselineGradeRecipeIds : allGradeRecipeIds;
+        const projectedRecipeIds = result.gradeExecuted ? [result.recipeId] : expectedRecipeIds;
+        return projectedRecipeIds.map((recipeId) => {
+            const evidence = repositoryCommandTestEvidenceV1(result, recipeId);
+            return {
+                id: `${phase}-${recipeId}-${String(result.repetition)}`,
+                kind: "test-command",
+                subjectId: recipeId,
+                outcome: evidence.outcome,
+                detail: [
+                    `exit=${String(result.exitCode)}`,
+                    `stage=${result.stage}`,
+                    `gradeExecuted=${String(result.gradeExecuted)}`,
+                    `evidence=${evidence.detail}`,
+                    `timeout=${String(result.timedOut)}`,
+                    `durationMs=${String(result.durationMs)}`,
+                    ...(result.gradeExecuted ? [] : [`terminalRecipe=${result.recipeId}`]),
+                    ...result.trustedPreparationResults.map((preparation) => `trustedPreparation=${preparation.recipeId}:exit=${String(preparation.exitCode)}:timeout=${String(preparation.timedOut)}`),
+                    ...result.candidateValidationResults.map((validation) => `candidateValidation=${validation.recipeId}:exit=${String(validation.exitCode)}:timeout=${String(validation.timedOut)}`),
+                    ...(result.outputTruncated ? ["output=truncated"] : []),
+                    ...(diagnostic === undefined ? [] : [`diagnostic=${JSON.stringify(diagnostic)}`])
+                ].join("; ")
+            };
+        });
+    });
+    const qualified = {
+        ...input.seed,
+        status: rejectionReasons.length === 0 ? "qualified" : "rejected",
+        baselineObservations: observation("baseline", baseline),
+        preChangeObservations: observation("pre", pre),
+        postChangeObservations: observation("post", post),
+        confidence: rejectionReasons.length === 0 ? "high" : "review-required",
+        risks: rejectionReasons.length === 0
+            ? input.seed.risks.filter((risk) => risk !== "review-required")
+            : [...new Set([...input.seed.risks, "review-required"])],
+        rejectionReasons
+    };
+    assertRepositoryTaskSeedV1(qualified);
+    return qualified;
+});
+const observationSignature = (observation) => {
+    const detail = observation.detail;
+    const value = (name) => new RegExp(`(?:^|; )${name}=([^;]+)`, "u").exec(detail)?.[1] ?? "unknown";
+    return [
+        observation.subjectId,
+        observation.outcome,
+        `stage=${value("stage")}`,
+        `exit=${value("exit")}`,
+        `gradeExecuted=${value("gradeExecuted")}`,
+        `timeout=${value("timeout")}`
+    ].join(":");
+};
+const phaseObservations = (seed, phase) => phase === "baseline"
+    ? seed.baselineObservations
+    : phase === "pre-change"
+        ? seed.preChangeObservations
+        : seed.postChangeObservations;
+const qualificationPhases = [
+    "baseline",
+    "pre-change",
+    "post-change"
+];
+const assembleCrossBatchQualificationV1 = (input) => {
+    const { qualifiedBatches, batchesRequired, repetitionsPerBatch } = input;
+    const batches = qualifiedBatches.map((seed, index) => ({
+        batch: index + 1,
+        status: seed.status === "qualified" ? "qualified" : "rejected",
+        phaseSignatures: qualificationPhases.map((phase) => ({
+            phase,
+            signatures: [...new Set(phaseObservations(seed, phase).map(observationSignature))].sort()
+        })),
+        rejectionReasons: [...seed.rejectionReasons]
+    }));
+    const divergentPhases = qualificationPhases.filter((phase) => {
+        const signatures = batches.map((batch) => JSON.stringify(batch.phaseSignatures.find((entry) => entry.phase === phase)?.signatures ?? []));
+        return new Set(signatures).size > 1;
+    });
+    const failureSignatureCounts = new Map();
+    for (const seed of qualifiedBatches) {
+        for (const phase of qualificationPhases) {
+            for (const observation of phaseObservations(seed, phase)) {
+                if (observation.outcome !== "fail")
+                    continue;
+                const signature = `${phase}:${observationSignature(observation)}`;
+                failureSignatureCounts.set(signature, (failureSignatureCounts.get(signature) ?? 0) + 1);
+            }
+        }
+    }
+    const rejectionReasons = [
+        ...qualifiedBatches.flatMap((seed, index) => seed.rejectionReasons.map((reason) => `batch ${String(index + 1)}: ${reason}`)),
+        ...divergentPhases.map((phase) => `cross-batch qualification diverged for ${phase}`)
+    ];
+    const stable = rejectionReasons.length === 0;
+    const observations = (select) => qualifiedBatches.flatMap((seed, index) => select(seed).map((observation) => ({
+        ...observation,
+        id: `batch-${String(index + 1)}-${observation.id}`
+    })));
+    const seed = {
+        ...qualifiedBatches.at(-1),
+        status: stable ? "qualified" : "rejected",
+        baselineObservations: observations((qualified) => qualified.baselineObservations),
+        preChangeObservations: observations((qualified) => qualified.preChangeObservations),
+        postChangeObservations: observations((qualified) => qualified.postChangeObservations),
+        confidence: stable ? "high" : "review-required",
+        risks: stable
+            ? input.sourceSeed.risks.filter((risk) => risk !== "review-required")
+            : [
+                ...new Set([
+                    ...input.sourceSeed.risks,
+                    "cross-batch-instability",
+                    "review-required"
+                ])
+            ],
+        rejectionReasons
+    };
+    const qualification = {
+        seed,
+        stability: {
+            version: 1,
+            seedId: seed.id,
+            batchesRequired,
+            repetitionsPerBatch,
+            stable,
+            batches,
+            divergentPhases,
+            failureSignatures: [...failureSignatureCounts]
+                .sort((left, right) => left[0].localeCompare(right[0]))
+                .map(([signature, count]) => ({ signature, count })),
+            rejectionReasons
+        }
+    };
+    assertRepositoryTaskSeedV1(seed);
+    assertRepositorySeedCrossBatchQualificationV1(qualification);
+    return qualification;
+};
+export const qualifyHistoricalTaskSeedAcrossBatchesV1 = Effect.fn("TaskSeed.qualifyHistoricalAcrossBatches")(function* (input) {
+    const batchesRequired = Math.max(2, Math.min(input.batches ?? 2, 5));
+    const repetitionsPerBatch = Math.max(2, Math.min(input.repetitionsPerBatch ?? 2, 5));
+    const qualifiedBatches = yield* Effect.scoped(Effect.gen(function* () {
+        const preparationCache = yield* makeRepositoryPreparationCacheV1({
+            repositoryRoot: input.repositoryRoot,
+            commits: [
+                input.seed.initialState.commit,
+                ...(input.seed.referenceCommit === undefined ? [] : [input.seed.referenceCommit])
+            ],
+            trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes
+        });
+        const qualified = [];
+        for (let batch = 1; batch <= batchesRequired; batch += 1) {
+            qualified.push(yield* qualifyHistoricalTaskSeedV1({
+                repositoryRoot: input.repositoryRoot,
+                seed: input.seed,
+                ...(input.hiddenFixtureSuite === undefined
+                    ? {}
+                    : { hiddenFixtureSuite: input.hiddenFixtureSuite }),
+                repetitions: repetitionsPerBatch,
+                diagnosticBatch: batch,
+                preparationCache
+            }));
+        }
+        return qualified;
+    }));
+    return assembleCrossBatchQualificationV1({
+        sourceSeed: input.seed,
+        qualifiedBatches,
+        batchesRequired,
+        repetitionsPerBatch
+    });
+});
+const qualificationUnitKey = (unit) => `${String(unit.batch)}:${unit.phase}:${String(unit.repetition)}`;
+export const repositorySeedQualificationProgressSummaryV1 = (progress) => ({
+    completedBatches: progress.completedBatches.length,
+    batchesRequired: progress.batchesRequired,
+    completedUnits: progress.activeUnits.length,
+    unitsPerBatch: qualificationPhases.length * progress.repetitionsPerBatch
+});
+/**
+ * Resume reference qualification only at completed replay boundaries. Every
+ * started replay still owns and closes its checkout scope; interruption may
+ * repeat the in-flight replay, but never a previously checkpointed repetition.
+ */
+export const qualifyHistoricalTaskSeedAcrossBatchesResumableV1 = Effect.fn("TaskSeed.qualifyHistoricalAcrossBatchesResumable")(function* (input) {
+    const batchesRequired = Math.max(2, Math.min(input.batches ?? 2, 5));
+    const repetitionsPerBatch = Math.max(2, Math.min(input.repetitionsPerBatch ?? 2, 5));
+    if ((input.seed.source.kind !== "historical-fix" &&
+        input.seed.source.kind !== "historical-feature" &&
+        input.seed.source.kind !== "historical-refactor") ||
+        input.seed.referenceCommit === undefined) {
+        return yield* failure("historical qualification requires a historical change seed with a reference commit");
+    }
+    const emptyProgress = () => ({
+        version: 1,
+        bindingDigest: input.bindingDigest,
+        batchesRequired,
+        repetitionsPerBatch,
+        completedBatches: [],
+        activeUnits: []
+    });
+    let progress = input.progress?.bindingDigest === input.bindingDigest &&
+        input.progress.batchesRequired === batchesRequired &&
+        input.progress.repetitionsPerBatch === repetitionsPerBatch
+        ? input.progress
+        : emptyProgress();
+    const expectedCompletedBatches = progress.completedBatches.map((_, index) => index + 1);
+    const activeBatch = progress.completedBatches.length + 1;
+    const activeKeys = progress.activeUnits.map(qualificationUnitKey);
+    if (progress.completedBatches.length > batchesRequired ||
+        progress.completedBatches.some((entry, index) => entry.batch !== expectedCompletedBatches[index] ||
+            (entry.seed.status !== "qualified" && entry.seed.status !== "rejected")) ||
+        progress.activeUnits.some((unit) => unit.batch !== activeBatch ||
+            unit.repetition < 1 ||
+            unit.repetition > repetitionsPerBatch ||
+            unit.results.some((result) => result.repetition !== unit.repetition)) ||
+        new Set(activeKeys).size !== activeKeys.length) {
+        return yield* failure("retained historical qualification progress violates its batch, phase, or repetition binding");
+    }
+    // Completed batches are persisted verdicts, not permission to bypass the
+    // current evidence contract. Reject legacy compile-only qualifications before
+    // any preparation or queued replay can run.
+    for (const entry of progress.completedBatches) {
+        yield* Effect.try({
+            try: () => assertRepositoryTaskSeedV1(entry.seed),
+            catch: (cause) => new RepositoryFoundryError({
+                operation: "extract-task-seeds",
+                classification: "environment_blocked",
+                detail: "retained qualification does not satisfy the executed behavioral evidence contract; select another candidate or repair the grading environment",
+                cause
+            })
+        });
+    }
+    // An incomplete or unattributable grade is retained diagnostic evidence, not useful
+    // forward execution. Reopening the same binding must report it without
+    // replaying it or spending on queued phases.
+    for (const unit of progress.activeUnits) {
+        const blocked = unit.results.find((result) => qualificationExecutionBlocked(result));
+        if (blocked !== undefined)
+            return yield* qualificationExecutionFailure(unit.phase, blocked);
+    }
+    const { hiddenTestOverlays, hiddenContentOverlays } = yield* hiddenQualificationOverlays(input.seed, input.hiddenFixtureSuite);
+    const qualification = yield* Effect.scoped(Effect.gen(function* () {
+        const preparationCache = yield* makeRepositoryPreparationCacheV1({
+            repositoryRoot: input.repositoryRoot,
+            commits: [input.seed.initialState.commit, input.seed.referenceCommit],
+            trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes
+        });
+        for (let batch = progress.completedBatches.length + 1; batch <= batchesRequired; batch += 1) {
+            for (const phase of qualificationPhases) {
+                for (let repetition = 1; repetition <= repetitionsPerBatch; repetition += 1) {
+                    const key = qualificationUnitKey({ batch, phase, repetition });
+                    if (progress.activeUnits.some((unit) => qualificationUnitKey(unit) === key))
+                        continue;
+                    const common = {
+                        repositoryRoot: input.repositoryRoot,
+                        trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes,
+                        candidateValidationRecipes: input.seed.environment.candidateValidationRecipes,
+                        preparationCache,
+                        repetitions: 1,
+                        repetitionStart: repetition
+                    };
+                    const replayInput = phase === "baseline"
+                        ? {
+                            ...common,
+                            commit: input.seed.initialState.commit,
+                            recipes: input.seed.environment.baselineGradeRecipes
+                        }
+                        : {
+                            ...common,
+                            commit: phase === "pre-change"
+                                ? input.seed.initialState.commit
+                                : input.seed.referenceCommit,
+                            recipes: input.seed.environment.gradeRecipes,
+                            overlays: hiddenTestOverlays,
+                            contentOverlays: hiddenContentOverlays
+                        };
+                    const results = yield* replayRepositoryCommandsV1(replayInput);
+                    progress = {
+                        ...progress,
+                        activeUnits: [...progress.activeUnits, { batch, phase, repetition, results }]
+                    };
+                    yield* input.checkpoint(progress);
+                    const operational = results.find((result) => qualificationExecutionBlocked(result));
+                    if (operational !== undefined)
+                        return yield* qualificationExecutionFailure(phase, operational);
+                    yield* reportFoundryHeartbeatV1({
+                        role: "seed-qualifier",
+                        detail: `qualification replay checkpointed; batch=${String(batch)}/${String(batchesRequired)}; phase=${phase}; repetition=${String(repetition)}/${String(repetitionsPerBatch)}`
+                    });
+                }
+            }
+            const phaseResults = qualificationPhases.map((phase) => progress.activeUnits
+                .filter((unit) => unit.batch === batch && unit.phase === phase)
+                .sort((left, right) => left.repetition - right.repetition)
+                .flatMap((unit) => unit.results));
+            let cursor = 0;
+            const reconstruction = {
+                commands: () => {
+                    const results = phaseResults[cursor++];
+                    return results === undefined
+                        ? Effect.fail(failure("retained qualification phase evidence was exhausted early"))
+                        : Effect.succeed(results);
+                },
+                oracle: () => Effect.fail(failure("seed qualification reconstruction cannot supply oracle evidence")),
+                assertConsumed: Effect.suspend(() => cursor === phaseResults.length
+                    ? Effect.void
+                    : Effect.fail(failure("retained qualification phase evidence was not fully consumed")))
+            };
+            const seed = yield* qualifyHistoricalTaskSeedV1({
+                repositoryRoot: input.repositoryRoot,
+                seed: input.seed,
+                ...(input.hiddenFixtureSuite === undefined
+                    ? {}
+                    : { hiddenFixtureSuite: input.hiddenFixtureSuite }),
+                repetitions: repetitionsPerBatch,
+                diagnosticBatch: batch
+            }).pipe(Effect.provideService(RepositoryFoundryEvidenceReconstruction, reconstruction));
+            yield* reconstruction.assertConsumed;
+            progress = {
+                ...progress,
+                completedBatches: [...progress.completedBatches, { batch, seed }],
+                activeUnits: []
+            };
+            yield* input.checkpoint(progress);
+        }
+        return assembleCrossBatchQualificationV1({
+            sourceSeed: input.seed,
+            qualifiedBatches: progress.completedBatches.map((entry) => entry.seed),
+            batchesRequired,
+            repetitionsPerBatch
+        });
+    }));
+    return { qualification, progress };
+});
+export const makeTaskSeed = Effect.succeed(TaskSeed.of({
+    extractHistorical: extractHistoricalTaskSeedsV1,
+    qualifyHistorical: qualifyHistoricalTaskSeedV1,
+    qualifyHistoricalAcrossBatches: qualifyHistoricalTaskSeedAcrossBatchesV1
+}));
+export const TaskSeedLive = Layer.effect(TaskSeed, makeTaskSeed);