@davesheffer/hunch 1.8.3 → 1.9.2

package/dist/constitution/service.js

@@ -1,10 +1,11 @@
 import { execFileSync, spawnSync } from "node:child_process";
 import { headSha } from "../extractors/git.js";
 import { canonicalHash, canonicalJson } from "./canonical.js";
+import { replacementFreeGitEnvironment } from "./replacementFreeGit.js";
 import { shortHash } from "../core/ids.js";
 import { compileDecisionPolicy } from "./compiler.js";
-import { evaluatePolicy, policyBlocks, policyIsActive } from "./evaluator.js";
-import { approvePolicy, blockingProofError, demotePolicy, linkPolicyException, proposeProvedPolicy, retirePolicy, withdrawPolicy } from "./lifecycle.js";
+import { evaluatePolicy, policyBlocks } from "./evaluator.js";
+import { activationGateError, approvePolicy, blockingProofError, demotePolicy, linkPolicyException, proposeProvedPolicy, retirePolicy, withdrawPolicy } from "./lifecycle.js";
 import { provePolicy } from "./proof.js";
 import { PolicyRepository } from "./repository.js";
 import { bootstrapPolicies } from "./bootstrap.js";
@@ -33,6 +34,17 @@ import { G3_REQUIRED_EXPERIMENTS, G3EvidenceRepository, compileExperimentPreregi
 import { executeG3AdapterConformance, g3ConformanceSourceHash } from "./g3Conformance.js";
 import { ExperimentRepository, assignmentTreatment, buildExperimentReport, compileExperimentCaseBank, compileExperimentFollowup, compileExperimentOutcome, compileExperimentReviewStart, compileExperimentReviewerQualification, compileExperimentRun, compileExperimentStop, compileExp03ReviewResponse, currentExperimentOutcomes, experimentReviewGuide, normalizedEditDistance, } from "./experiment.js";
 import { executeExp01Assignment } from "./experimentRunner.js";
+import { materializeCorrectionPolicies, materializeCorrectionPolicy, } from "./correctionPolicyMaterializer.js";
+export function policyEvaluationEnvelope(result) {
+    return {
+        ...result.evaluation,
+        enforcement: {
+            blocks: result.blocks,
+            strict_error: result.strict_error,
+            gate_error: result.gate_error ?? null,
+        },
+    };
+}
 function relationSummary(policy) {
     return {
         id: policy.id,
@@ -76,6 +88,7 @@ export function shadowCommitEligible(root, policy, commit) {
     const sourceCommit = policy.assertion.test.source_commit;
     const check = spawnSync("git", ["-C", root, "merge-base", "--is-ancestor", sourceCommit, commit], {
         encoding: "utf8",
+        env: replacementFreeGitEnvironment(),
         stdio: ["ignore", "ignore", "pipe"],
     });
     if (check.status === 0)
@@ -693,6 +706,7 @@ export class ConstitutionService {
         const manifest = this.g2Repository.currentPlan();
         const commits = manifest ? execFileSync("git", ["-C", this.root, "rev-list", "--first-parent", `--max-count=${maxCommits}`, "HEAD"], {
             encoding: "utf8",
+            env: replacementFreeGitEnvironment(),
             stdio: ["ignore", "pipe", "ignore"],
         }).trim().split("\n").filter((commit) => /^[a-f0-9]{40}$/.test(commit)) : [];
         const attempted = (manifest?.policy_ids.length ?? 0) * commits.length;
@@ -944,6 +958,12 @@ export class ConstitutionService {
     ingest(opts = {}) {
         return ingestLocalEvidence(this.store, this.root, this.repository, opts);
     }
+    upgradeCorrection(id, opts = {}) {
+        return materializeCorrectionPolicy(this.store, this.root, this.repository, id, opts);
+    }
+    upgradeCorrections(opts = {}) {
+        return materializeCorrectionPolicies(this.store, this.root, this.repository, opts);
+    }
     plan(id, opts = {}) {
         const policy = this.get(id, opts);
         const home = opts.publicOnly ? "public" : opts.privateOnly ? "private" : this.repository.homeOfPolicy(id);
@@ -961,7 +981,7 @@ export class ConstitutionService {
         const publicOnly = policy.data_class === "public" && this.repository.homeOfPolicy(id) === "public";
         const homeOpts = publicOnly ? { publicOnly: true } : { privateOnly: true };
         const composition = this.composition(policy, homeOpts);
-        const plan = this.plan(id, { publicOnly, now: opts.now });
+        const plan = this.plan(id, { publicOnly, now: opts.now, repositoryName: opts.repositoryName });
         const proof = provePolicy(this.store, this.root, policy, { publicOnly, now: opts.now, plan, composition });
         this.repository.putProof(proof, policy.id);
         const proposed = proposeProvedPolicy(policy, proof, opts.now ?? proof.generated_at, composition, this.g2BehaviorAttestationRepository.current());
@@ -1037,13 +1057,18 @@ export class ConstitutionService {
             throw new Error(`historical shadow backfill supports executable-behavior policies only; ${policy.id} is ${policy.assertion.kind}`);
         }
         else {
-            evaluation = evaluatePolicy(this.store, this.root, policy, { publicOnly: home === "public", composition });
+            evaluation = evaluatePolicy(this.store, this.root, policy, {
+                publicOnly: home === "public",
+                composition,
+                snapshot: opts.snapshot,
+                behavior: opts.behavior,
+            });
         }
         const latencyMs = opts.latencyMs ?? performance.now() - started;
         const sameMatches = canonicalJson(evaluation.matches);
         const alsoDetectedBy = evaluation.result === "violated"
             && (!opts.commit || opts.commit === currentHead)
-            ? this.evaluate({ activeOnly: true, publicOnly: home === "public" })
+            ? this.evaluate({ activeOnly: true, publicOnly: home === "public", snapshot: opts.snapshot, behavior: opts.behavior })
                 .filter((candidate) => candidate.policy.id !== id
                 && candidate.evaluation.result === "violated"
                 && canonicalJson(candidate.evaluation.matches) === sameMatches)
@@ -1074,7 +1099,10 @@ export class ConstitutionService {
         const audit = this.repository.listShadowDispositions(opts).filter((record) => record.policy_id === id);
         const current = currentShadowDispositions(audit);
         const history = this.repository.listDispositions(opts).filter((record) => record.policy_id === id && record.proof_id === proof.id);
-        const scoringRecords = records.filter((record) => shadowCommitEligible(this.root, policy, record.evaluation.repository.head));
+        const scoringRecords = records.filter((record) => shadowCommitEligible(this.root, policy, 
+        // Workspace receipts retain their content-addressed pseudo-head for
+        // dedupe, but ancestry eligibility is anchored to the real base commit.
+        record.evaluation.repository.base ?? record.evaluation.repository.head));
         const report = scoreShadowPrecision(policy, proof, scoringRecords, audit, history, thresholds);
         return {
             ...report,
@@ -1200,11 +1228,21 @@ export class ConstitutionService {
     }
     evaluate(opts = {}) {
         let policies = opts.id ? [this.get(opts.id, opts)] : this.list(opts);
-        if (opts.activeOnly)
-            policies = policies.filter(policyIsActive);
+        // Select the persisted active lifecycle states, including invalid/tampered
+        // ones. The evaluator below must surface their gate/proof error so strict CI
+        // fails visibly; filtering through policyIsActive would silently erase the
+        // exact fail-closed configuration errors this seam is responsible for.
+        if (opts.activeOnly) {
+            policies = policies.filter((policy) => policy.state === "active_advisory" || policy.state === "active_blocking");
+        }
         return policies.map((policy) => {
             const composition = this.composition(policy, opts);
-            const evaluation = evaluatePolicy(this.store, this.root, policy, { publicOnly: opts.publicOnly, composition, behavior: opts.behavior });
+            const evaluation = evaluatePolicy(this.store, this.root, policy, {
+                publicOnly: opts.publicOnly,
+                composition,
+                behavior: opts.behavior,
+                snapshot: opts.snapshot,
+            });
             let proof;
             let dispositions = [];
             if (policy.state === "active_blocking" && policy.proof) {
@@ -1214,7 +1252,12 @@ export class ConstitutionService {
                 dispositions = this.repository.listDispositions(homeOpts).filter((record) => record.policy_id === policy.id && record.proof_id === policy.proof);
             }
             const behaviorBindingError = executableBehaviorAttestationError(policy, this.g2BehaviorAttestationRepository.current());
-            const gateError = behaviorBindingError ?? blockingProofError(policy, proof, dispositions, composition, this.g2BehaviorAttestationRepository.current());
+            const activeActivationError = policy.state === "active_advisory" || policy.state === "active_blocking"
+                ? activationGateError(policy)
+                : null;
+            const gateError = behaviorBindingError
+                ?? activeActivationError
+                ?? blockingProofError(policy, proof, dispositions, composition, this.g2BehaviorAttestationRepository.current());
             return {
                 policy,
                 evaluation,

package/dist/constitution/sourceMutation.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join, posix, relative } from "node:path";
+import { closeSync, constants, fstatSync, ftruncateSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, realpathSync, rmSync, writeFileSync, writeSync, } from "node:fs";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { hunchPathsForDir } from "../core/paths.js";
 import { symbolId } from "../core/ids.js";
 import { externalPackage } from "../core/externalImports.js";
@@ -11,6 +11,7 @@ import { parseSource } from "../extractors/parse.js";
 import { HunchStore } from "../store/hunchStore.js";
 import { canonicalHash } from "./canonical.js";
 import { evaluatePolicyOnSnapshot, graphSnapshot } from "./evaluator.js";
+import { hasUnsafeCheckoutAttributes } from "./safeCheckout.js";
 function safeEnvironment(home, gitConfig) {
     const env = {};
     for (const key of ["PATH", "SystemRoot", "WINDIR", "TMPDIR", "TMP", "TEMP"]) {
@@ -22,6 +23,7 @@ function safeEnvironment(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: "",
@@ -232,6 +234,37 @@ function removeWorktree(root, hooks, env, checkout) {
         }
     }
 }
+function openRegularSourceNoFollow(checkout, sourceFile) {
+    const file = join(checkout, sourceFile);
+    const before = lstatSync(file);
+    if (before.isSymbolicLink())
+        throw new Error("mutation-source-symlink-unsupported");
+    if (!before.isFile())
+        throw new Error("mutation-source-not-regular");
+    const canonicalCheckout = realpathSync(checkout);
+    const canonicalFile = realpathSync(file);
+    const fromCheckout = relative(canonicalCheckout, canonicalFile);
+    if (!fromCheckout || fromCheckout === ".." || fromCheckout.startsWith(`..${sep}`) || isAbsolute(fromCheckout)
+        || canonicalFile !== resolve(canonicalCheckout, sourceFile)) {
+        throw new Error("mutation-source-outside-checkout");
+    }
+    let descriptor;
+    try {
+        descriptor = openSync(file, constants.O_RDWR | constants.O_NOFOLLOW);
+        const opened = fstatSync(descriptor);
+        if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) {
+            throw new Error("mutation-source-changed-before-open");
+        }
+        return descriptor;
+    }
+    catch (error) {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+        if (error.code === "ELOOP")
+            throw new Error("mutation-source-symlink-unsupported");
+        throw error;
+    }
+}
 /** Apply one primary mutation to an immutable disposable source checkout. No
  * project script, build, test, provider, model, or repository hook executes. */
 export function runSourceMutation(root, policy, base) {
@@ -255,6 +288,9 @@ export function runSourceMutation(root, policy, base) {
     try {
         if (unsafeLocalFilter(root, env))
             throw new Error("unsafe-local-filter-config");
+        if (hasUnsafeCheckoutAttributes(root, base.head, env, { allowDisabledLfs: true })) {
+            throw new Error("unsafe-checkout-attributes");
+        }
         execFileSync("git", gitArgs(root, hooks, ["worktree", "add", "--detach", "--force", checkout, base.head]), {
             env,
             timeout: 30_000,
@@ -266,15 +302,32 @@ export function runSourceMutation(root, policy, base) {
         const sourceFile = subject?.file ?? (subjectComponent ? componentFiles(base, subjectComponent)[0] : undefined);
         if (!sourceFile)
             throw new Error("mutation-subject-unresolved");
-        const file = join(checkout, sourceFile);
-        const mutation = mutateSource(policy, base, sourceFile, readFileSync(file, "utf8"));
-        if ("error" in mutation)
-            throw new Error(mutation.error);
-        const parsed = parseSource(mutation.file, mutation.source);
-        if (!parsed?.parseable)
-            throw new Error("mutation-source-unparseable");
-        writeFileSync(file, mutation.source);
-        const diff = execFileSync("git", gitArgs(checkout, hooks, ["diff", "--no-ext-diff", "--", mutation.file]), {
+        const descriptor = openRegularSourceNoFollow(checkout, sourceFile);
+        let mutation;
+        try {
+            const attempted = mutateSource(policy, base, sourceFile, readFileSync(descriptor, "utf8"));
+            if ("error" in attempted)
+                throw new Error(attempted.error);
+            mutation = attempted;
+            if (mutation.file !== sourceFile)
+                throw new Error("mutation-source-target-changed");
+            const parsed = parseSource(mutation.file, mutation.source);
+            if (!parsed?.parseable)
+                throw new Error("mutation-source-unparseable");
+            ftruncateSync(descriptor, 0);
+            const bytes = Buffer.from(mutation.source, "utf8");
+            let written = 0;
+            while (written < bytes.length) {
+                const count = writeSync(descriptor, bytes, written, bytes.length - written, written);
+                if (!count)
+                    throw new Error("mutation-source-write-incomplete");
+                written += count;
+            }
+        }
+        finally {
+            closeSync(descriptor);
+        }
+        const diff = execFileSync("git", gitArgs(checkout, hooks, ["diff", "--no-ext-diff", "--no-textconv", "--", mutation.file]), {
             env,
             encoding: "utf8",
             timeout: 10_000,
@@ -286,7 +339,7 @@ export function runSourceMutation(root, policy, base) {
             throw new Error("mutation-source-diff-too-large");
         store = new HunchStore(hunchPathsForDir(graph));
         store.json.ensureDirs();
-        indexRepo(store, checkout, { churn: false });
+        indexRepo(store, checkout, { churn: false, requireComplete: true });
         const snapshot = graphSnapshot(store, root, { publicOnly: true, head: base.head });
         outcome = {
             snapshot,

package/dist/constitution/staticGraphBaseline.js

@@ -0,0 +1,44 @@
+import { CODE_EXTENSIONS } from "../extractors/languages.js";
+import { replacementFreeCommitFiles, replacementFreeExactCommit, replacementFreeIsAncestorOrSame, } from "./replacementFreeGit.js";
+const touchesGraphOrCheckoutInputs = (files) => files.some((file) => CODE_EXTENSIONS.some((extension) => file.endsWith(extension))
+    || file === ".gitattributes"
+    || file.endsWith("/.gitattributes"));
+/** Canonical committed identity for the deterministic static graph.
+ *
+ * Public Hunch pumping creates clone-local commits containing `.hunch/` JSON and
+ * sometimes refreshed grounding docs. Those commits do not change anything the
+ * indexer parses, so binding a shared static receipt to their local SHA makes the
+ * same graph produce different artifact ids in otherwise identical clones. Walk
+ * first-parent until the newest indexed-code or checkout-attribute change instead.
+ * Attributes are a boundary because proof replay validates them before materializing
+ * exact source bytes. A merge is always a boundary: its resolution can change the
+ * effective tree even when a simple diff listing is incomplete. Reverts touch code
+ * and therefore remain distinct. */
+export function canonicalStaticGraphBaseline(root, ref = "HEAD") {
+    const repositoryRef = replacementFreeExactCommit(root, ref);
+    if (!repositoryRef)
+        throw new Error(`static graph baseline needs a resolvable Git commit, got ${ref}`);
+    let current = repositoryRef;
+    const seen = new Set();
+    while (!seen.has(current)) {
+        seen.add(current);
+        if (replacementFreeExactCommit(root, `${current}^2`))
+            return current;
+        if (touchesGraphOrCheckoutInputs(replacementFreeCommitFiles(root, current)))
+            return current;
+        // With no indexed-code commit at all, the repository root is the one
+        // cross-clone-resolvable anchor for the empty static graph. Returning the
+        // caller's docs/memory-only HEAD would reintroduce clone-local receipt churn.
+        const parent = replacementFreeExactCommit(root, `${current}^1`);
+        if (!parent)
+            return current;
+        if (parent === current)
+            return repositoryRef;
+        current = parent;
+    }
+    return current;
+}
+export function isAncestorOrSame(root, ancestor, descendant) {
+    return replacementFreeIsAncestorOrSame(root, ancestor, descendant);
+}
+//# sourceMappingURL=staticGraphBaseline.js.map

package/dist/constitution/structural.js

@@ -1,4 +1,5 @@
-import { basename } from "node:path";
+import { builtinModules } from "node:module";
+import { basename, extname } from "node:path";
 import { externalImportNodeId, externalPackage } from "../core/externalImports.js";
 import { pathMatchesGlob } from "../core/glob.js";
 import { shortHash } from "../core/ids.js";
@@ -9,6 +10,7 @@ import { clampCandidateLimit, durationCutoff } from "./bootstrap.js";
 import { compileStructuralPolicy } from "./compiler.js";
 import { extractStructuralDelta } from "./delta.js";
 import { EvidenceEventSchema, PolicySpecSchema, } from "./schema.js";
+const builtinModuleSpecifiers = new Set(builtinModules);
 const exactSelector = (symbol) => ({ selector: `symbol:${symbol.file}:${symbol.name}` });
 function scopeFor(store, file, publicOnly) {
     const components = (publicOnly ? store.json.loadAll("components") : store.recs("components"))
@@ -20,6 +22,58 @@ function scopeFor(store, file, publicOnly) {
 function candidateId(assertion, scope) {
     return `cand_${shortHash(canonicalHash({ assertion, scope }))}`;
 }
+/** Bind one exact file/package boundary to the existing static import graph.
+ * The file-level fact is anchored to the first stable symbol because the
+ * indexer attaches every external import in a file to every symbol in it. */
+export function inspectExternalImportBoundary(store, file, specifier, opts = {}) {
+    const supportedExtensions = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+    if (!supportedExtensions.has(extname(file).toLowerCase())) {
+        return {
+            candidate: null,
+            reason: `${file} is outside MD-1a's TypeScript/JavaScript static ESM import-declaration projection`,
+            code: "unsupported_file",
+        };
+    }
+    const exactSpecifier = specifier.trim();
+    const dependency = externalPackage(exactSpecifier);
+    const external = externalImportNodeId(exactSpecifier);
+    const exactNpmPackage = /^(?:@[A-Za-z0-9][A-Za-z0-9._~-]*\/)?[A-Za-z0-9][A-Za-z0-9._~-]*$/;
+    if (!dependency || !external || dependency !== exactSpecifier || builtinModuleSpecifiers.has(exactSpecifier)
+        || !exactNpmPackage.test(exactSpecifier)) {
+        return {
+            candidate: null,
+            reason: `${specifier} is not one exact top-level npm package identity; package subpaths, built-ins, and scheme specifiers are unsupported`,
+            code: "unsupported_dependency",
+        };
+    }
+    const symbols = (opts.publicOnly ? store.json.loadAll("symbols") : store.recs("symbols"))
+        .filter((symbol) => symbol.file === file)
+        .sort((left, right) => left.id.localeCompare(right.id));
+    if (!symbols.length)
+        return { candidate: null, reason: `${file} has no exact current symbol to anchor a file-scoped import policy`, code: "missing_anchor" };
+    const edges = opts.publicOnly ? store.json.loadAll("edges") : store.recs("edges");
+    const symbolIds = new Set(symbols.map((symbol) => symbol.id));
+    if (edges.some((edge) => edge.type === "imports" && symbolIds.has(edge.from) && edge.to === external)) {
+        return { candidate: null, reason: `${file} currently imports ${dependency}; fix the baseline before Hunch builds a proof packet`, code: "baseline_violated" };
+    }
+    const assertion = {
+        kind: "not-reaches",
+        subject: exactSelector(symbols[0]),
+        relation: { edges: ["imports"], transitive: false, max_depth: 1 },
+        object: { selector: `external:${dependency}` },
+    };
+    const scope = scopeFor(store, file, !!opts.publicOnly);
+    return {
+        candidate: {
+            id: candidateId(assertion, scope),
+            assertion,
+            scope,
+            basis: "correction-forbidden-import",
+            reason: `human correction forbids direct external package ${dependency} in ${file}`,
+        },
+        reason: null,
+    };
+}
 function alternativeFor(candidate) {
     return {
         id: candidate.id,
@@ -45,16 +99,18 @@ function candidateContext(enumerated, selected, conflicts = [], incumbent = null
         counterexamples: [...new Set(counterexamples)].sort(),
     };
 }
-function structuralKey(policy) {
+export function structuralKey(policy) {
     return canonicalHash({ assertion: policy.assertion, scope: policy.scope, data_class: policy.data_class });
 }
 function scopesOverlap(left, right) {
     const repoOverlap = !left.repos.length || !right.repos.length || left.repos.some((repo) => right.repos.includes(repo));
-    const pathOverlap = !left.paths.length || !right.paths.length || left.paths.some((path) => right.paths.includes(path));
+    const pathOverlap = !left.paths.length || !right.paths.length || left.paths.some((leftPath) => right.paths.some((rightPath) => leftPath === rightPath
+        || pathMatchesGlob(leftPath, rightPath)
+        || pathMatchesGlob(rightPath, leftPath)));
     const componentOverlap = !left.components.length || !right.components.length || left.components.some((component) => right.components.includes(component));
     return repoOverlap && pathOverlap && componentOverlap;
 }
-function directConflict(candidate, incumbent) {
+export function directConflict(candidate, incumbent) {
     const left = candidate.assertion;
     const right = incumbent.assertion;
     if (!((left.kind === "reaches" && right.kind === "not-reaches") || (left.kind === "not-reaches" && right.kind === "reaches")))

package/dist/core/autoreview.js

@@ -48,7 +48,7 @@ export function planAutoReview(drafts, allDecisions, verdicts, cfg = {}) {
     }
     return plan;
 }
-/** Total drafts the plan would mutate (accept + both delete buckets). */
+/** Total drafts the plan would mutate (accept + both rejection buckets). */
 export function planMutations(plan) {
     return plan.accept.length + plan.rejectDuplicate.length + plan.rejectIrrelevant.length;
 }

package/dist/core/canonicalOrder.js

@@ -0,0 +1,6 @@
+/** Locale-free UTF-16 code-unit ordering for content-addressed artifacts.
+ * Never use localeCompare where ordering contributes to a hash or selection. */
+export function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+//# sourceMappingURL=canonicalOrder.js.map

package/dist/core/conformance.js

@@ -1,56 +1,97 @@
-function resolveSymbol(store, ref) {
-    const syms = store.recs("symbols");
+function resolveSymbols(graph, ref) {
+    const syms = graph.symbols;
     if (ref.startsWith("sym_"))
-        return syms.find((s) => s.id === ref) ?? null;
+        return syms.filter((s) => s.id === ref);
     if (ref.includes(":")) {
-        const [f, n] = ref.split(":");
-        return syms.find((s) => s.name === n && (s.file === f || s.file.endsWith("/" + (f ?? "")))) ?? null;
+        const split = ref.lastIndexOf(":");
+        const file = ref.slice(0, split);
+        const name = ref.slice(split + 1);
+        return syms.filter((s) => s.name === name && (s.file === file || s.file.endsWith("/" + file)));
     }
-    return syms.find((s) => s.name === ref) ?? null;
+    return syms.filter((s) => s.name === ref);
 }
-function reaches(store, id, transitive) {
-    const set = new Set();
-    for (const d of store.getDependencies(id, transitive ? 6 : 1)) {
-        if (transitive || d.depth === 1)
-            set.add(d.id);
+function reaches(graph, id, transitive) {
+    const reached = new Set();
+    const seen = new Set([id]);
+    const queue = [{ id, depth: 0 }];
+    const maxDepth = transitive ? 6 : 1;
+    const traversable = new Set(["calls", "depends_on", "imports", "contains"]);
+    const outgoing = new Map();
+    for (const edge of graph.edges) {
+        if (!traversable.has(edge.type))
+            continue;
+        const targets = outgoing.get(edge.from) ?? [];
+        targets.push(edge.to);
+        outgoing.set(edge.from, targets);
     }
-    return set;
+    while (queue.length) {
+        const current = queue.shift();
+        if (current.depth >= maxDepth)
+            continue;
+        for (const next of outgoing.get(current.id) ?? []) {
+            reached.add(next);
+            if (seen.has(next))
+                continue;
+            seen.add(next);
+            queue.push({ id: next, depth: current.depth + 1 });
+        }
+    }
+    return reached;
 }
-function evalPredicate(store, d, p) {
+function evalPredicate(graph, d, p) {
     const base = { decision: d.id, title: d.title, assert: p.assert, subject: p.subject, object: p.object };
-    const subj = resolveSymbol(store, p.subject);
+    const subjects = resolveSymbols(graph, p.subject);
     if (p.assert === "exists") {
-        return { ...base, satisfied: !!subj, detail: subj ? `${p.subject} exists (${subj.file})` : `${p.subject} no longer exists in the graph` };
+        return { ...base, satisfied: subjects.length > 0, detail: subjects.length ? `${p.subject} exists (${subjects.map((subject) => subject.file).join(", ")})` : `${p.subject} no longer exists in the graph` };
     }
-    if (!subj)
+    if (!subjects.length)
         return { ...base, satisfied: false, detail: `subject "${p.subject}" not found in the graph — intent's subject is gone` };
     const wantReach = p.assert === "calls" || p.assert === "imports";
-    const obj = p.object ? resolveSymbol(store, p.object) : null;
-    if (!obj) {
+    const objects = p.object ? resolveSymbols(graph, p.object) : [];
+    if (!objects.length) {
         // a required target gone ⇒ the link can't hold (violated); a forbidden one trivially holds.
         return { ...base, satisfied: !wantReach, detail: `target "${p.object ?? ""}" not found in the graph` };
     }
-    const linked = reaches(store, subj.id, p.transitive).has(obj.id);
+    // A required relation cannot guess which same-name symbol carries the intent.
+    // Force qualification instead of accidentally proving a different binding.
+    if (wantReach && (subjects.length !== 1 || objects.length !== 1)) {
+        return {
+            ...base,
+            satisfied: false,
+            detail: `ambiguous required binding (${subjects.length} subject, ${objects.length} target matches) — qualify as file:symbol; intent VIOLATED`,
+        };
+    }
+    // A forbidden relation is conservative in the other direction: ANY matching
+    // subject reaching ANY same-name target is a real counterexample. Looking at
+    // only the first target lets a duplicate symbol hide a violation.
+    const linked = subjects.some((subject) => {
+        const reached = reaches(graph, subject.id, p.transitive);
+        return objects.some((object) => reached.has(object.id));
+    });
     const satisfied = wantReach ? linked : !linked;
     const via = p.transitive ? " (transitively)" : "";
     const detail = satisfied
         ? wantReach
-            ? `${subj.name} →${via} ${obj.name} ✓`
-            : `${subj.name} does not reach ${obj.name} ✓`
+            ? `${p.subject} →${via} ${p.object} ✓`
+            : `${p.subject} does not reach ${p.object} ✓`
         : wantReach
-            ? `${subj.name} no longer reaches${via} ${obj.name} — intent VIOLATED`
-            : `${subj.name} now reaches${via} ${obj.name} — intent VIOLATED`;
+            ? `${p.subject} no longer reaches${via} ${p.object} — intent VIOLATED`
+            : `${p.subject} now reaches${via} ${p.object} — intent VIOLATED`;
     return { ...base, satisfied, detail };
 }
 /** Check every in-force decision's conformance predicates against the CURRENT graph.
- *  `.satisfied === false` means the code drifted from the recorded intent. Deterministic. */
-export function checkConformance(store) {
+ *  `.satisfied === false` means the code drifted from the recorded intent. Deterministic.
+ *  `publicOnly` selects every input at the JSON read boundary so a private decision,
+ *  symbol, or edge can never influence (or be rendered into) a public CI receipt. */
+export function checkConformance(store, opts = {}) {
+    const load = (kind) => opts.publicOnly ? store.json.loadAll(kind) : store.recs(kind);
+    const graph = opts.graph ?? { symbols: load("symbols"), edges: load("edges") };
     const out = [];
-    for (const d of store.recs("decisions")) {
+    for (const d of load("decisions")) {
         if (d.status === "superseded" || d.superseded_by)
             continue; // in-force decisions only
         for (const p of d.conformance ?? [])
-            out.push(evalPredicate(store, d, p));
+            out.push(evalPredicate(graph, d, p));
     }
     return out;
 }

package/dist/core/docscan.js

@@ -19,6 +19,7 @@ import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { join, extname } from "node:path";
 import { parseDocAnchors } from "./docanchors.js";
 import { currentForTopic } from "./topics.js";
+import { compareCodeUnits } from "./canonicalOrder.js";
 export const STALE_MARKER = /\b(proposed|not yet implemented|no code yet)\b/i;
 export const SRC_REF = /\bsrc\/[A-Za-z0-9_\-/]+\.ts\b/g;
 const SKIP_DIRS = new Set(["node_modules", ".git", ".hunch", ".hunch-private", "dist", "vscode-extension", "site"]);
@@ -111,6 +112,6 @@ export function scanRepoDocs(decisions, root) {
         const title = /^#\s+(.+)$/m.exec(text)?.[1]?.trim() ?? doc.rel;
         out.push({ rel: doc.rel, title, topics, srcRefs, status, issues });
     }
-    return out.sort((a, b) => a.rel.localeCompare(b.rel));
+    return out.sort((a, b) => compareCodeUnits(a.rel, b.rel));
 }
 //# sourceMappingURL=docscan.js.map

package/dist/core/escalations.js

@@ -46,6 +46,17 @@ export function policyEscalations(policies) {
             });
         }
         else if (p.state === "proposed") {
+            if (p.activation_gate?.status === "blocked") {
+                out.push({
+                    kind: "policy-proposal",
+                    topic: p.id,
+                    decisionIds: [p.id],
+                    question: `Proposed rule "${clip(p.statement)}" (${p.id}) is ready for review but mechanically blocked from activation — keep it as evidence?`,
+                    detail: `state proposed · ${p.proof ? `proof ${p.proof}` : "no proof"} · authority none · activation gate ${p.activation_gate.kind}`,
+                    resolution: `inspect: hunch policy card ${p.id} — activation remains unavailable until the source-currentness gate is implemented and cleared`,
+                });
+                continue;
+            }
             out.push({
                 kind: "policy-proposal",
                 topic: p.id,