@davesheffer/hunch 1.6.0 → 1.7.1

package/dist/constitution/g2BehaviorDependencies.js

@@ -0,0 +1,379 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { basename, join } from "node:path";
+import { shortHash } from "../core/ids.js";
+import { canonicalHash, canonicalJson } from "./canonical.js";
+import { replaySafeEnvironment } from "./replay.js";
+const FULL_SHA = /^[a-f0-9]{40}$/;
+const PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/i;
+const SNAPSHOT_VERSION = 1;
+function sha256(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function gitFile(root, commit, file) {
+    if (!FULL_SHA.test(commit))
+        throw new Error(`dependency snapshot commit ${commit} is not a full SHA`);
+    try {
+        return execFileSync("git", ["-C", root, "show", `${commit}:${file}`], {
+            encoding: "utf8",
+            maxBuffer: 20 * 1024 * 1024,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch {
+        throw new Error(`dependency snapshot requires ${file} at ${commit}`);
+    }
+}
+function parseObject(raw, label) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`dependency snapshot ${label} is not valid JSON`);
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`dependency snapshot ${label} must be a JSON object`);
+    return value;
+}
+function dependencyProjection(pkg) {
+    return {
+        dependencies: pkg.dependencies ?? {},
+        devDependencies: pkg.devDependencies ?? {},
+        optionalDependencies: pkg.optionalDependencies ?? {},
+        peerDependencies: pkg.peerDependencies ?? {},
+        peerDependenciesMeta: pkg.peerDependenciesMeta ?? {},
+        engines: pkg.engines ?? {},
+    };
+}
+function lockedPackageNames(lock) {
+    const names = new Set();
+    const packages = lock.packages;
+    if (!packages || typeof packages !== "object" || Array.isArray(packages))
+        return names;
+    for (const key of Object.keys(packages)) {
+        if (!key.startsWith("node_modules/"))
+            continue;
+        const name = key.slice("node_modules/".length);
+        if (name && !name.includes("/node_modules/"))
+            names.add(name);
+    }
+    return names;
+}
+function normalizeAllowlist(values, lock) {
+    const result = [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort();
+    const locked = lockedPackageNames(lock);
+    for (const name of result) {
+        if (!PACKAGE_NAME.test(name))
+            throw new Error(`invalid dependency install-script package ${JSON.stringify(name)}`);
+        if (!locked.has(name))
+            throw new Error(`dependency install-script package ${name} is absent from the exact lockfile`);
+    }
+    return result;
+}
+function npmExecutable() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+// npm on Windows is a .cmd shim, which Node's CVE-2024-27980 hardening refuses
+// to spawn with shell:false (EINVAL). Mirror src/synthesis/provider.ts: route
+// through cmd.exe as ONE trusted line — every argv here is a fixed flag or a
+// lockfile-validated package name, so nothing can be shell-interpreted. POSIX
+// keeps shell:false with argv as-is.
+function spawnNpm(args, opts) {
+    return process.platform === "win32"
+        ? spawnSync([npmExecutable(), ...args].join(" "), { ...opts, encoding: "utf8", shell: true, windowsHide: true })
+        : spawnSync(npmExecutable(), args, { ...opts, encoding: "utf8", shell: false });
+}
+function buildEnvironment(home) {
+    const env = replaySafeEnvironment(home, join(home, "global.gitconfig"));
+    for (const key of ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy", "npm_config_registry"]) {
+        if (process.env[key])
+            env[key] = process.env[key];
+    }
+    return env;
+}
+function runtimeIdentity(env) {
+    const result = spawnNpm(["--version"], {
+        env,
+        timeout: 10_000,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (result.status !== 0 || !result.stdout.trim())
+        throw new Error("dependency snapshot could not identify npm");
+    return { node: process.version, npm: result.stdout.trim(), platform: process.platform, arch: process.arch };
+}
+function snapshotInput(root, commit, allowInstallScripts, env) {
+    const packageJson = gitFile(root, commit, "package.json");
+    const packageLock = gitFile(root, commit, "package-lock.json");
+    const pkg = parseObject(packageJson, "package.json");
+    const lock = parseObject(packageLock, "package-lock.json");
+    if (lock.lockfileVersion !== 2 && lock.lockfileVersion !== 3) {
+        throw new Error(`dependency snapshot requires npm lockfileVersion 2 or 3 at ${commit}`);
+    }
+    const normalizedAllowlist = normalizeAllowlist(allowInstallScripts, lock);
+    const sanitizedPackage = { ...pkg, scripts: {} };
+    const runtime = runtimeIdentity(env);
+    const body = {
+        package_json_hash: sha256(packageJson),
+        sanitized_package_json_hash: sha256(canonicalJson(sanitizedPackage)),
+        package_lock_hash: sha256(packageLock),
+        dependency_projection_hash: canonicalHash(dependencyProjection(pkg)),
+        runtime,
+        allow_install_scripts: normalizedAllowlist,
+        format_version: SNAPSHOT_VERSION,
+    };
+    return {
+        packageJson,
+        packageLock,
+        sanitizedPackage,
+        inputHash: canonicalHash(body),
+        packageJsonHash: body.package_json_hash,
+        sanitizedPackageJsonHash: body.sanitized_package_json_hash,
+        packageLockHash: body.package_lock_hash,
+        dependencyProjectionHash: body.dependency_projection_hash,
+        runtime,
+        allowInstallScripts: normalizedAllowlist,
+    };
+}
+function nativeInventory(nodeModules) {
+    const files = [];
+    const walk = (dir, relative) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            const absolute = join(dir, entry.name);
+            const next = relative ? `${relative}/${entry.name}` : entry.name;
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory())
+                walk(absolute, next);
+            else if (entry.isFile() && entry.name.endsWith(".node"))
+                files.push({ file: next, sha256: sha256(readFileSync(absolute)) });
+        }
+    };
+    walk(nodeModules, "");
+    return files;
+}
+function manifestHash(snapshot) {
+    const { id: _id, content_hash: _contentHash, ...body } = snapshot;
+    return canonicalHash(body);
+}
+function readSnapshot(dir) {
+    const file = join(dir, "manifest.json");
+    if (!existsSync(file))
+        return null;
+    try {
+        const value = JSON.parse(readFileSync(file, "utf8"));
+        if (value.format_version !== SNAPSHOT_VERSION || value.content_hash !== manifestHash(value))
+            return null;
+        if (value.id !== `g2deps_${shortHash(value.content_hash)}` || basename(dir) !== value.id)
+            return null;
+        const nodeModules = join(dir, "node_modules");
+        const installedLock = join(nodeModules, ".package-lock.json");
+        if (!existsSync(nodeModules) || !lstatSync(nodeModules).isDirectory())
+            return null;
+        const installedLockHash = existsSync(installedLock) ? sha256(readFileSync(installedLock)) : sha256("");
+        if (installedLockHash !== value.installed_lock_hash)
+            return null;
+        if (canonicalJson(nativeInventory(nodeModules)) !== canonicalJson(value.native_binaries))
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function snapshotDirs(base) {
+    if (!existsSync(base))
+        return [];
+    return readdirSync(base, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith("g2deps_"))
+        .map((entry) => join(base, entry.name))
+        .sort();
+}
+function findSnapshot(base, inputHash) {
+    for (const dir of snapshotDirs(base)) {
+        const snapshot = readSnapshot(dir);
+        if (snapshot?.input_hash === inputHash)
+            return { snapshot, dir };
+    }
+    return null;
+}
+function runNpm(args, cwd, env, timeoutMs) {
+    const result = spawnNpm(args, {
+        cwd,
+        env,
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.error) {
+        const code = result.error.code === "ETIMEDOUT" ? "timed out" : "failed to start";
+        throw new Error(`dependency snapshot npm ${code}`);
+    }
+    if (result.status !== 0) {
+        const detail = `${result.stderr ?? ""}\n${result.stdout ?? ""}`.trim().split("\n").slice(-8).join("\n")
+            .replace(/(_authToken=)[^\s]+/gi, "$1[redacted]")
+            .replace(/(https?:\/\/)[^/@\s]+@/gi, "$1[redacted]@");
+        throw new Error(`dependency snapshot npm exited ${result.status}${detail ? `:\n${detail}` : ""}`);
+    }
+}
+function buildSnapshot(base, input, env, timeoutMs) {
+    const existing = findSnapshot(base, input.inputHash);
+    if (existing)
+        return existing.snapshot;
+    const work = mkdtempSync(join(base, ".build-"));
+    try {
+        writeFileSync(join(work, "package.json"), canonicalJson(input.sanitizedPackage));
+        writeFileSync(join(work, "package-lock.json"), input.packageLock);
+        runNpm(["ci", "--ignore-scripts", "--no-audit", "--no-fund"], work, env, timeoutMs);
+        if (input.allowInstallScripts.length) {
+            runNpm(["rebuild", ...input.allowInstallScripts, "--foreground-scripts", "--no-audit", "--no-fund"], work, env, timeoutMs);
+        }
+        const nodeModules = join(work, "node_modules");
+        const installedLock = join(nodeModules, ".package-lock.json");
+        mkdirSync(nodeModules, { recursive: true });
+        const body = {
+            input_hash: input.inputHash,
+            package_json_hash: input.packageJsonHash,
+            sanitized_package_json_hash: input.sanitizedPackageJsonHash,
+            package_lock_hash: input.packageLockHash,
+            dependency_projection_hash: input.dependencyProjectionHash,
+            runtime: input.runtime,
+            allow_install_scripts: input.allowInstallScripts,
+            installed_lock_hash: existsSync(installedLock) ? sha256(readFileSync(installedLock)) : sha256(""),
+            native_binaries: nativeInventory(nodeModules),
+            format_version: SNAPSHOT_VERSION,
+            data_class: "private",
+            authority: "none",
+            effects: "cache_only",
+            writes: "cache_only",
+        };
+        const contentHash = canonicalHash(body);
+        const snapshot = {
+            id: `g2deps_${shortHash(contentHash)}`,
+            content_hash: contentHash,
+            ...body,
+        };
+        writeFileSync(join(work, "manifest.json"), canonicalJson(snapshot));
+        const finalDir = join(base, snapshot.id);
+        if (existsSync(finalDir)) {
+            const collision = readSnapshot(finalDir);
+            if (!collision || collision.content_hash !== snapshot.content_hash)
+                throw new Error(`dependency snapshot collision at ${snapshot.id}`);
+            return collision;
+        }
+        try {
+            renameSync(work, finalDir);
+        }
+        catch (error) {
+            if (!existsSync(finalDir))
+                throw error;
+            const concurrent = readSnapshot(finalDir);
+            if (!concurrent || concurrent.content_hash !== snapshot.content_hash) {
+                throw new Error(`dependency snapshot collision at ${snapshot.id}`);
+            }
+            return concurrent;
+        }
+        const validated = readSnapshot(finalDir);
+        if (!validated)
+            throw new Error(`dependency snapshot ${snapshot.id} failed post-build validation`);
+        return validated;
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}
+export function dependencySnapshotById(root, id) {
+    if (!/^g2deps_[a-f0-9]{10}$/.test(id))
+        return null;
+    const dir = join(root, ".hunch-cache", "behavior-deps", id);
+    const snapshot = readSnapshot(dir);
+    return snapshot ? { snapshot, nodeModules: join(dir, "node_modules") } : null;
+}
+export function dependencySnapshotForCommit(root, commit, allowedIds) {
+    const base = join(root, ".hunch-cache", "behavior-deps");
+    if (!existsSync(base))
+        return null;
+    const env = buildEnvironment(base);
+    let packageJson;
+    let packageLock;
+    try {
+        packageJson = gitFile(root, commit, "package.json");
+        packageLock = gitFile(root, commit, "package-lock.json");
+    }
+    catch {
+        return null;
+    }
+    const runtime = runtimeIdentity(env);
+    const packageJsonHash = sha256(packageJson);
+    const packageLockHash = sha256(packageLock);
+    const matches = [];
+    for (const dir of snapshotDirs(base)) {
+        const snapshot = readSnapshot(dir);
+        if (snapshot
+            && (!allowedIds || allowedIds.includes(snapshot.id))
+            && snapshot.package_json_hash === packageJsonHash
+            && snapshot.package_lock_hash === packageLockHash
+            && canonicalJson(snapshot.runtime) === canonicalJson(runtime)) {
+            matches.push({ snapshot, nodeModules: join(dir, "node_modules") });
+        }
+    }
+    return matches.length === 1 ? matches[0] : null;
+}
+export function provisionG2BehaviorDependencySnapshotsForCommits(root, commits, allowInstallScripts = [], timeoutMs = 300_000) {
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 900_000) {
+        throw new Error("dependency snapshot timeoutMs must be a positive integer no greater than 900000");
+    }
+    const normalizedCommits = [...new Set(commits)].sort();
+    if (!normalizedCommits.length || normalizedCommits.some((commit) => !FULL_SHA.test(commit))) {
+        throw new Error("dependency snapshots require at least one full lowercase 40-character commit SHA");
+    }
+    const base = join(root, ".hunch-cache", "behavior-deps");
+    mkdirSync(base, { recursive: true });
+    const home = mkdtempSync(join(base, ".npm-home-"));
+    writeFileSync(join(home, "global.gitconfig"), "");
+    const env = buildEnvironment(home);
+    try {
+        const byInput = new Map();
+        const mapped = normalizedCommits.map((commit) => {
+            const input = snapshotInput(root, commit, allowInstallScripts, env);
+            const snapshot = byInput.get(input.inputHash) ?? buildSnapshot(base, input, env, timeoutMs);
+            byInput.set(input.inputHash, snapshot);
+            return { commit, dependency_snapshot_id: snapshot.id };
+        });
+        return {
+            snapshots: [...new Map([...byInput.values()].map((snapshot) => [snapshot.id, snapshot])).values()]
+                .sort((left, right) => left.id.localeCompare(right.id)),
+            commits: mapped,
+        };
+    }
+    finally {
+        rmSync(home, { recursive: true, force: true });
+    }
+}
+export function provisionG2BehaviorDependencySnapshots(root, report, candidate, allowInstallScripts = [], timeoutMs = 300_000) {
+    const provisioned = provisionG2BehaviorDependencySnapshotsForCommits(root, [
+        candidate.proposed_corpus.known_bad.ref,
+        candidate.proposed_corpus.known_good.ref,
+    ], allowInstallScripts, timeoutMs);
+    const bad = provisioned.commits.find((entry) => entry.commit === candidate.proposed_corpus.known_bad.ref);
+    const good = provisioned.commits.find((entry) => entry.commit === candidate.proposed_corpus.known_good.ref);
+    const body = {
+        candidate_id: candidate.id,
+        candidate_hash: canonicalHash(candidate),
+        review_hash: report.content_hash,
+        snapshots: provisioned.snapshots,
+        legs: {
+            known_bad: { commit: candidate.proposed_corpus.known_bad.ref, dependency_snapshot_id: bad.dependency_snapshot_id },
+            known_good: { commit: candidate.proposed_corpus.known_good.ref, dependency_snapshot_id: good.dependency_snapshot_id },
+        },
+        allow_install_scripts: [...new Set(allowInstallScripts.map((value) => value.trim()).filter(Boolean))].sort(),
+        data_class: "private",
+        authority: "none",
+        effects: "cache_only",
+        writes: "cache_only",
+    };
+    const contentHash = canonicalHash(body);
+    return { id: `g2depsreceipt_${shortHash(contentHash)}`, content_hash: contentHash, ...body };
+}
+//# sourceMappingURL=g2BehaviorDependencies.js.map

package/dist/constitution/g2BehaviorMaterialization.js

@@ -0,0 +1,171 @@
+import { z } from "zod";
+import { shortHash } from "../core/ids.js";
+import { canonicalHash } from "./canonical.js";
+import { g2BehaviorCandidateHash, g2BehaviorReviewContentHash, } from "./g2BehaviorCandidates.js";
+import { g2BehaviorAttestationContentHash, } from "./g2BehaviorAttestation.js";
+import { BEHAVIOR_POLICY_EVALUATOR, EXECUTABLE_BEHAVIOR_IR_VERSION } from "./schema.js";
+const HASH = /^sha1:[a-f0-9]{40}$/;
+const SUPPORTED_ASSERTION_KINDS = ["executable-behavior", "exists", "must-pass-through", "not-reaches", "reaches"];
+const SourceReviewSchema = z.object({
+    id: z.string().regex(/^g2behaviorcandidates_[a-f0-9]{10}$/),
+    content_hash: z.string().regex(HASH),
+    structural_review_hash: z.string().regex(HASH),
+    grounding_mode: z.literal("human_decision_plus_added_test").optional(),
+    source_decision_id: z.string().regex(/^dec_[A-Za-z0-9_-]+$/).optional(),
+    source_grounding_hash: z.string().regex(HASH).optional(),
+}).strict();
+const MaterializationItemSchema = z.object({
+    candidate_id: z.string().regex(/^g2behavior_[a-f0-9]{10}$/),
+    candidate_hash: z.string().regex(HASH),
+    attestation_id: z.string().regex(/^g2behaviorattest_[a-f0-9]{10}$/),
+    attestation_hash: z.string().regex(HASH),
+    attested_review_hash: z.string().regex(HASH),
+    replay_id: z.string().regex(/^g2behaviorreplay_[a-f0-9]{10}$/),
+    replay_hash: z.string().regex(HASH),
+    dependency_snapshot_ids: z.array(z.string().regex(/^g2deps_[a-f0-9]{10}$/)).min(1).max(2),
+    commit: z.string().regex(/^[a-f0-9]{40}$/),
+    test: z.object({
+        file: z.string().min(1),
+        name: z.string().min(1),
+        source_hash: z.string().regex(HASH),
+    }).strict(),
+    durable_meaning: z.string().min(1),
+    status: z.literal("ready_for_materialization"),
+    reason: z.string().min(1),
+    required_capability: z.object({
+        assertion: z.literal("executable-behavior"),
+        current_baseline: z.literal("required"),
+        known_bad: z.literal("must_fail_behaviorally"),
+        known_good: z.literal("must_pass"),
+        mutation_controls: z.literal("required"),
+    }).strict(),
+}).strict();
+export const G2BehaviorMaterializationAssessmentSchema = z.object({
+    id: z.string().regex(/^g2behaviormaterialization_[a-f0-9]{10}$/),
+    content_hash: z.string().regex(HASH),
+    source_review: SourceReviewSchema,
+    policy_ir_version: z.literal(EXECUTABLE_BEHAVIOR_IR_VERSION),
+    evaluator: z.object({
+        name: z.literal(BEHAVIOR_POLICY_EVALUATOR.name),
+        version: z.literal(BEHAVIOR_POLICY_EVALUATOR.version),
+    }).strict(),
+    supported_assertion_kinds: z.array(z.enum(SUPPORTED_ASSERTION_KINDS)).length(SUPPORTED_ASSERTION_KINDS.length),
+    selected_attestations: z.number().int().min(1),
+    materialized_policies: z.literal(0),
+    readiness: z.literal("ready_for_materialization"),
+    items: z.array(MaterializationItemSchema).min(1),
+    outputs: z.object({
+        policies: z.array(z.never()).length(0),
+        corpora: z.array(z.never()).length(0),
+        plans: z.array(z.never()).length(0),
+        proofs: z.array(z.never()).length(0),
+    }).strict(),
+    limitations: z.array(z.string().min(1)).min(1),
+    data_class: z.literal("private"),
+    authority: z.literal("none"),
+    effects: z.literal("assessment_only"),
+    writes: z.literal("none"),
+    proof_status: z.literal("not_run"),
+    activation: z.literal("separate_human_action_required"),
+}).strict();
+export function g2BehaviorMaterializationContentHash(assessment) {
+    const { id: _id, content_hash: _contentHash, ...body } = assessment;
+    return canonicalHash(body);
+}
+const readyReason = `The selected receipt is expressible by Policy IR v${EXECUTABLE_BEHAVIOR_IR_VERSION} through ${BEHAVIOR_POLICY_EVALUATOR.name}@${BEHAVIOR_POLICY_EVALUATOR.version}; materialization must still produce exact current, known-bad, known-good, and mutation-control receipts before proposal.`;
+/**
+ * Assess exact selected behavior receipts against the currently implemented
+ * Policy IR. This is intentionally fail-closed: it never substitutes a static
+ * symbol or edge proxy for behavior that the evaluator cannot execute.
+ */
+export function assessG2BehaviorMaterialization(report, currentAttestations) {
+    if (report.content_hash !== g2BehaviorReviewContentHash(report)
+        || report.id !== `g2behaviorcandidates_${shortHash(report.content_hash)}`) {
+        throw new Error(`G2 behavior candidate review ${report.id} content hash mismatch`);
+    }
+    if (report.has_more)
+        throw new Error("G2 behavior materialization requires a complete, untruncated behavior review");
+    if (report.unreviewed_candidates !== 0)
+        throw new Error("G2 behavior materialization requires every behavior candidate to have a current human disposition");
+    const candidateHashes = new Map(report.items.map((candidate) => [candidate.id, g2BehaviorCandidateHash(candidate)]));
+    const selected = currentAttestations
+        .filter((attestation) => attestation.disposition === "selected"
+        && candidateHashes.get(attestation.candidate_id) === attestation.candidate_hash)
+        .sort((left, right) => left.candidate_id.localeCompare(right.candidate_id));
+    if (!selected.length)
+        throw new Error("G2 behavior materialization requires at least one current selected attestation");
+    if (report.selected_candidates !== selected.length) {
+        throw new Error("G2 behavior materialization selected-attestation count does not match the exact current review");
+    }
+    const items = selected.map((attestation) => {
+        if (attestation.content_hash !== g2BehaviorAttestationContentHash(attestation)
+            || attestation.id !== `g2behaviorattest_${shortHash(attestation.content_hash)}`) {
+            throw new Error(`G2 behavior attestation ${attestation.id} content hash mismatch`);
+        }
+        const candidate = report.items.find((item) => item.id === attestation.candidate_id);
+        if (!candidate || g2BehaviorCandidateHash(candidate) !== attestation.candidate_hash) {
+            throw new Error(`G2 behavior attestation ${attestation.id} does not bind a candidate in the exact current review`);
+        }
+        if (candidate.human_review?.id !== attestation.id || candidate.human_review.disposition !== "selected") {
+            throw new Error(`G2 behavior attestation ${attestation.id} is not the current selected disposition projected by the review`);
+        }
+        return {
+            candidate_id: candidate.id,
+            candidate_hash: attestation.candidate_hash,
+            attestation_id: attestation.id,
+            attestation_hash: attestation.content_hash,
+            attested_review_hash: attestation.review_hash,
+            replay_id: attestation.replay_id,
+            replay_hash: attestation.replay_hash,
+            dependency_snapshot_ids: attestation.dependency_snapshot_ids,
+            commit: attestation.commit,
+            test: candidate.test,
+            durable_meaning: attestation.reason,
+            status: "ready_for_materialization",
+            reason: readyReason,
+            required_capability: {
+                assertion: "executable-behavior",
+                current_baseline: "required",
+                known_bad: "must_fail_behaviorally",
+                known_good: "must_pass",
+                mutation_controls: "required",
+            },
+        };
+    });
+    const body = {
+        source_review: {
+            id: report.id,
+            content_hash: report.content_hash,
+            structural_review_hash: report.structural_review_hash,
+            ...(report.grounding_mode ? { grounding_mode: report.grounding_mode } : {}),
+            ...(report.source_decision_id ? { source_decision_id: report.source_decision_id } : {}),
+            ...(report.source_grounding_hash ? { source_grounding_hash: report.source_grounding_hash } : {}),
+        },
+        policy_ir_version: EXECUTABLE_BEHAVIOR_IR_VERSION,
+        evaluator: { ...BEHAVIOR_POLICY_EVALUATOR },
+        supported_assertion_kinds: [...SUPPORTED_ASSERTION_KINDS],
+        selected_attestations: items.length,
+        materialized_policies: 0,
+        readiness: "ready_for_materialization",
+        items,
+        outputs: { policies: [], corpora: [], plans: [], proofs: [] },
+        limitations: [
+            "Assessment alone creates no PolicySpec, corpus, proof plan, proof, authority, warning, or block.",
+            "Executable materialization must independently prove current, known-bad, known-good, and mutation-control behavior before proposal.",
+            "Committed HEAD remains the proof baseline; advisory delivery may separately evaluate a content-addressed staged or working snapshot.",
+        ],
+        data_class: "private",
+        authority: "none",
+        effects: "assessment_only",
+        writes: "none",
+        proof_status: "not_run",
+        activation: "separate_human_action_required",
+    };
+    const contentHash = canonicalHash(body);
+    return G2BehaviorMaterializationAssessmentSchema.parse({
+        id: `g2behaviormaterialization_${shortHash(contentHash)}`,
+        content_hash: contentHash,
+        ...body,
+    });
+}
+//# sourceMappingURL=g2BehaviorMaterialization.js.map