assertledger 1.4.0 → 1.5.0

package/dist/engine/index.js

@@ -1,21 +1,23 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { cp, link, lstat, mkdir, mkdtemp, open, readdir, readFile, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { cp, link, lstat, mkdir, mkdtemp, open, readdir, readFile, readlink, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createScanner, SyntaxKind } from "typescript/unstable/ast";
-import { AdapterSchema, isRepositoryExcludeName, parseAgenticBenchmarkAcquisitionRequest, parseAgenticBenchmarkAcquisitionResult, parseEvidenceManifest, parseRepositoryAudit, parseRepositoryInitConfig, parseRepositoryInitConfigV2, parseRepositoryInitLock, parseRepositoryInitLockV2, parseRepositoryInitResult, parseRepositoryInitResultV2, parseVerificationRequest, parseVersionedRepositoryInitConfig, parseVersionedRepositoryInitLock, parseVersionedVerificationRequest, RepositoryInitDetectionsSchema, repositoryInitConfigDigest, repositoryInitConfigV2Digest, repositoryInitLockDigest, repositoryInitLockV2Digest, } from "../contracts/index.js";
+import { AdapterSchema, isRepositoryExcludeName, parseAgenticBenchmarkAcquisitionRequest, parseAgenticBenchmarkAcquisitionResult, parseEvidenceManifest, parseRepositoryAudit, parseRepositoryInitConfig, parseRepositoryInitConfigV2, parseRepositoryInitLock, parseRepositoryInitLockV2, parseRepositoryInitResult, parseRepositoryInitResultV2, parseVerificationRequest, parseVersionedRepositoryInitConfig, parseVersionedRepositoryInitLock, parseVersionedVerificationRequest, RepositoryInitDetectionsSchema, repositoryInitConfigDigest, repositoryInitConfigV2Digest, repositoryInitLockDigest, repositoryInitLockV2Digest, VERIFICATION_SCHEMA_VERSION_V4, } from "../contracts/index.js";
 import { assertSafeRelativePath, canonicalize, createAgenticBenchmark, decideEvidence, portablePathKey, replayAgenticBenchmark, replayEvidenceManifest, sealManifestArtifact, sha256Canonical, } from "../core/index.js";
+import { BUN_TEST_DESIGNATED_ADAPTER_PROFILE } from "./adapters/bun-test-designated-profile.js";
 import { BUN_TEST_ADAPTER_PROFILE } from "./adapters/bun-test-profile.js";
 import { NODE_TEST_ADAPTER_PROFILE } from "./adapters/node-test-profile.js";
 import { runNodeTestRuntimePreflight, } from "./adapters/node-test-runtime.js";
 import { normalizeRuntimeFacts, RUNTIME_FACTS_VERSION } from "./adapters/runtime-facts.js";
-import { CONTAINER_LIMITATIONS, CONTAINER_REPORTER_FILE, CONTAINER_RESULT_FILE, CONTAINER_WORKSPACE, DEFAULT_CONTAINER_RUNTIME_COMMAND, prepareContainerBackend, runContainerExecution, } from "./container.js";
+import { CONTAINER_ASSET_DIRECTORY, CONTAINER_LIMITATIONS, CONTAINER_REPORTER_FILE, CONTAINER_RESULT_FILE, CONTAINER_WORKSPACE, DEFAULT_CONTAINER_RUNTIME_COMMAND, prepareContainerBackend, runContainerExecution, } from "./container.js";
 import { NODE_TEST_REPORTER_SOURCE } from "./node-test-reporter.js";
+import { computeTestClosure, } from "./test-closure.js";
 import { runBunRuntimeDoctorChecks, runRuntimeDoctorChecks, } from "./runtime-doctor.js";
 const DEFAULT_EXCLUDES = new Set([".git", ".testforge", "node_modules"]);
 const SHA256_PREFIX = "sha256:";
@@ -331,7 +333,9 @@ function repositoryLinkError(relative) {
         cause: relative.split(path.sep).join("/"),
     });
 }
-async function walkFiles(root, excludes) {
+/** Walks the regular files of a repository. A link refuses the walk unless `links` collects it;
+ * a collected link is never followed. */
+async function walkFiles(root, excludes, links) {
     const files = [];
     const spellings = new Map();
     let totalBytes = 0;
@@ -344,8 +348,13 @@ async function walkFiles(root, excludes) {
                 continue;
             const relative = path.posix.join(relativeDirectory.split(path.sep).join("/"), entry.name);
             const entryStats = await lstat(path.join(root, ...relative.split("/")));
-            if (entryStats.isSymbolicLink())
-                throw repositoryLinkError(relative);
+            if (entryStats.isSymbolicLink()) {
+                if (links === undefined)
+                    throw repositoryLinkError(relative);
+                registerPortablePath(spellings, relative);
+                links.push(relative);
+                continue;
+            }
             registerPortablePath(spellings, relative);
             if (entryStats.isDirectory())
                 await visit(relative);
@@ -357,8 +366,176 @@ async function walkFiles(root, excludes) {
     }
     await visit("");
     files.sort(comparePortablePaths);
+    links?.sort(comparePortablePaths);
     return { files, spellings, totalBytes };
 }
+/** Whether a link resolves, or would resolve when dangling, outside the repository root. */
+async function linkEscapesRoot(root, relative) {
+    const linkPath = path.join(root, ...relative.split("/"));
+    let target;
+    try {
+        target = await realpath(linkPath);
+    }
+    catch {
+        try {
+            target = path.resolve(path.dirname(linkPath), await readlink(linkPath));
+        }
+        catch {
+            return true;
+        }
+    }
+    const fromRoot = path.relative(root, target);
+    return fromRoot === ".." || fromRoot.startsWith(`..${path.sep}`) || path.isAbsolute(fromRoot);
+}
+const LINK_DISCOVERY_ENTRY_LIMIT = 100_000;
+/**
+ * Whether a runner discovering tests from the root could reach one through this link: the link
+ * is itself named as a test, or it resolves to a directory holding one. A nested link, or a tree
+ * past the entry limit, is assumed to reach one.
+ */
+async function linkReachesDiscoverableTest(root, link, discoverable) {
+    if (discoverable(link))
+        return true;
+    let target;
+    try {
+        target = await realpath(path.join(root, ...link.split("/")));
+        if (!(await stat(target)).isDirectory())
+            return false;
+    }
+    catch {
+        return false;
+    }
+    let seen = 0;
+    const pending = [""];
+    for (let relative = pending.pop(); relative !== undefined; relative = pending.pop()) {
+        for (const entry of await readdir(path.join(target, relative), { withFileTypes: true })) {
+            seen += 1;
+            if (seen > LINK_DISCOVERY_ENTRY_LIMIT || entry.isSymbolicLink())
+                return true;
+            const child = relative === "" ? entry.name : `${relative}/${entry.name}`;
+            if (entry.isDirectory())
+                pending.push(child);
+            else if (discoverable(`${link}/${child}`))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Refuses a link that leaves the root or lies in the closure of `roots`; every other link stays
+ * outside the evidence. With `discoverable`, the tests a runner finds by itself, a link through
+ * which one can be reached is in the closure too. `strictUnbounded` also refuses any link when the
+ * closure is unbounded, as a campaign must; a static diagnostic reports that case without refusing.
+ * Without `roots` the closure is unknown and every link refuses.
+ */
+async function assessRepositoryLinks(root, files, links, roots, read, strictUnbounded, discoverable) {
+    const assessment = {
+        links: [...links],
+        refused: undefined,
+        omitted: [],
+        unbounded: [],
+    };
+    if (links.length === 0)
+        return assessment;
+    for (const link of links) {
+        if (await linkEscapesRoot(root, link)) {
+            assessment.refused = { path: link, reasonCode: "REPOSITORY_LINK_ESCAPES_ROOT" };
+            return assessment;
+        }
+    }
+    if (roots === undefined) {
+        assessment.refused = { path: links[0], reasonCode: "TEST_CLOSURE_UNSUPPORTED" };
+        return assessment;
+    }
+    if (discoverable !== undefined) {
+        for (const link of links) {
+            if (await linkReachesDiscoverableTest(root, link, discoverable)) {
+                assessment.refused = { path: link, reasonCode: "REPOSITORY_LINK_IN_TEST_CLOSURE" };
+                return assessment;
+            }
+        }
+    }
+    const closure = await computeTestClosure({ files, links, roots, read });
+    assessment.unbounded = closure.unbounded;
+    const linked = closure.links[0];
+    if (linked !== undefined) {
+        assessment.refused = { path: linked, reasonCode: "REPOSITORY_LINK_IN_TEST_CLOSURE" };
+        return assessment;
+    }
+    if (strictUnbounded && closure.unbounded.length > 0) {
+        assessment.refused = { path: links[0], reasonCode: "TEST_CLOSURE_UNBOUNDED" };
+        return assessment;
+    }
+    assessment.omitted = [...links];
+    return assessment;
+}
+/** The digest analyzeRepository computes, over an inventory already walked. */
+async function repositoryInventoryDigest(root, files) {
+    const digest = createHash("sha256");
+    for (const file of files) {
+        const content = await readFile(path.join(root, ...file.split("/")));
+        digest.update(Buffer.from(`${file}\0${content.byteLength}\0`, "utf8"));
+        digest.update(content);
+    }
+    return `${SHA256_PREFIX}${digest.digest("hex")}`;
+}
+/**
+ * Judges a v4 campaign's links against the module closure of every test the adapter executes,
+ * read with each world's and candidate's overlay. A link that leaves the root or lies in that
+ * closure refuses the campaign and is named; so does any link when the closure is unbounded or
+ * unknown, as for a structured command. The others are left out of the snapshot and recorded.
+ */
+async function campaignOmittedLinks(request, root, files, links) {
+    const overlays = new Map();
+    for (const overlay of [
+        ...request.worlds.flatMap((world) => world.files),
+        ...request.candidates.flatMap((candidate) => candidate.files),
+    ]) {
+        const key = portablePathKey(overlay.path);
+        const entry = overlays.get(key) ?? { path: overlay.path, contents: [] };
+        entry.contents.push(overlay.content);
+        overlays.set(key, entry);
+    }
+    const repositoryFiles = new Set(files.map(portablePathKey));
+    const roots = request.adapter.kind === "node-test" || request.adapter.kind === "bun-test"
+        ? [
+            ...request.adapter.baseTestFiles,
+            ...request.candidates.flatMap((candidate) => candidate.files.map((file) => file.path)),
+        ]
+        : request.adapter.kind === "bun-test-designated"
+            ? request.candidates.flatMap((candidate) => candidate.designated === undefined ? [] : [candidate.designated.file])
+            : undefined;
+    const assessment = await assessRepositoryLinks(root, [
+        ...files,
+        ...[...overlays.entries()]
+            .filter(([key]) => !repositoryFiles.has(key))
+            .map(([, entry]) => entry.path),
+    ], links, roots, async (file) => {
+        const key = portablePathKey(file);
+        const texts = overlays.get(key)?.contents ?? [];
+        return repositoryFiles.has(key)
+            ? [await readFile(path.join(root, ...file.split("/")), "utf8"), ...texts]
+            : texts;
+    }, true);
+    const refused = assessment.refused;
+    if (refused !== undefined) {
+        throw new Error(refused.reasonCode === "TEST_CLOSURE_UNSUPPORTED"
+            ? "UNSUPPORTED_REPOSITORY_SYMLINK"
+            : refused.reasonCode, { cause: refused.path });
+    }
+    return assessment.omitted;
+}
+/** The closure roots of a test framework's discovered sources; undefined when not analyzable. */
+function frameworkClosureRoots(framework, files) {
+    if (framework === "bun:test") {
+        return files.filter((file) => /(?:^|\/)[^/]+[._](?:test|spec)\.[cm]?[jt]sx?$/u.test(file));
+    }
+    if (framework === "node:test" || framework === "vitest" || framework === "jest") {
+        return files.filter((file) => (initEvidenceKind(file) === "TEST_SOURCE" && /\.[cm]?[jt]sx?$/u.test(file)) ||
+            /(?:^|\/)(?:vitest|jest)\.config\.[cm]?[jt]s$/u.test(file));
+    }
+    return undefined;
+}
 function rawSha256(content) {
     return `${SHA256_PREFIX}${createHash("sha256").update(content).digest("hex")}`;
 }
@@ -727,16 +904,28 @@ export async function initializeRepository(requestedRoot, options = {}, writeDep
         const fileKey = portablePathKey(file);
         return fileKey === rootKey || fileKey.startsWith(`${rootKey}/`);
     });
-    let inventory;
-    try {
-        inventory = await walkFiles(root, inventoryExcludes);
-    }
-    catch (error) {
-        if (!(error instanceof Error) || error.message !== "UNSUPPORTED_REPOSITORY_SYMLINK")
-            throw error;
-        return initTerminalResult("CONFLICT", initEmptyDetections(["UNSUPPORTED_REPOSITORY_SYMLINK"]), [
+    const links = [];
+    const inventory = await walkFiles(root, inventoryExcludes, links);
+    // A link is judged against the tests that would run, once the framework is known; one that
+    // leaves the root refuses the repository whatever the framework.
+    const linkConflict = (assessment, detections) => {
+        options.onLinkAssessment?.(assessment);
+        const code = assessment.refused?.reasonCode;
+        const codes = [
             "UNSUPPORTED_REPOSITORY_SYMLINK",
-        ]);
+            ...(code === undefined || code === "TEST_CLOSURE_UNSUPPORTED" ? [] : [code]),
+        ];
+        return initTerminalResult("CONFLICT", { ...detections, reasonCodes: codes }, codes);
+    };
+    for (const link of links) {
+        if (await linkEscapesRoot(root, link)) {
+            return linkConflict({
+                links: [...links],
+                refused: { path: link, reasonCode: "REPOSITORY_LINK_ESCAPES_ROOT" },
+                omitted: [],
+                unbounded: [],
+            }, initEmptyDetections([]));
+        }
     }
     const inScopeFiles = inventory.files.filter(outsideCandidateRoots);
     const contents = new Map();
@@ -870,6 +1059,20 @@ export async function initializeRepository(requestedRoot, options = {}, writeDep
         detections.packageManager = packageManager;
         return initTerminalResult("CONFLICT", detections, ["FRAMEWORK_UNDETECTED"]);
     }
+    const linkReasonCodes = [];
+    if (links.length > 0) {
+        const assessment = await assessRepositoryLinks(root, inScopeFiles, links, frameworkClosureRoots(framework, inScopeFiles), async (file) => [await readFile(path.join(root, ...file.split("/")), "utf8")], false, (file) => frameworkClosureRoots(framework, [file])?.length === 1);
+        if (assessment.refused !== undefined) {
+            const detections = initEmptyDetections([]);
+            detections.packageManager = packageManager;
+            detections.framework = framework;
+            return linkConflict(assessment, detections);
+        }
+        options.onLinkAssessment?.(assessment);
+        linkReasonCodes.push("REPOSITORY_LINK_OUTSIDE_TEST_CLOSURE");
+        if (assessment.unbounded.length > 0)
+            linkReasonCodes.push("TEST_CLOSURE_UNBOUNDED");
+    }
     let testCommand = options.testCommand === undefined ? undefined : safeInitCommand(options.testCommand);
     if (options.testCommand !== undefined && testCommand === undefined) {
         const detections = initEmptyDetections(["TEST_COMMAND_INVALID"]);
@@ -974,13 +1177,16 @@ export async function initializeRepository(requestedRoot, options = {}, writeDep
             adapterRecommendation = "bun-test";
         }
     }
-    const reasonCodes = adapter === undefined
-        ? [
-            framework === "node:test" || framework === "bun:test"
-                ? "BASE_TEST_FILES_UNAVAILABLE"
-                : "OFFICIAL_ADAPTER_UNAVAILABLE",
-        ]
-        : [];
+    const reasonCodes = [
+        ...(adapter === undefined
+            ? [
+                framework === "node:test" || framework === "bun:test"
+                    ? "BASE_TEST_FILES_UNAVAILABLE"
+                    : "OFFICIAL_ADAPTER_UNAVAILABLE",
+            ]
+            : []),
+        ...linkReasonCodes,
+    ].sort();
     const detections = {
         packageManager,
         framework,
@@ -1059,14 +1265,16 @@ export async function initializeRepository(requestedRoot, options = {}, writeDep
         { path: INIT_LOCK_FILE, digest: rawSha256(lockContent), content: lockContent },
     ];
     let finalInScopeFiles;
+    const finalLinks = [];
     try {
-        const finalInventory = await walkFiles(root, inventoryExcludes);
+        const finalInventory = await walkFiles(root, inventoryExcludes, finalLinks);
         finalInScopeFiles = finalInventory.files.filter(outsideCandidateRoots);
     }
     catch {
         finalInScopeFiles = [];
     }
-    let repositoryChanged = JSON.stringify(finalInScopeFiles) !== JSON.stringify(inScopeFiles);
+    let repositoryChanged = JSON.stringify(finalInScopeFiles) !== JSON.stringify(inScopeFiles) ||
+        JSON.stringify(finalLinks) !== JSON.stringify(links);
     if (!repositoryChanged) {
         for (const [file, snapshot] of evidenceBytes) {
             try {
@@ -1130,7 +1338,7 @@ export async function initializeRepository(requestedRoot, options = {}, writeDep
         const result = {
             schemaVersion: bunBuiltIn ? "2.0.0" : "1.0.0",
             status: "UNCHANGED",
-            reasonCodes: [],
+            reasonCodes: detections.reasonCodes,
             detections,
             actions: [],
             files: plannedFiles,
@@ -1151,7 +1359,8 @@ export async function initializeRepository(requestedRoot, options = {}, writeDep
     const resultValue = {
         schemaVersion: bunBuiltIn ? "2.0.0" : "1.0.0",
         status,
-        reasonCodes: [],
+        // Only non-blocking link findings can remain here; the contract mirrors the detections.
+        reasonCodes: detections.reasonCodes,
         detections,
         actions,
         files: plannedFiles,
@@ -1245,7 +1454,7 @@ export async function doctorRepositoryRuntime(requestedRoot, options) {
             },
             probeTemporaryWorkspace: probeRuntimeTemporaryWorkspace,
             runSyntheticPreflight: async () => {
-                await runBunTestRuntimePreflight(resolvedExecutable, environmentAllowlist, 5_000, CONTROLLED_REPORT_MAXIMUM_BYTES);
+                await runBunTestRuntimePreflight(localBunDriverExecutor(resolvedExecutable, environmentAllowlist, 5_000, CONTROLLED_REPORT_MAXIMUM_BYTES));
             },
         });
     }
@@ -2005,6 +2214,7 @@ function parseRequest(value) {
     assertPortableStringCollection(candidateRoots, "DUPLICATE_CANDIDATE_ROOT");
     if (adapter.kind !== "node-test" &&
         adapter.kind !== "bun-test" &&
+        adapter.kind !== "bun-test-designated" &&
         adapter.kind !== "testforge-command") {
         throw new TypeError("UNSUPPORTED_ADAPTER");
     }
@@ -2021,10 +2231,17 @@ function parseRequest(value) {
         })()
         : undefined;
     if (containerIsolation === undefined) {
-        if (isolation.kind !== "trusted-local")
+        if (isolation.kind !== "trusted-local" && isolation.kind !== "windows-native") {
             throw new TypeError("UNSUPPORTED_ISOLATION");
+        }
         if (isolation.acknowledgedUnsafeExecution !== true) {
-            throw new Error("UNSAFE_LOCAL_EXECUTION_NOT_ACKNOWLEDGED");
+            throw new Error(isolation.kind === "windows-native"
+                ? "WINDOWS_NATIVE_EXECUTION_NOT_ACKNOWLEDGED"
+                : "UNSAFE_LOCAL_EXECUTION_NOT_ACKNOWLEDGED");
+        }
+        // The declared level names a Windows host; it is never claimed for any other platform.
+        if (isolation.kind === "windows-native" && process.platform !== "win32") {
+            throw new Error("WINDOWS_NATIVE_HOST_REQUIRED");
         }
     }
     const parsedBudgets = {
@@ -2073,6 +2290,27 @@ function parseRequest(value) {
     });
     const candidates = request.candidates.map((value) => {
         const candidate = requireRecord(value, "candidate");
+        if (candidate.test !== undefined) {
+            const test = requireRecord(candidate.test, "designated_test");
+            let file;
+            try {
+                file = assertSafeRelativePath(requireString(test.file, "designated_test_file"), candidateRoots);
+            }
+            catch {
+                throw new Error("FORBIDDEN_CANDIDATE_PATH");
+            }
+            return {
+                id: requireString(candidate.id, "candidate_id"),
+                files: [],
+                designated: {
+                    file,
+                    path: requireStringArray(test.path, "designated_test_path"),
+                    expectedFailure: candidate.expectedFailure === null
+                        ? null
+                        : requireString(candidate.expectedFailure, "expected_failure"),
+                },
+            };
+        }
         if (!Array.isArray(candidate.files) || candidate.files.length === 0) {
             throw new TypeError("INVALID_CANDIDATE_FILES");
         }
@@ -2138,21 +2376,41 @@ function parseRequest(value) {
                 ...(extraArguments === undefined ? {} : { extraArguments }),
             };
         })()
-        : {
-            kind: "testforge-command",
-            executable: requireString(adapter.executable, "adapter_executable"),
-            arguments: requireStringArray(adapter.arguments, "adapter_arguments"),
-            protocolVersion: "1.0.0",
-        };
+        : adapter.kind === "bun-test-designated"
+            ? {
+                kind: "bun-test-designated",
+                executable: requireString(adapter.executable, "adapter_executable"),
+                testTimeoutMs: adapter.testTimeoutMs === null || adapter.testTimeoutMs === undefined
+                    ? null
+                    : requirePositiveInteger(adapter.testTimeoutMs, "adapter_test_timeout_ms"),
+            }
+            : {
+                kind: "testforge-command",
+                executable: requireString(adapter.executable, "adapter_executable"),
+                arguments: requireStringArray(adapter.arguments, "adapter_arguments"),
+                protocolVersion: "1.0.0",
+            };
+    // A designated test runs with the same bytes in every world: no world may overlay it.
+    const designatedFiles = new Set(candidates.flatMap((candidate) => candidate.designated === undefined ? [] : [portablePathKey(candidate.designated.file)]));
+    if (worlds.some((world) => world.files.some((file) => designatedFiles.has(portablePathKey(file.path))))) {
+        throw new Error("DESIGNATED_TEST_OVERLAID");
+    }
+    const includeDependencies = repository.includeDependencies === true;
+    const exclude = requireStringArray(repository.exclude, "repository_exclude");
+    if (includeDependencies && exclude.some((entry) => portablePathKey(entry) === "node_modules")) {
+        throw new Error("REPOSITORY_DEPENDENCIES_EXCLUDED");
+    }
     return {
         schemaVersion: requireString(request.schemaVersion, "schema_version"),
         repository: {
             root: requireString(repository.root, "repository_root"),
-            exclude: requireStringArray(repository.exclude, "repository_exclude"),
+            exclude,
+            includeDependencies,
+            git: repository.git === "synthesized" ? "synthesized" : "excluded",
         },
         adapter: normalizedAdapter,
         isolation: containerIsolation ?? {
-            kind: "trusted-local",
+            kind: isolation.kind === "windows-native" ? "windows-native" : "trusted-local",
             acknowledgedUnsafeExecution: true,
             environmentAllowlist,
         },
@@ -2592,10 +2850,113 @@ function containerPreflightExecutor(container, executable) {
         };
     });
 }
-async function executeContainerAdapter(request, container, workspace, candidateFiles) {
+const CONTAINER_BUN_PROBE_SOURCE = 'const fs = require("node:fs"); const crypto = require("node:crypto"); const execPath = fs.realpathSync(process.execPath); console.log(JSON.stringify({ digest: "sha256:" + crypto.createHash("sha256").update(fs.readFileSync(execPath)).digest("hex"), execPath, bunVersion: Bun.version, bunRevision: Bun.revision }));';
+async function runContainerBunProbe(container, executable, workspace, timeoutMs, maximumOutputBytes) {
+    const { process: result } = await runContainerExecution(container, {
+        workspace,
+        executable,
+        args: ["-e", CONTAINER_BUN_PROBE_SOURCE],
+        environment: {},
+        timeoutMs: Math.min(timeoutMs, 30_000),
+        maximumOutputBytes: Math.min(maximumOutputBytes, CONTROLLED_REPORT_MAXIMUM_BYTES),
+    }, runBoundedProcess, os.tmpdir());
+    if (result.outcome !== "PASS" || result.stdout.truncated || result.stderr.totalBytes > 0) {
+        throw new Error("BUN_TEST_EXECUTABLE_PROBE_FAILED");
+    }
+    let report;
+    try {
+        report = JSON.parse(result.stdout.text.trim());
+    }
+    catch {
+        throw new Error("BUN_TEST_EXECUTABLE_PROBE_FAILED");
+    }
+    if (!isRecord(report) ||
+        Object.keys(report).sort().join("\0") !== "bunRevision\0bunVersion\0digest\0execPath" ||
+        typeof report.execPath !== "string" ||
+        !report.execPath.startsWith("/") ||
+        typeof report.digest !== "string" ||
+        !/^sha256:[a-f0-9]{64}$/u.test(report.digest) ||
+        typeof report.bunVersion !== "string" ||
+        typeof report.bunRevision !== "string") {
+        throw new Error("BUN_TEST_EXECUTABLE_PROBE_FAILED");
+    }
+    if (report.bunVersion !== BUN_TEST_ADAPTER_PROFILE.bunVersion ||
+        report.bunRevision !== BUN_TEST_ADAPTER_PROFILE.bunRevision) {
+        throw new Error("BUN_TEST_VERSION_UNSUPPORTED");
+    }
+    return {
+        execPath: report.execPath,
+        bunVersion: report.bunVersion,
+        bunRevision: report.bunRevision,
+        executableDigest: report.digest,
+    };
+}
+/** Resolves the image's Bun twice, as the local probe does, and binds its digest. */
+async function probeContainerBunExecutable(container, requestedExecutable, timeoutMs, maximumOutputBytes) {
+    return withEmptyWorkspace(async (workspace) => {
+        const first = await runContainerBunProbe(container, requestedExecutable, workspace, timeoutMs, maximumOutputBytes);
+        const second = await runContainerBunProbe(container, first.execPath, workspace, timeoutMs, maximumOutputBytes);
+        if (second.execPath !== first.execPath ||
+            second.bunVersion !== first.bunVersion ||
+            second.bunRevision !== first.bunRevision ||
+            second.executableDigest !== first.executableDigest) {
+            throw new Error("BUN_TEST_EXECUTABLE_PROBE_FAILED");
+        }
+        return {
+            requestedExecutable,
+            resolvedExecutable: first.execPath,
+            executableDigest: first.executableDigest,
+            bunVersion: first.bunVersion,
+            bunRevision: first.bunRevision,
+        };
+    });
+}
+/** The driver, its preload and the assertion helper, as one container asset set. */
+async function bunContainerAssets() {
+    return [
+        { name: "driver.mjs", content: await readFile(BUN_TEST_DRIVER_PATH, "utf8") },
+        { name: "preload.mjs", content: await readFile(BUN_TEST_PRELOAD_PATH, "utf8") },
+        { name: "assertions.mjs", content: await readFile(BUN_TEST_HELPER_PATH, "utf8") },
+    ];
+}
+/** Runs the Bun driver under the image's own Bun; the report comes back as result.json only. */
+async function runContainerBunDriver(container, workspace, executable, files, environment, timeoutMs, maximumOutputBytes) {
+    const executed = await runContainerExecution(container, {
+        workspace,
+        assets: await bunContainerAssets(),
+        executable,
+        args: [
+            `${CONTAINER_ASSET_DIRECTORY}/driver.mjs`,
+            executable,
+            `${CONTAINER_ASSET_DIRECTORY}/assertions.mjs`,
+            ...files,
+        ],
+        environment: { ...environment, ASSERTLEDGER_BUN_RESULT_FILE: CONTAINER_RESULT_FILE },
+        timeoutMs,
+        maximumOutputBytes,
+        resultMaximumBytes: CONTROLLED_REPORT_MAXIMUM_BYTES,
+    }, runBoundedProcess, os.tmpdir());
+    const result = executed.process;
+    const document = result.outcome === "TIMEOUT" || result.outcome === "INFRA_ERROR"
+        ? undefined
+        : parseJsonBytes(executed.result);
+    return { result, report: parseStructuredCommandReport(document, result) };
+}
+async function executeContainerBunAdapter(request, container, workspace, candidate, candidateFiles) {
     const adapter = request.adapter;
-    if (adapter.kind === "bun-test")
-        throw new Error("BUN_TEST_CONTAINER_UNSUPPORTED");
+    if (adapter.kind !== "bun-test" && adapter.kind !== "bun-test-designated") {
+        throw new Error("UNSUPPORTED_ADAPTER");
+    }
+    const { result, report } = await runContainerBunDriver(container, workspace, adapter.executable, adapter.kind === "bun-test" ? adapter.baseTestFiles : designatedFiles(request, candidate), adapter.kind === "bun-test"
+        ? { TESTFORGE_CANDIDATE_FILES: JSON.stringify(candidateFiles) }
+        : { ASSERTLEDGER_BUN_DESIGNATED: JSON.stringify(designatedSelection(request, candidate)) }, request.budgets.timeoutMsPerExecution, request.budgets.maximumOutputBytes);
+    return { result, structuredReport: report, nodeTestReport: undefined };
+}
+async function executeContainerAdapter(request, container, workspace, candidate, candidateFiles) {
+    const adapter = request.adapter;
+    if (adapter.kind === "bun-test" || adapter.kind === "bun-test-designated") {
+        return executeContainerBunAdapter(request, container, workspace, candidate, candidateFiles);
+    }
     const executed = await runContainerExecution(container, {
         workspace,
         ...(adapter.kind === "node-test" ? { reporterSource: NODE_TEST_REPORTER_SOURCE } : {}),
@@ -2636,7 +2997,114 @@ async function executeContainerAdapter(request, container, workspace, candidateF
     };
 }
 function trustedLocalEnvironmentAllowlist(request) {
-    return request.isolation.kind === "trusted-local" ? request.isolation.environmentAllowlist : [];
+    return request.isolation.kind === "container" ? [] : request.isolation.environmentAllowlist;
+}
+/** The snapshot exclusions: the defaults and the request's names, keeping dependencies on request. */
+function campaignExcludes(request) {
+    const excludes = effectiveExcludes(request.repository.exclude);
+    if (request.repository.includeDependencies)
+        excludes.delete(portablePathKey("node_modules"));
+    return excludes;
+}
+/** A workspace copy keeps the snapshot's synthesized Git metadata; the source's own never enters. */
+function workspaceExcludes(request) {
+    const excludes = campaignExcludes(request);
+    if (request.repository.git === "synthesized")
+        excludes.delete(portablePathKey(".git"));
+    return excludes;
+}
+/**
+ * Commits the snapshot once into a fresh repository with a fixed identity and date, no template,
+ * hooks or global configuration, honoring the snapshot's own .gitignore. Returns the tree identity.
+ */
+async function synthesizeGitWorktree(snapshot) {
+    // An empty file outside the snapshot: Git for Windows cannot open os.devNull as a config file.
+    const globalConfig = path.join(path.dirname(snapshot), "git-global-config");
+    await writeFile(globalConfig, "", { flag: "wx" });
+    const environment = {
+        ...environmentFromAllowlist(["PATH", "SystemRoot", "WINDIR", "TEMP", "TMP"]),
+        GIT_CONFIG_NOSYSTEM: "1",
+        GIT_ATTR_NOSYSTEM: "1",
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_CONFIG_GLOBAL: globalConfig,
+        GIT_AUTHOR_NAME: "AssertLedger",
+        GIT_AUTHOR_EMAIL: "snapshot@assertledger.invalid",
+        GIT_AUTHOR_DATE: "1970-01-01T00:00:00Z",
+        GIT_COMMITTER_NAME: "AssertLedger",
+        GIT_COMMITTER_EMAIL: "snapshot@assertledger.invalid",
+        GIT_COMMITTER_DATE: "1970-01-01T00:00:00Z",
+    };
+    const git = async (args) => {
+        const result = await runProcess({
+            executable: "git",
+            args: [
+                "-c",
+                "core.autocrlf=false",
+                "-c",
+                "core.safecrlf=false",
+                "-c",
+                "core.fileMode=false",
+                "-c",
+                "core.hooksPath=",
+                "-c",
+                "commit.gpgsign=false",
+                ...args,
+            ],
+            cwd: snapshot,
+            environment,
+            timeoutMs: 600_000,
+            maximumOutputBytes: CONTROLLED_REPORT_MAXIMUM_BYTES,
+        });
+        if (result.outcome !== "PASS" || result.stdout.truncated) {
+            throw new Error("REPOSITORY_GIT_SYNTHESIS_FAILED", {
+                cause: result.stderr.text.slice(0, 500),
+            });
+        }
+        return result.stdout.text.trim();
+    };
+    const gitVersion = await git(["--version"]);
+    await git(["init", "--quiet", "--template="]);
+    await git(["add", "--all"]);
+    await git([
+        "commit",
+        "--quiet",
+        "--no-verify",
+        "--allow-empty",
+        "--message",
+        "AssertLedger snapshot",
+    ]);
+    const treeId = await git(["rev-parse", "HEAD^{tree}"]);
+    if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(treeId)) {
+        throw new Error("REPOSITORY_GIT_SYNTHESIS_FAILED");
+    }
+    return { mode: "synthesized", treeId, gitVersion };
+}
+/** The selection a designated campaign gives the Bun driver: load every test, or run one. */
+function designatedSelection(request, candidate) {
+    if (candidate !== null) {
+        const designated = candidate.designated;
+        if (designated === undefined)
+            throw new Error("DESIGNATED_CANDIDATE_REQUIRED");
+        return {
+            mode: "run",
+            test: { file: designated.file, path: designated.path },
+            expectedFailure: designated.expectedFailure,
+            testTimeoutMs: request.adapter.kind === "bun-test-designated" ? request.adapter.testTimeoutMs : null,
+        };
+    }
+    return {
+        mode: "load",
+        tests: request.candidates.map((entry) => {
+            if (entry.designated === undefined)
+                throw new Error("DESIGNATED_CANDIDATE_REQUIRED");
+            return { file: entry.designated.file, path: entry.designated.path };
+        }),
+    };
+}
+/** The test files a designated run loads: every designated file for a control, one for a run. */
+function designatedFiles(request, candidate) {
+    const files = (candidate === null ? request.candidates : [candidate]).map((entry) => entry.designated?.file ?? "");
+    return [...new Map(files.map((file) => [portablePathKey(file), file])).values()].sort(comparePortablePaths);
 }
 function classifyNodeTest(result, report, hasCandidate) {
     if (result.outcome === "TIMEOUT")
@@ -2654,7 +3122,7 @@ function classifyNodeTest(result, report, hasCandidate) {
         candidateFailuresAllAssertions: report?.candidateFailuresAllAssertions ?? false,
     });
 }
-async function copyRepository(source, destination, excludes) {
+async function copyRepository(source, destination, excludes, omittedLinks = new Set()) {
     await cp(source, destination, {
         recursive: true,
         force: false,
@@ -2667,13 +3135,16 @@ async function copyRepository(source, destination, excludes) {
                 return false;
             }
             if ((await lstat(sourcePath)).isSymbolicLink()) {
+                // Only a link already judged outside every executed test's closure is left out.
+                if (omittedLinks.has(portablePathKey(relative.split(path.sep).join("/"))))
+                    return false;
                 throw new Error("UNSUPPORTED_REPOSITORY_SYMLINK");
             }
             return true;
         },
     });
 }
-async function executeTrustedLocalAdapter(request, workspace, temporaryRoot, candidateFiles, nodeTestReporterPath) {
+async function executeTrustedLocalAdapter(request, workspace, temporaryRoot, candidate, candidateFiles, nodeTestReporterPath) {
     const resultFile = path.join(temporaryRoot, "structured-command-result.json");
     const environment = environmentFromAllowlist(trustedLocalEnvironmentAllowlist(request));
     if (request.adapter.kind === "testforge-command") {
@@ -2683,6 +3154,9 @@ async function executeTrustedLocalAdapter(request, workspace, temporaryRoot, can
     else if (request.adapter.kind === "bun-test") {
         environment.TESTFORGE_CANDIDATE_FILES = JSON.stringify(candidateFiles);
     }
+    else if (request.adapter.kind === "bun-test-designated") {
+        environment.ASSERTLEDGER_BUN_DESIGNATED = JSON.stringify(designatedSelection(request, candidate));
+    }
     else {
         if (nodeTestReporterPath === undefined)
             throw new Error("NODE_TEST_REPORTER_MISSING");
@@ -2705,9 +3179,18 @@ async function executeTrustedLocalAdapter(request, workspace, temporaryRoot, can
                 BUN_TEST_HELPER_PATH,
                 ...request.adapter.baseTestFiles,
             ]
-            : request.adapter.arguments;
+            : request.adapter.kind === "bun-test-designated"
+                ? [
+                    BUN_TEST_DRIVER_PATH,
+                    request.adapter.executable,
+                    BUN_TEST_HELPER_PATH,
+                    ...designatedFiles(request, candidate),
+                ]
+                : request.adapter.arguments;
     const result = await runProcess({
-        executable: request.adapter.kind === "bun-test" ? process.execPath : request.adapter.executable,
+        executable: request.adapter.kind === "bun-test" || request.adapter.kind === "bun-test-designated"
+            ? process.execPath
+            : request.adapter.executable,
         args,
         cwd: workspace,
         environment,
@@ -2716,7 +3199,7 @@ async function executeTrustedLocalAdapter(request, workspace, temporaryRoot, can
     });
     const structuredReport = request.adapter.kind === "testforge-command"
         ? await readStructuredCommandReport(resultFile, result, CONTROLLED_REPORT_MAXIMUM_BYTES)
-        : request.adapter.kind === "bun-test"
+        : request.adapter.kind === "bun-test" || request.adapter.kind === "bun-test-designated"
             ? readBunDriverReport(result)
             : undefined;
     return {
@@ -2731,14 +3214,14 @@ async function executeObservation(request, repositoryRoot, world, candidate, att
     const temporaryRoot = await realpath(await mkdtemp(path.join(os.tmpdir(), "testforge-run-")));
     const workspace = path.join(temporaryRoot, "repository");
     try {
-        await copyRepository(repositoryRoot, workspace, effectiveExcludes(request.repository.exclude));
+        await copyRepository(repositoryRoot, workspace, workspaceExcludes(request));
         await applyFiles(workspace, world.files);
         if (candidate)
             await applyFiles(workspace, candidate.files);
         const candidateFiles = candidate ? candidate.files.map((file) => file.path) : [];
         const { result, structuredReport, nodeTestReport } = container === undefined
-            ? await executeTrustedLocalAdapter(request, workspace, temporaryRoot, candidateFiles, nodeTestReporterPath)
-            : await executeContainerAdapter(request, container, workspace, candidateFiles);
+            ? await executeTrustedLocalAdapter(request, workspace, temporaryRoot, candidate, candidateFiles, nodeTestReporterPath)
+            : await executeContainerAdapter(request, container, workspace, candidate, candidateFiles);
         const nodeClassification = request.adapter.kind === "node-test"
             ? classifyNodeTest(result, nodeTestReport, candidate !== null)
             : undefined;
@@ -2767,7 +3250,119 @@ async function executeObservation(request, repositoryRoot, world, candidate, att
         await removeTemporaryDirectory(temporaryRoot);
     }
 }
-async function runBunTestRuntimePreflight(executable, environmentAllowlist, timeoutMs, maximumOutputBytes) {
+function localBunDriverExecutor(executable, environmentAllowlist, timeoutMs, maximumOutputBytes) {
+    return async (workspace, files, environment) => readBunDriverReport(await runProcess({
+        executable: process.execPath,
+        args: [BUN_TEST_DRIVER_PATH, executable, BUN_TEST_HELPER_PATH, ...files],
+        cwd: workspace,
+        environment: { ...environmentFromAllowlist(environmentAllowlist), ...environment },
+        timeoutMs: Math.min(timeoutMs, 5_000),
+        maximumOutputBytes: Math.min(maximumOutputBytes, CONTROLLED_REPORT_MAXIMUM_BYTES),
+    }));
+}
+function containerBunDriverExecutor(container, executable, timeoutMs, maximumOutputBytes) {
+    return async (workspace, files, environment) => (await runContainerBunDriver(container, workspace, executable, files, environment, Math.min(timeoutMs, 30_000), Math.min(maximumOutputBytes, CONTROLLED_REPORT_MAXIMUM_BYTES))).report;
+}
+const DESIGNATED_PROBES = (() => {
+    const run = (name, body, outcome, expectedFailure) => {
+        const counted = outcome !== "NO_TEST_DISCOVERED" && outcome !== "INFRA_ERROR";
+        return {
+            name,
+            body,
+            mode: "run",
+            ...(expectedFailure === undefined ? {} : { expectedFailure }),
+            outcome,
+            attributed: outcome === "PASS" || outcome === "ASSERTION_FAILURE",
+            testsDiscovered: counted ? 1 : 0,
+            candidateTestsDiscovered: counted ? 1 : 0,
+        };
+    };
+    const failing = 'test("probe", () => expect(1).toBe(2));';
+    return [
+        run("expect-assertion", failing, "ASSERTION_FAILURE"),
+        run("expected-line", failing, "ASSERTION_FAILURE", "error: expect(received).toBe(expected)"),
+        run("other-line", failing, "PROCESS_CRASH", "expect(received).toEqual(expected)"),
+        run("assert-same", 'test("probe", () => assertSame(1, 2));', "ASSERTION_FAILURE"),
+        run("async-matcher", 'test("probe", async () => { await expect(Promise.resolve(1)).resolves.toBe(2); });', "ASSERTION_FAILURE"),
+        run("forged-message", 'test("probe", () => { throw new Error("expect(received).toBe(expected)"); });', "PROCESS_CRASH"),
+        run("caught-expect", 'test("probe", () => { try { expect(1).toBe(2); } catch {} throw new Error("generic"); });', "PROCESS_CRASH"),
+        run("replayed-expect", 'let saved; try { expect(1).toBe(2); } catch (error) { saved = error; } test("probe", () => { throw saved; });', "PROCESS_CRASH"),
+        run("matcher-usage", 'test("probe", () => expect(1).toContain());', "PROCESS_CRASH"),
+        run("custom-matcher", 'expect.extend({ toFail() { throw new Error("expect(received).toFail()"); } }); test("probe", () => expect(1).toFail());', "PROCESS_CRASH"),
+        run("passing", 'test("probe", () => expect(1).toBe(1));', "PASS"),
+        run("absent", 'test("other", () => expect(1).toBe(2));', "NO_TEST_DISCOVERED"),
+        run("hook-failure", 'afterEach(() => { throw new Error("hook"); }); test("probe", () => expect(1).toBe(2));', "INFRA_ERROR"),
+        {
+            // The callback fails its matcher only after Bun's per-test timeout: never an assertion.
+            ...run("late-after-timeout", 'test("probe", () => { const end = Date.now() + 300; while (Date.now() < end); expect(1).toBe(2); });', "INFRA_ERROR"),
+            testTimeoutMs: 50,
+        },
+        {
+            name: "load",
+            body: 'test("probe", () => expect(1).toBe(2)); test("other", () => {});',
+            mode: "load",
+            outcome: "PASS",
+            attributed: false,
+            testsDiscovered: 2,
+            candidateTestsDiscovered: 0,
+        },
+        {
+            name: "load-failure",
+            body: 'import "./missing-module"; test("probe", () => {});',
+            mode: "load",
+            outcome: "INFRA_ERROR",
+            attributed: false,
+            testsDiscovered: 0,
+            candidateTestsDiscovered: 0,
+        },
+    ];
+})();
+/**
+ * Qualifies the designated mode before a campaign: only a built-in matcher's or assertSame's
+ * failure inside the designated test, with the declared first line, is an assertion; forged,
+ * caught, replayed, misused and custom failures, hook and load failures and an absent test are not.
+ */
+async function runBunDesignatedPreflight(executor) {
+    const header = 'import { afterEach, expect, test } from "bun:test"; import { assertSame } from "assertledger/bun";';
+    try {
+        const recorded = [];
+        for (const probe of DESIGNATED_PROBES) {
+            const report = await withEmptyWorkspace(async (workspace) => {
+                await writeFile(path.join(workspace, "package.json"), '{"type":"module"}\n');
+                await writeFile(path.join(workspace, "probe.test.ts"), `${header} ${probe.body}\n`);
+                const test = { file: "probe.test.ts", path: ["probe"] };
+                return executor(workspace, ["probe.test.ts"], {
+                    ASSERTLEDGER_BUN_DESIGNATED: JSON.stringify(probe.mode === "run"
+                        ? {
+                            mode: "run",
+                            test,
+                            expectedFailure: probe.expectedFailure ?? null,
+                            testTimeoutMs: probe.testTimeoutMs ?? null,
+                        }
+                        : { mode: "load", tests: [test] }),
+                });
+            });
+            if (report?.outcome !== probe.outcome ||
+                report.attributed !== probe.attributed ||
+                report.testsDiscovered !== probe.testsDiscovered ||
+                report.candidateTestsDiscovered !== probe.candidateTestsDiscovered) {
+                throw new Error("BUN_TEST_PROFILE_PREFLIGHT_FAILED", { cause: probe.name });
+            }
+            recorded.push({
+                name: probe.name,
+                outcome: report.outcome,
+                attributed: report.attributed,
+                testsDiscovered: report.testsDiscovered,
+                candidateTestsDiscovered: report.candidateTestsDiscovered,
+            });
+        }
+        return { protocolVersion: "1.0.0", probes: recorded };
+    }
+    catch (error) {
+        throw new Error("BUN_TEST_PROFILE_PREFLIGHT_FAILED", { cause: error });
+    }
+}
+async function runBunTestRuntimePreflight(executor) {
     const probeSources = [
         {
             name: "assertion",
@@ -2838,18 +3433,9 @@ async function runBunTestRuntimePreflight(executable, environmentAllowlist, time
                 await writeFile(path.join(workspace, "base.test.ts"), 'import { test } from "bun:test"; test("control", () => {});\n');
                 const candidatePath = path.join(workspace, "candidate.test.ts");
                 await writeFile(candidatePath, probe.source);
-                const result = await runProcess({
-                    executable: process.execPath,
-                    args: [BUN_TEST_DRIVER_PATH, executable, BUN_TEST_HELPER_PATH, "base.test.ts"],
-                    cwd: workspace,
-                    environment: {
-                        ...environmentFromAllowlist(environmentAllowlist),
-                        TESTFORGE_CANDIDATE_FILES: JSON.stringify(["candidate.test.ts"]),
-                    },
-                    timeoutMs: Math.min(timeoutMs, 5_000),
-                    maximumOutputBytes: Math.min(maximumOutputBytes, CONTROLLED_REPORT_MAXIMUM_BYTES),
+                const report = await executor(workspace, ["base.test.ts"], {
+                    TESTFORGE_CANDIDATE_FILES: JSON.stringify(["candidate.test.ts"]),
                 });
-                const report = readBunDriverReport(result);
                 const expectedCandidateCount = probe.name === "hook-failure"
                     ? 0
                     : probe.name === "replayed-row" ||
@@ -2886,14 +3472,20 @@ export async function verifyCampaign(value, options = {}) {
         ? await prepareContainerBackend(options.containerRuntime?.command ?? DEFAULT_CONTAINER_RUNTIME_COMMAND, request.isolation, runBoundedProcess, os.tmpdir())
         : undefined;
     const repositoryRoot = await resolveRepositoryRoot(request.repository.root);
-    const excludes = effectiveExcludes(request.repository.exclude);
-    const sourceInventory = await walkFiles(repositoryRoot, excludes);
+    const version4 = request.schemaVersion === VERIFICATION_SCHEMA_VERSION_V4;
+    const excludes = campaignExcludes(request);
+    // Before v4 any link refuses the walk; v4 collects them and judges each one below.
+    const sourceLinks = version4 ? [] : undefined;
+    const sourceInventory = await walkFiles(repositoryRoot, excludes, sourceLinks);
     if (sourceInventory.files.length > request.budgets.maximumRepositoryFiles) {
         throw new Error("REPOSITORY_FILE_BUDGET_EXCEEDED");
     }
     if (sourceInventory.totalBytes > request.budgets.maximumRepositoryBytes) {
         throw new Error("REPOSITORY_BYTES_BUDGET_EXCEEDED");
     }
+    const omittedLinks = sourceLinks === undefined || sourceLinks.length === 0
+        ? []
+        : await campaignOmittedLinks(request, repositoryRoot, sourceInventory.files, sourceLinks);
     const nodeIdentity = request.adapter.kind !== "node-test"
         ? undefined
         : container === undefined
@@ -2902,15 +3494,19 @@ export async function verifyCampaign(value, options = {}) {
     if (request.adapter.kind === "node-test" && nodeIdentity !== undefined) {
         request.adapter.executable = nodeIdentity.resolvedExecutable;
     }
-    const bunIdentity = request.adapter.kind === "bun-test"
-        ? await probeBunTestExecutable(request.adapter.executable, repositoryRoot, trustedLocalEnvironmentAllowlist(request), request.budgets.timeoutMsPerExecution, request.budgets.maximumOutputBytes)
-        : undefined;
-    if (request.adapter.kind === "bun-test" && bunIdentity !== undefined) {
+    const bunAdapter = request.adapter.kind === "bun-test" || request.adapter.kind === "bun-test-designated";
+    const bunIdentity = request.adapter.kind !== "bun-test" && request.adapter.kind !== "bun-test-designated"
+        ? undefined
+        : container === undefined
+            ? await probeBunTestExecutable(request.adapter.executable, repositoryRoot, trustedLocalEnvironmentAllowlist(request), request.budgets.timeoutMsPerExecution, request.budgets.maximumOutputBytes)
+            : await probeContainerBunExecutable(container, request.adapter.executable, request.budgets.timeoutMsPerExecution, request.budgets.maximumOutputBytes);
+    if ((request.adapter.kind === "bun-test" || request.adapter.kind === "bun-test-designated") &&
+        bunIdentity !== undefined) {
         request.adapter.executable = bunIdentity.resolvedExecutable;
     }
-    const bunDriverDigest = request.adapter.kind === "bun-test" ? await sha256File(BUN_TEST_DRIVER_PATH) : undefined;
-    const bunHelperDigest = request.adapter.kind === "bun-test" ? await sha256File(BUN_TEST_HELPER_PATH) : undefined;
-    const bunPreloadDigest = request.adapter.kind === "bun-test" ? await sha256File(BUN_TEST_PRELOAD_PATH) : undefined;
+    const bunDriverDigest = bunAdapter ? await sha256File(BUN_TEST_DRIVER_PATH) : undefined;
+    const bunHelperDigest = bunAdapter ? await sha256File(BUN_TEST_HELPER_PATH) : undefined;
+    const bunPreloadDigest = bunAdapter ? await sha256File(BUN_TEST_PRELOAD_PATH) : undefined;
     const nodeRuntimePreflight = request.adapter.kind === "node-test" && nodeIdentity !== undefined
         ? await runNodeTestRuntimePreflight({
             executable: nodeIdentity.resolvedExecutable,
@@ -2926,13 +3522,20 @@ export async function verifyCampaign(value, options = {}) {
                 }),
         })
         : undefined;
-    const bunRuntimePreflight = request.adapter.kind === "bun-test" && bunIdentity !== undefined
-        ? await runBunTestRuntimePreflight(bunIdentity.resolvedExecutable, trustedLocalEnvironmentAllowlist(request), request.budgets.timeoutMsPerExecution, request.budgets.maximumOutputBytes)
-        : undefined;
+    const bunExecutor = bunIdentity === undefined
+        ? undefined
+        : container === undefined
+            ? localBunDriverExecutor(bunIdentity.resolvedExecutable, trustedLocalEnvironmentAllowlist(request), request.budgets.timeoutMsPerExecution, request.budgets.maximumOutputBytes)
+            : containerBunDriverExecutor(container, bunIdentity.resolvedExecutable, request.budgets.timeoutMsPerExecution, request.budgets.maximumOutputBytes);
+    const bunRuntimePreflight = bunExecutor === undefined
+        ? undefined
+        : request.adapter.kind === "bun-test-designated"
+            ? await runBunDesignatedPreflight(bunExecutor)
+            : await runBunTestRuntimePreflight(bunExecutor);
     const campaignRoot = await realpath(await mkdtemp(path.join(os.tmpdir(), "testforge-campaign-")));
     const repositorySnapshot = path.join(campaignRoot, "repository");
     try {
-        await copyRepository(repositoryRoot, repositorySnapshot, excludes);
+        await copyRepository(repositoryRoot, repositorySnapshot, excludes, new Set(omittedLinks.map(portablePathKey)));
         const snapshotInventory = await walkFiles(repositorySnapshot, excludes);
         if (snapshotInventory.files.length > request.budgets.maximumRepositoryFiles) {
             throw new Error("REPOSITORY_FILE_BUDGET_EXCEEDED");
@@ -2940,9 +3543,18 @@ export async function verifyCampaign(value, options = {}) {
         if (snapshotInventory.totalBytes > request.budgets.maximumRepositoryBytes) {
             throw new Error("REPOSITORY_BYTES_BUDGET_EXCEEDED");
         }
+        const gitRecord = request.repository.git === "synthesized"
+            ? await synthesizeGitWorktree(repositorySnapshot)
+            : null;
+        const designatedTestFiles = request.candidates.flatMap((candidate) => candidate.designated === undefined ? [] : [candidate.designated.file]);
+        const snapshotFiles = new Set(snapshotInventory.files.map(portablePathKey));
+        if (designatedTestFiles.some((file) => !snapshotFiles.has(portablePathKey(file)))) {
+            throw new Error("DESIGNATED_TEST_FILE_MISSING");
+        }
         const inputPaths = [
             ...request.worlds.flatMap((world) => world.files.map((file) => file.path)),
             ...request.candidates.flatMap((candidate) => candidate.files.map((file) => file.path)),
+            ...designatedTestFiles,
             ...(request.adapter.kind === "node-test" || request.adapter.kind === "bun-test"
                 ? request.adapter.baseTestFiles
                 : []),
@@ -2964,7 +3576,11 @@ export async function verifyCampaign(value, options = {}) {
         if (nodeTestReporterPath !== undefined) {
             await writeFile(nodeTestReporterPath, NODE_TEST_REPORTER_SOURCE, { flag: "wx" });
         }
-        const analysis = (await analyzeRepository(repositorySnapshot));
+        // A v4 digest covers exactly the snapshot, dependencies included when the request says so.
+        const repositoryDigest = version4
+            ? await repositoryInventoryDigest(repositorySnapshot, snapshotInventory.files)
+            : (await analyzeRepository(repositorySnapshot))
+                .repositoryDigest;
         const observations = [];
         for (const world of request.worlds) {
             for (let attempt = 1; attempt <= request.policy.requiredAttempts; attempt += 1) {
@@ -2978,16 +3594,37 @@ export async function verifyCampaign(value, options = {}) {
                 }
             }
         }
+        // A designated candidate is identified by its selection and the bytes of its test file.
+        const designatedIdentities = new Map();
+        for (const candidate of request.candidates) {
+            if (candidate.designated === undefined)
+                continue;
+            const bytes = await readFile(path.join(repositorySnapshot, ...candidate.designated.file.split("/")));
+            designatedIdentities.set(candidate.id, {
+                digest: sha256Canonical({
+                    test: { file: candidate.designated.file, path: candidate.designated.path },
+                    expectedFailure: candidate.designated.expectedFailure,
+                    testFileDigest: rawSha256(bytes),
+                }),
+                sizeBytes: bytes.byteLength,
+            });
+        }
+        const windowsNative = request.isolation.kind === "windows-native";
+        const isolationLevel = container !== undefined
+            ? "CONTAINER"
+            : windowsNative
+                ? "WINDOWS_NATIVE_UNSANDBOXED"
+                : "UNSANDBOXED";
         const evidence = {
             schemaVersion: request.schemaVersion,
-            repositoryDigest: analysis.repositoryDigest,
+            repositoryDigest,
             evidenceContext: {
                 engine: { name: "testforge", version: "0.1.0" },
                 adapter: {
                     name: request.adapter.kind,
                     version: request.adapter.kind === "testforge-command"
                         ? request.adapter.protocolVersion
-                        : request.adapter.kind === "bun-test"
+                        : bunAdapter
                             ? (bunIdentity?.bunVersion ?? "unprobed")
                             : (nodeIdentity?.nodeVersion ?? "unprobed"),
                     configuration: request.adapter.kind === "node-test" && nodeIdentity !== undefined
@@ -3036,10 +3673,45 @@ export async function verifyCampaign(value, options = {}) {
                                     ...request.adapter.baseTestFiles,
                                 ],
                             }
-                            : request.adapter,
+                            : request.adapter.kind === "bun-test-designated" && bunIdentity !== undefined
+                                ? {
+                                    kind: "bun-test-designated",
+                                    profile: BUN_TEST_DESIGNATED_ADAPTER_PROFILE,
+                                    requestedExecutable: bunIdentity.requestedExecutable,
+                                    resolvedExecutable: bunIdentity.resolvedExecutable,
+                                    executableDigest: bunIdentity.executableDigest,
+                                    bunVersion: bunIdentity.bunVersion,
+                                    bunRevision: bunIdentity.bunRevision,
+                                    driverDigest: bunDriverDigest,
+                                    helperDigest: bunHelperDigest,
+                                    preloadDigest: bunPreloadDigest,
+                                    runtimePreflight: bunRuntimePreflight,
+                                    arguments: [
+                                        "test",
+                                        "--max-concurrency=1",
+                                        "--retry=0",
+                                        "--preload",
+                                        "./node_modules/assertledger/preload.mjs",
+                                        "--reporter=junit",
+                                        "--reporter-outfile=<generated-junit-file>",
+                                        "--test-name-pattern=<anchored-designated-test-path>",
+                                        ...(request.adapter.testTimeoutMs === null
+                                            ? []
+                                            : [`--timeout=${request.adapter.testTimeoutMs}`]),
+                                        "<designated-test-file>",
+                                    ],
+                                    testTimeoutMs: request.adapter.testTimeoutMs,
+                                    designatedTests: request.candidates.map((candidate) => ({
+                                        candidateId: candidate.id,
+                                        file: candidate.designated?.file ?? null,
+                                        path: candidate.designated?.path ?? [],
+                                        expectedFailure: candidate.designated?.expectedFailure ?? null,
+                                    })),
+                                }
+                                : request.adapter,
                 },
                 execution: {
-                    isolation: container === undefined ? "UNSANDBOXED" : "CONTAINER",
+                    isolation: isolationLevel,
                     environmentAllowlist: container === undefined
                         ? trustedLocalEnvironmentAllowlist(request)
                         : container.isolation.environment.map((variable) => variable.name).sort(),
@@ -3048,11 +3720,26 @@ export async function verifyCampaign(value, options = {}) {
                     ...(request.schemaVersion === "1.0.0"
                         ? {}
                         : {
-                            backend: container === undefined
-                                ? { kind: "trusted-local", level: "UNSANDBOXED" }
-                                : container.record,
+                            backend: container !== undefined
+                                ? container.record
+                                : windowsNative
+                                    ? {
+                                        kind: "windows-native",
+                                        level: "WINDOWS_NATIVE_UNSANDBOXED",
+                                        platform: "win32",
+                                    }
+                                    : { kind: "trusted-local", level: "UNSANDBOXED" },
                         }),
                 },
+                ...(version4
+                    ? {
+                        repository: {
+                            includeDependencies: request.repository.includeDependencies,
+                            omittedLinks: [...omittedLinks].sort(),
+                            git: gitRecord,
+                        },
+                    }
+                    : {}),
                 worlds: request.worlds.map((world) => ({
                     id: world.id,
                     provenance: world.provenance ?? "unspecified",
@@ -3064,29 +3751,71 @@ export async function verifyCampaign(value, options = {}) {
             },
             policy: request.policy,
             worlds: request.worlds.map(({ files: _files, provenance: _provenance, ...world }) => world),
-            candidates: request.candidates.map((candidate) => ({
-                id: candidate.id,
-                digest: sha256Canonical(candidate.files),
-                sizeBytes: candidate.files.reduce((total, file) => total + Buffer.byteLength(file.content), 0),
-            })),
+            candidates: request.candidates.map((candidate) => {
+                const designated = designatedIdentities.get(candidate.id);
+                return {
+                    id: candidate.id,
+                    digest: designated?.digest ?? sha256Canonical(candidate.files),
+                    sizeBytes: designated?.sizeBytes ??
+                        candidate.files.reduce((total, file) => total + Buffer.byteLength(file.content), 0),
+                };
+            }),
             observations,
         };
         const manifest = decideEvidence(evidence);
+        const designatedLimitations = request.adapter.kind === "bun-test-designated"
+            ? [
+                "Only a failure thrown inside the designated test by a bun:test built-in matcher, in Bun's matcher message form, or by assertSame is admitted as an assertion; with a declared expected line, its first message line must equal it. Custom matchers, usage errors and every other error are not assertion evidence.",
+                "Controls load every designated test file without running a test: they show that each world evaluates the file and its imports and still registers the designated test, not that other tests pass.",
+                "Bun callback instrumentation determines assertion ownership; JUnit counts only check completeness and never classify assertions.",
+            ]
+            : [];
+        const snapshotLimitations = version4
+            ? [
+                ...(request.repository.includeDependencies
+                    ? [
+                        "Dependency directories (node_modules) are part of the snapshot and its digest as found; AssertLedger did not install or verify them.",
+                    ]
+                    : []),
+                ...(gitRecord !== null
+                    ? [
+                        "Each execution ran in a synthesized Git repository: the snapshot committed once with a fixed identity and date; the source repository's own Git metadata and history were not used.",
+                    ]
+                    : []),
+                ...(omittedLinks.length > 0
+                    ? [
+                        `${omittedLinks.length} repository link(s) outside the module closure of every executed test were left out of the snapshot; the closure follows literal module specifiers only and does not cover files read at run time.`,
+                    ]
+                    : []),
+            ]
+            : [];
         const finalManifest = {
             ...manifest,
             adapter: request.adapter.kind === "testforge-command"
                 ? { kind: request.adapter.kind, protocolVersion: request.adapter.protocolVersion }
                 : { kind: request.adapter.kind },
-            isolation: container === undefined
-                ? {
-                    kind: "trusted-local",
-                    level: "UNSANDBOXED",
-                    acknowledgedUnsafeExecution: true,
-                }
-                : { kind: "container", level: "CONTAINER", runtimeCommand: container.runtimeCommand },
+            isolation: container !== undefined
+                ? { kind: "container", level: "CONTAINER", runtimeCommand: container.runtimeCommand }
+                : windowsNative
+                    ? {
+                        kind: "windows-native",
+                        level: "WINDOWS_NATIVE_UNSANDBOXED",
+                        acknowledgedUnsafeExecution: true,
+                    }
+                    : {
+                        kind: "trusted-local",
+                        level: "UNSANDBOXED",
+                        acknowledgedUnsafeExecution: true,
+                    },
             limitations: container === undefined
                 ? [
-                    "UNSANDBOXED trusted-local execution cannot safely contain hostile candidate code.",
+                    ...(windowsNative
+                        ? [
+                            "WINDOWS_NATIVE_UNSANDBOXED execution ran directly on the Windows host at the operator's explicit request; it cannot safely contain hostile code.",
+                        ]
+                        : [
+                            "UNSANDBOXED trusted-local execution cannot safely contain hostile candidate code.",
+                        ]),
                     "Process-tree termination is best effort and depends on host operating-system facilities.",
                     ...(request.adapter.kind === "bun-test"
                         ? [
@@ -3094,10 +3823,12 @@ export async function verifyCampaign(value, options = {}) {
                             "Bun callback instrumentation determines assertion ownership; JUnit counts only check completeness and never classify assertions.",
                         ]
                         : []),
+                    ...designatedLimitations,
+                    ...snapshotLimitations,
                 ]
-                : [...CONTAINER_LIMITATIONS],
+                : [...CONTAINER_LIMITATIONS, ...designatedLimitations, ...snapshotLimitations],
         };
-        if (request.adapter.kind === "bun-test" &&
+        if (bunAdapter &&
             ((await sha256File(BUN_TEST_DRIVER_PATH)) !== bunDriverDigest ||
                 (await sha256File(BUN_TEST_HELPER_PATH)) !== bunHelperDigest ||
                 (await sha256File(BUN_TEST_PRELOAD_PATH)) !== bunPreloadDigest)) {