@davesheffer/hunch 1.8.2 → 1.9.2

package/dist/constitution/adapters.js

@@ -4,9 +4,11 @@ import { basename, resolve } from "node:path";
 import { shortHash } from "../core/ids.js";
 import { parseDocAnchors } from "../core/docanchors.js";
 import { toPosixTarget } from "../core/paths.js";
-import { commitMeta, revExists, revParse } from "../extractors/git.js";
+import { isHumanConfirmed } from "../core/strictgate.js";
+import { stableRepositoryName } from "../extractors/git.js";
 import { durationCutoff } from "./bootstrap.js";
 import { canonicalHash } from "./canonical.js";
+import { replacementFreeCommitMeta, replacementFreeExactCommit, replacementFreeGitEnvironment, } from "./replacementFreeGit.js";
 import { EvidenceEventSchema, EvidenceImportSchema, } from "./schema.js";
 const MAX_INSTRUCTION_FILES = 64;
 const MAX_INSTRUCTION_FILE_BYTES = 512 * 1024;
@@ -55,6 +57,7 @@ function committedInstructionFiles(root) {
     try {
         const raw = execFileSync("git", ["-C", root, "ls-tree", "-r", "-z", "--name-only", "HEAD"], {
             encoding: "buffer",
+            env: replacementFreeGitEnvironment(),
             maxBuffer: 16 * 1024 * 1024,
             stdio: ["ignore", "pipe", "ignore"],
         });
@@ -69,12 +72,14 @@ function committedFileAt(root, revision, file, maxBytes) {
         const object = `${revision}:${file}`;
         const size = Number(execFileSync("git", ["-C", root, "cat-file", "-s", object], {
             encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
             stdio: ["ignore", "pipe", "ignore"],
         }).trim());
         if (!Number.isFinite(size) || size < 0 || size > maxBytes)
             return null;
         return execFileSync("git", ["-C", root, "cat-file", "blob", object], {
             encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
             maxBuffer: maxBytes + 1,
             stdio: ["ignore", "pipe", "ignore"],
         });
@@ -102,6 +107,7 @@ function authoredInstructionCommit(root, file, sourceHash) {
             file,
         ], {
             encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
             maxBuffer: 1024 * 1024,
             stdio: ["ignore", "pipe", "ignore"],
         }).split(/\r?\n/).filter(Boolean);
@@ -135,12 +141,12 @@ function instructionEvents(root, dataClass, policies, constraints) {
         totalBytes += Buffer.byteLength(source, "utf8");
         const sourceHash = canonicalHash(source);
         const introducedAt = authoredInstructionCommit(root, file, sourceHash);
-        if (!introducedAt || !revExists(introducedAt, root)) {
+        const commit = introducedAt ? replacementFreeExactCommit(root, introducedAt) : null;
+        if (!commit) {
             excluded++;
             continue;
         }
-        const commit = revParse(`${introducedAt}^{commit}`, root);
-        const meta = commitMeta(commit, root);
+        const meta = replacementFreeCommitMeta(root, commit);
         if (!meta || !Number.isFinite(Date.parse(meta.date))) {
             excluded++;
             continue;
@@ -213,9 +219,10 @@ function importEvents(root, file, store, repository, opts, policies, constraints
         }
         let commit;
         if (item.commit) {
-            if (!revExists(item.commit, root))
+            const exactCommit = replacementFreeExactCommit(root, item.commit);
+            if (!exactCommit)
                 throw new Error(`evidence import item ${item.id} commit ${item.commit} does not resolve`);
-            commit = revParse(`${item.commit}^{commit}`, root);
+            commit = exactCommit;
         }
         const files = [...new Set(item.files.map(normalizeRepoFile))].sort();
         const symbols = [...new Set(item.symbols)].sort();
@@ -294,7 +301,9 @@ function isPrivateRecord(store, kind, id, opts) {
         return false;
     return !!store.getPrivateRec(kind, id);
 }
-function correctionEvent(root, constraint, isPrivate) {
+/** Canonical evidence projection for one captured correction. Materializers may
+ * reuse this projection, but ingestion itself remains evidence-only. */
+export function correctionEvidenceEvent(root, constraint, dataClass) {
     const occurredAt = constraint.valid_from ?? constraint.provenance.last_verified;
     if (!occurredAt || !Number.isFinite(Date.parse(occurredAt)))
         return null;
@@ -306,16 +315,16 @@ function correctionEvent(root, constraint, isPrivate) {
         match: constraint.match,
         source_decision: constraint.source_decision,
     });
-    const event = EvidenceEventSchema.parse({
+    return EvidenceEventSchema.parse({
         id: `ev_${shortHash(`correction:${contentHash}`)}`,
         kind: "correction",
         occurred_at: occurredAt,
-        repository: basename(root),
+        repository: stableRepositoryName(root),
         files: constraint.scope.filter((scope) => scope !== "**"),
         symbols: constraint.forbids?.symbols ?? [],
         text_ref: constraint.id,
         related_records: [constraint.id, ...(constraint.source_decision ? [constraint.source_decision] : [])],
-        data_class: isPrivate ? "private" : "public",
+        data_class: dataClass,
         content_hash: contentHash,
         compiler: {
             status: "covered",
@@ -329,11 +338,19 @@ function correctionEvent(root, constraint, isPrivate) {
             last_verified: constraint.provenance.last_verified,
         },
     });
-    return { occurredAt, event, private: isPrivate };
+}
+function correctionEvent(store, root, constraint, isPrivate) {
+    // A public evidence event may only name a source decision that is itself
+    // public. Missing/private-only ids are excluded before serialization so a
+    // machine without the overlay cannot accidentally declassify the reference.
+    if (!isPrivate && constraint.source_decision && !store.json.get("decisions", constraint.source_decision))
+        return null;
+    const event = correctionEvidenceEvent(root, constraint, isPrivate ? "private" : "public");
+    return event ? { occurredAt: event.occurred_at, event, private: isPrivate } : null;
 }
 function bugEvent(root, store, repository, bug, isPrivate, opts) {
     const commit = bug.lineage.fixed_commit ?? bug.lineage.introduced_commit;
-    const meta = commit ? commitMeta(commit, root) : null;
+    const meta = commit ? replacementFreeCommitMeta(root, commit) : null;
     const occurredAt = meta?.date ?? bug.provenance.last_verified;
     if (!occurredAt || !Number.isFinite(Date.parse(occurredAt)))
         return null;
@@ -411,11 +428,11 @@ export function ingestLocalEvidence(store, root, repository, opts = {}) {
     let scanned = records.constraints.length + records.bugs.length;
     let excluded = 0;
     for (const constraint of records.constraints) {
-        if (constraint.status !== "active" || !constraint.provenance.source.includes("human_confirmed")) {
+        if (constraint.status !== "active" || !isHumanConfirmed(constraint.provenance.source)) {
             excluded++;
             continue;
         }
-        const item = correctionEvent(root, constraint, isPrivateRecord(store, "constraints", constraint.id, opts));
+        const item = correctionEvent(store, root, constraint, isPrivateRecord(store, "constraints", constraint.id, opts));
         if (!item || Date.parse(item.occurredAt) < minDate)
             excluded++;
         else

package/dist/constitution/behaviorEvaluator.js

@@ -1,13 +1,15 @@
 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 { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { headSha, revExists } from "../extractors/git.js";
+import { headSha } from "../extractors/git.js";
 import { canonicalHash } from "./canonical.js";
 import { nodeTestInfrastructureError } from "./g2BehaviorCandidates.js";
-import { dependencySnapshotForCommit } from "./g2BehaviorDependencies.js";
+import { dependencySnapshotForCommit, materializeDependencySnapshot } from "./g2BehaviorDependencies.js";
 import { cleanupReplayWorktree, hasUnsafeReplayFilter, replayGitArgs } from "./replay.js";
+import { hasUnsafeCheckoutAttributes } from "./safeCheckout.js";
+import { replacementFreeExactCommit, replacementFreeGitEnvironment } from "./replacementFreeGit.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";
@@ -22,6 +24,7 @@ function behaviorEnvironment(home, gitConfig) {
         HOME: home,
         GIT_CONFIG_GLOBAL: gitConfig,
         GIT_CONFIG_NOSYSTEM: "1",
+        GIT_NO_REPLACE_OBJECTS: "1",
         GIT_TERMINAL_PROMPT: "0",
         GIT_LFS_SKIP_SMUDGE: "1",
         HUNCH_PRIVATE_DIR: "",
@@ -31,10 +34,17 @@ function behaviorEnvironment(home, gitConfig) {
         FORCE_COLOR: "0",
     };
 }
+function behaviorWorkspaceCaptureEnvironment(home, gitConfig) {
+    const env = behaviorEnvironment(home, gitConfig);
+    if (process.env.GIT_INDEX_FILE)
+        env.GIT_INDEX_FILE = process.env.GIT_INDEX_FILE;
+    return env;
+}
 function sourceAt(root, commit, file) {
     try {
         return execFileSync("git", ["-C", root, "show", `${commit}:${file}`], {
             encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
             maxBuffer: 10 * 1024 * 1024,
             stdio: ["ignore", "pipe", "ignore"],
         });
@@ -74,7 +84,7 @@ export function evaluateExecutableBehaviorPolicy(root, policy, opts = {}) {
     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"));
+        const env = behaviorWorkspaceCaptureEnvironment(probe, join(probe, "global.gitconfig"));
         try {
             writeFileSync(join(probe, "global.gitconfig"), "");
             workspace = captureBehaviorWorkspace(root, commit, opts.workspace, env);
@@ -103,7 +113,7 @@ export function evaluateExecutableBehaviorPolicy(root, policy, opts = {}) {
         exit_code: null,
         selected_event: null,
     };
-    if (!/^[a-f0-9]{40}$/.test(commit) || !revExists(commit, root)) {
+    if (!/^[a-f0-9]{40}$/.test(commit) || replacementFreeExactCommit(root, commit) !== commit) {
         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);
@@ -132,6 +142,9 @@ export function evaluateExecutableBehaviorPolicy(root, policy, opts = {}) {
         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 if (hasUnsafeCheckoutAttributes(root, commit, env, { allowDisabledLfs: true })) {
+            result = evaluation(policy, commit, { ...baseExecution, commit, dependency_snapshot_id: dependency.snapshot.id, error_code: "unsafe-checkout-attributes" }, "error", "repository has checkout attributes that could transform or merge exact source bytes");
+        }
         else {
             execFileSync("git", replayGitArgs(root, hooks, ["worktree", "add", "--detach", "--force", checkout, commit]), {
                 env,
@@ -141,7 +154,7 @@ export function evaluateExecutableBehaviorPolicy(root, policy, opts = {}) {
             added = true;
             if (workspace)
                 applyBehaviorWorkspace(root, checkout, workspace, env);
-            symlinkSync(dependency.nodeModules, join(checkout, "node_modules"), process.platform === "win32" ? "junction" : "dir");
+            materializeDependencySnapshot(dependency, join(checkout, "node_modules"));
             const testFile = join(checkout, assertion.test.file);
             mkdirSync(dirname(testFile), { recursive: true });
             writeFileSync(testFile, source);
@@ -155,7 +168,7 @@ export function evaluateExecutableBehaviorPolicy(root, policy, opts = {}) {
             ];
             const args = assertion.runner === "node-test"
                 ? common
-                : [join(dependency.nodeModules, "tsx", "dist", "cli.mjs"), ...common];
+                : [join(checkout, "node_modules", "tsx", "dist", "cli.mjs"), ...common];
             const run = spawnSync(process.execPath, args, {
                 cwd: checkout,
                 env,

package/dist/constitution/behaviorProof.js

@@ -1,4 +1,3 @@
-import { basename } from "node:path";
 import { shortHash } from "../core/ids.js";
 import { headSha } from "../extractors/git.js";
 import { evaluateExecutableBehaviorPolicy } from "./behaviorEvaluator.js";
@@ -81,7 +80,9 @@ export function createExecutableBehaviorProofPlan(root, repository, policy, opts
     const body = {
         policy_id: policy.id,
         policy_candidate_hash: policyHash,
-        repository: basename(root),
+        // Bind to the immutable corpus label so a teammate in a differently named
+        // clone reuses the same executable-behavior plan instead of minting a fork.
+        repository: corpus.repository,
         data_class: policy.data_class,
         source_commit: policy.assertion.test.source_commit,
         valid_from_commit: policy.assertion.test.source_commit,

package/dist/constitution/canonical.js

@@ -1,11 +1,12 @@
 import { sha1, shortHash } from "../core/ids.js";
+import { compareCodeUnits } from "../core/canonicalOrder.js";
 function canonicalValue(value) {
     if (Array.isArray(value))
         return value.map(canonicalValue);
     if (value && typeof value === "object") {
         return Object.fromEntries(Object.entries(value)
             .filter(([, v]) => v !== undefined)
-            .sort(([a], [b]) => a.localeCompare(b))
+            .sort(([a], [b]) => compareCodeUnits(a, b))
             .map(([k, v]) => [k, canonicalValue(v)]));
     }
     return value;
@@ -23,6 +24,11 @@ export function canonicalHash(value) {
 export function policySemanticHash(policy) {
     return canonicalHash({
         id: policy.id,
+        // Preserve existing generic-policy hashes while binding the correction
+        // compiler's provenance and permanent MD-1a activation gate into every
+        // correction proof. Removing either makes that proof stale.
+        ...(policy.origin !== "generic" ? { origin: policy.origin } : {}),
+        ...(policy.activation_gate ? { activation_gate: policy.activation_gate } : {}),
         ir_version: policy.ir_version,
         statement: policy.statement,
         scope: policy.scope,

package/dist/constitution/card.js

@@ -14,8 +14,9 @@ export function buildProofCard(policy, proof, dispositions = [], composition = [
     const baselineClean = proof.current.total === 1 && proof.current.satisfied === 1 && proof.current.unknown === 0 && proof.current.error === 0;
     const dispositionAssessment = assessHistoryDispositions(proof, dispositions);
     const evidenceError = blockingEvidenceError(proof, dispositions);
+    const activationError = policy.activation_gate?.status === "blocked" ? policy.activation_gate.reason : null;
     const proofStrongEnough = proofRank[proof.proof_class] >= proofRank.P3;
-    const eligible = semanticMatch && baselineClean && proofStrongEnough && !evidenceError;
+    const eligible = semanticMatch && baselineClean && proofStrongEnough && !evidenceError && !activationError;
     const canBlock = eligible && policy.state === "active_blocking" && policy.severity === "blocking" && policy.authority?.kind === "human";
     const unknownResults = proof.current.unknown + proof.known_bad.unknown + proof.known_good.unknown + proof.accepted_history.unknown + proof.mutations.unknown;
     const errorResults = proof.current.error + proof.known_bad.error + proof.known_good.error + proof.accepted_history.error + proof.mutations.error;
@@ -36,6 +37,8 @@ export function buildProofCard(policy, proof, dispositions = [], composition = [
         actions.push("Repair every failed required mutation control before considering blocking approval.");
     if (policy.candidate.conflicts.length)
         actions.push("Resolve every direct candidate conflict with a human disposition before lifecycle promotion.");
+    if (activationError)
+        actions.push(`Activation is mechanically blocked: ${activationError}`);
     if (shadowPrecision?.recommendation === "eligible_for_p4_review")
         actions.push("Shadow thresholds are met; a human may review P4 evidence, but measurement grants no authority.");
     else if (shadowPrecision)
@@ -57,6 +60,7 @@ export function buildProofCard(policy, proof, dispositions = [], composition = [
             evidence: [...policy.evidence],
             candidate: policy.candidate,
             exception_of: policy.exception_of,
+            activation_gate: policy.activation_gate,
         },
         proof: { id: proof.id, proof_class: proof.proof_class, plan_hash: proof.plan_hash, generated_at: proof.generated_at },
         evidence_vector: {
@@ -88,7 +92,7 @@ export function buildProofCard(policy, proof, dispositions = [], composition = [
             current: policy.authority,
             eligible_for_human_blocking_approval: eligible,
             can_block_now: canBlock,
-            blocking_evidence_error: evidenceError,
+            blocking_evidence_error: activationError ?? evidenceError,
         },
         actions,
     };
@@ -108,6 +112,7 @@ export function renderProofCard(card) {
         `  candidate alternatives: ${card.policy.candidate.alternatives.length} · conflicts: ${card.policy.candidate.conflicts.length} · incumbent: ${card.policy.candidate.incumbent ?? "none"}`,
         `  scope suggestion: ${card.policy.candidate.scope_suggestion ? JSON.stringify(card.policy.candidate.scope_suggestion) : "none — narrow compiled scope retained"}`,
         `  exception parent: ${card.policy.exception_of ?? "none"}`,
+        ...(card.policy.activation_gate ? [`  activation gate: ${card.policy.activation_gate.status} — ${card.policy.activation_gate.reason}`] : []),
         `  ${line("current", card.evidence_vector.current)}`,
         `  ${line("known bad", card.evidence_vector.known_bad)}`,
         `  ${line("known good", card.evidence_vector.known_good)}`,

package/dist/constitution/compiler.js

@@ -1,5 +1,5 @@
 import { policyId } from "./canonical.js";
-import { POLICY_IR_VERSION, PolicySpecSchema } from "./schema.js";
+import { CORRECTION_POLICY_IR_VERSION, POLICY_IR_VERSION, PolicySpecSchema } from "./schema.js";
 function selector(ref) {
     if (ref.startsWith("symbol-id:") || ref.startsWith("symbol:"))
         return { selector: ref };
@@ -173,4 +173,74 @@ export function compileStructuralPolicy(store, input) {
     });
     return { policy, private: isPrivate };
 }
+/** Compile one already-bound correction projection. The caller must first prove
+ * that the projection has exactly one supported structural interpretation. */
+export function compileCorrectionPolicy(store, input) {
+    const isPrivate = input.dataClass !== "public";
+    if (isPrivate && !store.hasPrivate)
+        throw new Error("private correction compilation needs a configured Hunch private overlay");
+    const now = input.now ?? new Date().toISOString();
+    const id = policyId({ assertion: input.assertion, scope: input.scope, data_class: input.dataClass });
+    const refs = [...new Set([
+            input.source.id,
+            input.evidenceId,
+            ...(input.source.source_decision ? [input.source.source_decision] : []),
+        ])].sort();
+    const policy = PolicySpecSchema.parse({
+        id,
+        topic: `correction.${input.source.id}`,
+        origin: "correction_md1a",
+        ir_version: CORRECTION_POLICY_IR_VERSION,
+        revision: 1,
+        state: "compiled",
+        statement: input.source.statement,
+        rationale: input.source.rationale,
+        scope: input.scope,
+        assertion: input.assertion,
+        severity: "warning",
+        surfaces: ["cli", "mcp", "ci"],
+        authority: null,
+        activation_gate: {
+            kind: "source_currentness",
+            status: "blocked",
+            reason: "MD-1a correction projections cannot activate until MD-2 proves that every source correction and decision is still current.",
+        },
+        evidence: refs,
+        proof: null,
+        reversal_conditions: [
+            `Source correction ${input.source.id} is retired or its exact structural interpretation is rejected.`,
+            ...(input.source.source_decision ? [`Source decision ${input.source.source_decision} is superseded or explicitly closed.`] : []),
+        ],
+        supersedes: null,
+        superseded_by: null,
+        exception_of: null,
+        valid_from: null,
+        valid_to: null,
+        data_class: input.dataClass,
+        limitations: [
+            "Scope is intentionally limited to one exact file and anchored to one stable symbol in that file.",
+            "TypeScript/JavaScript static ESM import declarations only; re-exports, require(), dynamic import(), package aliases, and runtime loading are not covered.",
+            "The immediate legacy Constraint remains the fast guard; this MD-1a policy cannot activate until the source-currentness gate is implemented and cleared.",
+        ],
+        candidate: input.candidate,
+        legacy_refs: [input.source.id, ...(input.source.source_decision ? [input.source.source_decision] : [])],
+        audit: [{
+                action: "compiled",
+                actor_kind: "system",
+                actor: "hunch:correction-policy-materializer",
+                at: now,
+                reason: `Compiled from one deterministic supported projection bound to correction ${input.source.id}.`,
+                proof: null,
+            }],
+        created_at: now,
+        updated_at: now,
+        provenance: {
+            source: "derived",
+            confidence: 1,
+            evidence: refs,
+            last_verified: now,
+        },
+    });
+    return { policy, private: isPrivate };
+}
 //# sourceMappingURL=compiler.js.map