@davesheffer/hunch 1.7.0 → 1.7.1

package/dist/constitution/behaviorEvaluator.js

@@ -0,0 +1,220 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { headSha, revExists } from "../extractors/git.js";
+import { canonicalHash } from "./canonical.js";
+import { nodeTestInfrastructureError } from "./g2BehaviorCandidates.js";
+import { dependencySnapshotForCommit } from "./g2BehaviorDependencies.js";
+import { cleanupReplayWorktree, hasUnsafeReplayFilter, replayGitArgs } from "./replay.js";
+import { BEHAVIOR_POLICY_EVALUATOR, PolicyEvaluationSchema, } from "./schema.js";
+import { NODE_TEST_REPORTER_SOURCE, exactNodeTestPattern, nodeTestIsolationFlag, nodeTestReporterEvents, } from "./nodeTestEvidence.js";
+import { applyBehaviorWorkspace, BehaviorWorkspaceError, captureBehaviorWorkspace, } from "./behaviorWorkspace.js";
+function behaviorEnvironment(home, gitConfig) {
+    const env = {};
+    for (const key of ["PATH", "SystemRoot", "WINDIR", "TMPDIR", "TMP", "TEMP"]) {
+        if (process.env[key])
+            env[key] = process.env[key];
+    }
+    return {
+        ...env,
+        HOME: home,
+        GIT_CONFIG_GLOBAL: gitConfig,
+        GIT_CONFIG_NOSYSTEM: "1",
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_LFS_SKIP_SMUDGE: "1",
+        HUNCH_PRIVATE_DIR: "",
+        HUNCH_SYNTH_PROVIDER: "deterministic",
+        CI: "1",
+        NO_COLOR: "1",
+        FORCE_COLOR: "0",
+    };
+}
+function sourceAt(root, commit, file) {
+    try {
+        return execFileSync("git", ["-C", root, "show", `${commit}:${file}`], {
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function evaluation(policy, commit, execution, result, explanation) {
+    const executionHash = canonicalHash(execution);
+    const behavior = { ...execution, execution_hash: executionHash };
+    const repository = behavior.workspace
+        ? { base: commit, head: `${behavior.workspace.kind}:${behavior.workspace.snapshot_hash}`, graph_hash: executionHash }
+        : { head: commit, graph_hash: executionHash };
+    const body = {
+        policy_id: policy.id,
+        policy_revision: policy.revision,
+        result,
+        evaluator: { ...BEHAVIOR_POLICY_EVALUATOR },
+        repository,
+        matches: [{ file: behavior.test.file, symbol: behavior.test.name }],
+        explanation,
+        evidence_refs: [...policy.evidence],
+        behavior,
+    };
+    return PolicyEvaluationSchema.parse({ ...body, deterministic_hash: canonicalHash(body) });
+}
+export function evaluateExecutableBehaviorPolicy(root, policy, opts = {}) {
+    if (policy.assertion.kind !== "executable-behavior") {
+        throw new Error(`policy ${policy.id} is not an executable-behavior policy`);
+    }
+    const assertion = policy.assertion;
+    if (opts.commit && opts.workspace)
+        throw new Error("executable behavior evaluation accepts either a commit or a workspace snapshot, not both");
+    const commit = opts.commit ?? headSha(root);
+    const selectedName = opts.selectedName ?? assertion.test.name;
+    let workspace;
+    if (opts.workspace && /^[a-f0-9]{40}$/.test(commit)) {
+        const probe = mkdtempSync(join(tmpdir(), "hunch-behavior-workspace-probe-"));
+        const env = behaviorEnvironment(probe, join(probe, "global.gitconfig"));
+        try {
+            writeFileSync(join(probe, "global.gitconfig"), "");
+            workspace = captureBehaviorWorkspace(root, commit, opts.workspace, env);
+        }
+        catch (error) {
+            const code = error instanceof BehaviorWorkspaceError ? error.code : "workspace-snapshot-failed";
+            const failed = {
+                commit,
+                test: { file: assertion.test.file, name: selectedName, source_hash: assertion.test.source_hash },
+                runner: assertion.runner,
+                exit_code: null,
+                selected_event: null,
+                error_code: code,
+            };
+            return evaluation(policy, commit, failed, "error", `executable behavior ${opts.workspace} workspace snapshot failed (${code})`);
+        }
+        finally {
+            rmSync(probe, { recursive: true, force: true });
+        }
+    }
+    const baseExecution = {
+        commit: /^[a-f0-9]{40}$/.test(commit) ? commit : "0".repeat(40),
+        ...(workspace ? { workspace: workspace.metadata } : {}),
+        test: { file: assertion.test.file, name: selectedName, source_hash: assertion.test.source_hash },
+        runner: assertion.runner,
+        exit_code: null,
+        selected_event: null,
+    };
+    if (!/^[a-f0-9]{40}$/.test(commit) || !revExists(commit, root)) {
+        return evaluation(policy, baseExecution.commit, { ...baseExecution, error_code: "commit-ref-unresolved" }, "error", "executable behavior commit does not resolve");
+    }
+    const source = sourceAt(root, assertion.test.source_commit, assertion.test.file);
+    if (source == null || canonicalHash(source) !== assertion.test.source_hash) {
+        return evaluation(policy, commit, { ...baseExecution, commit, error_code: "test-source-hash-mismatch" }, "error", "pinned behavior test source does not match its exact commit/hash binding");
+    }
+    if (workspace?.metadata.files.some((file) => file === "package.json" || file === "package-lock.json")) {
+        return evaluation(policy, commit, { ...baseExecution, commit, error_code: "workspace-dependency-input-changed" }, "error", "workspace dependency inputs changed; provision an exact dependency snapshot after commit");
+    }
+    const dependency = dependencySnapshotForCommit(root, commit, assertion.dependency_snapshot_ids);
+    if (!dependency) {
+        return evaluation(policy, commit, { ...baseExecution, commit, error_code: "dependency-snapshot-unavailable" }, "error", "no unique exact dependency snapshot is available for executable behavior evaluation");
+    }
+    const session = mkdtempSync(join(tmpdir(), "hunch-behavior-policy-"));
+    const hooks = join(session, "hooks-disabled");
+    const gitConfig = join(session, "global.gitconfig");
+    const checkout = join(session, "checkout");
+    const reporter = join(session, "reporter.mjs");
+    mkdirSync(hooks, { recursive: true });
+    writeFileSync(gitConfig, "");
+    writeFileSync(reporter, NODE_TEST_REPORTER_SOURCE);
+    const env = behaviorEnvironment(session, gitConfig);
+    let added = false;
+    let result;
+    try {
+        if (hasUnsafeReplayFilter(root, env)) {
+            result = evaluation(policy, commit, { ...baseExecution, commit, dependency_snapshot_id: dependency.snapshot.id, error_code: "unsafe-local-filter-config" }, "error", "repository has an unsafe local Git content filter");
+        }
+        else {
+            execFileSync("git", replayGitArgs(root, hooks, ["worktree", "add", "--detach", "--force", checkout, commit]), {
+                env,
+                timeout: assertion.timeout_ms,
+                stdio: "ignore",
+            });
+            added = true;
+            if (workspace)
+                applyBehaviorWorkspace(root, checkout, workspace, env);
+            symlinkSync(dependency.nodeModules, join(checkout, "node_modules"), process.platform === "win32" ? "junction" : "dir");
+            const testFile = join(checkout, assertion.test.file);
+            mkdirSync(dirname(testFile), { recursive: true });
+            writeFileSync(testFile, source);
+            const common = [
+                "--test",
+                nodeTestIsolationFlag(),
+                `--test-name-pattern=${exactNodeTestPattern(selectedName)}`,
+                `--test-reporter=${pathToFileURL(reporter).href}`,
+                "--test-reporter-destination=stdout",
+                assertion.test.file,
+            ];
+            const args = assertion.runner === "node-test"
+                ? common
+                : [join(dependency.nodeModules, "tsx", "dist", "cli.mjs"), ...common];
+            const run = spawnSync(process.execPath, args, {
+                cwd: checkout,
+                env,
+                encoding: "utf8",
+                timeout: assertion.timeout_ms,
+                maxBuffer: 2 * 1024 * 1024,
+                stdio: ["ignore", "pipe", "pipe"],
+                shell: false,
+            });
+            const output = `${run.stdout ?? ""}\n${run.stderr ?? ""}`;
+            const matches = nodeTestReporterEvents(run.stdout ?? "")
+                .filter((event) => event.name === selectedName && !event.skip && !event.todo);
+            const exitCode = run.status ?? null;
+            const execution = {
+                ...baseExecution,
+                commit,
+                dependency_snapshot_id: dependency.snapshot.id,
+                exit_code: exitCode,
+                selected_event: matches.length === 1 ? (matches[0].type === "test:pass" ? "passed" : "failed") : null,
+            };
+            if (run.error) {
+                const code = run.error.code === "ETIMEDOUT" ? "timeout" : "runner-failed";
+                result = evaluation(policy, commit, { ...execution, error_code: code }, "error", `executable behavior runner ${code}`);
+            }
+            else if (run.signal) {
+                result = evaluation(policy, commit, { ...execution, error_code: "runner-signaled" }, "error", `executable behavior runner exited by ${run.signal}`);
+            }
+            else if (matches.length === 0) {
+                const infrastructure = nodeTestInfrastructureError(output) ?? "selected-test-not-executed";
+                result = evaluation(policy, commit, { ...execution, error_code: infrastructure }, "error", `exact selected test produced no executed pass/fail event (${infrastructure})`);
+            }
+            else if (matches.length > 1) {
+                result = evaluation(policy, commit, { ...execution, error_code: "selected-test-ambiguous" }, "error", "exact selected test name produced multiple executed events");
+            }
+            else if (matches[0].type === "test:pass" && exitCode === 0) {
+                result = evaluation(policy, commit, execution, "satisfied", `exact selected executable behavior test passed${opts.workspace ? ` in ${opts.workspace} workspace snapshot` : ""}`);
+            }
+            else if (matches[0].type === "test:fail" && exitCode !== 0) {
+                result = evaluation(policy, commit, execution, "violated", `exact selected executable behavior test failed${opts.workspace ? ` in ${opts.workspace} workspace snapshot` : ""}`);
+            }
+            else {
+                result = evaluation(policy, commit, { ...execution, error_code: "runner-outcome-inconsistent" }, "error", "selected test event and runner exit code disagree");
+            }
+        }
+    }
+    catch (error) {
+        const code = error instanceof BehaviorWorkspaceError
+            ? error.code
+            : error.code === "ETIMEDOUT" ? "timeout" : added ? "runner-setup-failed" : "worktree-create-failed";
+        result = evaluation(policy, commit, { ...baseExecution, commit, dependency_snapshot_id: dependency.snapshot.id, error_code: code }, "error", `executable behavior evaluation failed during isolated setup (${code})`);
+    }
+    finally {
+        if (added && cleanupReplayWorktree(root, hooks, env, session, checkout)) {
+            result = evaluation(policy, commit, { ...baseExecution, commit, dependency_snapshot_id: dependency.snapshot.id, error_code: "worktree-cleanup-failed" }, "error", "executable behavior worktree cleanup failed");
+        }
+        else if (!added) {
+            rmSync(session, { recursive: true, force: true });
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=behaviorEvaluator.js.map

package/dist/constitution/behaviorProof.js

@@ -0,0 +1,205 @@
+import { basename } from "node:path";
+import { shortHash } from "../core/ids.js";
+import { headSha } from "../extractors/git.js";
+import { evaluateExecutableBehaviorPolicy } from "./behaviorEvaluator.js";
+import { canonicalHash, policySemanticHash, proofEvaluationHash, proofId, proofPlanContentHash } from "./canonical.js";
+import { BEHAVIOR_MUTATION_ENGINE, BEHAVIOR_POLICY_EVALUATOR, MutationReceiptSchema, PolicyProofSchema, ProofPlanSchema, ReplayReceiptSchema, } from "./schema.js";
+function summary(evaluations) {
+    const count = (result) => evaluations.filter((evaluation) => evaluation.result === result).length;
+    return {
+        total: evaluations.length,
+        satisfied: count("satisfied"),
+        violated: count("violated"),
+        not_applicable: count("not_applicable"),
+        unknown: count("unknown"),
+        error: count("error"),
+        receipt_hashes: evaluations.map(proofEvaluationHash),
+    };
+}
+function replayReceipt(leg, policyHash, expected, evaluation) {
+    const body = {
+        leg,
+        commit: evaluation.behavior.commit,
+        expected,
+        policy_hash: policyHash,
+        evaluator: { ...BEHAVIOR_POLICY_EVALUATOR },
+        result: evaluation.result,
+        graph_hash: evaluation.behavior.execution_hash,
+        evaluation_hash: proofEvaluationHash(evaluation),
+        ...(evaluation.behavior.error_code ? { error_code: evaluation.behavior.error_code } : {}),
+        behavior: evaluation.behavior,
+    };
+    return ReplayReceiptSchema.parse({ ...body, deterministic_hash: canonicalHash(body) });
+}
+function mutationReceipt(policyHash, planned, kind, evaluation, passed) {
+    const seed = {
+        engine: BEHAVIOR_MUTATION_ENGINE,
+        policy_hash: policyHash,
+        base_commit: evaluation.behavior.commit,
+        base_graph_hash: evaluation.behavior.execution_hash,
+        kind,
+        operator: planned.operator,
+    };
+    const body = {
+        id: `mut_${shortHash(canonicalHash(seed))}`,
+        kind,
+        operator: planned.operator,
+        required: planned.required,
+        engine: { ...BEHAVIOR_MUTATION_ENGINE },
+        policy_hash: policyHash,
+        base_commit: evaluation.behavior.commit,
+        base_graph_hash: evaluation.behavior.execution_hash,
+        mutated_graph_hash: evaluation.behavior.execution_hash,
+        expected: planned.expected,
+        result: evaluation.result,
+        passed,
+        parseability: "not_applicable",
+        graph_diff: { added_symbols: [], removed_symbols: [], added_edges: [], removed_edges: [] },
+        evaluation_hash: proofEvaluationHash(evaluation),
+        ...(evaluation.behavior.error_code ? { error_code: evaluation.behavior.error_code } : {}),
+        behavior: evaluation.behavior,
+    };
+    return MutationReceiptSchema.parse({ ...body, deterministic_hash: canonicalHash(body) });
+}
+export function createExecutableBehaviorProofPlan(root, repository, policy, opts = {}) {
+    if (policy.assertion.kind !== "executable-behavior")
+        throw new Error(`policy ${policy.id} is not executable behavior`);
+    if (policy.data_class === "public")
+        throw new Error("executable-behavior policy materialization requires private storage");
+    const head = headSha(root);
+    if (!/^[a-f0-9]{40}$/.test(head))
+        throw new Error("executable behavior proof planning requires a current full-SHA HEAD");
+    const corpus = repository.getCorpus(policy.id, { privateOnly: opts.privateOnly ?? true });
+    if (!corpus || corpus.known_bad.length !== 1 || corpus.known_good.length !== 1) {
+        throw new Error("executable behavior proof requires exactly one imported known-bad and one known-good commit");
+    }
+    const policyHash = policySemanticHash(policy);
+    if (corpus.policy_hash !== policyHash)
+        throw new Error(`behavior corpus ${corpus.id} is stale for policy ${policy.id}`);
+    const bad = corpus.known_bad[0];
+    const good = corpus.known_good[0];
+    const body = {
+        policy_id: policy.id,
+        policy_candidate_hash: policyHash,
+        repository: basename(root),
+        data_class: policy.data_class,
+        source_commit: policy.assertion.test.source_commit,
+        valid_from_commit: policy.assertion.test.source_commit,
+        evaluator: { ...BEHAVIOR_POLICY_EVALUATOR },
+        mutation_engine: { ...BEHAVIOR_MUTATION_ENGINE },
+        corpus_manifest: { id: corpus.id, content_hash: corpus.content_hash },
+        corpus: {
+            current_baseline: { kind: "commit", ref: head, label: "current committed executable behavior baseline", expected: "satisfied" },
+            accepted_history: { from: head, to: head, first_parent: true, max_commits: 0, exclude: [bad.ref, good.ref].sort() },
+            known_bad: [bad],
+            known_good: [good],
+        },
+        mutations: [
+            { operator: "known-bad-regression", base: bad.ref, expected: "violated", required: true },
+            { operator: "selected-test-execution-control", base: good.ref, expected: "error", required: true },
+        ],
+        budgets: { max_commits: 0, max_mutations: 2, max_minutes: 5 },
+        expected: [
+            { leg: "current_baseline", result: "satisfied", classification_required: false },
+            { leg: "known_bad", result: "violated", classification_required: false },
+            { leg: "known_good", result: "satisfied", classification_required: false },
+            { leg: "mutations", result: "violated", classification_required: false },
+        ],
+        evidence_refs: [...policy.evidence].sort(),
+        limitations: [
+            "Executable behavior proof runs only a hash-pinned node:test case through an allowlisted runner in disposable committed worktrees.",
+            "The proof baseline is committed HEAD; advisory delivery may separately evaluate a content-addressed staged or working snapshot.",
+            "Known-bad replay is the primary historical regression mutation; a missing-name control proves that zero executed tests cannot satisfy the evaluator.",
+            "Repository test code executes as evidence but grants no authority; policy activation remains a separate explicit human action.",
+        ],
+    };
+    const contentHash = canonicalHash(body);
+    return ProofPlanSchema.parse({
+        id: `plan_${shortHash(contentHash)}`,
+        content_hash: contentHash,
+        ...body,
+        created_at: opts.now ?? new Date().toISOString(),
+    });
+}
+export function proveExecutableBehaviorPolicy(root, policy, plan, opts = {}) {
+    if (policy.assertion.kind !== "executable-behavior")
+        throw new Error(`policy ${policy.id} is not executable behavior`);
+    if (plan.content_hash !== proofPlanContentHash(plan))
+        throw new Error(`proof plan ${plan.id} content hash mismatch`);
+    const policyHash = policySemanticHash(policy);
+    if (plan.policy_id !== policy.id || plan.policy_candidate_hash !== policyHash)
+        throw new Error(`proof plan ${plan.id} does not match behavior policy semantics`);
+    if (plan.evaluator.name !== BEHAVIOR_POLICY_EVALUATOR.name || plan.evaluator.version !== BEHAVIOR_POLICY_EVALUATOR.version)
+        throw new Error(`proof plan ${plan.id} behavior evaluator is stale`);
+    if (plan.mutation_engine?.name !== BEHAVIOR_MUTATION_ENGINE.name || plan.mutation_engine.version !== BEHAVIOR_MUTATION_ENGINE.version)
+        throw new Error(`proof plan ${plan.id} behavior mutation engine is stale`);
+    const primaryPlan = plan.mutations.find((mutation) => mutation.operator === "known-bad-regression");
+    const controlPlan = plan.mutations.find((mutation) => mutation.operator === "selected-test-execution-control");
+    if (!primaryPlan || !controlPlan)
+        throw new Error("executable behavior proof plan lacks required mutation/control operators");
+    const current = evaluateExecutableBehaviorPolicy(root, policy, { commit: plan.corpus.current_baseline.ref });
+    const knownBad = plan.corpus.known_bad.map((fixture) => evaluateExecutableBehaviorPolicy(root, policy, { commit: fixture.ref }));
+    const knownGood = plan.corpus.known_good.map((fixture) => evaluateExecutableBehaviorPolicy(root, policy, { commit: fixture.ref }));
+    const controlName = `__hunch_missing_${shortHash(policyHash)}`;
+    const control = evaluateExecutableBehaviorPolicy(root, policy, { commit: controlPlan.base, selectedName: controlName });
+    const replayReceipts = [
+        replayReceipt("current_baseline", policyHash, "satisfied", current),
+        ...knownBad.map((evaluation) => replayReceipt("known_bad", policyHash, "violated", evaluation)),
+        ...knownGood.map((evaluation) => replayReceipt("known_good", policyHash, "satisfied", evaluation)),
+    ];
+    const primaryEvaluation = knownBad.find((evaluation) => evaluation.behavior?.commit === primaryPlan.base) ?? knownBad[0];
+    const primaryReceipt = mutationReceipt(policyHash, primaryPlan, "primary", primaryEvaluation, primaryEvaluation.result === primaryPlan.expected);
+    const controlPassed = control.result === "error" && control.behavior?.error_code === "selected-test-not-executed";
+    const controlReceipt = mutationReceipt(policyHash, controlPlan, "control", control, controlPassed);
+    const mutationReceipts = [primaryReceipt, controlReceipt];
+    const currentSummary = summary([current]);
+    const badSummary = summary(knownBad);
+    const goodSummary = summary(knownGood);
+    const baselineSatisfied = currentSummary.satisfied === 1 && currentSummary.error === 0 && currentSummary.unknown === 0;
+    const exactBad = badSummary.total > 0 && badSummary.violated === badSummary.total;
+    const exactGood = goodSummary.total > 0 && goodSummary.satisfied === goodSummary.total;
+    const controlsPassed = mutationReceipts.every((receipt) => receipt.passed);
+    const proofClass = baselineSatisfied && exactBad && exactGood && controlsPassed ? "P3" : baselineSatisfied ? "P1" : "P0";
+    const generatedAt = opts.now ?? new Date().toISOString();
+    const id = proofId({ policy_hash: policyHash, plan_hash: plan.content_hash, evaluator: BEHAVIOR_POLICY_EVALUATOR });
+    return PolicyProofSchema.parse({
+        id,
+        plan_hash: plan.content_hash,
+        policy_hash: policyHash,
+        evaluator: { ...BEHAVIOR_POLICY_EVALUATOR },
+        mutation_engine: { ...BEHAVIOR_MUTATION_ENGINE },
+        generated_at: generatedAt,
+        current: currentSummary,
+        known_bad: badSummary,
+        known_good: goodSummary,
+        accepted_history: { ...summary([]), classified_hits: [] },
+        mutations: { ...summary([primaryEvaluation]), operator_coverage: { [primaryReceipt.operator]: primaryReceipt.passed ? 1 : 0 } },
+        replay_receipts: replayReceipts,
+        mutation_receipts: mutationReceipts,
+        mutation_controls: {
+            total: 1,
+            passed: controlReceipt.passed ? 1 : 0,
+            failed: controlReceipt.passed ? 0 : 1,
+            receipt_hashes: [controlReceipt.deterministic_hash],
+        },
+        project_checks: {
+            build: "not_run",
+            test: baselineSatisfied && exactBad && exactGood ? "passed" : "failed",
+            required_for_evaluator_sensitivity: true,
+        },
+        limitations: [...plan.limitations],
+        proof_class: proofClass,
+        artifact_hashes: {
+            policy: policyHash,
+            plan: plan.content_hash,
+            attestation: policy.assertion.attestation.content_hash,
+            replay: policy.assertion.attestation.replay_hash,
+            test_source: policy.assertion.test.source_hash,
+            replay_manifest: canonicalHash(replayReceipts),
+            mutation_manifest: canonicalHash(mutationReceipts),
+            current_receipt: replayReceipts[0].deterministic_hash,
+        },
+        data_class: policy.data_class,
+    });
+}
+//# sourceMappingURL=behaviorProof.js.map

package/dist/constitution/behaviorWorkspace.js

@@ -0,0 +1,124 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { chmodSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { canonicalHash } from "./canonical.js";
+export class BehaviorWorkspaceError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const MAX_PATCH_BYTES = 8 * 1024 * 1024;
+const MAX_UNTRACKED_FILES = 1_000;
+const MAX_UNTRACKED_BYTES = 8 * 1024 * 1024;
+const WORKSPACE_PATHS = [".", ":(exclude).hunch/**", ":(exclude).hunch-cache/**"];
+function bufferSha1(value) {
+    return `sha1:${createHash("sha1").update(value).digest("hex")}`;
+}
+function git(root, args, env, maxBuffer = MAX_PATCH_BYTES) {
+    const run = spawnSync("git", ["-C", root, ...args], {
+        env,
+        encoding: "buffer",
+        maxBuffer,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+    });
+    if (run.error) {
+        const code = run.error.code === "ENOBUFS" ? "workspace-snapshot-too-large" : "workspace-git-failed";
+        throw new BehaviorWorkspaceError(code, `workspace Git command failed: ${args[0]}`);
+    }
+    if (run.status !== 0)
+        throw new BehaviorWorkspaceError("workspace-git-failed", `workspace Git command exited ${run.status}: ${args[0]}`);
+    return run.stdout ?? Buffer.alloc(0);
+}
+function safeRelative(root, file) {
+    if (!file || file.includes("\0") || file.includes("\\") || isAbsolute(file)) {
+        throw new BehaviorWorkspaceError("workspace-path-unsafe", "workspace contains an unsafe path");
+    }
+    const parts = file.split("/");
+    if (parts.some((part) => !part || part === "." || part === "..")) {
+        throw new BehaviorWorkspaceError("workspace-path-unsafe", "workspace contains an unsafe path");
+    }
+    const absolute = resolve(root, file);
+    const fromRoot = relative(root, absolute);
+    if (!fromRoot || fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
+        throw new BehaviorWorkspaceError("workspace-path-unsafe", "workspace path escapes the repository");
+    }
+    return file;
+}
+function nulList(buffer) {
+    return buffer.toString("utf8").split("\0").filter(Boolean);
+}
+export function captureBehaviorWorkspace(root, baseCommit, kind, env) {
+    const diffArgs = ["diff", "--binary", "--full-index", "--no-color", "--no-ext-diff", "--no-textconv"];
+    if (kind === "staged")
+        diffArgs.push("--cached");
+    diffArgs.push(baseCommit, "--", ...WORKSPACE_PATHS);
+    const patch = git(root, diffArgs, env);
+    const changedArgs = ["diff", "--name-only", "-z", "--diff-filter=ACMRD"];
+    if (kind === "staged")
+        changedArgs.push("--cached");
+    changedArgs.push(baseCommit, "--", ...WORKSPACE_PATHS);
+    const changed = nulList(git(root, changedArgs, env)).map((file) => safeRelative(root, file));
+    const untrackedNames = kind === "working"
+        ? nulList(git(root, ["ls-files", "-z", "--others", "--exclude-standard", "--", ...WORKSPACE_PATHS], env))
+        : [];
+    if (untrackedNames.length > MAX_UNTRACKED_FILES) {
+        throw new BehaviorWorkspaceError("workspace-snapshot-too-large", `workspace has more than ${MAX_UNTRACKED_FILES} untracked files`);
+    }
+    let untrackedBytes = 0;
+    const untracked = untrackedNames.map((raw) => {
+        const file = safeRelative(root, raw);
+        const absolute = resolve(root, file);
+        const stat = lstatSync(absolute);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            throw new BehaviorWorkspaceError("workspace-file-unsupported", `workspace untracked path is not a regular file: ${file}`);
+        }
+        untrackedBytes += stat.size;
+        if (untrackedBytes > MAX_UNTRACKED_BYTES) {
+            throw new BehaviorWorkspaceError("workspace-snapshot-too-large", "workspace untracked content exceeds the 8 MiB limit");
+        }
+        const content = readFileSync(absolute);
+        return { file, content_hash: bufferSha1(content), mode: stat.mode & 0o777, content };
+    });
+    const files = [...new Set([...changed, ...untracked.map((entry) => entry.file)])].sort();
+    if (files.length > 10_000) {
+        throw new BehaviorWorkspaceError("workspace-snapshot-too-large", "workspace has more than 10000 changed files");
+    }
+    const snapshotHash = canonicalHash({
+        kind,
+        base_commit: baseCommit,
+        patch_hash: bufferSha1(patch),
+        untracked: untracked.map(({ content: _content, ...entry }) => entry),
+    });
+    return {
+        metadata: { kind, base_commit: baseCommit, snapshot_hash: snapshotHash, files },
+        patch,
+        untracked,
+    };
+}
+export function applyBehaviorWorkspace(root, checkout, snapshot, env) {
+    if (snapshot.patch.length) {
+        const apply = spawnSync("git", ["-C", checkout, "apply", "--binary", "--whitespace=nowarn"], {
+            env,
+            input: snapshot.patch,
+            encoding: "buffer",
+            maxBuffer: MAX_PATCH_BYTES,
+            stdio: ["pipe", "pipe", "pipe"],
+            shell: false,
+        });
+        if (apply.error || apply.status !== 0) {
+            throw new BehaviorWorkspaceError("workspace-patch-apply-failed", "workspace patch could not be applied to the disposable checkout");
+        }
+    }
+    for (const entry of snapshot.untracked) {
+        const file = safeRelative(root, entry.file);
+        const destination = resolve(checkout, file);
+        mkdirSync(dirname(destination), { recursive: true });
+        writeFileSync(destination, entry.content);
+        chmodSync(destination, entry.mode);
+    }
+}
+//# sourceMappingURL=behaviorWorkspace.js.map