@davesheffer/hunch 1.8.2 → 1.9.2

package/dist/constitution/experiment.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "../core/io.js";
 import { shortHash } from "../core/ids.js";
+import { compareCodeUnits } from "../core/canonicalOrder.js";
 import { canonicalHash } from "./canonical.js";
 import { currentAppendOnly, loadPrivateRecords } from "./g2.js";
 const HASH = /^sha1:[a-f0-9]{40}$/;
@@ -245,6 +246,46 @@ export function assignmentTreatment(bank, run, assignment) {
         throw new Error(`assignment ${assignment.id} treatment hash mismatch`);
     return treatment;
 }
+/** Human-facing help is deliberately outside the hash-bound treatment. It may
+ * explain the review task, but must never interpret the assigned evidence. */
+export function experimentReviewGuide(arm) {
+    const notEnough = {
+        value: "uncompilable",
+        label: "Not enough information",
+        use_when: "The requirement does not clearly say which code relationship must always hold.",
+    };
+    if (arm === "A") {
+        return {
+            title: "Write one code rule from the requirement",
+            question: "Can one exact code rule be written from the requirement without guessing?",
+            action: "If yes, write one sentence naming the code elements, required or forbidden relationship, direct or transitive meaning, and file scope. If no, choose Not enough information.",
+            answer_template: "<subject> must <directly or transitively> <required or forbidden relationship> <target>; scope: <file or component>",
+            warning: "Use only the stated requirement. Current code may confirm names, but cannot add intent.",
+            choices: [
+                { value: "accepted_precise", label: "Rule written", use_when: "Your sentence expresses one exact rule fully supported by the requirement." },
+                notEnough,
+            ],
+        };
+    }
+    const choices = [
+        { value: "accepted_precise", label: "Yes — exact match", use_when: "The proposed rule says exactly what the requirement says." },
+        { value: "accepted_edited", label: "Needs editing", use_when: "The requirement supports one rule, but the proposal needs a specific correction." },
+        { value: "rejected", label: "Unsupported", use_when: "The proposal adds or changes meaning that the requirement does not support." },
+        notEnough,
+    ];
+    return {
+        title: arm === "C" ? "Check the proposed rule and its proof card" : "Check the proposed rule",
+        question: "Does the proposed rule say exactly what the requirement says?",
+        action: arm === "C"
+            ? "Compare the requirement with the proposed rule, then use the proof card only to check that the named code targets are bound correctly."
+            : "Compare the requirement with the proposed rule. Check the relationship, direction, direct or transitive meaning, and scope.",
+        answer_template: "Choose one plain-language option; include corrected rule text only for Needs editing.",
+        warning: arm === "C"
+            ? "The proof card can verify code bindings, but it cannot add intent missing from the requirement."
+            : "Do not infer intent from the current implementation or from nearby code.",
+        choices,
+    };
+}
 export function experimentRunContentHash(run) {
     const { id: _id, content_hash: _hash, ...body } = run;
     return canonicalHash(body);
@@ -272,7 +313,7 @@ export function compileExperimentRun(input, preregistration, bank, opts = {}) {
         if (bank.cases.length !== input.sample_per_arm)
             throw new Error("EXP-01 requires exactly sample_per_arm fresh case templates; every case is run once in every arm");
         for (const item of bank.cases) {
-            const orderedArms = [...arms].sort((a, b) => rank(preregistration.assignment.seed, item.block, item.id, a).localeCompare(rank(preregistration.assignment.seed, item.block, item.id, b)));
+            const orderedArms = [...arms].sort((a, b) => compareCodeUnits(rank(preregistration.assignment.seed, item.block, item.id, a), rank(preregistration.assignment.seed, item.block, item.id, b)));
             for (const arm of orderedArms) {
                 const treatmentHash = canonicalHash(treatmentFor(preregistration.experiment, arm, item));
                 const id = `expassign_${shortHash(canonicalHash({ preregistration: preregistration.content_hash, bank: bank.content_hash, case_id: item.id, arm, treatment_hash: treatmentHash }))}`;
@@ -287,9 +328,9 @@ export function compileExperimentRun(input, preregistration, bank, opts = {}) {
         for (const item of bank.cases)
             byBlock.set(item.block, [...(byBlock.get(item.block) ?? []), item]);
         let offset = 0;
-        for (const [block, blockCases] of [...byBlock.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-            const ordered = [...blockCases].sort((a, b) => rank(preregistration.assignment.seed, block, a.id).localeCompare(rank(preregistration.assignment.seed, block, b.id)));
-            const armOrder = [...arms].sort((a, b) => rank(preregistration.assignment.seed, block, "arm", a).localeCompare(rank(preregistration.assignment.seed, block, "arm", b)));
+        for (const [block, blockCases] of [...byBlock.entries()].sort(([a], [b]) => compareCodeUnits(a, b))) {
+            const ordered = [...blockCases].sort((a, b) => compareCodeUnits(rank(preregistration.assignment.seed, block, a.id), rank(preregistration.assignment.seed, block, b.id)));
+            const armOrder = [...arms].sort((a, b) => compareCodeUnits(rank(preregistration.assignment.seed, block, "arm", a), rank(preregistration.assignment.seed, block, "arm", b)));
             for (const [index, item] of ordered.entries()) {
                 const arm = armOrder[(offset + index) % armOrder.length];
                 const treatmentHash = canonicalHash(treatmentFor(preregistration.experiment, arm, item));
@@ -302,7 +343,7 @@ export function compileExperimentRun(input, preregistration, bank, opts = {}) {
         if ([...counts.values()].some((count) => count !== input.sample_per_arm))
             throw new Error("EXP-03 blocks cannot be assigned to an exactly balanced arm allocation; adjust block sizes");
     }
-    assignments.sort((a, b) => rank(preregistration.assignment.seed, "execution", a.id).localeCompare(rank(preregistration.assignment.seed, "execution", b.id)));
+    assignments.sort((a, b) => compareCodeUnits(rank(preregistration.assignment.seed, "execution", a.id), rank(preregistration.assignment.seed, "execution", b.id)));
     assignments.forEach((assignment, order) => { assignment.order = order; });
     if (assignments.length > preregistration.sample_plan.maximum_total)
         throw new Error("assignment count exceeds preregistered maximum_total");
@@ -537,6 +578,38 @@ export function compileExperimentReviewStart(run, assignment, reviewer, opts = {
     const contentHash = canonicalHash(body);
     return ExperimentReviewStartSchema.parse({ id: `expreview_${shortHash(contentHash)}`, content_hash: contentHash, ...body });
 }
+export const ExperimentReviewerQualificationSchema = z.object({
+    id: z.string().regex(/^expreviewqual_[a-f0-9]{10}$/),
+    content_hash: z.string().regex(HASH),
+    preregistration_id: z.string().regex(/^expreg_[a-f0-9]{10}$/),
+    preregistration_hash: z.string().regex(HASH),
+    reviewer: z.string().regex(/^human:[^\s]+$/i),
+    protocol: z.literal("exp03-plain-language-comprehension-v2"),
+    cases_hash: z.string().regex(HASH),
+    passed: z.literal(true),
+    reason: z.string().trim().min(1).max(4000),
+    data_class: z.literal("private"),
+    authority: z.literal("none"),
+    recorded_at: z.string().datetime({ offset: true }),
+}).strict();
+export function experimentReviewerQualificationContentHash(record) {
+    const { id: _id, content_hash: _hash, ...body } = record;
+    return canonicalHash(body);
+}
+export function compileExperimentReviewerQualification(input, preregistration, opts = {}) {
+    if (preregistration.experiment !== "EXP-03" || preregistration.revision < 2)
+        throw new Error("plain-language reviewer qualification requires EXP-03 revision 2 or later");
+    if (input.preregistration_id !== preregistration.id || input.preregistration_hash !== preregistration.content_hash)
+        throw new Error("reviewer qualification must bind the exact current preregistration");
+    const body = {
+        ...input,
+        data_class: "private",
+        authority: "none",
+        recorded_at: opts.now ?? new Date().toISOString(),
+    };
+    const contentHash = canonicalHash(body);
+    return ExperimentReviewerQualificationSchema.parse({ id: `expreviewqual_${shortHash(contentHash)}`, content_hash: contentHash, ...body });
+}
 export const ExperimentFollowupSchema = z.object({
     id: z.string().regex(/^expfollow_[a-f0-9]{10}$/),
     content_hash: z.string().regex(HASH),
@@ -943,6 +1016,24 @@ export class ExperimentRepository {
         this.put("experiment-review-starts", parsed.id, parsed);
         return parsed;
     }
+    listReviewerQualifications() {
+        return this.load("experiment-review-qualifications", "expreviewqual_", (raw) => {
+            const parsed = ExperimentReviewerQualificationSchema.parse(raw);
+            if (experimentReviewerQualificationContentHash(parsed) !== parsed.content_hash || parsed.id !== `expreviewqual_${shortHash(parsed.content_hash)}`)
+                throw new Error(`experiment reviewer qualification ${parsed.id} content hash mismatch`);
+            return parsed;
+        }).sort((a, b) => a.id.localeCompare(b.id));
+    }
+    putReviewerQualification(record) {
+        const parsed = ExperimentReviewerQualificationSchema.parse(record);
+        if (experimentReviewerQualificationContentHash(parsed) !== parsed.content_hash || parsed.id !== `expreviewqual_${shortHash(parsed.content_hash)}`)
+            throw new Error(`experiment reviewer qualification ${parsed.id} content hash mismatch`);
+        const incumbent = this.listReviewerQualifications().find((item) => item.preregistration_id === parsed.preregistration_id && item.reviewer === parsed.reviewer);
+        if (incumbent)
+            return incumbent;
+        this.put("experiment-review-qualifications", parsed.id, parsed);
+        return parsed;
+    }
     listFollowups() {
         const records = this.load("experiment-followups", "expfollow_", (raw) => {
             const parsed = ExperimentFollowupSchema.parse(raw);

package/dist/constitution/experimentRunner.js

@@ -1,10 +1,14 @@
 import { execFileSync, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { z } from "zod";
 import { canonicalHash } from "./canonical.js";
+import { hasUnsafeCheckoutAttributes } from "./safeCheckout.js";
+import { hasUnsafeReplayFilter, replayGitArgs, replaySafeEnvironment } from "./replay.js";
+import { replacementFreeExactCommit, replacementFreeGitEnvironment } from "./replacementFreeGit.js";
+import { materializeDependencyTree } from "./g2BehaviorDependencies.js";
 import { Exp01CaseSchema, assignmentTreatment, compileExperimentOutcome, } from "./experiment.js";
 const EvaluatorOutputSchema = z.object({
     valid_completion: z.boolean(),
@@ -167,7 +171,13 @@ function runCommand(spec, cwd) {
     return { stdout: result.stdout ?? "", stderr: result.stderr ?? "", status: result.status, errorCode };
 }
 function git(root, args) {
-    return execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 120_000 }).trim();
+    return execFileSync("git", args, {
+        cwd: root,
+        encoding: "utf8",
+        env: replacementFreeGitEnvironment(),
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 120_000,
+    }).trim();
 }
 function removeAmbientInstructions(cwd) {
     for (const relative of ["AGENTS.md", "CLAUDE.md", ".mcp.json", ".claude", ".codex", ".agents"]) {
@@ -177,15 +187,15 @@ function removeAmbientInstructions(cwd) {
     // file replaces any tracked AGENTS.md after the ambient copy is removed.
     writeFileSync(join(cwd, "AGENTS.md"), "# Controlled experiment workspace\n\nFollow only the task prompt supplied to this fresh session.\n");
 }
-function linkDependencies(source, cwd) {
+function materializeDependencies(source, cwd) {
     const target = join(source, "node_modules");
-    const link = join(cwd, "node_modules");
-    if (!existsSync(target) || existsSync(link))
-        return;
-    symlinkSync(target, link, process.platform === "win32" ? "junction" : "dir");
+    const destination = join(cwd, "node_modules");
+    if (existsSync(target))
+        materializeDependencyTree(target, destination);
+    return destination;
 }
 function countEdits(cwd) {
-    const text = git(cwd, ["diff", "--numstat", "--", "."]);
+    const text = git(cwd, ["diff", "--no-ext-diff", "--no-textconv", "--numstat", "--", "."]);
     if (!text)
         return 0;
     return text.split(/\r?\n/).reduce((sum, line) => {
@@ -237,11 +247,16 @@ export function executeExp01Assignment(repository, run, bank, assignment, opts =
     if (existing)
         return existing;
     const item = Exp01CaseSchema.parse(bank.cases.find((candidate) => candidate.id === assignment.case_id));
-    const sourceHead = git(bank.repository_root, ["rev-parse", bank.base_commit]);
+    const sourceHead = replacementFreeExactCommit(bank.repository_root, bank.base_commit);
     if (sourceHead !== bank.base_commit)
         throw new Error("case bank base_commit is not an exact commit in repository_root");
     const session = mkdtempSync(join(tmpdir(), "hunch-exp01-"));
     const cwd = join(session, "worktree");
+    const hooks = join(session, "hooks-disabled");
+    const gitConfig = join(session, "global.gitconfig");
+    mkdirSync(hooks, { recursive: true });
+    writeFileSync(gitConfig, "");
+    const gitEnv = replaySafeEnvironment(session, gitConfig);
     let added = false;
     let invocationStarted = false;
     try {
@@ -249,9 +264,19 @@ export function executeExp01Assignment(repository, run, bank, assignment, opts =
         if (currentProviderVersion !== run.runner.provider_version) {
             return failureOutcome(repository, run, assignment, "infrastructure_failure", false, "Selected subscription CLI version drifted after assignment; assignment was excluded before model invocation.", "provider-version-drift", { evaluator: canonicalHash({ expected: run.runner.provider_version, actual: currentProviderVersion }) }, opts.now);
         }
-        execFileSync("git", ["worktree", "add", "--detach", cwd, bank.base_commit], { cwd: bank.repository_root, stdio: ["ignore", "pipe", "pipe"], timeout: 120_000 });
+        if (hasUnsafeReplayFilter(bank.repository_root, gitEnv)) {
+            return failureOutcome(repository, run, assignment, "infrastructure_failure", false, "Repository-local Git content filters make the controlled checkout unsafe.", "unsafe-local-filter-config", {}, opts.now);
+        }
+        if (hasUnsafeCheckoutAttributes(bank.repository_root, bank.base_commit, gitEnv, { allowDisabledLfs: true })) {
+            return failureOutcome(repository, run, assignment, "infrastructure_failure", false, "Git checkout attributes could transform or execute content outside the locked case bytes.", "unsafe-checkout-attributes", {}, opts.now);
+        }
+        execFileSync("git", replayGitArgs(bank.repository_root, hooks, ["worktree", "add", "--detach", "--force", cwd, bank.base_commit]), {
+            env: gitEnv,
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 120_000,
+        });
         added = true;
-        linkDependencies(bank.repository_root, cwd);
+        const dependencyRoot = materializeDependencies(bank.repository_root, cwd);
         removeAmbientInstructions(cwd);
         if (item.setup) {
             if (!isAbsolute(item.setup.artifact) || !existsSync(item.setup.artifact) || externalArtifactHash(item.setup.artifact) !== item.setup.artifact_hash) {
@@ -271,9 +296,9 @@ export function executeExp01Assignment(repository, run, bank, assignment, opts =
         }
         const treatment = assignmentTreatment(bank, run, assignment);
         invocationStarted = true;
-        const agent = invokeAgent(run, cwd, controlledPrompt(treatment), opts.timeoutMs ?? 30 * 60 * 1000, join(bank.repository_root, "node_modules"));
+        const agent = invokeAgent(run, cwd, controlledPrompt(treatment), opts.timeoutMs ?? 30 * 60 * 1000, dependencyRoot);
         const outputHash = canonicalHash(agent.stdout);
-        const diff = git(cwd, ["diff", "--binary", "--", "."]);
+        const diff = git(cwd, ["diff", "--no-ext-diff", "--no-textconv", "--binary", "--", "."]);
         const diffHash = canonicalHash(diff);
         if (agent.errorCode) {
             return failureOutcome(repository, run, assignment, "invalid_completion", true, "Subscription CLI did not produce a successful terminal run; outcome remains visible and unscored.", agent.errorCode, { output: outputHash, diff: diffHash }, opts.now);
@@ -333,7 +358,11 @@ export function executeExp01Assignment(repository, run, bank, assignment, opts =
     finally {
         try {
             if (added)
-                execFileSync("git", ["worktree", "remove", "--force", cwd], { cwd: bank.repository_root, stdio: "ignore", timeout: 120_000 });
+                execFileSync("git", replayGitArgs(bank.repository_root, hooks, ["worktree", "remove", "--force", cwd]), {
+                    env: gitEnv,
+                    stdio: "ignore",
+                    timeout: 120_000,
+                });
         }
         catch {
             // The assignment outcome already records any execution failure; prune is best effort.

package/dist/constitution/g2BehaviorCandidates.js

@@ -1,15 +1,17 @@
 import { execFileSync, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { shortHash } from "../core/ids.js";
+import { compareCodeUnits } from "../core/canonicalOrder.js";
 import { loadNativeTreeSitter } from "../extractors/nativeTreeSitter.js";
-import { commitMeta, revExists } from "../extractors/git.js";
 import { canonicalHash } from "./canonical.js";
 import { buildG2CandidateReview, positiveBound, } from "./g2Candidates.js";
 import { cleanupReplayWorktree, hasUnsafeReplayFilter, replayGitArgs, replaySafeEnvironment, } from "./replay.js";
-import { dependencySnapshotForCommit } from "./g2BehaviorDependencies.js";
+import { dependencySnapshotForCommit, materializeDependencySnapshot } from "./g2BehaviorDependencies.js";
+import { hasUnsafeCheckoutAttributes } from "./safeCheckout.js";
+import { replacementFreeCommitFiles, replacementFreeExactCommit, replacementFreeGitEnvironment, } from "./replacementFreeGit.js";
 import { NODE_TEST_REPORTER_SOURCE, exactNodeTestPattern, nodeTestIsolationFlag, nodeTestReporterEvents, } from "./nodeTestEvidence.js";
 const TEST_FILE = /\.(?:test|spec)\.(?:[cm]?[jt]sx?)$/;
 const FULL_SHA = /^[a-f0-9]{40}$/;
@@ -38,6 +40,7 @@ function fileAt(root, commit, file) {
     try {
         return execFileSync("git", ["-C", root, "show", `${commit}:${file}`], {
             encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
             maxBuffer: 10 * 1024 * 1024,
             stdio: ["ignore", "pipe", "ignore"],
         });
@@ -203,8 +206,9 @@ function literalNodeTestCases(file, source) {
 function addedLineNumbers(root, knownBad, knownGood, file) {
     let diff;
     try {
-        diff = execFileSync("git", ["-C", root, "diff", "--unified=0", "--no-ext-diff", knownBad, knownGood, "--", file], {
+        diff = execFileSync("git", ["-C", root, "diff", "--unified=0", "--no-ext-diff", "--no-textconv", knownBad, knownGood, "--", file], {
             encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
             maxBuffer: 10 * 1024 * 1024,
             stdio: ["ignore", "pipe", "ignore"],
         });
@@ -271,13 +275,28 @@ function currentHumanDecision(store, decisionId) {
 }
 function directDecisionCommit(store, root, decisionId) {
     const decision = currentHumanDecision(store, decisionId);
-    const meta = commitMeta(decision.commit, root);
-    if (!meta)
+    const sha = replacementFreeExactCommit(root, decision.commit);
+    if (!sha || !FULL_SHA.test(sha))
         throw new Error(`G2 behavior decision ${decisionId} fixing commit is unavailable`);
+    let subject;
+    let date;
+    try {
+        const raw = execFileSync("git", ["-C", root, "show", "-s", "--format=%s%x00%aI", sha], {
+            encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
+            maxBuffer: 10 * 1024 * 1024,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trimEnd();
+        [subject = "", date = ""] = raw.split("\0");
+    }
+    catch {
+        throw new Error(`G2 behavior decision ${decisionId} fixing commit metadata is unavailable`);
+    }
     let knownBad;
     try {
-        knownBad = execFileSync("git", ["-C", root, "rev-parse", `${meta.sha}^`], {
+        knownBad = execFileSync("git", ["-C", root, "rev-parse", `${sha}^`], {
             encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
     }
@@ -287,10 +306,10 @@ function directDecisionCommit(store, root, decisionId) {
     if (!FULL_SHA.test(knownBad))
         throw new Error(`G2 behavior decision ${decisionId} first parent is invalid`);
     return {
-        commit: meta.sha,
-        subject: meta.subject,
-        date: meta.date,
-        changedFiles: new Set(meta.files),
+        commit: sha,
+        subject,
+        date,
+        changedFiles: new Set(replacementFreeCommitFiles(root, sha)),
         decisionId: decision.id,
         knownBad,
         groundingHash: canonicalHash(decision),
@@ -360,7 +379,7 @@ function directDecisionReview(store, root, opts, behaviorResolutions, since, max
         if (resolution)
             candidate.human_review = resolution;
     }
-    candidates.sort((left, right) => left.test.file.localeCompare(right.test.file) || left.test.name.localeCompare(right.test.name));
+    candidates.sort((left, right) => compareCodeUnits(left.test.file, right.test.file) || compareCodeUnits(left.test.name, right.test.name));
     const items = candidates.slice(0, limit);
     const reviewCounts = candidates.some((candidate) => candidate.human_review !== undefined) ? {
         selected_candidates: candidates.filter((candidate) => candidate.human_review?.disposition === "selected").length,
@@ -425,9 +444,9 @@ export function buildG2BehaviorCandidateReview(store, root, opts = {}, resolutio
     const candidates = [];
     const failures = [];
     const withoutTests = [];
-    for (const commit of [...commits.values()].sort((left, right) => left.commit.localeCompare(right.commit))) {
+    for (const commit of [...commits.values()].sort((left, right) => compareCodeUnits(left.commit, right.commit))) {
         let found = false;
-        for (const file of [...commit.changedFiles].filter(safeTestFile).sort()) {
+        for (const file of [...commit.changedFiles].filter(safeTestFile).sort(compareCodeUnits)) {
             const after = fileAt(root, commit.commit, file);
             if (after == null) {
                 failures.push({ commit: commit.commit, file, error: "known-good test source unavailable" });
@@ -447,9 +466,9 @@ export function buildG2BehaviorCandidateReview(store, root, opts = {}, resolutio
                     statement: name,
                     test: { file, name, source_hash: sourceHash },
                     runner: runnerFor(file, name),
-                    decision_ids: [...commit.decisionIds].sort(),
-                    source_candidate_ids: [...commit.sourceCandidateIds].sort(),
-                    source_attestation_ids: [...commit.sourceAttestationIds].sort(),
+                    decision_ids: [...commit.decisionIds].sort(compareCodeUnits),
+                    source_candidate_ids: [...commit.sourceCandidateIds].sort(compareCodeUnits),
+                    source_attestation_ids: [...commit.sourceAttestationIds].sort(compareCodeUnits),
                     proposed_corpus: {
                         known_bad: { ref: commit.knownBad, expected: "failed" },
                         known_good: { ref: commit.commit, expected: "passed" },
@@ -471,10 +490,10 @@ export function buildG2BehaviorCandidateReview(store, root, opts = {}, resolutio
         if (resolution)
             candidate.human_review = resolution;
     }
-    candidates.sort((left, right) => right.commit_date.localeCompare(left.commit_date)
-        || left.commit.localeCompare(right.commit)
-        || left.test.file.localeCompare(right.test.file)
-        || left.test.name.localeCompare(right.test.name));
+    candidates.sort((left, right) => compareCodeUnits(right.commit_date, left.commit_date)
+        || compareCodeUnits(left.commit, right.commit)
+        || compareCodeUnits(left.test.file, right.test.file)
+        || compareCodeUnits(left.test.name, right.test.name));
     const items = candidates.slice(0, limit);
     const reviewCounts = candidates.some((candidate) => candidate.human_review !== undefined) ? {
         selected_candidates: candidates.filter((candidate) => candidate.human_review?.disposition === "selected").length,
@@ -490,8 +509,8 @@ export function buildG2BehaviorCandidateReview(store, root, opts = {}, resolutio
         candidate_commits: commits.size,
         behavior_candidates: candidates.length,
         ...reviewCounts,
-        commits_without_added_tests: withoutTests.sort(),
-        extraction_failures: failures.sort((left, right) => left.commit.localeCompare(right.commit) || left.file.localeCompare(right.file)),
+        commits_without_added_tests: withoutTests.sort(compareCodeUnits),
+        extraction_failures: failures.sort((left, right) => compareCodeUnits(left.commit, right.commit) || compareCodeUnits(left.file, right.file)),
         items,
         has_more: candidates.length > items.length,
         limitations: LIMITATIONS,
@@ -523,12 +542,16 @@ export function nodeTestInfrastructureError(output) {
     return null;
 }
 function runLeg(root, session, hooks, env, candidate, commit, expected, source, budgetMs) {
-    if (!FULL_SHA.test(commit) || !revExists(commit, root))
+    if (!FULL_SHA.test(commit) || replacementFreeExactCommit(root, commit) !== commit)
         return errorLeg(commit, expected, "commit-ref-unresolved");
     const run = mkdtempSync(join(session, `${expected}-`));
     const checkout = join(run, "checkout");
     const dependencySnapshot = dependencySnapshotForCommit(root, commit);
     const dependencySnapshotId = dependencySnapshot?.snapshot.id;
+    if (hasUnsafeCheckoutAttributes(root, commit, env, { allowDisabledLfs: true })) {
+        rmSync(run, { recursive: true, force: true });
+        return errorLeg(commit, expected, "unsafe-checkout-attributes", dependencySnapshotId);
+    }
     let added = false;
     let leg;
     try {
@@ -539,7 +562,7 @@ function runLeg(root, session, hooks, env, candidate, commit, expected, source,
         });
         added = true;
         if (dependencySnapshot) {
-            symlinkSync(dependencySnapshot.nodeModules, join(checkout, "node_modules"), process.platform === "win32" ? "junction" : "dir");
+            materializeDependencySnapshot(dependencySnapshot, join(checkout, "node_modules"));
         }
         const testFile = join(checkout, candidate.test.file);
         mkdirSync(dirname(testFile), { recursive: true });
@@ -565,7 +588,7 @@ function runLeg(root, session, hooks, env, candidate, commit, expected, source,
             args = testArgs;
         }
         else {
-            const tsx = dependencySnapshot ? join(dependencySnapshot.nodeModules, "tsx", "dist", "cli.mjs") : "";
+            const tsx = dependencySnapshot ? join(checkout, "node_modules", "tsx", "dist", "cli.mjs") : "";
             args = existsSync(tsx) ? [tsx, ...testArgs] : null;
         }
         if (!args) {