@davesheffer/hunch 1.6.0 → 1.7.1

package/dist/constitution/g2BehaviorPolicyMaterializer.js

@@ -0,0 +1,241 @@
+import { basename } from "node:path";
+import { z } from "zod";
+import { shortHash } from "../core/ids.js";
+import { headSha } from "../extractors/git.js";
+import { canonicalHash, policyId, policySemanticHash } from "./canonical.js";
+import { compileProofCorpus } from "./corpus.js";
+import { assessG2BehaviorMaterialization } from "./g2BehaviorMaterialization.js";
+import { dependencySnapshotById, dependencySnapshotForCommit, provisionG2BehaviorDependencySnapshotsForCommits, } from "./g2BehaviorDependencies.js";
+import { g2BehaviorCandidateHash, } from "./g2BehaviorCandidates.js";
+import { proposeProvedPolicy } from "./lifecycle.js";
+import { createProofPlan } from "./plan.js";
+import { provePolicy } from "./proof.js";
+import { EXECUTABLE_BEHAVIOR_IR_VERSION, PolicySpecSchema, } from "./schema.js";
+const HASH = /^sha1:[a-f0-9]{40}$/;
+const MaterializedItemSchema = z.object({
+    candidate_id: z.string().regex(/^g2behavior_[a-f0-9]{10}$/),
+    attestation_id: z.string().regex(/^g2behaviorattest_[a-f0-9]{10}$/),
+    policy_id: z.string().regex(/^pol_[a-f0-9]{10}$/),
+    policy_hash: z.string().regex(HASH),
+    corpus_id: z.string().regex(/^corpus_[a-f0-9]{10}$/),
+    corpus_hash: z.string().regex(HASH),
+    plan_id: z.string().regex(/^plan_[a-f0-9]{10}$/),
+    plan_hash: z.string().regex(HASH),
+    proof_id: z.string().regex(/^proof_[a-f0-9]{10}$/),
+    proof_hash: z.string().regex(HASH),
+    proof_class: z.literal("P3"),
+    policy_state: z.enum(["proposed", "active_advisory", "active_blocking"]),
+}).strict();
+export const G2BehaviorPolicyMaterializationSchema = z.object({
+    id: z.string().regex(/^g2behaviorpolicies_[a-f0-9]{10}$/),
+    content_hash: z.string().regex(HASH),
+    assessment_id: z.string().regex(/^g2behaviormaterialization_[a-f0-9]{10}$/),
+    assessment_hash: z.string().regex(HASH),
+    source_review_id: z.string().regex(/^g2behaviorcandidates_[a-f0-9]{10}$/),
+    source_review_hash: z.string().regex(HASH),
+    current_commit: z.string().regex(/^[a-f0-9]{40}$/),
+    dependency_snapshots: z.array(z.object({ id: z.string().regex(/^g2deps_[a-f0-9]{10}$/), content_hash: z.string().regex(HASH) }).strict()).min(1),
+    materialized_policies: z.number().int().min(1),
+    items: z.array(MaterializedItemSchema).min(1),
+    data_class: z.literal("private"),
+    authority: z.literal("none"),
+    effects: z.literal("policy_proposal_only"),
+    writes: z.literal("private_policy_artifacts"),
+    activation: z.literal("separate_human_action_required"),
+}).strict();
+function compileBehaviorPolicy(root, candidate, attestation, dependencySnapshotIds, now) {
+    const assertion = {
+        kind: "executable-behavior",
+        test: {
+            file: candidate.test.file,
+            name: candidate.test.name,
+            source_commit: candidate.proposed_corpus.known_good.ref,
+            source_hash: candidate.test.source_hash,
+        },
+        runner: candidate.runner.kind,
+        attestation: {
+            id: attestation.id,
+            content_hash: attestation.content_hash,
+            candidate_id: attestation.candidate_id,
+            candidate_hash: attestation.candidate_hash,
+            replay_id: attestation.replay_id,
+            replay_hash: attestation.replay_hash,
+        },
+        dependency_snapshot_ids: [...new Set(dependencySnapshotIds)].sort(),
+        timeout_ms: 30_000,
+    };
+    const id = policyId({ assertion, repository: basename(root), data_class: "private" });
+    const evidence = [...new Set([
+            attestation.id,
+            attestation.replay_id,
+            candidate.id,
+            ...candidate.decision_ids,
+            ...candidate.source_attestation_ids,
+        ])].sort();
+    return PolicySpecSchema.parse({
+        id,
+        topic: `g2.behavior.${candidate.id}`,
+        ir_version: EXECUTABLE_BEHAVIOR_IR_VERSION,
+        revision: 1,
+        state: "compiled",
+        statement: attestation.reason,
+        rationale: `Human-selected executable regression ${candidate.test.file} :: ${candidate.test.name}`,
+        scope: { repos: [basename(root)], paths: [], components: [] },
+        assertion,
+        severity: "warning",
+        surfaces: ["pre_commit", "ci", "mcp", "cli"],
+        authority: null,
+        evidence,
+        proof: null,
+        reversal_conditions: [`Behavior attestation ${attestation.id} is superseded, rejected, or its exact test/replay binding no longer verifies.`],
+        supersedes: null,
+        superseded_by: null,
+        exception_of: null,
+        valid_from: null,
+        valid_to: null,
+        data_class: "private",
+        limitations: [
+            "The assertion executes one exact hash-pinned node:test case from a human-selected fixing commit; it does not encode a helper symbol or call-edge proxy.",
+            "Proof and history replay use committed Git states; advisory delivery may evaluate a content-addressed staged or working snapshot in a disposable checkout.",
+            "Executable evidence creates no authority. Advisory or blocking activation requires a separate explicit human lifecycle action.",
+        ],
+        candidate: {
+            alternatives: [],
+            uncertainty: [],
+            conflicts: [],
+            incumbent: null,
+            scope_suggestion: null,
+            counterexamples: [],
+        },
+        legacy_refs: candidate.decision_ids,
+        audit: [{
+                action: "compiled",
+                actor_kind: "system",
+                actor: "hunch:behavior-materializer",
+                at: now,
+                reason: `Compiled only from current selected behavior attestation ${attestation.id}.`,
+                proof: null,
+            }],
+        created_at: now,
+        updated_at: now,
+        provenance: {
+            source: "human_confirmed+executable_regression",
+            confidence: 1,
+            evidence,
+            last_verified: now,
+        },
+    });
+}
+function exactSnapshotProjection(snapshots) {
+    return snapshots.map((snapshot) => ({ id: snapshot.id, content_hash: snapshot.content_hash }))
+        .sort((left, right) => left.id.localeCompare(right.id));
+}
+export function materializeSelectedG2BehaviorPolicies(store, root, repository, report, currentAttestations, opts = {}) {
+    if (!store.hasPrivate)
+        throw new Error("selected executable behavior materialization requires a configured private Hunch overlay");
+    const assessment = assessG2BehaviorMaterialization(report, currentAttestations);
+    if (assessment.readiness !== "ready_for_materialization")
+        throw new Error(`behavior assessment ${assessment.id} is not ready for materialization`);
+    const currentCommit = headSha(root);
+    if (!/^[a-f0-9]{40}$/.test(currentCommit))
+        throw new Error("behavior materialization requires a current full-SHA HEAD");
+    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));
+    const dependencies = provisionG2BehaviorDependencySnapshotsForCommits(root, [currentCommit], opts.allowInstallScripts ?? [], opts.dependencyTimeoutMs ?? 300_000);
+    const currentDependencyId = dependencies.commits[0].dependency_snapshot_id;
+    const attestedSnapshots = selected.flatMap((attestation) => attestation.dependency_snapshot_ids.map((id) => {
+        const snapshot = dependencySnapshotById(root, id);
+        if (!snapshot)
+            throw new Error(`selected behavior attestation ${attestation.id} binds unavailable dependency snapshot ${id}`);
+        return snapshot.snapshot;
+    }));
+    for (const attestation of selected) {
+        const candidate = report.items.find((item) => item.id === attestation.candidate_id);
+        for (const commit of [candidate.proposed_corpus.known_bad.ref, candidate.proposed_corpus.known_good.ref]) {
+            if (!dependencySnapshotForCommit(root, commit, attestation.dependency_snapshot_ids)) {
+                throw new Error(`selected behavior attestation ${attestation.id} has no exact bound dependency snapshot for ${commit}`);
+            }
+        }
+    }
+    const allSnapshots = [...new Map([...dependencies.snapshots, ...attestedSnapshots].map((snapshot) => [snapshot.id, snapshot])).values()];
+    const now = opts.now ?? new Date().toISOString();
+    const items = selected.map((attestation) => {
+        const candidate = report.items.find((item) => item.id === attestation.candidate_id);
+        const compiled = compileBehaviorPolicy(root, candidate, attestation, [currentDependencyId, ...attestation.dependency_snapshot_ids], now);
+        const existingPolicy = repository.getPolicy(compiled.id, { privateOnly: true });
+        if (existingPolicy && policySemanticHash(existingPolicy) !== policySemanticHash(compiled)) {
+            throw new Error(`existing behavior policy ${compiled.id} has different semantics`);
+        }
+        let policy = existingPolicy ?? repository.putPolicy(compiled, { private: true });
+        const compiledCorpus = compileProofCorpus(root, policy, {
+            known_bad: [{ ref: candidate.proposed_corpus.known_bad.ref, label: `known-bad behavior before ${candidate.commit}` }],
+            known_good: [{
+                    ref: candidate.proposed_corpus.known_good.ref,
+                    label: `human-selected fixing behavior ${candidate.commit}`,
+                    attestation: { actor: attestation.actor, reason: attestation.reason },
+                }],
+        }, { now });
+        const existingCorpus = repository.getCorpus(policy.id, { privateOnly: true });
+        if (existingCorpus && existingCorpus.content_hash !== compiledCorpus.content_hash) {
+            throw new Error(`existing behavior corpus ${existingCorpus.id} differs from exact selected evidence`);
+        }
+        const corpus = existingCorpus ?? repository.putCorpus(compiledCorpus, policy.id);
+        const generatedPlan = createProofPlan(store, root, repository, policy, { privateOnly: true, maxCommits: 0, maxMutations: 2, now });
+        const plan = repository.getPlan(generatedPlan.id, { privateOnly: true }) ?? repository.putPlan(generatedPlan, policy.id, { private: true });
+        const generatedProof = provePolicy(store, root, policy, { plan, now });
+        if (generatedProof.proof_class !== "P3") {
+            const outcomes = generatedProof.replay_receipts
+                .map((receipt) => `${receipt.leg}:${receipt.result}${receipt.error_code ? `(${receipt.error_code})` : ""}`)
+                .join(", ");
+            throw new Error(`behavior policy ${policy.id} proof is ${generatedProof.proof_class}; exact P3 is required for materialization (${outcomes})`);
+        }
+        const proof = repository.getProof(generatedProof.id, { privateOnly: true }) ?? repository.putProof(generatedProof, policy.id);
+        if (policy.state === "compiled" || policy.state === "validating" || policy.state === "proposed") {
+            const proposed = policy.state === "proposed" && policy.proof === proof.id
+                ? policy
+                : proposeProvedPolicy(policy, proof, now, [], currentAttestations);
+            policy = proposed === policy ? policy : repository.putPolicy(proposed, { private: true });
+        }
+        else if (policy.proof !== proof.id) {
+            throw new Error(`behavior policy ${policy.id} is ${policy.state} with a different proof`);
+        }
+        return {
+            candidate_id: candidate.id,
+            attestation_id: attestation.id,
+            policy_id: policy.id,
+            policy_hash: policySemanticHash(policy),
+            corpus_id: corpus.id,
+            corpus_hash: corpus.content_hash,
+            plan_id: plan.id,
+            plan_hash: plan.content_hash,
+            proof_id: proof.id,
+            proof_hash: canonicalHash(proof),
+            proof_class: proof.proof_class,
+            policy_state: policy.state,
+        };
+    });
+    const body = {
+        assessment_id: assessment.id,
+        assessment_hash: assessment.content_hash,
+        source_review_id: report.id,
+        source_review_hash: report.content_hash,
+        current_commit: currentCommit,
+        dependency_snapshots: exactSnapshotProjection(allSnapshots),
+        materialized_policies: items.length,
+        items,
+        data_class: "private",
+        authority: "none",
+        effects: "policy_proposal_only",
+        writes: "private_policy_artifacts",
+        activation: "separate_human_action_required",
+    };
+    const contentHash = canonicalHash(body);
+    return G2BehaviorPolicyMaterializationSchema.parse({
+        id: `g2behaviorpolicies_${shortHash(contentHash)}`,
+        content_hash: contentHash,
+        ...body,
+    });
+}
+//# sourceMappingURL=g2BehaviorPolicyMaterializer.js.map

package/dist/constitution/g2CandidateAttestation.js

@@ -0,0 +1,179 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "../core/io.js";
+import { shortHash } from "../core/ids.js";
+import { canonicalHash } from "./canonical.js";
+import { g2CandidateItemHash, g2CandidateReviewContentHash, } from "./g2Candidates.js";
+const HASH = /^sha1:[a-f0-9]{40}$/;
+const HUMAN_ACTOR = /^(human|github|git):[^\s]+$/i;
+const encode = (value) => `${JSON.stringify(value, null, 2)}\n`;
+export const G2CandidateDispositionSchema = z.enum(["selected", "rejected"]);
+export const G2CandidateAttestationSchema = z.object({
+    id: z.string().regex(/^g2attest_[a-f0-9]{10}$/),
+    content_hash: z.string().regex(HASH),
+    candidate_id: z.string().regex(/^g2candidate_[a-f0-9]{10}$/),
+    candidate_hash: z.string().regex(HASH),
+    structural_candidate_id: z.string().regex(/^cand_[a-f0-9]{10}$/),
+    commit: z.string().regex(/^[a-f0-9]{40}$/),
+    review_hash: z.string().regex(HASH),
+    disposition: G2CandidateDispositionSchema,
+    actor: z.string().regex(HUMAN_ACTOR, "candidate attestation requires an explicit human actor (human:, github:, or git:)"),
+    reason: z.string().trim().min(1).max(4000),
+    supersedes: z.string().regex(/^g2attest_[a-f0-9]{10}$/).nullable(),
+    data_class: z.literal("private"),
+    authority: z.literal("none"),
+    effects: z.literal("review_only"),
+    created_at: z.string().datetime({ offset: true }),
+}).strict();
+export function g2CandidateAttestationContentHash(attestation) {
+    const { id: _id, content_hash: _contentHash, ...body } = attestation;
+    return canonicalHash(body);
+}
+export function compileG2CandidateAttestation(report, candidateId, reviewHash, disposition, actor, reason, opts = {}) {
+    if (report.content_hash !== g2CandidateReviewContentHash(report) || report.id !== `g2candidates_${shortHash(report.content_hash)}`) {
+        throw new Error(`G2 candidate review ${report.id} content hash mismatch`);
+    }
+    if (reviewHash !== report.content_hash)
+        throw new Error("candidate review hash does not match the exact current review packet");
+    const candidate = report.items.find((item) => item.id === candidateId);
+    if (!candidate)
+        throw new Error(`candidate ${candidateId} is not present in review ${report.id}`);
+    const body = {
+        candidate_id: candidate.id,
+        candidate_hash: g2CandidateItemHash(candidate),
+        structural_candidate_id: candidate.candidate_id,
+        commit: candidate.commit,
+        review_hash: report.content_hash,
+        disposition: G2CandidateDispositionSchema.parse(disposition),
+        actor,
+        reason: reason.trim(),
+        supersedes: opts.supersedes ?? null,
+        data_class: "private",
+        authority: "none",
+        effects: "review_only",
+        created_at: opts.now ?? new Date().toISOString(),
+    };
+    const contentHash = canonicalHash(body);
+    return G2CandidateAttestationSchema.parse({
+        id: `g2attest_${shortHash(contentHash)}`,
+        content_hash: contentHash,
+        ...body,
+    });
+}
+/** Resolve exact-candidate supersession chains without timestamp trust. */
+export function currentG2CandidateAttestations(records) {
+    const parsed = records.map((record) => G2CandidateAttestationSchema.parse(record));
+    const byId = new Map(parsed.map((record) => [record.id, record]));
+    if (byId.size !== parsed.length)
+        throw new Error("duplicate G2 candidate attestation id");
+    const identity = (record) => `${record.candidate_id}:${record.candidate_hash}`;
+    const childCount = new Map();
+    for (const record of parsed) {
+        if (!record.supersedes)
+            continue;
+        const parent = byId.get(record.supersedes);
+        if (!parent)
+            throw new Error(`G2 candidate attestation ${record.id} supersedes missing ${record.supersedes}`);
+        if (identity(parent) !== identity(record)
+            || parent.structural_candidate_id !== record.structural_candidate_id
+            || parent.commit !== record.commit) {
+            throw new Error(`G2 candidate attestation ${record.id} supersedes a different exact candidate`);
+        }
+        childCount.set(parent.id, (childCount.get(parent.id) ?? 0) + 1);
+        if (childCount.get(parent.id) > 1)
+            throw new Error(`G2 candidate attestation ${parent.id} has a branched supersession chain`);
+    }
+    for (const record of parsed) {
+        const visited = new Set();
+        let cursor = record;
+        while (cursor?.supersedes) {
+            if (visited.has(cursor.id))
+                throw new Error(`G2 candidate attestation chain contains a cycle at ${cursor.id}`);
+            visited.add(cursor.id);
+            cursor = byId.get(cursor.supersedes);
+        }
+    }
+    const current = parsed.filter((record) => !childCount.has(record.id));
+    const currentTargets = new Set();
+    for (const record of current) {
+        const key = identity(record);
+        if (currentTargets.has(key))
+            throw new Error(`G2 candidate ${key} has multiple current attestations`);
+        currentTargets.add(key);
+    }
+    return current.sort((left, right) => left.candidate_id.localeCompare(right.candidate_id) || left.id.localeCompare(right.id));
+}
+export class G2CandidateAttestationRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    list() {
+        const dir = this.store.privateDir ? join(this.store.privateDir, "candidate-attestations") : undefined;
+        if (!dir || !existsSync(dir))
+            return [];
+        const records = readdirSync(dir)
+            .filter((name) => name.endsWith(".json"))
+            .sort()
+            .map((name) => {
+            try {
+                if (!/^g2attest_[a-f0-9]{10}\.json$/.test(name))
+                    throw new Error("unexpected attestation filename");
+                const parsed = G2CandidateAttestationSchema.parse(JSON.parse(readFileSync(join(dir, name), "utf8")));
+                if (parsed.content_hash !== g2CandidateAttestationContentHash(parsed)
+                    || parsed.id !== `g2attest_${shortHash(parsed.content_hash)}`) {
+                    throw new Error(`G2 candidate attestation ${parsed.id} content hash mismatch`);
+                }
+                if (name !== `${parsed.id}.json`)
+                    throw new Error(`filename does not match attestation ${parsed.id}`);
+                return parsed;
+            }
+            catch (error) {
+                throw new Error(`invalid candidate-attestations/${name}: ${error.message}`);
+            }
+        });
+        currentG2CandidateAttestations(records);
+        return records;
+    }
+    current() {
+        return currentG2CandidateAttestations(this.list());
+    }
+    resolutions() {
+        return this.current().map((record) => ({
+            id: record.id,
+            candidate_id: record.candidate_id,
+            candidate_hash: record.candidate_hash,
+            review_hash: record.review_hash,
+            disposition: record.disposition,
+            actor: record.actor,
+            reason: record.reason,
+            created_at: record.created_at,
+        }));
+    }
+    put(attestation) {
+        if (!this.store.privateDir)
+            throw new Error("No private Hunch overlay is configured; refusing to write G2 candidate attestation.");
+        const parsed = G2CandidateAttestationSchema.parse(attestation);
+        if (parsed.content_hash !== g2CandidateAttestationContentHash(parsed)
+            || parsed.id !== `g2attest_${shortHash(parsed.content_hash)}`) {
+            throw new Error(`G2 candidate attestation ${parsed.id} content hash mismatch`);
+        }
+        const records = this.list();
+        const existing = records.find((record) => record.id === parsed.id);
+        if (existing)
+            return existing;
+        const current = currentG2CandidateAttestations(records).find((record) => (record.candidate_id === parsed.candidate_id && record.candidate_hash === parsed.candidate_hash));
+        if (current && parsed.supersedes !== current.id) {
+            throw new Error(`G2 candidate attestation ${current.id} is current; pass supersedes:${current.id} to append a correction`);
+        }
+        if (!current && parsed.supersedes)
+            throw new Error(`G2 candidate attestation ${parsed.id} supersedes no current exact candidate review`);
+        currentG2CandidateAttestations([...records, parsed]);
+        const dir = join(this.store.privateDir, "candidate-attestations");
+        mkdirSync(dir, { recursive: true });
+        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        return parsed;
+    }
+}
+//# sourceMappingURL=g2CandidateAttestation.js.map

package/dist/constitution/g2Candidates.js

@@ -0,0 +1,195 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { shortHash } from "../core/ids.js";
+import { hunchPathsForDir } from "../core/paths.js";
+import { commitMeta, fixCommits } from "../extractors/git.js";
+import { indexRepo } from "../extractors/indexer.js";
+import { HunchStore } from "../store/hunchStore.js";
+import { canonicalHash } from "./canonical.js";
+import { extractStructuralDelta } from "./delta.js";
+import { enumerateStructuralCandidates } from "./structural.js";
+export function g2CandidateItemHash(item) {
+    const { human_review: _humanReview, ...body } = item;
+    return canonicalHash(body);
+}
+export function g2CandidateReviewContentHash(report) {
+    const { id: _id, content_hash: _contentHash, ...body } = report;
+    return canonicalHash(body);
+}
+const attestationRank = {
+    human_grounded_exact: 0,
+    human_grounded_needs_selection: 1,
+    unattested_structural_coincidence: 2,
+};
+const basisRank = {
+    "added-call": 0,
+    "removed-call": 0,
+    "removed-import": 1,
+    "added-relative-import": 1,
+    "removed-relative-import": 1,
+    "added-symbol": 2,
+};
+export function positiveBound(value, label, max) {
+    if (!Number.isInteger(value) || value < 1)
+        throw new Error(`${label} must be a positive integer`);
+    if (value > max)
+        throw new Error(`${label} cannot exceed ${max}`);
+    return value;
+}
+function privateGrounding(decisionStore, graphStore, root) {
+    const byCommit = new Map();
+    if (!decisionStore.hasPrivate)
+        return byCommit;
+    const decisions = decisionStore.recsInHome("decisions", "private")
+        .filter((decision) => decision.status === "accepted"
+        && !decision.superseded_by
+        && !decision.valid_to
+        && !!decision.commit
+        && decision.provenance.source.includes("human_confirmed"));
+    for (const decision of decisions) {
+        const meta = commitMeta(decision.commit, root);
+        if (!meta)
+            continue;
+        try {
+            const delta = extractStructuralDelta(root, meta.sha);
+            const inspection = enumerateStructuralCandidates(graphStore, delta, { publicOnly: true, judgment: decision });
+            const list = byCommit.get(meta.sha) ?? [];
+            list.push({
+                decision_id: decision.id,
+                candidate_ids: new Set(inspection.candidates.map((candidate) => candidate.id)),
+                exact: inspection.candidates.length === 1,
+            });
+            byCommit.set(meta.sha, list);
+        }
+        catch {
+            // A human decision can be real while still lacking a supported structural
+            // binding. It contributes no candidate attestation rather than being
+            // stretched over a coincidental fact from the same commit.
+        }
+    }
+    return byCommit;
+}
+/** Read-only review packet. Structural facts propose corpus pairs but cannot
+ * become policy evidence until an exact human judgment selects their semantics. */
+export function buildG2CandidateReview(store, root, opts = {}, resolutions = []) {
+    const scratchRoot = mkdtempSync(join(tmpdir(), "hunch-g2-candidates-"));
+    const graphStore = new HunchStore(hunchPathsForDir(scratchRoot));
+    try {
+        graphStore.json.ensureDirs();
+        indexRepo(graphStore, root, { churn: false });
+        return buildFromIndexedGraph(store, graphStore, root, opts, resolutions);
+    }
+    finally {
+        graphStore.close();
+        rmSync(scratchRoot, { recursive: true, force: true });
+    }
+}
+function buildFromIndexedGraph(decisionStore, graphStore, root, opts, resolutions) {
+    const since = (opts.since ?? "180d").trim();
+    if (!since || since.length > 100)
+        throw new Error("G2 candidate since window must be a non-empty bounded string");
+    const maxCommits = positiveBound(opts.maxCommits ?? 100, "G2 candidate maxCommits", 200);
+    const limit = positiveBound(opts.limit ?? 30, "G2 candidate limit", 100);
+    const commits = fixCommits(since, root, maxCommits);
+    const grounding = privateGrounding(decisionStore, graphStore, root);
+    const failures = [];
+    const candidates = [];
+    let candidateCommits = 0;
+    for (const commit of commits) {
+        try {
+            const meta = commitMeta(commit, root);
+            if (!meta)
+                throw new Error("commit metadata is unavailable");
+            const delta = extractStructuralDelta(root, commit);
+            // The private overlay supplies human intent only. Symbols and edges are a
+            // derived view of public source and may be stale in long-lived overlays,
+            // so bindings must come from the freshly indexed public graph alone.
+            const enumerated = enumerateStructuralCandidates(graphStore, delta, { publicOnly: true });
+            if (enumerated.candidates.length)
+                candidateCommits++;
+            for (const candidate of enumerated.candidates) {
+                const matches = (grounding.get(meta.sha) ?? []).filter((entry) => entry.candidate_ids.has(candidate.id));
+                const status = matches.some((entry) => entry.exact)
+                    ? "human_grounded_exact"
+                    : matches.length
+                        ? "human_grounded_needs_selection"
+                        : "unattested_structural_coincidence";
+                const seed = canonicalHash({ commit: meta.sha, candidate_id: candidate.id });
+                candidates.push({
+                    id: `g2candidate_${shortHash(seed)}`,
+                    candidate_id: candidate.id,
+                    commit: meta.sha,
+                    commit_subject: meta.subject,
+                    commit_date: meta.date,
+                    changed_files: [...meta.files].sort(),
+                    sibling_candidates: enumerated.candidates.length,
+                    basis: candidate.basis,
+                    reason: candidate.reason,
+                    assertion: candidate.assertion,
+                    scope: candidate.scope,
+                    proposed_corpus: {
+                        known_bad: { ref: delta.before_commit, expected: "violated" },
+                        known_good: { ref: delta.after_commit, expected: "satisfied" },
+                        observed: false,
+                    },
+                    attestation: {
+                        status,
+                        decision_ids: [...new Set(matches.map((entry) => entry.decision_id))].sort(),
+                    },
+                    human_review: null,
+                });
+            }
+        }
+        catch (error) {
+            failures.push({ commit, error: error.message });
+        }
+    }
+    for (const candidate of candidates) {
+        const candidateHash = g2CandidateItemHash(candidate);
+        candidate.human_review = resolutions.find((resolution) => resolution.candidate_id === candidate.id && resolution.candidate_hash === candidateHash) ?? null;
+    }
+    candidates.sort((left, right) => {
+        const attestation = attestationRank[left.attestation.status] - attestationRank[right.attestation.status];
+        if (attestation)
+            return attestation;
+        const leftSource = left.scope.paths.some((path) => path.startsWith("src/")) ? 0 : 1;
+        const rightSource = right.scope.paths.some((path) => path.startsWith("src/")) ? 0 : 1;
+        if (leftSource !== rightSource)
+            return leftSource - rightSource;
+        const basis = basisRank[left.basis] - basisRank[right.basis];
+        if (basis)
+            return basis;
+        return right.commit_date.localeCompare(left.commit_date)
+            || left.commit.localeCompare(right.commit)
+            || left.candidate_id.localeCompare(right.candidate_id);
+    });
+    const counts = {
+        human_grounded_exact: candidates.filter((candidate) => candidate.attestation.status === "human_grounded_exact").length,
+        human_grounded_needs_selection: candidates.filter((candidate) => candidate.attestation.status === "human_grounded_needs_selection").length,
+        unattested_structural_coincidence: candidates.filter((candidate) => candidate.attestation.status === "unattested_structural_coincidence").length,
+        selected_candidates: candidates.filter((candidate) => candidate.human_review?.disposition === "selected").length,
+        rejected_candidates: candidates.filter((candidate) => candidate.human_review?.disposition === "rejected").length,
+        unreviewed_candidates: candidates.filter((candidate) => candidate.human_review === null).length,
+    };
+    const items = candidates.slice(0, limit);
+    const body = {
+        since,
+        max_commits: maxCommits,
+        limit,
+        scanned_fix_commits: commits.length,
+        candidate_commits: candidateCommits,
+        total_candidates: candidates.length,
+        ...counts,
+        extraction_failures: failures.sort((left, right) => left.commit.localeCompare(right.commit)),
+        items,
+        has_more: candidates.length > items.length,
+        data_class: "private",
+        authority: "none",
+        writes: "none",
+        proof_status: "not_run",
+    };
+    const contentHash = canonicalHash(body);
+    return { id: `g2candidates_${shortHash(contentHash)}`, content_hash: contentHash, ...body };
+}
+//# sourceMappingURL=g2Candidates.js.map